From 78271775757c151fac1d260aac066f8958998d00 Mon Sep 17 00:00:00 2001
From: Hrvoje Jasak <h.jasak@wikki.co.uk>
Date: Fri, 4 Aug 2023 17:57:47 +0100
Subject: [PATCH 1/7] Polyhedral AMR

---
 .../mesh/manipulation/stitchMesh/stitchMesh.C |    2 +-
 src/dynamicMesh/Make/files                    |    5 +
 src/dynamicMesh/attachDetach/attachDetach.C   |    4 +-
 src/dynamicMesh/attachDetach/attachDetach.H   |    6 +-
 .../attachDetach/attachInterface.C            |    8 +-
 .../attachDetach/detachInterface.C            |   10 +-
 .../layerAdditionRemoval/addCellLayer.C       |    8 +-
 .../layerAdditionRemoval.C                    |    6 +-
 .../layerAdditionRemoval.H                    |    6 +-
 .../layerAdditionRemoval/removeCellLayer.C    |    4 +-
 .../perfectInterface/perfectInterface.C       |    8 +-
 .../perfectInterface/perfectInterface.H       |    4 +-
 .../attachPolyTopoChanger.C                   |    5 +-
 .../polyMeshModifier/polyMeshModifier.H       |    4 +-
 .../polyTopoChange/removeFaces.C              | 1084 +-----
 .../polyTopoChange/removeFaces.H              |   32 +-
 .../polyTopoChange/removeFacesTemplates.C     | 1112 ++++++
 .../polyTopoChanger/polyTopoChanger.C         |   67 +-
 .../polyTopoChanger/polyTopoChanger.H         |   57 +-
 .../polyTopoChangerChangeMesh.C               | 2431 ++++++++++++++
 .../polyhedralRefinement.C                    | 2442 ++++++++++++++
 .../polyhedralRefinement.H                    |  246 ++
 .../prismatic2DRefinement.C                   | 2978 +++++++++++++++++
 .../prismatic2DRefinement.H                   |  254 ++
 .../refinement/refinement/refinement.C        | 1489 +++++++++
 .../refinement/refinement/refinement.H        |  392 +++
 .../refinement/refinement/refinementTools.H   |  351 ++
 src/dynamicMesh/setUpdater/setUpdater.C       |    4 +-
 src/dynamicMesh/setUpdater/setUpdater.H       |    2 +-
 .../slidingInterface/coupleSlidingInterface.C |    4 +-
 .../decoupleSlidingInterface.C                |    4 +-
 .../slidingInterface/slidingInterface.C       |    4 +-
 .../slidingInterface/slidingInterface.H       |    8 +-
 .../slidingInterfaceClearCouple.C             |    4 +-
 src/meshTools/Make/files                      |    2 +
 .../batchPolyTopoChange/batchPolyTopoChange.C |  417 +++
 .../batchPolyTopoChange/batchPolyTopoChange.H |  256 ++
 .../batchPolyTopoChangeI.H                    |   47 +
 src/meshTools/meshTools/meshTools.C           |  154 +
 src/meshTools/meshTools/meshTools.H           |   31 +
 src/topoChangerFvMesh/Make/files              |   10 +
 src/topoChangerFvMesh/Make/options            |    2 +
 .../dynamicMotionSolverTopoFvMesh.C           |    2 +-
 .../movingConeTopoFvMesh.C                    |    2 +-
 .../rawTopoChangerFvMesh.C                    |    4 +-
 45 files changed, 12849 insertions(+), 1123 deletions(-)
 create mode 100644 src/dynamicMesh/polyTopoChange/polyTopoChange/removeFacesTemplates.C
 create mode 100644 src/dynamicMesh/polyTopoChange/polyTopoChanger/polyTopoChangerChangeMesh.C
 create mode 100644 src/dynamicMesh/refinement/polyhedralRefinement/polyhedralRefinement.C
 create mode 100644 src/dynamicMesh/refinement/polyhedralRefinement/polyhedralRefinement.H
 create mode 100644 src/dynamicMesh/refinement/prismatic2DRefinement/prismatic2DRefinement.C
 create mode 100644 src/dynamicMesh/refinement/prismatic2DRefinement/prismatic2DRefinement.H
 create mode 100644 src/dynamicMesh/refinement/refinement/refinement.C
 create mode 100644 src/dynamicMesh/refinement/refinement/refinement.H
 create mode 100644 src/dynamicMesh/refinement/refinement/refinementTools.H
 create mode 100644 src/meshTools/batchPolyTopoChange/batchPolyTopoChange.C
 create mode 100644 src/meshTools/batchPolyTopoChange/batchPolyTopoChange.H
 create mode 100644 src/meshTools/batchPolyTopoChange/batchPolyTopoChangeI.H

diff --git a/applications/utilities/mesh/manipulation/stitchMesh/stitchMesh.C b/applications/utilities/mesh/manipulation/stitchMesh/stitchMesh.C
index 15dd2c3043..930163451e 100644
--- a/applications/utilities/mesh/manipulation/stitchMesh/stitchMesh.C
+++ b/applications/utilities/mesh/manipulation/stitchMesh/stitchMesh.C
@@ -622,7 +622,7 @@ int main(int argc, char *argv[])
         }
 
         // Execute all polyMeshModifiers
-        autoPtr<mapPolyMesh> morphMap = stitcher.changeMesh(true);
+        autoPtr<mapPolyMesh> morphMap = stitcher.changeMesh();
 
         mesh.movePoints(morphMap->preMotionPoints());
 
diff --git a/src/dynamicMesh/Make/files b/src/dynamicMesh/Make/files
index d87341be3e..ea83ff7cc4 100644
--- a/src/dynamicMesh/Make/files
+++ b/src/dynamicMesh/Make/files
@@ -22,6 +22,7 @@ $(polyMeshModifier)/polyMeshModifier.C
 $(polyMeshModifier)/polyMeshModifierNew.C
 
 polyTopoChange/polyTopoChanger/polyTopoChanger.C
+polyTopoChange/polyTopoChanger/polyTopoChangerChangeMesh.C
 polyTopoChange/polyTopoChange/addPatchCellLayer.C
 polyTopoChange/polyTopoChange/pointEdgeCollapse/pointEdgeCollapse.C
 polyTopoChange/polyTopoChange/edgeCollapser.C
@@ -76,6 +77,10 @@ meshCut/refineCell/refineCell.C
 meshCut/wallLayerCells/wallLayerCells.C
 meshCut/wallLayerCells/wallNormalInfo/wallNormalInfo.C
 
+refinement/refinement/refinement.C
+refinement/polyhedralRefinement/polyhedralRefinement.C
+refinement/prismatic2DRefinement/prismatic2DRefinement.C
+
 polyTopoChange/attachPolyTopoChanger/attachPolyTopoChanger.C
 polyTopoChange/repatchPolyTopoChanger/repatchPolyTopoChanger.C
 
diff --git a/src/dynamicMesh/attachDetach/attachDetach.C b/src/dynamicMesh/attachDetach/attachDetach.C
index 51e9143730..0a3c6d529f 100644
--- a/src/dynamicMesh/attachDetach/attachDetach.C
+++ b/src/dynamicMesh/attachDetach/attachDetach.C
@@ -31,7 +31,7 @@ License
 #include "polyMesh.H"
 #include "Time.H"
 #include "primitiveMesh.H"
-#include "polyTopoChange.H"
+#include "batchPolyTopoChange.H"
 #include "addToRunTimeSelectionTable.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
@@ -365,7 +365,7 @@ bool Foam::attachDetach::changeTopology() const
 }
 
 
-void Foam::attachDetach::setRefinement(polyTopoChange& ref) const
+void Foam::attachDetach::setRefinement(batchPolyTopoChange& ref) const
 {
     // Insert the attach/detach instructions into the topological change
 
diff --git a/src/dynamicMesh/attachDetach/attachDetach.H b/src/dynamicMesh/attachDetach/attachDetach.H
index eecc3f1ba0..0d4c646520 100644
--- a/src/dynamicMesh/attachDetach/attachDetach.H
+++ b/src/dynamicMesh/attachDetach/attachDetach.H
@@ -122,10 +122,10 @@ class attachDetach
         // Topological changes
 
             //- Attach interface
-            void attachInterface(polyTopoChange&) const;
+            void attachInterface(batchPolyTopoChange&) const;
 
             //- Detach interface
-            void detachInterface(polyTopoChange&) const;
+            void detachInterface(batchPolyTopoChange&) const;
 
             //- Calculate point match addressing
             void calcPointMatchMap() const;
@@ -215,7 +215,7 @@ public:
 
         //- Insert the layer addition/removal instructions
         //  into the topological change
-        virtual void setRefinement(polyTopoChange&) const;
+        virtual void setRefinement(batchPolyTopoChange&) const;
 
         //- Modify motion points to comply with the topological change
         virtual void modifyMotionPoints(pointField& motionPoints) const;
diff --git a/src/dynamicMesh/attachDetach/attachInterface.C b/src/dynamicMesh/attachDetach/attachInterface.C
index 70e996d297..1da8367b0d 100644
--- a/src/dynamicMesh/attachDetach/attachInterface.C
+++ b/src/dynamicMesh/attachDetach/attachInterface.C
@@ -29,7 +29,7 @@ License
 #include "attachDetach.H"
 #include "polyMesh.H"
 #include "primitiveMesh.H"
-#include "polyTopoChange.H"
+#include "batchPolyTopoChange.H"
 #include "polyTopoChanger.H"
 #include "polyRemovePoint.H"
 #include "polyRemoveFace.H"
@@ -43,7 +43,7 @@ const Foam::scalar Foam::attachDetach::positionDifference_ = 1e-8;
 
 void Foam::attachDetach::attachInterface
 (
-    polyTopoChange& ref
+    batchPolyTopoChange& ref
 ) const
 {
     // Algorithm:
@@ -62,7 +62,7 @@ void Foam::attachDetach::attachInterface
     if (debug)
     {
         Pout<< "void attachDetach::attachInterface("
-            << "polyTopoChange& ref) const "
+            << "batchPolyTopoChange& ref) const "
             << " for object " << name() << " : "
             << "Attaching interface" << endl;
     }
@@ -266,7 +266,7 @@ void Foam::attachDetach::attachInterface
     if (debug)
     {
         Pout<< "void attachDetach::attachInterface("
-            << "polyTopoChange& ref) const "
+            << "batchPolyTopoChange& ref) const "
             << " for object " << name() << " : "
             << "Finished attaching interface" << endl;
     }
diff --git a/src/dynamicMesh/attachDetach/detachInterface.C b/src/dynamicMesh/attachDetach/detachInterface.C
index 34f94d4cad..35d06ec761 100644
--- a/src/dynamicMesh/attachDetach/detachInterface.C
+++ b/src/dynamicMesh/attachDetach/detachInterface.C
@@ -28,7 +28,7 @@ License
 #include "attachDetach.H"
 #include "polyMesh.H"
 #include "primitiveMesh.H"
-#include "polyTopoChange.H"
+#include "batchPolyTopoChange.H"
 #include "polyTopoChanger.H"
 #include "polyAddPoint.H"
 #include "polyModifyFace.H"
@@ -38,7 +38,7 @@ License
 
 void Foam::attachDetach::detachInterface
 (
-    polyTopoChange& ref
+    batchPolyTopoChange& ref
 ) const
 {
     // Algorithm:
@@ -66,7 +66,7 @@ void Foam::attachDetach::detachInterface
     if (debug)
     {
         Pout<< "void attachDetach::detachInterface("
-            << "polyTopoChange& ref) const "
+            << "batchPolyTopoChange& ref) const "
             << " for object " << name() << " : "
             << "Detaching interface" << endl;
     }
@@ -75,7 +75,7 @@ void Foam::attachDetach::detachInterface
     const faceZoneMesh& zoneMesh = mesh.faceZones();
 
     // Check that zone is in increasing order (needed since adding faces
-    // in same order - otherwise polyTopoChange face ordering will mess up
+    // in same order - otherwise batchPolyTopoChange face ordering will mess up
     // correspondence)
     if (debug)
     {
@@ -467,7 +467,7 @@ void Foam::attachDetach::detachInterface
     if (debug)
     {
         Pout<< "void attachDetach::detachInterface("
-            << "polyTopoChange& ref) const "
+            << "batchPolyTopoChange& ref) const "
             << " for object " << name() << " : "
             << "Finished detaching interface" << endl;
     }
diff --git a/src/dynamicMesh/layerAdditionRemoval/addCellLayer.C b/src/dynamicMesh/layerAdditionRemoval/addCellLayer.C
index 2c6eb27b36..569f389186 100644
--- a/src/dynamicMesh/layerAdditionRemoval/addCellLayer.C
+++ b/src/dynamicMesh/layerAdditionRemoval/addCellLayer.C
@@ -29,7 +29,7 @@ License
 #include "layerAdditionRemoval.H"
 #include "polyMesh.H"
 #include "primitiveMesh.H"
-#include "polyTopoChange.H"
+#include "batchPolyTopoChange.H"
 #include "polyTopoChanger.H"
 #include "polyAddPoint.H"
 #include "polyAddCell.H"
@@ -88,7 +88,7 @@ Foam::tmp<Foam::vectorField> Foam::layerAdditionRemoval::extrusionDir() const
 
 void Foam::layerAdditionRemoval::addCellLayer
 (
-    polyTopoChange& ref
+    batchPolyTopoChange& ref
 ) const
 {
     // Insert the layer addition instructions into the topological change
@@ -108,7 +108,7 @@ void Foam::layerAdditionRemoval::addCellLayer
     if (debug)
     {
         Pout<< "void layerAdditionRemoval::addCellLayer("
-            << "polyTopoChange& ref) const for object " << name() << " : "
+            << "batchPolyTopoChange& ref) const for object " << name() << " : "
             << "Adding cell layer" << endl;
     }
 
@@ -682,7 +682,7 @@ void Foam::layerAdditionRemoval::addCellLayer
 
     if (debug)
     {
-        Pout<< "void layerAdditionRemoval::addCellLayer(polyTopoChange&) const "
+        Pout<< "void layerAdditionRemoval::addCellLayer(batchPolyTopoChange&) const "
             << " for object " << name() << ": "
             << "Finished adding cell layer" << endl;
     }
diff --git a/src/dynamicMesh/layerAdditionRemoval/layerAdditionRemoval.C b/src/dynamicMesh/layerAdditionRemoval/layerAdditionRemoval.C
index d7baa813f4..507d559c98 100644
--- a/src/dynamicMesh/layerAdditionRemoval/layerAdditionRemoval.C
+++ b/src/dynamicMesh/layerAdditionRemoval/layerAdditionRemoval.C
@@ -355,7 +355,7 @@ bool Foam::layerAdditionRemoval::changeTopology() const
 }
 
 
-void Foam::layerAdditionRemoval::setRefinement(polyTopoChange& ref) const
+void Foam::layerAdditionRemoval::setRefinement(batchPolyTopoChange& ref) const
 {
     // Insert the layer addition/removal instructions
     // into the topological change
@@ -367,7 +367,7 @@ void Foam::layerAdditionRemoval::setRefinement(polyTopoChange& ref) const
         // Clear addressing.  This also resets the addition/removal data
         if (debug)
         {
-            Pout<< "layerAdditionRemoval::setRefinement(polyTopoChange&) "
+            Pout<< "layerAdditionRemoval::setRefinement(batchPolyTopoChange&) "
                 << "for object " << name() << " : "
                 << "Clearing addressing after layer removal" << endl;
         }
@@ -383,7 +383,7 @@ void Foam::layerAdditionRemoval::setRefinement(polyTopoChange& ref) const
         // Clear addressing.  This also resets the addition/removal data
         if (debug)
         {
-            Pout<< "layerAdditionRemoval::setRefinement(polyTopoChange&) "
+            Pout<< "layerAdditionRemoval::setRefinement(batchPolyTopoChange&) "
                 << "for object " << name() << " : "
                 << "Clearing addressing after layer addition" << endl;
         }
diff --git a/src/dynamicMesh/layerAdditionRemoval/layerAdditionRemoval.H b/src/dynamicMesh/layerAdditionRemoval/layerAdditionRemoval.H
index 25e5e68327..45c983b5dc 100644
--- a/src/dynamicMesh/layerAdditionRemoval/layerAdditionRemoval.H
+++ b/src/dynamicMesh/layerAdditionRemoval/layerAdditionRemoval.H
@@ -119,10 +119,10 @@ class layerAdditionRemoval
             tmp<vectorField> extrusionDir() const;
 
             //- Add a layer of cells
-            void addCellLayer(polyTopoChange&) const;
+            void addCellLayer(batchPolyTopoChange&) const;
 
             //- Remove a layer of cells
-            void removeCellLayer(polyTopoChange&) const;
+            void removeCellLayer(batchPolyTopoChange&) const;
 
             //- Clear addressing
             void clearAddressing() const;
@@ -179,7 +179,7 @@ public:
 
         //- Insert the layer addition/removal instructions
         //  into the topological change
-        virtual void setRefinement(polyTopoChange&) const;
+        virtual void setRefinement(batchPolyTopoChange&) const;
 
         //- Modify motion points to comply with the topological change
         virtual void modifyMotionPoints(pointField& motionPoints) const;
diff --git a/src/dynamicMesh/layerAdditionRemoval/removeCellLayer.C b/src/dynamicMesh/layerAdditionRemoval/removeCellLayer.C
index e04075d2e0..9dd6fa51cf 100644
--- a/src/dynamicMesh/layerAdditionRemoval/removeCellLayer.C
+++ b/src/dynamicMesh/layerAdditionRemoval/removeCellLayer.C
@@ -29,7 +29,7 @@ License
 #include "layerAdditionRemoval.H"
 #include "polyMesh.H"
 #include "primitiveMesh.H"
-#include "polyTopoChange.H"
+#include "batchPolyTopoChange.H"
 #include "oppositeFace.H"
 #include "polyTopoChanger.H"
 #include "polyRemoveCell.H"
@@ -83,7 +83,7 @@ bool Foam::layerAdditionRemoval::validCollapse() const
 
 void Foam::layerAdditionRemoval::removeCellLayer
 (
-    polyTopoChange& ref
+    batchPolyTopoChange& ref
 ) const
 {
     // Algorithm for layer removal.  Second phase: topological change
diff --git a/src/dynamicMesh/perfectInterface/perfectInterface.C b/src/dynamicMesh/perfectInterface/perfectInterface.C
index da1cc5130f..b4c973f8e8 100644
--- a/src/dynamicMesh/perfectInterface/perfectInterface.C
+++ b/src/dynamicMesh/perfectInterface/perfectInterface.C
@@ -33,7 +33,7 @@ Description
 #include "perfectInterface.H"
 #include "polyTopoChanger.H"
 #include "polyMesh.H"
-#include "polyTopoChange.H"
+#include "batchPolyTopoChange.H"
 #include "addToRunTimeSelectionTable.H"
 #include "mapPolyMesh.H"
 #include "matchPoints.H"
@@ -154,7 +154,7 @@ void Foam::perfectInterface::setRefinement
 (
     const indirectPrimitivePatch& pp0,
     const indirectPrimitivePatch& pp1,
-    polyTopoChange& ref
+    batchPolyTopoChange& ref
 ) const
 {
     const polyMesh& mesh = topoChanger().mesh();
@@ -423,11 +423,11 @@ void Foam::perfectInterface::setRefinement
 }
 
 
-void Foam::perfectInterface::setRefinement(polyTopoChange& ref) const
+void Foam::perfectInterface::setRefinement(batchPolyTopoChange& ref) const
 {
     if (debug)
     {
-        Pout<< "bool perfectInterface::setRefinement(polyTopoChange&) const : "
+        Pout<< "bool perfectInterface::setRefinement(batchPolyTopoChange&) const : "
             << "for object " << name() << " : "
             << "masterPatchID_:" << masterPatchID_
             << " slavePatchID_:" << slavePatchID_
diff --git a/src/dynamicMesh/perfectInterface/perfectInterface.H b/src/dynamicMesh/perfectInterface/perfectInterface.H
index 20352c4bee..f5895723dc 100644
--- a/src/dynamicMesh/perfectInterface/perfectInterface.H
+++ b/src/dynamicMesh/perfectInterface/perfectInterface.H
@@ -129,7 +129,7 @@ public:
 
         //- Insert the layer addition/removal instructions
         //  into the topological change
-        virtual void setRefinement(polyTopoChange&) const;
+        virtual void setRefinement(batchPolyTopoChange&) const;
 
         //- Insert the layer addition/removal instructions
         //  into the topological change. Uses only mesh, not any of the
@@ -139,7 +139,7 @@ public:
         (
             const indirectPrimitivePatch& pp0,
             const indirectPrimitivePatch& pp1,
-            polyTopoChange&
+            batchPolyTopoChange&
         ) const;
 
         //- Modify motion points to comply with the topological change
diff --git a/src/dynamicMesh/polyTopoChange/attachPolyTopoChanger/attachPolyTopoChanger.C b/src/dynamicMesh/polyTopoChange/attachPolyTopoChanger/attachPolyTopoChanger.C
index a88b03e5d5..a11a743f32 100644
--- a/src/dynamicMesh/polyTopoChange/attachPolyTopoChanger/attachPolyTopoChanger.C
+++ b/src/dynamicMesh/polyTopoChange/attachPolyTopoChanger/attachPolyTopoChanger.C
@@ -65,7 +65,10 @@ void Foam::attachPolyTopoChanger::attach(const bool removeEmptyPatches)
     const fileName oldInst = mesh_.facesInstance();
 
     // Execute all polyMeshModifiers
-    changeMesh(false);  // no inflation
+    // DISABLED - this functionality is lost
+    // Bad rewrite by Mattijs Janssens - completely misunderstood the interface
+    // Needs to use polyTopoChange, and not changer.
+    // changeMesh(false);  // no inflation
 
     const pointField p = mesh_.oldPoints();
 
diff --git a/src/dynamicMesh/polyTopoChange/polyMeshModifier/polyMeshModifier.H b/src/dynamicMesh/polyTopoChange/polyMeshModifier/polyMeshModifier.H
index 62bc93bcfc..48f9936795 100644
--- a/src/dynamicMesh/polyTopoChange/polyMeshModifier/polyMeshModifier.H
+++ b/src/dynamicMesh/polyTopoChange/polyMeshModifier/polyMeshModifier.H
@@ -55,7 +55,7 @@ namespace Foam
 
 // Forward Declarations
 class polyTopoChanger;
-class polyTopoChange;
+class batchPolyTopoChange;
 class mapPolyMesh;
 class polyMeshModifier;
 
@@ -166,7 +166,7 @@ public:
         virtual bool changeTopology() const = 0;
 
         //- Insert the topological change instructions
-        virtual void setRefinement(polyTopoChange&) const = 0;
+        virtual void setRefinement(batchPolyTopoChange&) const = 0;
 
         //- Modify motion points to comply with the topological change
         virtual void modifyMotionPoints(pointField& motionPoints) const = 0;
diff --git a/src/dynamicMesh/polyTopoChange/polyTopoChange/removeFaces.C b/src/dynamicMesh/polyTopoChange/polyTopoChange/removeFaces.C
index 2c4cae838d..36f7ff456c 100644
--- a/src/dynamicMesh/polyTopoChange/polyTopoChange/removeFaces.C
+++ b/src/dynamicMesh/polyTopoChange/polyTopoChange/removeFaces.C
@@ -77,6 +77,62 @@ void Foam::removeFaces::changeCellRegion
 }
 
 
+Foam::label Foam::removeFaces::changeFaceRegion
+(
+    const labelList& cellRegion,
+    const boolList& removedFace,
+    const labelList& nFacesPerEdge,
+    const label faceI,
+    const label newRegion,
+
+    labelList& faceRegion
+) const
+{
+    // Count number of changed faces
+    label nChanged = 0;
+
+    if (faceRegion[faceI] == -1 && !removedFace[faceI])
+    {
+        faceRegion[faceI] = newRegion;
+
+        nChanged = 1;
+
+        // Get mesh data
+        const labelListList& meshFaceEdges = mesh_.faceEdges();
+        const labelListList& meshEdgeFaces = mesh_.edgeFaces();
+
+        // Step to neighbouring faces across edges that will get removed
+        const labelList& fEdges = meshFaceEdges[faceI];
+
+        forAll(fEdges, i)
+        {
+            const label& edgeI = fEdges[i];
+
+            if (nFacesPerEdge[edgeI] >= 0 && nFacesPerEdge[edgeI] <= 2)
+            {
+                const labelList& eFaces = meshEdgeFaces[edgeI];
+
+                forAll(eFaces, j)
+                {
+                    nChanged += changeFaceRegion
+                    (
+                        cellRegion,
+                        removedFace,
+                        nFacesPerEdge,
+                        eFaces[j],
+                        newRegion,
+
+                        faceRegion
+                    );
+                }
+            }
+        }
+    }
+
+    return nChanged;
+}
+
+
 // Changes region of connected set of faces. Returns number of changed faces.
 Foam::label Foam::removeFaces::changeFaceRegion
 (
@@ -231,187 +287,6 @@ void Foam::removeFaces::writeOBJ
 }
 
 
-// Inserts commands to merge faceLabels into one face.
-void Foam::removeFaces::mergeFaces
-(
-    const labelList& cellRegion,
-    const labelList& cellRegionMaster,
-    const labelHashSet& pointsToRemove,
-    const labelList& faceLabels,
-    polyTopoChange& meshMod
-) const
-{
-    // Construct addressing engine from faceLabels (in order of faceLabels as
-    // well)
-    indirectPrimitivePatch fp
-    (
-        IndirectList<face>
-        (
-            mesh_.faces(),
-            faceLabels
-        ),
-        mesh_.points()
-    );
-
-    // Get outside vertices (in local vertex numbering)
-
-    if (fp.edgeLoops().size() != 1)
-    {
-        writeOBJ(fp, mesh_.time().path()/"facesToBeMerged.obj");
-        FatalErrorInFunction
-            << "Cannot merge faces " << faceLabels
-            << " into single face since outside vertices " << fp.edgeLoops()
-            << " do not form single loop but form " << fp.edgeLoops().size()
-            << " loops instead." << abort(FatalError);
-    }
-
-    const labelList& edgeLoop = fp.edgeLoops()[0];
-
-    // Get outside vertices in order of one of the faces in faceLabels.
-    // (this becomes the master face)
-    // Find the first face that uses edgeLoop[0] and edgeLoop[1] as consecutive
-    // vertices.
-
-    label masterIndex = -1;
-    bool reverseLoop = false;
-
-    const labelList& pFaces = fp.pointFaces()[edgeLoop[0]];
-
-    // Find face among pFaces which uses edgeLoop[1]
-    forAll(pFaces, i)
-    {
-        label facei = pFaces[i];
-
-        const face& f = fp.localFaces()[facei];
-
-        label index1 = f.find(edgeLoop[1]);
-
-        if (index1 != -1)
-        {
-            // Check whether consecutive to edgeLoop[0]
-            label index0 = f.find(edgeLoop[0]);
-
-            if (index0 != -1)
-            {
-                if (index1 == f.fcIndex(index0))
-                {
-                    masterIndex = facei;
-                    reverseLoop = false;
-                    break;
-                }
-                else if (index1 == f.rcIndex(index0))
-                {
-                    masterIndex = facei;
-                    reverseLoop = true;
-                    break;
-                }
-            }
-        }
-    }
-
-    if (masterIndex == -1)
-    {
-        writeOBJ(fp, mesh_.time().path()/"facesToBeMerged.obj");
-        FatalErrorInFunction
-            << "Problem" << abort(FatalError);
-    }
-
-
-    // Modify the master face.
-    // ~~~~~~~~~~~~~~~~~~~~~~~
-
-    // Modify first face.
-    label facei = faceLabels[masterIndex];
-
-    label own = mesh_.faceOwner()[facei];
-
-    if (cellRegion[own] != -1)
-    {
-        own = cellRegionMaster[cellRegion[own]];
-    }
-
-    label patchID, zoneID, zoneFlip;
-
-    getFaceInfo(facei, patchID, zoneID, zoneFlip);
-
-    label nei = -1;
-
-    if (mesh_.isInternalFace(facei))
-    {
-        nei = mesh_.faceNeighbour()[facei];
-
-        if (cellRegion[nei] != -1)
-        {
-            nei = cellRegionMaster[cellRegion[nei]];
-        }
-    }
-
-
-    DynamicList<label> faceVerts(edgeLoop.size());
-
-    forAll(edgeLoop, i)
-    {
-        label pointi = fp.meshPoints()[edgeLoop[i]];
-
-        if (pointsToRemove.found(pointi))
-        {
-            //Pout<< "**Removing point " << pointi << " from "
-            //    << edgeLoop << endl;
-        }
-        else
-        {
-            faceVerts.append(pointi);
-        }
-    }
-
-    face mergedFace;
-    mergedFace.transfer(faceVerts);
-
-    if (reverseLoop)
-    {
-        reverse(mergedFace);
-    }
-
-    //{
-    //    Pout<< "Modifying masterface " << facei
-    //        << " from faces:" << faceLabels
-    //        << " old verts:" << UIndirectList<face>(mesh_.faces(), faceLabels)
-    //        << " for new verts:"
-    //        << mergedFace
-    //        << " possibly new owner " << own
-    //        << " or new nei " << nei
-    //        << endl;
-    //}
-
-    modFace
-    (
-        mergedFace,         // modified face
-        facei,              // label of face being modified
-        own,                // owner
-        nei,                // neighbour
-        false,              // face flip
-        patchID,            // patch for face
-        false,              // remove from zone
-        zoneID,             // zone for face
-        zoneFlip,           // face flip in zone
-
-        meshMod
-    );
-
-
-    // Remove all but master face.
-    forAll(faceLabels, patchFacei)
-    {
-        if (patchFacei != masterIndex)
-        {
-            //Pout<< "Removing face " << faceLabels[patchFacei] << endl;
-
-            meshMod.setAction(polyRemoveFace(faceLabels[patchFacei], facei));
-        }
-    }
-}
-
-
 // Get patch, zone info for facei
 void Foam::removeFaces::getFaceInfo
 (
@@ -471,91 +346,6 @@ Foam::face Foam::removeFaces::filterFace
 }
 
 
-// Wrapper for meshMod.modifyFace. Reverses face if own>nei.
-void Foam::removeFaces::modFace
-(
-    const face& f,
-    const label masterFaceID,
-    const label own,
-    const label nei,
-    const bool flipFaceFlux,
-    const label newPatchID,
-    const bool removeFromZone,
-    const label zoneID,
-    const bool zoneFlip,
-
-    polyTopoChange& meshMod
-) const
-{
-    if ((nei == -1) || (own < nei))
-    {
-//        if (debug)
-//        {
-//            Pout<< "ModifyFace (unreversed) :"
-//                << "  facei:" << masterFaceID
-//                << "  f:" << f
-//                << "  own:" << own
-//                << "  nei:" << nei
-//                << "  flipFaceFlux:" << flipFaceFlux
-//                << "  newPatchID:" << newPatchID
-//                << "  removeFromZone:" << removeFromZone
-//                << "  zoneID:" << zoneID
-//                << "  zoneFlip:" << zoneFlip
-//                << endl;
-//        }
-
-        meshMod.setAction
-        (
-            polyModifyFace
-            (
-                f,              // modified face
-                masterFaceID,   // label of face being modified
-                own,            // owner
-                nei,            // neighbour
-                flipFaceFlux,   // face flip
-                newPatchID,     // patch for face
-                removeFromZone, // remove from zone
-                zoneID,         // zone for face
-                zoneFlip        // face flip in zone
-            )
-        );
-    }
-    else
-    {
-//        if (debug)
-//        {
-//            Pout<< "ModifyFace (!reversed) :"
-//                << "  facei:" << masterFaceID
-//                << "  f:" << f.reverseFace()
-//                << "  own:" << nei
-//                << "  nei:" << own
-//                << "  flipFaceFlux:" << flipFaceFlux
-//                << "  newPatchID:" << newPatchID
-//                << "  removeFromZone:" << removeFromZone
-//                << "  zoneID:" << zoneID
-//                << "  zoneFlip:" << zoneFlip
-//                << endl;
-//        }
-
-        meshMod.setAction
-        (
-            polyModifyFace
-            (
-                f.reverseFace(),// modified face
-                masterFaceID,   // label of face being modified
-                nei,            // owner
-                own,            // neighbour
-                flipFaceFlux,   // face flip
-                newPatchID,     // patch for face
-                removeFromZone, // remove from zone
-                zoneID,         // zone for face
-                zoneFlip        // face flip in zone
-            )
-        );
-    }
-}
-
-
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
 // Construct from mesh
@@ -759,766 +549,4 @@ Foam::label Foam::removeFaces::compatibleRemoves
 }
 
 
-void Foam::removeFaces::setRefinement
-(
-    const labelList& faceLabels,
-    const labelList& cellRegion,
-    const labelList& cellRegionMaster,
-    polyTopoChange& meshMod
-) const
-{
-    if (debug)
-    {
-        faceSet facesToRemove(mesh_, "facesToRemove", faceLabels);
-        Pout<< "Writing faces to remove to faceSet " << facesToRemove.name()
-            << endl;
-        facesToRemove.write();
-    }
-
-    // Make map of all faces to be removed
-    boolList removedFace(mesh_.nFaces(), false);
-
-    forAll(faceLabels, i)
-    {
-        label facei = faceLabels[i];
-
-        if (!mesh_.isInternalFace(facei))
-        {
-            FatalErrorInFunction
-                << "Face to remove is not internal face:" << facei
-                << abort(FatalError);
-        }
-
-        removedFace[facei] = true;
-    }
-
-
-    // Edges to be removed
-    // ~~~~~~~~~~~~~~~~~~~
-
-
-    // Edges to remove
-    labelHashSet edgesToRemove(faceLabels.size());
-
-    // Per face the region it is in. -1 for removed faces, -2 for regions
-    // consisting of single face only.
-    labelList faceRegion(mesh_.nFaces(), -1);
-
-    // Number of connected face regions
-    label nRegions = 0;
-
-    // Storage for on-the-fly addressing
-    DynamicList<label> fe;
-    DynamicList<label> ef;
-
-
-    {
-        const polyBoundaryMesh& patches = mesh_.boundaryMesh();
-
-        // Usage of edges by non-removed faces.
-        // See below about initialization.
-        labelList nFacesPerEdge(mesh_.nEdges(), -1);
-
-        // Count usage of edges by non-removed faces.
-        forAll(faceLabels, i)
-        {
-            label facei = faceLabels[i];
-
-            const labelList& fEdges = mesh_.faceEdges(facei, fe);
-
-            forAll(fEdges, i)
-            {
-                label edgeI = fEdges[i];
-
-                if (nFacesPerEdge[edgeI] == -1)
-                {
-                    nFacesPerEdge[edgeI] = mesh_.edgeFaces(edgeI, ef).size()-1;
-                }
-                else
-                {
-                    nFacesPerEdge[edgeI]--;
-                }
-            }
-        }
-
-        // Count usage for edges not on faces-to-be-removed.
-        // Note that this only needs to be done for possibly coupled edges
-        // so we could choose to loop only over boundary faces and use faceEdges
-        // of those.
-
-        forAll(mesh_.edges(), edgeI)
-        {
-            if (nFacesPerEdge[edgeI] == -1)
-            {
-                // Edge not yet handled in loop above so is not used by any
-                // face to be removed.
-
-                const labelList& eFaces = mesh_.edgeFaces(edgeI, ef);
-
-                if (eFaces.size() > 2)
-                {
-                    nFacesPerEdge[edgeI] = eFaces.size();
-                }
-                else if (eFaces.size() == 2)
-                {
-                    // nFacesPerEdge already -1 so do nothing.
-                }
-                else
-                {
-                    const edge& e = mesh_.edges()[edgeI];
-
-                    FatalErrorInFunction
-                        << "Problem : edge has too few face neighbours:"
-                        << eFaces << endl
-                        << "edge:" << edgeI
-                        << " vertices:" << e
-                        << " coords:" << mesh_.points()[e[0]]
-                        << mesh_.points()[e[1]]
-                        << abort(FatalError);
-                }
-            }
-        }
-
-
-
-        if (debug)
-        {
-            OFstream str(mesh_.time().path()/"edgesWithTwoFaces.obj");
-            Pout<< "Dumping edgesWithTwoFaces to " << str.name() << endl;
-            label vertI = 0;
-
-            forAll(nFacesPerEdge, edgeI)
-            {
-                if (nFacesPerEdge[edgeI] == 2)
-                {
-                    // Edge will get removed.
-                    const edge& e = mesh_.edges()[edgeI];
-
-                    meshTools::writeOBJ(str, mesh_.points()[e[0]]);
-                    vertI++;
-                    meshTools::writeOBJ(str, mesh_.points()[e[1]]);
-                    vertI++;
-                    str<< "l " << vertI-1 << ' ' << vertI << nl;
-                }
-            }
-        }
-
-
-        // Now all unaffected edges will have labelMax, all affected edges the
-        // number of unremoved faces.
-
-        // Filter for edges inbetween two remaining boundary faces that
-        // make too big an angle.
-        forAll(nFacesPerEdge, edgeI)
-        {
-            if (nFacesPerEdge[edgeI] == 2)
-            {
-                // Get the two face labels
-                label f0 = -1;
-                label f1 = -1;
-
-                const labelList& eFaces = mesh_.edgeFaces(edgeI, ef);
-
-                forAll(eFaces, i)
-                {
-                    label facei = eFaces[i];
-
-                    if (!removedFace[facei])
-                    {
-                        if (f0 == -1)
-                        {
-                            f0 = facei;
-                        }
-                        else
-                        {
-                            f1 = facei;
-                            break;
-                        }
-                    }
-                }
-
-                if (!mesh_.isInternalFace(f0) && !mesh_.isInternalFace(f1))
-                {
-                    // Edge has two boundary faces remaining.
-                    // See if should be merged.
-
-                    label patch0 = patches.whichPatch(f0);
-                    label patch1 = patches.whichPatch(f1);
-
-                    if (patch0 != patch1)
-                    {
-                        // Different patches. Do not merge edge.
-                        WarningInFunction
-                            << "not merging faces " << f0 << " and "
-                            << f1 << " across patch boundary edge " << edgeI
-                            << endl;
-
-                        // Mark so it gets preserved
-                        nFacesPerEdge[edgeI] = 3;
-                    }
-                    else if (minCos_ < 1 && minCos_ > -1)
-                    {
-                        const polyPatch& pp0 = patches[patch0];
-                        const vectorField& n0 = pp0.faceNormals();
-
-                        if
-                        (
-                            mag
-                            (
-                                n0[f0 - pp0.start()]
-                              & n0[f1 - pp0.start()]
-                            )
-                            < minCos_
-                        )
-                        {
-                            WarningInFunction
-                                << "not merging faces " << f0 << " and "
-                                << f1 << " across edge " << edgeI
-                                << endl;
-
-                            // Angle between two remaining faces too large.
-                            // Mark so it gets preserved
-                            nFacesPerEdge[edgeI] = 3;
-                        }
-                    }
-                }
-                else if (mesh_.isInternalFace(f0) != mesh_.isInternalFace(f1))
-                {
-                    const edge& e = mesh_.edges()[edgeI];
-
-                    // Only found one boundary face. Problem.
-                    FatalErrorInFunction
-                        << "Problem : edge would have one boundary face"
-                        << " and one internal face using it." << endl
-                        << "Your remove pattern is probably incorrect." << endl
-                        << "edge:" << edgeI
-                        << " nFaces:" << nFacesPerEdge[edgeI]
-                        << " vertices:" << e
-                        << " coords:" << mesh_.points()[e[0]]
-                        << mesh_.points()[e[1]]
-                        << " face0:" << f0
-                        << " face1:" << f1
-                        << abort(FatalError);
-                }
-                else
-                {
-                    // Both kept faces are internal. Mark edge for preserving
-                    // if inbetween different cells. If inbetween same cell
-                    // pair we probably want to merge them to
-                    //  - avoid upper-triangular ordering problems
-                    //  - allow hex unrefinement (expects single face inbetween
-                    //    cells)
-
-                    const edge ownEdge
-                    (
-                        cellRegion[mesh_.faceOwner()[f0]],
-                        cellRegion[mesh_.faceNeighbour()[f0]]
-                    );
-                    const edge neiEdge
-                    (
-                        cellRegion[mesh_.faceOwner()[f1]],
-                        cellRegion[mesh_.faceNeighbour()[f1]]
-                    );
-
-                    if (ownEdge != neiEdge)
-                    {
-                        nFacesPerEdge[edgeI] = 3;
-                    }
-                }
-            }
-        }
-
-
-
-        // Check locally (before synchronizing) for strangeness
-        forAll(nFacesPerEdge, edgeI)
-        {
-            if (nFacesPerEdge[edgeI] == 1)
-            {
-                const edge& e = mesh_.edges()[edgeI];
-
-                FatalErrorInFunction
-                    << "Problem : edge would get 1 face using it only"
-                    << " edge:" << edgeI
-                    << " nFaces:" << nFacesPerEdge[edgeI]
-                    << " vertices:" << e
-                    << " coords:" << mesh_.points()[e[0]]
-                    << ' ' << mesh_.points()[e[1]]
-                    << abort(FatalError);
-            }
-            // Could check here for boundary edge with <=1 faces remaining.
-        }
-
-
-        // Synchronize edge usage. This is to make sure that both sides remove
-        // (or not remove) an edge on the boundary at the same time.
-        //
-        // Coupled edges (edge0, edge1 are opposite each other)
-        // a. edge not on face to be removed, edge has >= 3 faces
-        // b.  ,,                             edge has 2 faces
-        // c. edge has >= 3 remaining faces
-        // d. edge has 2 remaining faces (assume angle>minCos already handled)
-        //
-        // - a + a: do not remove edge
-        // - a + b: do not remove edge
-        // - a + c: do not remove edge
-        // - a + d: do not remove edge
-        //
-        // - b + b: do not remove edge
-        // - b + c: do not remove edge
-        // - b + d: remove edge
-        //
-        // - c + c: do not remove edge
-        // - c + d: do not remove edge
-        // - d + d: remove edge
-        //
-        //
-        // So code situation a. with >= 3
-        //                   b. with -1
-        //                   c. with >=3
-        //                   d. with 2
-        // then do max and check result.
-        //
-        // a+a : max(3,3) = 3. do not remove
-        // a+b : max(3,-1) = 3. do not remove
-        // a+c : max(3,3) = 3. do not remove
-        // a+d : max(3,2) = 3. do not remove
-        //
-        // b+b : max(-1,-1) = -1. do not remove
-        // b+c : max(-1,3) = 3. do not remove
-        // b+d : max(-1,2) = 2. remove
-        //
-        // c+c : max(3,3) = 3. do not remove
-        // c+d : max(3,2) = 3. do not remove
-        //
-        // d+d : max(2,2) = 2. remove
-
-        syncTools::syncEdgeList
-        (
-            mesh_,
-            nFacesPerEdge,
-            maxEqOp<label>(),
-            labelMin                // guaranteed to be overridden by maxEqOp
-        );
-
-        // Convert to labelHashSet
-        forAll(nFacesPerEdge, edgeI)
-        {
-            if (nFacesPerEdge[edgeI] == 0)
-            {
-                // 0: edge not used anymore.
-                edgesToRemove.insert(edgeI);
-            }
-            else if (nFacesPerEdge[edgeI] == 1)
-            {
-                // 1: illegal. Tested above.
-            }
-            else if (nFacesPerEdge[edgeI] == 2)
-            {
-                // 2: merge faces.
-                edgesToRemove.insert(edgeI);
-            }
-        }
-
-        if (debug)
-        {
-            OFstream str(mesh_.time().path()/"edgesToRemove.obj");
-            Pout<< "Dumping edgesToRemove to " << str.name() << endl;
-            label vertI = 0;
-
-            for (const label edgei : edgesToRemove)
-            {
-                // Edge will get removed.
-                const edge& e = mesh_.edges()[edgei];
-
-                meshTools::writeOBJ(str, mesh_.points()[e[0]]);
-                vertI++;
-                meshTools::writeOBJ(str, mesh_.points()[e[1]]);
-                vertI++;
-                str<< "l " << vertI-1 << ' ' << vertI << nl;
-            }
-        }
-
-
-        // Walk to fill faceRegion with faces that will be connected across
-        // edges that will be removed.
-
-        label startFacei = 0;
-
-        while (true)
-        {
-            // Find unset region.
-            for (; startFacei < mesh_.nFaces(); startFacei++)
-            {
-                if (faceRegion[startFacei] == -1 && !removedFace[startFacei])
-                {
-                    break;
-                }
-            }
-
-            if (startFacei == mesh_.nFaces())
-            {
-                break;
-            }
-
-            // Start walking face-edge-face, crossing edges that will get
-            // removed. Every thus connected region will get single region
-            // number.
-            label nRegion = changeFaceRegion
-            (
-                cellRegion,
-                removedFace,
-                nFacesPerEdge,
-                startFacei,
-                nRegions,
-                mesh_.faceEdges(startFacei, fe),
-                faceRegion
-            );
-
-            if (nRegion < 1)
-            {
-                FatalErrorInFunction << "Problem" << abort(FatalError);
-            }
-            else if (nRegion == 1)
-            {
-                // Reset face to be single region.
-                faceRegion[startFacei] = -2;
-            }
-            else
-            {
-                nRegions++;
-            }
-        }
-
-
-        // Check we're deciding the same on both sides. Since the regioning
-        // is done based on nFacesPerEdge (which is synced) this should
-        // indeed be the case.
-
-        labelList nbrFaceRegion(faceRegion);
-
-        syncTools::swapFaceList
-        (
-            mesh_,
-            nbrFaceRegion
-        );
-
-        labelList toNbrRegion(nRegions, -1);
-
-        for
-        (
-            label facei = mesh_.nInternalFaces();
-            facei < mesh_.nFaces();
-            facei++
-        )
-        {
-            // Get the neighbouring region.
-            label nbrRegion = nbrFaceRegion[facei];
-            label myRegion = faceRegion[facei];
-
-            if (myRegion <= -1 || nbrRegion <= -1)
-            {
-                if (nbrRegion != myRegion)
-                {
-                    FatalErrorInFunction
-                        << "Inconsistent face region across coupled patches."
-                        << endl
-                        << "This side has for facei:" << facei
-                        << " region:" << myRegion << endl
-                        << "The other side has region:" << nbrRegion
-                        << endl
-                        << "(region -1 means face is to be deleted)"
-                        << abort(FatalError);
-                }
-            }
-            else if (toNbrRegion[myRegion] == -1)
-            {
-                // First visit of region. Store correspondence.
-                toNbrRegion[myRegion] = nbrRegion;
-            }
-            else
-            {
-                // Second visit of this region.
-                if (toNbrRegion[myRegion] != nbrRegion)
-                {
-                    FatalErrorInFunction
-                        << "Inconsistent face region across coupled patches."
-                        << endl
-                        << "This side has for facei:" << facei
-                        << " region:" << myRegion
-                        << " with coupled neighbouring regions:"
-                        << toNbrRegion[myRegion] << " and "
-                        << nbrRegion
-                        << abort(FatalError);
-                }
-            }
-        }
-    }
-
-    //if (debug)
-    //{
-    //    labelListList regionToFaces(invertOneToMany(nRegions, faceRegion));
-    //
-    //    forAll(regionToFaces, regionI)
-    //    {
-    //        Pout<< "    " << regionI << " faces:" << regionToFaces[regionI]
-    //            << endl;
-    //    }
-    //}
-
-
-    // Points to be removed
-    // ~~~~~~~~~~~~~~~~~~~~
-
-    labelHashSet pointsToRemove(4*faceLabels.size());
-
-
-    // Per point count the number of unremoved edges. Store the ones that
-    // are only used by 2 unremoved edges.
-    {
-        // Usage of points by non-removed edges.
-        labelList nEdgesPerPoint(mesh_.nPoints());
-
-        const labelListList& pointEdges = mesh_.pointEdges();
-
-        forAll(pointEdges, pointi)
-        {
-            nEdgesPerPoint[pointi] = pointEdges[pointi].size();
-        }
-
-        for (const label edgei : edgesToRemove)
-        {
-            // Edge will get removed.
-            const edge& e = mesh_.edges()[edgei];
-
-            forAll(e, i)
-            {
-                nEdgesPerPoint[e[i]]--;
-            }
-        }
-
-        // Check locally (before synchronizing) for strangeness
-        forAll(nEdgesPerPoint, pointi)
-        {
-            if (nEdgesPerPoint[pointi] == 1)
-            {
-                FatalErrorInFunction
-                    << "Problem : point would get 1 edge using it only."
-                    << " pointi:" << pointi
-                    << " coord:" << mesh_.points()[pointi]
-                    << abort(FatalError);
-            }
-        }
-
-        // Synchronize point usage. This is to make sure that both sides remove
-        // (or not remove) a point on the boundary at the same time.
-        syncTools::syncPointList
-        (
-            mesh_,
-            nEdgesPerPoint,
-            maxEqOp<label>(),
-            labelMin
-        );
-
-        forAll(nEdgesPerPoint, pointi)
-        {
-            if (nEdgesPerPoint[pointi] == 0)
-            {
-                pointsToRemove.insert(pointi);
-            }
-            else if (nEdgesPerPoint[pointi] == 1)
-            {
-                // Already checked before
-            }
-            else if (nEdgesPerPoint[pointi] == 2)
-            {
-                // Remove point and merge edges.
-                pointsToRemove.insert(pointi);
-            }
-        }
-    }
-
-
-    if (debug)
-    {
-        OFstream str(mesh_.time().path()/"pointsToRemove.obj");
-        Pout<< "Dumping pointsToRemove to " << str.name() << endl;
-
-        for (const label pointi : pointsToRemove)
-        {
-            meshTools::writeOBJ(str, mesh_.points()[pointi]);
-        }
-    }
-
-
-    // All faces affected in any way
-    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-    // Get all faces affected in any way by removal of points/edges/faces/cells
-    boolList affectedFace
-    (
-        getFacesAffected
-        (
-            cellRegion,
-            cellRegionMaster,
-            faceLabels,
-            edgesToRemove,
-            pointsToRemove
-        )
-    );
-
-    //
-    // Now we know
-    // - faceLabels         : faces to remove (sync since no boundary faces)
-    // - cellRegion/Master  : cells to remove (sync since cells)
-    // - pointsToRemove     : points to remove (sync)
-    // - faceRegion         : connected face region of faces to be merged (sync)
-    // - affectedFace       : faces with points removed and/or owner/neighbour
-    //                        changed (non sync)
-
-
-    // Start modifying mesh and keep track of faces changed.
-
-
-    // Do all removals
-    // ~~~~~~~~~~~~~~~
-
-    // Remove split faces.
-    forAll(faceLabels, labelI)
-    {
-        label facei = faceLabels[labelI];
-
-        // Remove face if not yet uptodate (which is never; but want to be
-        // consistent with rest of face removals/modifications)
-        if (affectedFace[facei])
-        {
-            affectedFace[facei] = false;
-
-            meshMod.setAction(polyRemoveFace(facei, -1));
-        }
-    }
-
-
-    // Remove points.
-    for (const label pointi : pointsToRemove)
-    {
-        meshMod.setAction(polyRemovePoint(pointi, -1));
-    }
-
-
-    // Remove cells.
-    forAll(cellRegion, celli)
-    {
-        label region = cellRegion[celli];
-
-        if (region != -1 && (celli != cellRegionMaster[region]))
-        {
-            meshMod.setAction(polyRemoveCell(celli, cellRegionMaster[region]));
-        }
-    }
-
-
-
-    // Merge faces across edges to be merged
-    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-    // Invert faceRegion so we get region to faces.
-    {
-        labelListList regionToFaces(invertOneToMany(nRegions, faceRegion));
-
-        forAll(regionToFaces, regionI)
-        {
-            const labelList& rFaces = regionToFaces[regionI];
-
-            if (rFaces.size() <= 1)
-            {
-                FatalErrorInFunction
-                    << "Region:" << regionI
-                    << " contains only faces " << rFaces
-                    << abort(FatalError);
-            }
-
-            // rFaces[0] is master, rest gets removed.
-            mergeFaces
-            (
-                cellRegion,
-                cellRegionMaster,
-                pointsToRemove,
-                rFaces,
-                meshMod
-            );
-
-            forAll(rFaces, i)
-            {
-                affectedFace[rFaces[i]] = false;
-            }
-        }
-    }
-
-
-    // Remaining affected faces
-    // ~~~~~~~~~~~~~~~~~~~~~~~~
-
-    // Check if any remaining faces have not been updated for new slave/master
-    // or points removed.
-    forAll(affectedFace, facei)
-    {
-        if (affectedFace[facei])
-        {
-            affectedFace[facei] = false;
-
-            face f(filterFace(pointsToRemove, facei));
-
-            label own = mesh_.faceOwner()[facei];
-
-            if (cellRegion[own] != -1)
-            {
-                own = cellRegionMaster[cellRegion[own]];
-            }
-
-            label patchID, zoneID, zoneFlip;
-
-            getFaceInfo(facei, patchID, zoneID, zoneFlip);
-
-            label nei = -1;
-
-            if (mesh_.isInternalFace(facei))
-            {
-                nei = mesh_.faceNeighbour()[facei];
-
-                if (cellRegion[nei] != -1)
-                {
-                    nei = cellRegionMaster[cellRegion[nei]];
-                }
-            }
-
-//            if (debug)
-//            {
-//                Pout<< "Modifying " << facei
-//                    << " old verts:" << mesh_.faces()[facei]
-//                    << " for new verts:" << f
-//                    << " or for new owner " << own << " or for new nei "
-//                    << nei
-//                    << endl;
-//            }
-
-            modFace
-            (
-                f,                  // modified face
-                facei,              // label of face being modified
-                own,                // owner
-                nei,                // neighbour
-                false,              // face flip
-                patchID,            // patch for face
-                false,              // remove from zone
-                zoneID,             // zone for face
-                zoneFlip,           // face flip in zone
-
-                meshMod
-            );
-        }
-    }
-}
-
-
 // ************************************************************************* //
diff --git a/src/dynamicMesh/polyTopoChange/polyTopoChange/removeFaces.H b/src/dynamicMesh/polyTopoChange/polyTopoChange/removeFaces.H
index 20652eb4db..4844fc77ec 100644
--- a/src/dynamicMesh/polyTopoChange/polyTopoChange/removeFaces.H
+++ b/src/dynamicMesh/polyTopoChange/polyTopoChange/removeFaces.H
@@ -86,6 +86,19 @@ class removeFaces
             labelList& cellRegion
         ) const;
 
+        //- Changes region of connected set of faces. Returns number of changed
+        //  faces. For use with batch topo change
+        label changeFaceRegion
+        (
+            const labelList& cellRegion,
+            const boolList& removedFace,
+            const labelList& nFacesPerEdge,
+            const label faceI,
+            const label newRegion,
+
+            labelList& faceRegion
+        ) const;
+
         //- Changes region of connected set of faces
         label changeFaceRegion
         (
@@ -119,13 +132,15 @@ class removeFaces
             );
 
             //- Merge faceLabels into single face.
+            template<class TopoChangeEngine>
             void mergeFaces
             (
                 const labelList& cellRegion,
                 const labelList& cellRegionMaster,
                 const labelHashSet& pointsToRemove,
                 const labelList& faceLabels,
-                polyTopoChange& meshMod
+
+                TopoChangeEngine& meshMod
             ) const;
 
             //- Get patch, zone info for facei
@@ -141,6 +156,7 @@ class removeFaces
             face filterFace(const labelHashSet&, const label) const;
 
             //- Wrapper for meshMod.modifyFace. Reverses face if own>nei.
+            template<class TopoChangeEngine>
             void modFace
             (
                 const face& f,
@@ -153,11 +169,10 @@ class removeFaces
                 const label zoneID,
                 const bool zoneFlip,
 
-                polyTopoChange& meshMod
+                TopoChangeEngine& meshMod
             ) const;
 
 
-
         //- No copy construct
         removeFaces(const removeFaces&) = delete;
 
@@ -199,12 +214,15 @@ public:
 
 
         //- Play commands into polyTopoChange to remove faces.
+        template<class TopoChangeEngine>
         void setRefinement
         (
             const labelList& piercedFaces,
             const labelList& cellRegion,
-            const labelList& cellRegionMaster,
-            polyTopoChange&
+            // const labelList& pointRegionMaster,
+            labelList& cellRegionMaster,
+
+            TopoChangeEngine&
         ) const;
 
         //- Force recalculation of locally stored data on topological change
@@ -221,6 +239,10 @@ public:
 
 } // End namespace Foam
 
+#ifdef NoRepository
+#   include "removeFacesTemplates.C"
+#endif
+
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 #endif
diff --git a/src/dynamicMesh/polyTopoChange/polyTopoChange/removeFacesTemplates.C b/src/dynamicMesh/polyTopoChange/polyTopoChange/removeFacesTemplates.C
new file mode 100644
index 0000000000..856ab2fb41
--- /dev/null
+++ b/src/dynamicMesh/polyTopoChange/polyTopoChange/removeFacesTemplates.C
@@ -0,0 +1,1112 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | www.openfoam.com
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+    Copyright (C) 2008 Hrvoje Jasak
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "removeFaces.H"
+#include "polyMesh.H"
+#include "polyTopoChange.H"
+#include "meshTools.H"
+#include "polyModifyFace.H"
+#include "polyRemoveFace.H"
+#include "polyRemoveCell.H"
+#include "polyRemovePoint.H"
+#include "syncTools.H"
+#include "OFstream.H"
+#include "indirectPrimitivePatch.H"
+#include "Time.H"
+#include "faceSet.H"
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+template<class TopoChangeEngine>
+void Foam::removeFaces::mergeFaces
+(
+    const labelList& cellRegion,
+    const labelList& cellRegionMaster,
+    const labelHashSet& pointsToRemove,
+    const labelList& faceLabels,
+
+    TopoChangeEngine& ref
+) const
+{
+    // Construct addressing engine from faceLabels (in order of faceLabels as
+    // well)
+    indirectPrimitivePatch fp
+    (
+        IndirectList<face>
+        (
+            mesh_.faces(),
+            faceLabels
+        ),
+        mesh_.points()
+    );
+
+    // Get outside vertices (in local vertex numbering)
+    if (fp.edgeLoops().size() != 1)
+    {
+        writeOBJ(fp, mesh_.time().path()/"facesToBeMerged.obj");
+
+        FatalErrorInFunction
+            << "Cannot merge faces " << faceLabels
+            << " into single face since outside vertices " << fp.edgeLoops()
+            << " do not form single loop but form " << fp.edgeLoops().size()
+            << " loops instead." << abort(FatalError);
+    }
+
+    const labelList& edgeLoop = fp.edgeLoops()[0];
+
+    // Get outside vertices in order of one of the faces in faceLabels.
+    // (this becomes the master face)
+    // Find the first face that uses edgeLoop[0] and edgeLoop[1] as consecutive
+    // vertices.
+
+    label masterIndex = -1;
+    bool reverseLoop = false;
+
+    const labelList& pFaces = fp.pointFaces()[edgeLoop[0]];
+
+    // Find face among pFaces which uses edgeLoop[1]
+    forAll(pFaces, i)
+    {
+        const label& faceI = pFaces[i];
+
+        const face& f = fp.localFaces()[faceI];
+
+        label index1 = f.find(edgeLoop[1]);
+
+        if (index1 != -1)
+        {
+            // Check whether consecutive to edgeLoop[0]
+            label index0 = f.find(edgeLoop[0]);
+
+            if (index0 != -1)
+            {
+                if (index1 == f.fcIndex(index0))
+                {
+                    masterIndex = faceI;
+                    reverseLoop = false;
+                    break;
+                }
+                else if (index1 == f.rcIndex(index0))
+                {
+                    masterIndex = faceI;
+                    reverseLoop = true;
+                    break;
+                }
+            }
+        }
+    }
+
+    if (masterIndex == -1)
+    {
+        writeOBJ(fp, mesh_.time().path()/"facesToBeMerged.obj");
+
+        FatalErrorInFunction
+            << "Problem." << abort(FatalError);
+    }
+
+
+    // Modify the master face
+
+    // Modify first face
+    label faceI = faceLabels[masterIndex];
+
+    label own = mesh_.faceOwner()[faceI];
+
+    if (cellRegion[own] != -1)
+    {
+        own = cellRegionMaster[cellRegion[own]];
+    }
+
+    // Set face information
+    label patchID, zoneID, zoneFlip;
+    meshTools::setFaceInfo(mesh_, faceI, patchID, zoneID, zoneFlip);
+
+    label nei = -1;
+
+    if (mesh_.isInternalFace(faceI))
+    {
+        nei = mesh_.faceNeighbour()[faceI];
+
+        if (cellRegion[nei] != -1)
+        {
+            nei = cellRegionMaster[cellRegion[nei]];
+        }
+    }
+
+    // Collect non-removed face vertices
+    DynamicList<label> faceVerts(edgeLoop.size());
+
+    // Get mesh points
+    const labelList& meshPoints = fp.meshPoints();
+
+    forAll(edgeLoop, i)
+    {
+        const label& pointI = meshPoints[edgeLoop[i]];
+
+        if (pointsToRemove.found(pointI))
+        {
+            // Point should be removed, nothing to do
+        }
+        else
+        {
+            faceVerts.append(pointI);
+        }
+    }
+
+    face mergedFace;
+    mergedFace.transfer(faceVerts);
+    faceVerts.clear();
+
+    if (reverseLoop)
+    {
+        // Reverse the merged face
+        reverse(mergedFace);
+    }
+
+    // Finally modify merged face
+    modFace
+    (
+        mergedFace,         // modified face
+        faceI,              // label of face being modified
+        own,                // owner
+        nei,                // neighbour
+        false,              // face flip
+        patchID,            // patch for face
+        false,              // remove from zone
+        zoneID,             // zone for face
+        zoneFlip,           // face flip in zone
+
+        ref                 // topo change engine
+    );
+
+
+    // Remove all but master face
+    forAll(faceLabels, patchFaceI)
+    {
+        if (patchFaceI != masterIndex)
+        {
+            ref.setAction(polyRemoveFace(faceLabels[patchFaceI], faceI));
+        }
+    }
+}
+
+
+template<class TopoChangeEngine>
+void Foam::removeFaces::modFace
+(
+    const face& f,
+    const label masterFaceID,
+    const label own,
+    const label nei,
+    const bool flipFaceFlux,
+    const label newPatchID,
+    const bool removeFromZone,
+    const label zoneID,
+    const bool zoneFlip,
+
+    TopoChangeEngine& ref
+) const
+{
+    // Print info with deep debug level only
+    if (debug > 1)
+    {
+        if (mesh_.isInternalFace(masterFaceID))
+        {
+            Pout<< "Modifying face " << masterFaceID
+                << ", old verts: " << mesh_.faces()[masterFaceID]
+                << " for new verts:" << f
+                << nl
+                << " or for new owner " << own
+                << " (old owner: " << mesh_.faceOwner()[masterFaceID] << ")"
+                << nl
+                << " or for new nei " << nei << " (old neighbour: "
+                << mesh_.faceNeighbour()[masterFaceID] << ")"
+                << endl;
+        }
+    }
+
+    if ((nei == -1) || (own < nei))
+    {
+        // No need to revert the face, use original owner/neighbour
+        ref.setAction
+        (
+            polyModifyFace
+            (
+                f,              // modified face
+                masterFaceID,   // label of face being modified
+                own,            // owner
+                nei,            // neighbour
+                flipFaceFlux,   // face flip
+                newPatchID,     // patch for face
+                removeFromZone, // remove from zone
+                zoneID,         // zone for face
+                zoneFlip        // face flip in zone
+            )
+        );
+    }
+    else
+    {
+        // Revert the face and flip owner/neighbour
+        ref.setAction
+        (
+            polyModifyFace
+            (
+                f.reverseFace(),// modified face
+                masterFaceID,   // label of face being modified
+                nei,            // owner
+                own,            // neighbour
+                flipFaceFlux,   // face flip
+                newPatchID,     // patch for face
+                removeFromZone, // remove from zone
+                zoneID,         // zone for face
+                zoneFlip        // face flip in zone
+            )
+        );
+    }
+}
+
+
+template<class TopoChangeEngine>
+void Foam::removeFaces::setRefinement
+(
+    const labelList& faceLabels,
+    const labelList& cellRegion,
+    // const labelList& pointRegionMaster,
+    labelList& cellRegionMaster,
+
+    TopoChangeEngine& ref
+) const
+{
+    if (debug)
+    {
+        const faceSet facesToRemove
+        (
+            mesh_,
+            "facesToRemove",
+            labelHashSet(faceLabels)
+        );
+
+        Pout<< "Writing faces to remove to faceSet " << facesToRemove.name()
+            << endl;
+
+        facesToRemove.write();
+    }
+
+    // Get number of mesh faces
+    const label nFaces = mesh_.nFaces();
+
+    // Mark-up field for all faces that need to be removed
+    boolList removedFace(nFaces, false);
+    forAll(faceLabels, i)
+    {
+        const label& faceI = faceLabels[i];
+
+        if (!mesh_.isInternalFace(faceI))
+        {
+            FatalErrorInFunction
+                << "Face " << faceI << " is not an internal faces, therefore"
+                << " it cannot be removed. Check faceLabels argument."
+                << abort(FatalError);
+        }
+
+        removedFace[faceI] = true;
+    }
+
+
+    // PART 1: Collect edges to be removed
+    labelHashSet edgesToRemove(faceLabels.size());
+
+    // Region for each face:
+    // -1 = removed faces
+    // -2 = regions consisting of single face only
+    labelList faceRegion(nFaces, -1);
+
+    // Number of connected face regions
+    label nRegions = 0;
+
+    {
+        // Number of edges per non-removed face. See below regarding
+        // initialization
+        labelList nFacesPerEdge(mesh_.nEdges(), -1);
+
+        // Get necessary mesh data
+        const labelListList& meshFaceEdges = mesh_.faceEdges();
+        const labelListList& meshEdgeFaces = mesh_.edgeFaces();
+        const polyBoundaryMesh& patches = mesh_.boundaryMesh();
+
+        // Count usage of edges by non-removed faces.
+        forAll(faceLabels, i)
+        {
+            // Get face Index and edges of this face
+            const label& faceI = faceLabels[i];
+            const labelList& fEdges = meshFaceEdges[faceI];
+
+            forAll(fEdges, j)
+            {
+                // Get edge index
+                const label& edgeI = fEdges[j];
+
+                if (nFacesPerEdge[edgeI] == -1)
+                {
+                    // Number of faces for this edge is not set, set to size - 1
+                    nFacesPerEdge[edgeI] = meshEdgeFaces[edgeI].size() - 1;
+                }
+                else
+                {
+                    // Decrement number of faces for this edge
+                    --nFacesPerEdge[edgeI];
+                }
+            }
+        }
+
+        // Count usage for edges not on faces-to-be-removed.
+        // Note that this only needs to be done for possibly coupled edges
+        // so we could choose to loop only over boundary faces and use faceEdges
+        // of those.
+        forAll(meshEdgeFaces, edgeI)
+        {
+            if (nFacesPerEdge[edgeI] == -1)
+            {
+                // Edge not yet handled in loop above so is not used by any
+                // face to be removed. Get edge faces
+                const labelList& eFaces = meshEdgeFaces[edgeI];
+
+                // Number of faces for this edge is greater than 2, set size
+                if (eFaces.size() > 2)
+                {
+                    nFacesPerEdge[edgeI] = eFaces.size();
+                }
+                else if (eFaces.size() == 2)
+                {
+                    // nFacesPerEdge already -1 so do nothing
+                }
+                else
+                {
+                    // Error: edge has less than two faces. Print additional
+                    // information and issue an error
+
+                    // Get edge and all its cells
+                    const edge& e = mesh_.edges()[edgeI];
+                    const labelListList& ec = mesh_.edgeCells();
+
+                    // Get point cells
+                    const labelListList& pc = mesh_.pointCells();
+
+                    // Write mesh before termination
+                    mesh_.write();
+
+                    // Write data for debugging
+                    FatalErrorInFunction
+                        << "Problem : edge has too few face neighbours:"
+                        << eFaces << endl
+                        << "edge:" << edgeI
+                        << " vertices:" << e
+                        << " coords:" << mesh_.points()[e[0]]
+                        << mesh_.points()[e[1]]
+                        << endl
+                        << "Edge cells: " << ec[edgeI] << nl
+                        << "First point cells: " << pc[e[0]] << nl
+                        << "Second point cells: " << pc[e[1]] << nl
+                        << abort(FatalError);
+                }
+            }
+        }
+
+
+        if (debug)
+        {
+            // Write edges with two faces
+            OFstream str(mesh_.time().path()/"edgesWithTwoFaces.obj");
+
+            Pout<< "Writing edgesWithTwoFaces to " << str.name() << endl;
+
+            // Vertex counter
+            label vertI = 0;
+
+            // Get mesh points and edges
+            const pointField& meshPoints = mesh_.points();
+            const edgeList& meshEdges = mesh_.edges();
+
+            forAll(nFacesPerEdge, edgeI)
+            {
+                if (nFacesPerEdge[edgeI] == 2)
+                {
+                    // Edge will get removed, write data
+                    const edge& e = meshEdges[edgeI];
+
+                    meshTools::writeOBJ(str, meshPoints[e[0]]);
+                    ++vertI;
+                    meshTools::writeOBJ(str, meshPoints[e[1]]);
+                    ++vertI;
+                    str<< "l " << vertI - 1 << ' ' << vertI << nl;
+                }
+            }
+        }
+
+
+        // At this point, all affected edges have the number of unremoved faces
+
+        // Filter for edges inbetween two remaining boundary faces that
+        // make too big an angle.
+        forAll(nFacesPerEdge, edgeI)
+        {
+            if (nFacesPerEdge[edgeI] == 2)
+            {
+                // See if these are two boundary faces
+                label f0 = -1;
+                label f1 = -1;
+
+                const labelList& eFaces = meshEdgeFaces[edgeI];
+
+                forAll(eFaces, i)
+                {
+                    const label& faceI = eFaces[i];
+
+                    if (!removedFace[faceI] && !mesh_.isInternalFace(faceI))
+                    {
+                        if (f0 == -1)
+                        {
+                            f0 = faceI;
+                        }
+                        else
+                        {
+                            f1 = faceI;
+                            break;
+                        }
+                    }
+                }
+
+                if (f0 != -1 && f1 != -1)
+                {
+                    // Edge has two boundary faces remaining, see if they should
+                    // be merged.
+                    const label patch0 = patches.whichPatch(f0);
+                    const label patch1 = patches.whichPatch(f1);
+
+                    if (patch0 != patch1)
+                    {
+                        // Different patches. Do not merge edge.
+                        WarningIn("removeFaces::setRefinement")
+                            << "Not merging faces " << f0 << " and "
+                            << f1 << " across patch boundary edge " << edgeI
+                            << " since they are not on the same patch."
+                            << endl;
+
+                        // Set number of faces to 3 to preserve the face
+                        nFacesPerEdge[edgeI] = 3;
+                    }
+                    else if (minCos_ < 1 && minCos_ > -1)
+                    {
+                        const polyPatch& pp0 = patches[patch0];
+                        const vectorField& n0 = pp0.faceNormals();
+
+                        if
+                        (
+                            mag
+                            (
+                                n0[f0 - pp0.start()]
+                              & n0[f1 - pp0.start()]
+                            )
+                            < minCos_
+                        )
+                        {
+                            WarningIn("removeFaces::setRefinement")
+                                << "Not merging faces " << f0 << " and "
+                                << f1 << " across edge " << edgeI
+                                << " since the angle between them is too large."
+                                << endl;
+
+                            // Set number of faces to 3 to preserve the face
+                            nFacesPerEdge[edgeI] = 3;
+                        }
+                    }
+                }
+                else if (f0 != -1 || f1 != -1)
+                {
+                    const edge& e = mesh_.edges()[edgeI];
+
+                    // Only found one boundary face. Problem
+                    FatalErrorInFunction
+                        << "Problem : edge would have one boundary face"
+                        << " and one internal face using it." << endl
+                        << "Your remove pattern is probably incorrect." << endl
+                        << "edge:" << edgeI
+                        << " nFaces:" << nFacesPerEdge[edgeI]
+                        << " vertices:" << e
+                        << " coords:" << mesh_.points()[e[0]]
+                        << mesh_.points()[e[1]]
+                        << " face0:" << f0
+                        << " face1:" << f1
+                        << abort(FatalError);
+                }
+            }
+        }
+
+
+        // Check locally (before synchronizing) for strangeness
+        forAll(nFacesPerEdge, edgeI)
+        {
+            if (nFacesPerEdge[edgeI] == 1)
+            {
+                const edge& e = mesh_.edges()[edgeI];
+
+                FatalErrorInFunction
+                    << "Problem : edge would get 1 face using it only"
+                    << " edge:" << edgeI
+                    << " nFaces:" << nFacesPerEdge[edgeI]
+                    << " vertices:" << e
+                    << " coords:" << mesh_.points()[e[0]]
+                    << ' ' << mesh_.points()[e[1]]
+                    << abort(FatalError);
+            }
+
+            // Could check here for boundary edge with <= 1 faces remaining
+        }
+
+
+        // Synchronize edge usage. This is to make sure that both sides remove
+        // (or not remove) an edge on the boundary at the same time.
+        //
+        // Coupled edges (edge0, edge1 are opposite each other)
+        // a. edge not on face to be removed, edge has >= 3 faces
+        // b.  ,,                             edge has 2 faces
+        // c. edge has >= 3 remaining faces
+        // d. edge has 2 remaining faces (assume angle>minCos already handled)
+        //
+        // - a + a: do not remove edge
+        // - a + b: do not remove edge
+        // - a + c: do not remove edge
+        // - a + d: do not remove edge
+        //
+        // - b + b: do not remove edge
+        // - b + c: do not remove edge
+        // - b + d: remove edge
+        //
+        // - c + c: do not remove edge
+        // - c + d: do not remove edge
+        // - d + d: remove edge
+        //
+        //
+        // So code situation a. with >= 3
+        //                   b. with -1
+        //                   c. with >=3
+        //                   d. with 2
+        // then do max and check result.
+        //
+        // a+a : max(3,3) = 3. do not remove
+        // a+b : max(3,-1) = 3. do not remove
+        // a+c : max(3,3) = 3. do not remove
+        // a+d : max(3,2) = 3. do not remove
+        //
+        // b+b : max(-1,-1) = -1. do not remove
+        // b+c : max(-1,3) = 3. do not remove
+        // b+d : max(-1,2) = 2. remove
+        //
+        // c+c : max(3,3) = 3. do not remove
+        // c+d : max(3,2) = 3. do not remove
+        //
+        // d+d : max(2,2) = 2. remove
+
+        syncTools::syncEdgeList
+        (
+            mesh_,
+            nFacesPerEdge,
+            maxEqOp<label>(),
+            labelMin                // guaranteed to be overridden by maxEqOp
+        );
+
+        // Convert to labelHashSet
+        forAll(nFacesPerEdge, edgeI)
+        {
+            if (nFacesPerEdge[edgeI] == 0)
+            {
+                // 0: edge not used anymore.
+                edgesToRemove.insert(edgeI);
+            }
+            else if (nFacesPerEdge[edgeI] == 1)
+            {
+                // 1: illegal. Tested above.
+            }
+            else if (nFacesPerEdge[edgeI] == 2)
+            {
+                // 2: merge faces.
+                edgesToRemove.insert(edgeI);
+            }
+        }
+
+        if (debug)
+        {
+            // Write edges to remove
+            OFstream str(mesh_.time().path()/"edgesToRemove.obj");
+
+            Pout<< "Writing edgesToRemove to " << str.name() << endl;
+
+            // Vertex counter
+            label vertI = 0;
+
+            // Get mesh points
+            const pointField& meshPoints = mesh_.points();
+
+            forAllConstIter(labelHashSet, edgesToRemove, iter)
+            {
+                // Edge will get removed.
+                const edge& e = mesh_.edges()[iter.key()];
+
+                meshTools::writeOBJ(str, meshPoints[e[0]]);
+                ++vertI;
+                meshTools::writeOBJ(str, meshPoints[e[1]]);
+                ++vertI;
+                str<< "l " << vertI - 1 << ' ' << vertI << nl;
+            }
+        }
+
+        // Walk to fill faceRegion with faces that will be connected across
+        // edges that will be removed
+
+        label startFaceI = 0;
+
+        while (true)
+        {
+            // Find unset region
+            for (; startFaceI < nFaces; ++startFaceI)
+            {
+                if (faceRegion[startFaceI] == -1 && !removedFace[startFaceI])
+                {
+                    break;
+                }
+            }
+
+            if (startFaceI == nFaces)
+            {
+                break;
+            }
+
+            // Start walking face-edge-face, crossing edges that will get
+            // removed. Every thus connected region will get single region
+            // number.
+            label nRegion = changeFaceRegion
+            (
+                cellRegion,
+                removedFace,
+                nFacesPerEdge,
+                startFaceI,
+                nRegions,
+
+                faceRegion
+            );
+
+            if (nRegion < 1)
+            {
+                FatalErrorInFunction
+                    << "Problem with region number." << abort(FatalError);
+            }
+            else if (nRegion == 1)
+            {
+                // Reset face to be single region
+                faceRegion[startFaceI] = -2;
+            }
+            else
+            {
+                ++nRegions;
+            }
+        }
+
+        // Check we're deciding the same on both sides. Since the regioning
+        // is done based on nFacesPerEdge (which is synced) this should
+        // indeed be the case.
+
+        // Create a copy of face region list and swap it
+        labelList nbrFaceRegion(faceRegion);
+        syncTools::swapFaceList
+        (
+            mesh_,
+            nbrFaceRegion
+        );
+
+        // Store data from neighbouring region
+        labelList toNbrRegion(nRegions, -1);
+
+        // Get number of internal faces
+        const label nInternalFaces = mesh_.nInternalFaces();
+
+        for
+        (
+            label faceI = nInternalFaces;
+            faceI < nFaces;
+            ++faceI
+        )
+        {
+            // Get the neighbouring region
+            const label& nbrRegion = nbrFaceRegion[faceI];
+            const label& myRegion = faceRegion[faceI];
+
+            if (myRegion <= -1 || nbrRegion <= -1)
+            {
+                if (nbrRegion != myRegion)
+                {
+                    FatalErrorInFunction
+                        << "Inconsistent face region across coupled patches."
+                        << endl
+                        << "This side has for faceI:" << faceI
+                        << " region:" << myRegion << endl
+                        << "The other side has region:" << nbrRegion
+                        << endl
+                        << "(region - 1 means face is to be deleted)"
+                        << abort(FatalError);
+                }
+            }
+            else if (toNbrRegion[myRegion] == -1)
+            {
+                // First visit of region. Store correspondence.
+                toNbrRegion[myRegion] = nbrRegion;
+            }
+            else
+            {
+                // Second visit of this region
+                if (toNbrRegion[myRegion] != nbrRegion)
+                {
+                    FatalErrorInFunction
+                        << "Inconsistent face region across coupled patches."
+                        << endl
+                        << "This side has for faceI:" << faceI
+                        << " region:" << myRegion
+                        << " with coupled neighbouring regions:"
+                        << toNbrRegion[myRegion] << " and "
+                        << nbrRegion
+                        << abort(FatalError);
+                }
+            }
+        }
+    } // End memory management
+
+
+    // PART 2: Collect points to remove
+
+    // Create a hash set of points to remove, assuming that each face has 4
+    // points to prevent excessive resizing
+    labelHashSet pointsToRemove(4*faceLabels.size());
+
+    // Memory management
+    {
+        // For each point, count the number of edges that will be kept
+        // (unremoved edges). Store the ones that are only used by exactly two
+        // unremoved edges.
+
+        // Get necessary mesh data
+        const label nPoints = mesh_.nPoints();
+        const labelListList& meshPointEdges = mesh_.pointEdges();
+        const edgeList& meshEdges = mesh_.edges();
+
+        // List containing number of nonremoved edges for each point
+        labelList nEdgesPerPoint(nPoints);
+
+        // Initialise to number of edges per point
+        forAll(meshPointEdges, pointI)
+        {
+            nEdgesPerPoint[pointI] = meshPointEdges[pointI].size();
+        }
+
+        // Loop through edges to remove
+        forAllConstIter(labelHashSet, edgesToRemove, iter)
+        {
+            // Get edge to be removed
+            const edge& e = meshEdges[iter.key()];
+
+            // Loop through both points of the edge and decrement the counter of
+            // unremoved edges per point
+            forAll(e, i)
+            {
+                --nEdgesPerPoint[e[i]];
+            }
+        }
+
+        // Check locally (before synchronizing) for strangeness
+        forAll(nEdgesPerPoint, pointI)
+        {
+            if (nEdgesPerPoint[pointI] == 1)
+            {
+                FatalErrorInFunction
+                    << "Problem : point would get 1 edge using it only."
+                    << " pointI:" << pointI
+                    << " coord:" << mesh_.points()[pointI]
+                    << abort(FatalError);
+            }
+        }
+
+        // Synchronize point usage. This is to make sure that both sides remove
+        // (or don't remove) a point at the boundary at the same time.
+        syncTools::syncPointList
+        (
+            mesh_,
+            nEdgesPerPoint,
+            maxEqOp<label>(),
+            labelMin
+        );
+
+        forAll(nEdgesPerPoint, pointI)
+        {
+            if (nEdgesPerPoint[pointI] == 0)
+            {
+                pointsToRemove.insert(pointI);
+            }
+            else if (nEdgesPerPoint[pointI] == 1)
+            {
+                // Already checked before
+            }
+            else if (nEdgesPerPoint[pointI] == 2)
+            {
+                // Remove point and merge edges
+                pointsToRemove.insert(pointI);
+            }
+        }
+    }
+
+
+    if (debug)
+    {
+        // Write points to remove
+        OFstream str(mesh_.time().path()/"pointsToRemove.obj");
+        Pout<< "Writing pointsToRemove to " << str.name() << endl;
+
+        // Get mesh points
+        const pointField& meshPoints = mesh_.points();
+
+        forAllConstIter(labelHashSet, pointsToRemove, iter)
+        {
+            meshTools::writeOBJ(str, meshPoints[iter.key()]);
+        }
+    }
+
+
+    // PART 3: Collect all faces affected in any way by removal of points,
+    // edges, faces and cells
+
+    // Note: return type of affectedFaces is Xfer<boolList>, so there is no
+    // unnecessary copying
+    boolList affectedFace
+    (
+        getFacesAffected
+        (
+            cellRegion,
+            cellRegionMaster,
+            faceLabels,
+            edgesToRemove,
+            pointsToRemove
+        )
+    );
+
+    // Now the data is complete:
+    // - faceLabels         : faces to remove (sync since no boundary faces)
+    // - cellRegion/Master  : cells to remove (sync since cells)
+    // - pointsToRemove     : points to remove (sync)
+    // - faceRegion         : connected face region of faces to be merged (sync)
+    // - affectedFace       : faces with points removed and/or owner/neighbour
+    //                        changed (non sync)
+    // We can start inserting mesh modifier instructions and keep track of
+    // changed faces.
+
+
+    // PART 4: Do all removals first
+
+    // Remove split faces
+    forAll(faceLabels, labelI)
+    {
+        // Get face index
+        const label& faceI = faceLabels[labelI];
+
+        // Remove face if not yet uptodate (which can't happen here; but want to
+        // be consistent with rest of face removals/modifications)
+        if (affectedFace[faceI])
+        {
+            // Mark face as unaffected
+            affectedFace[faceI] = false;
+
+            // Insert face removal instruction into topo change engine
+            ref.setAction(polyRemoveFace(faceI, -1));
+        }
+    }
+
+    // Remove points
+    forAllConstIter(labelHashSet, pointsToRemove, iter)
+    {
+        // Get point index
+        const label& pointI = iter.key();
+
+        // Inser point removal instruction into topo change engine
+        ref.setAction(polyRemovePoint(pointI, -1));
+    }
+
+/*
+    OpenFOAM does not support adequate mapping.
+    HJ, 20/Jul/2023
+    // Add master cells for correct mapping
+    forAll (cellRegionMaster, regionI)
+    {
+        // Note: it is legal to have cellRegionMaster = -1 if the region
+        // has been created and them marged into another region.
+        // Such masters will also have pointRegionMaster = -1 and should
+        // be ignored.  HJ, 6/Sep/2019
+
+        // Additionally protect for old directTopoChangers which do not
+        // identify points for mapping.  Non-existent pointRegionMaster
+        // is rejected
+        if (cellRegionMaster[regionI] > -1 && pointRegionMaster[regionI] > -1)
+        {
+            // Add master cell from master point for correct mapping
+            cellRegionMaster[regionI] =
+                ref.setAction
+                (
+                    polyAddCell
+                    (
+                        pointRegionMaster[regionI], // masterPointID
+                        -1,                         // masterEdgeID
+                        -1,                         // masterFaceID
+                        -1,                         // masterCellID
+                        mesh_.cellZones().whichZone(cellRegionMaster[regionI])
+                    )
+                );
+        }
+    }
+    */
+
+    // Remove cells
+    forAll(cellRegion, cellI)
+    {
+        label region = cellRegion[cellI];
+
+        // Old check is acceptable: for mapping from point, the cellRegionMaster
+        // has been replaced in polyAddPoint
+        // HJ, 6/Sep/2019
+        if (region != -1 && (cellI != cellRegionMaster[region]))
+        {
+            ref.setAction(polyRemoveCell(cellI, cellRegionMaster[region]));
+        }
+    }
+
+
+    // PART 5: Merge faces across edges to be merged
+
+    // Memory management
+    {
+        // Invert faceRegion so we get region to faces
+        labelListList regionToFaces(invertOneToMany(nRegions, faceRegion));
+
+        // Loop through regions
+        forAll(regionToFaces, regionI)
+        {
+            // Get region faces
+            const labelList& rFaces = regionToFaces[regionI];
+
+            if (rFaces.size() <= 1)
+            {
+                FatalErrorInFunction
+                    << "Region: " << regionI
+                    << " contains only these faces: " << rFaces
+                    << abort(FatalError);
+            }
+
+            // rFaces[0] is master, rest get removed
+            mergeFaces
+            (
+                cellRegion,
+                cellRegionMaster,
+                pointsToRemove,
+                rFaces,
+                ref
+            );
+
+            // Mark region faces as visited (non affected anymore)
+            forAll(rFaces, i)
+            {
+                affectedFace[rFaces[i]] = false;
+            }
+        }
+    }
+
+
+    // PART 6: Remaining affected faces
+
+    // Get necessary mesh data
+    const labelList& owner = mesh_.faceOwner();
+    const labelList& neighbour = mesh_.faceNeighbour();
+
+
+    // Check any remaining faces that have not been updated for either new
+    // owner/neighbour or points removed
+    forAll(affectedFace, faceI)
+    {
+        if (affectedFace[faceI])
+        {
+            // Mark face as unaffected
+            affectedFace[faceI] = false;
+
+            // Get filtered face: without points that will be removed
+            const face f(filterFace(pointsToRemove, faceI));
+
+            // Get owner of the face and change it
+            label own = owner[faceI];
+            if (cellRegion[own] != -1)
+            {
+                own = cellRegionMaster[cellRegion[own]];
+            }
+
+            // Set face information
+            label patchID, zoneID, zoneFlip;
+            meshTools::setFaceInfo(mesh_, faceI, patchID, zoneID, zoneFlip);
+
+            // Get neighbour of the face and change it
+            label nei = -1;
+            if (mesh_.isInternalFace(faceI))
+            {
+                nei = neighbour[faceI];
+                if (cellRegion[nei] != -1)
+                {
+                    nei = cellRegionMaster[cellRegion[nei]];
+                }
+            }
+
+            // Finally modify the face
+            modFace
+            (
+                f,                  // modified face
+                faceI,              // label of face being modified
+                own,                // owner
+                nei,                // neighbour
+                false,              // face flip
+                patchID,            // patch for face
+                false,              // remove from zone
+                zoneID,             // zone for face
+                zoneFlip,           // face flip in zone
+
+                ref                 // topo change engine
+            );
+        }
+    }
+}
+
+
+// ************************************************************************* //
diff --git a/src/dynamicMesh/polyTopoChange/polyTopoChanger/polyTopoChanger.C b/src/dynamicMesh/polyTopoChange/polyTopoChanger/polyTopoChanger.C
index 022de1d90d..5006832f60 100644
--- a/src/dynamicMesh/polyTopoChange/polyTopoChanger/polyTopoChanger.C
+++ b/src/dynamicMesh/polyTopoChange/polyTopoChanger/polyTopoChanger.C
@@ -28,7 +28,9 @@ License
 
 #include "polyTopoChanger.H"
 #include "polyMesh.H"
+#include "mapPolyMesh.H"
 #include "polyTopoChange.H"
+#include "batchPolyTopoChange.H"
 #include "Time.H"
 #include "PtrListOps.H"
 
@@ -192,14 +194,14 @@ bool Foam::polyTopoChanger::changeTopology() const
 }
 
 
-Foam::autoPtr<Foam::polyTopoChange>
+Foam::autoPtr<Foam::batchPolyTopoChange>
 Foam::polyTopoChanger::topoChangeRequest() const
 {
     // Collect changes from all modifiers
     const PtrList<polyMeshModifier>& topoChanges = *this;
 
-    auto ptr = autoPtr<polyTopoChange>::New(mesh());
-    polyTopoChange& ref = ptr.ref();
+    auto ptr = autoPtr<batchPolyTopoChange>::New(mesh());
+    batchPolyTopoChange& ref = ptr.ref();
 
     forAll(topoChanges, morphI)
     {
@@ -245,35 +247,35 @@ void Foam::polyTopoChanger::update(const mapPolyMesh& m)
 }
 
 
-Foam::autoPtr<Foam::mapPolyMesh> Foam::polyTopoChanger::changeMesh
-(
-    const bool inflate,
-    const bool syncParallel,
-    const bool orderCells,
-    const bool orderPoints
-)
-{
-    if (changeTopology())
-    {
-        autoPtr<polyTopoChange> ref = topoChangeRequest();
+// Foam::autoPtr<Foam::mapPolyMesh> Foam::polyTopoChanger::changeMesh
+// (
+//     const bool inflate,
+//     const bool syncParallel,
+//     const bool orderCells,
+//     const bool orderPoints
+// )
+// {
+//     if (changeTopology())
+//     {
+//         autoPtr<polyTopoChange> ref = topoChangeRequest();
 
-        autoPtr<mapPolyMesh> topoChangeMap = ref().changeMesh
-        (
-            mesh_,
-            inflate,
-            syncParallel,
-            orderCells,
-            orderPoints
-        );
+//         autoPtr<mapPolyMesh> topoChangeMap = ref().changeMesh
+//         (
+//             mesh_,
+//             inflate,
+//             syncParallel,
+//             orderCells,
+//             orderPoints
+//         );
 
-        update(topoChangeMap());
-        mesh_.updateMesh(topoChangeMap());
-        return topoChangeMap;
-    }
+//         update(topoChangeMap());
+//         mesh_.updateMesh(topoChangeMap());
+//         return topoChangeMap;
+//     }
 
-    mesh_.topoChanging(false);
-    return nullptr;
-}
+//     mesh_.topoChanging(false);
+//     return nullptr;
+// }
 
 
 void Foam::polyTopoChanger::addTopologyModifiers
@@ -326,6 +328,13 @@ Foam::label Foam::polyTopoChanger::findModifierID
 }
 
 
+Foam::label Foam::polyTopoChanger::morphIndex() const
+{
+    return morphIndex_;
+}
+
+
+// writeData member function required by regIOobject
 bool Foam::polyTopoChanger::writeData(Ostream& os) const
 {
     os << *this;
diff --git a/src/dynamicMesh/polyTopoChange/polyTopoChanger/polyTopoChanger.H b/src/dynamicMesh/polyTopoChange/polyTopoChanger/polyTopoChanger.H
index 8ed5efdda1..be9d14c989 100644
--- a/src/dynamicMesh/polyTopoChange/polyTopoChanger/polyTopoChanger.H
+++ b/src/dynamicMesh/polyTopoChange/polyTopoChanger/polyTopoChanger.H
@@ -51,6 +51,7 @@ namespace Foam
 class polyMesh;
 class mapPolyMesh;
 class polyBoundaryMesh;
+class polyTopoChange;
 class polyTopoChanger;
 
 Ostream& operator<<(Ostream&, const polyTopoChanger&);
@@ -65,6 +66,12 @@ class polyTopoChanger
     public PtrList<polyMeshModifier>,
     public regIOobject
 {
+    // Private data
+
+        //- Current time index for mesh morph
+        label morphIndex_;
+
+
     // Private Member Functions
 
         //- Read if IOobject flags set, set modifiers. Return true if read.
@@ -84,6 +91,33 @@ protected:
         //- Reference to mesh
         polyMesh& mesh_;
 
+
+    // Protected Member Functions
+
+        // Topology changes
+
+            //- Rotate a face nShift positions in anticlockwise direction
+            static face rotateFace(const face& f, const label nShift);
+
+            //- Determine ordering of faces in coupled patches.
+            //  Calculate mapping to shuffle faces inside coupled patches and
+            //  rotation to make 0th vertex in faces align.
+            static bool reorderCoupledPatches
+            (
+                const polyBoundaryMesh& boundary,
+                const labelList& patchStarts,
+                const labelList& patchSizes,
+                const faceList& faces,
+                const pointField& points,
+                labelList& faceMap,
+                labelList& rotation
+            );
+
+            //- Sync communications required for couple patch reordering when
+            //  there is no local topological change
+            void syncCoupledPatches();
+
+
 public:
 
     //- Runtime type information
@@ -125,19 +159,27 @@ public:
         bool changeTopology() const;
 
         //- Return topology change request
-        autoPtr<polyTopoChange> topoChangeRequest() const;
+        autoPtr<batchPolyTopoChange> topoChangeRequest() const;
 
         //- Modify point motion
         void modifyMotionPoints(pointField&) const;
 
-        autoPtr<mapPolyMesh> changeMesh
+        // autoPtr<mapPolyMesh> changeMesh
+        // (
+        //     const bool inflate,
+        //     const bool syncParallel = true,
+        //     const bool orderCells = false,
+        //     const bool orderPoints = false
+        // );
+
+        static autoPtr<mapPolyMesh> changeMesh
         (
-            const bool inflate,
-            const bool syncParallel = true,
-            const bool orderCells = false,
-            const bool orderPoints = false
+            polyMesh&,
+            const batchPolyTopoChange&
         );
 
+        autoPtr<mapPolyMesh> changeMesh();
+
         //- Force recalculation of locally stored data on topological change
         void update(const mapPolyMesh& m);
 
@@ -147,6 +189,9 @@ public:
         //- Find modifier given a name
         label findModifierID(const word& modName) const;
 
+        //- Return morph index
+        label morphIndex() const;
+
 
         //- writeData member function required by regIOobject
         bool writeData(Ostream&) const;
diff --git a/src/dynamicMesh/polyTopoChange/polyTopoChanger/polyTopoChangerChangeMesh.C b/src/dynamicMesh/polyTopoChange/polyTopoChanger/polyTopoChangerChangeMesh.C
new file mode 100644
index 0000000000..30f2bdce0e
--- /dev/null
+++ b/src/dynamicMesh/polyTopoChange/polyTopoChanger/polyTopoChangerChangeMesh.C
@@ -0,0 +1,2431 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | www.openfoam.com
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+    Copyright (C) 2002 Hrvoje Jasak
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "polyTopoChanger.H"
+#include "polyMesh.H"
+#include "Time.H"
+#include "faceZone.H"
+#include "batchPolyTopoChange.H"
+#include "pointField.H"
+#include "polyAddPoint.H"
+#include "polyModifyPoint.H"
+#include "polyAddFace.H"
+#include "polyModifyFace.H"
+#include "Map.H"
+#include "DynamicList.H"
+#include "primitiveMesh.H"
+#include "mapPolyMesh.H"
+#include "objectMap.H"
+#include "globalMeshData.H"
+#include "ListOps.H"
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+Foam::face Foam::polyTopoChanger::rotateFace
+(
+    const face& f,
+    const label nPos
+)
+{
+    face newF(f.size());
+
+    forAll (f, fp)
+    {
+        label fp1 = (fp + nPos) % f.size();
+
+        if (fp1 < 0)
+        {
+            fp1 += f.size();
+        }
+
+        newF[fp1] = f[fp];
+    }
+
+    return newF;
+}
+
+
+// Determine ordering of faces in coupled patches.
+// Calculate mapping to shuffle faces inside coupled patches and
+// rotation to make 0th vertex in faces align.
+bool Foam::polyTopoChanger::reorderCoupledPatches
+(
+    const polyBoundaryMesh& boundary,
+    const labelList& patchStarts,
+    const labelList& patchSizes,
+    const faceList& faces,
+    const pointField& points,
+
+    labelList& faceMap,
+    labelList& rotation
+)
+{
+    // Mapping for faces (old to new). Extends over all mesh faces for
+    // convenience (could be just the external faces)
+
+    // faceMap = identity(faces.size());
+    // faceMap for boundary faces will be forwarded to polyPatch::order(...)
+    for (label i = 0; i < patchStarts[0]; i++)
+    {
+        faceMap[i] = i;
+    }
+
+
+    // Rotation on new faces.
+    rotation.setSize(faces.size());
+    rotation = 0;
+
+    PstreamBuffers pBufs(Pstream::commsTypes::nonBlocking);
+
+    // Send ordering
+    forAll (boundary, patchI)
+    {
+        boundary[patchI].initOrder
+        (
+            pBufs,
+            primitivePatch
+            (
+                SubList<face>
+                (
+                    faces,
+                    patchSizes[patchI],
+                    patchStarts[patchI]
+                ),
+                points
+            )
+        );
+    }
+
+    pBufs.finishedSends();
+
+    // Receive and calculate ordering
+
+    bool anyChanged = false;
+
+    forAll (boundary, patchI)
+    {
+        labelList patchFaceMap(patchSizes[patchI], -1);
+        labelList patchFaceRotation(patchSizes[patchI], 0);
+
+        // Forward boundary faceMap to polyPatch::order(...)
+        label start = patchStarts[patchI];
+        forAll (patchFaceMap, patchFaceI)
+        {
+            patchFaceMap[patchFaceI] =
+                faceMap[patchFaceI + start];
+
+            faceMap[patchFaceI + start] = patchFaceI + start;
+        }
+
+        bool changed = boundary[patchI].order
+        (
+            pBufs,
+            primitivePatch
+            (
+                SubList<face>
+                (
+                    faces,
+                    patchSizes[patchI],
+                    patchStarts[patchI]
+                ),
+                points
+            ),
+            patchFaceMap,
+            patchFaceRotation
+        );
+
+        if (changed)
+        {
+            // Merge patch face reordering into mesh face reordering table
+            label start = patchStarts[patchI];
+
+            forAll (patchFaceMap, patchFaceI)
+            {
+                if (patchFaceMap[patchFaceI] == -1)
+                {
+                    SeriousErrorInFunction
+                        << "Could not determine correspondence for coupled "
+                        << " face " << start+patchFaceI
+                        << " on patch " << patchI << endl
+                        << "Continuing with incorrect ordering." << endl;
+                    return false;
+                }
+
+                faceMap[patchFaceI + start] = start + patchFaceMap[patchFaceI];
+            }
+
+            forAll (patchFaceRotation, patchFaceI)
+            {
+                rotation[patchFaceI + start] = patchFaceRotation[patchFaceI];
+            }
+
+            anyChanged = true;
+        }
+    }
+
+    return anyChanged;
+}
+
+
+// void Foam::polyTopoChanger::syncCoupledPatches()
+// {
+//     // Sync communications required for couple patch reordering when
+//     // there is no local topological change
+
+//     // Send ordering
+//     const polyPatchList& boundary = mesh_.boundaryMesh();
+
+//     PstreamBuffers pBufs(Pstream::commsTypes::nonBlocking);
+
+//     forAll (boundary, patchI)
+//     {
+//         boundary[patchI].initOrder(pBufs, boundary[patchI]);
+//     }
+
+//     pBufs.finishedSends();
+
+//     // Receive ordering
+
+//     // Note: HJ using syncOrder
+//     forAll (boundary, patchI)
+//     {
+//         boundary[patchI].order();
+//     }
+// }
+
+
+Foam::autoPtr<Foam::mapPolyMesh> Foam::polyTopoChanger::changeMesh
+(
+    polyMesh& mesh,
+    const batchPolyTopoChange& ref
+)
+{
+    // Create a new list of points
+    // Note.  Modified points are only influenced in the mesh motion stage
+    if (debug)
+    {
+        Pout<< "polyTopoChanger::changeMesh" << nl
+            << '(' << nl
+            << "    const batchPolyTopoChange& ref" << nl
+            << ") : started executing topological change." << nl << endl;
+
+        // Check topological change request for consistency and report
+        // the statistics of the refinement request
+        if (ref.check())
+        {
+            FatalErrorInFunction
+                << "Inconsistent topological change request."
+                << abort(FatalError);
+        }
+    }
+
+    const pointField& points = mesh.points();
+    const faceList& faces = mesh.faces();
+    const cellList& cells = mesh.cells();
+    const polyBoundaryMesh& boundary = mesh.boundaryMesh();
+    pointZoneMesh& pointZones = mesh.pointZones();
+    faceZoneMesh& faceZones = mesh.faceZones();
+    cellZoneMesh& cellZones = mesh.cellZones();
+
+
+    // Grab old live mesh sizes
+    const label nOldPoints = mesh.nPoints();
+    const label nOldFaces = mesh.nFaces();
+    const label nOldCells = mesh.nCells();
+
+    // Keep the old patch start labels
+    labelList oldPatchStarts(boundary.size());
+    forAll (boundary, patchi)
+    {
+        oldPatchStarts[patchi] = boundary[patchi].start();
+    }
+
+    pointField newPointsZeroVol(points.size() + ref.pointBalance());
+    pointField newPointsMotion(points.size() + ref.pointBalance());
+
+    // renumberPoints contains the new point label for every old
+    // and added point
+    labelList renumberPoints(points.size() + ref.addedPoints().size(), -1);
+
+    // pointMap contains the old point label or the master point label
+    // for all new points
+    labelList pointMap(points.size() + ref.addedPoints().size(), -1);
+    label nNewPoints = 0;
+
+    const labelHashSet& removedPoints = ref.removedPoints();
+    const labelHashSet& removedFaces = ref.removedFaces();
+    const labelHashSet& removedCells = ref.removedCells();
+
+    // Grab the untouched live points
+    for (label pointI = 0; pointI < nOldPoints; pointI++)
+    {
+        // Check if the point has been removed; if not add it to the list
+        if (!removedPoints.found(pointI))
+        {
+            // Grab a point
+            newPointsZeroVol[nNewPoints] = points[pointI];
+            newPointsMotion[nNewPoints] = points[pointI];
+
+            // Grab addressing
+            renumberPoints[pointI] = nNewPoints;
+            pointMap[nNewPoints] = pointI;
+
+            nNewPoints++;
+        }
+    }
+
+    label debugPointCounter = 0;
+
+    if (debug)
+    {
+        Pout<< "Added untouched points. Point count = "
+            << nNewPoints << endl;
+
+        debugPointCounter = nNewPoints;
+    }
+
+    // Change the modified points in two passes: first points
+    // supporting the cells and then auxiliary points
+    const DynamicList<polyModifyPoint>& mp = ref.modifiedPoints();
+
+    forAll (mp, mpI)
+    {
+        if (mp[mpI].inCell())
+        {
+            // Grab a point
+            newPointsZeroVol[nNewPoints] = points[mp[mpI].pointID()];
+            newPointsMotion[nNewPoints] = mp[mpI].newPoint();
+
+            // Grab addressing
+            renumberPoints[mp[mpI].pointID()] = nNewPoints;
+            pointMap[nNewPoints] = mp[mpI].pointID();
+            nNewPoints++;
+        }
+    }
+
+    if (debug)
+    {
+        Pout<< "Added live points: modified = "
+            << nNewPoints - debugPointCounter;
+
+        debugPointCounter = nNewPoints;
+    }
+
+    // Add the new points in two passes: first points supporting the cells
+    // and then auxiliary points
+    const DynamicList<polyAddPoint>& ap = ref.addedPoints();
+
+    // Follow the location in the renumbering list
+    const label np = points.size();
+
+    // Grab points supporting cells
+    forAll (ap, apI)
+    {
+        if (ap[apI].inCell())
+        {
+            // Grab a point
+            if (ap[apI].appended())
+            {
+                // Point appended directly; no motion
+                newPointsZeroVol[nNewPoints] = ap[apI].newPoint();
+            }
+            else
+            {
+                // Point added on top of another point
+                newPointsZeroVol[nNewPoints] = points[ap[apI].masterPointID()];
+            }
+
+            newPointsMotion[nNewPoints] = ap[apI].newPoint();
+
+            // Grab addressing
+            renumberPoints[np + apI] = nNewPoints;
+            pointMap[nNewPoints] = ap[apI].masterPointID();
+            nNewPoints++;
+        }
+    }
+
+    if (debug)
+    {
+        Pout<< " added = " << nNewPoints - debugPointCounter
+            << ".  Point count = "
+            << nNewPoints << endl;
+
+        debugPointCounter = nNewPoints;
+    }
+
+    // Grab the untouched auxiliary points
+    for (label pointI = nOldPoints; pointI < points.size(); pointI++)
+    {
+        // Check if the point has been removed; if not add it to the list
+        if (!removedPoints.found(pointI))
+        {
+            // Grab a point
+            newPointsZeroVol[nNewPoints] = points[pointI];
+            newPointsMotion[nNewPoints] = points[pointI];
+
+            // Grab addressing
+            renumberPoints[pointI] = nNewPoints;
+            pointMap[nNewPoints] = pointI;
+
+            nNewPoints++;
+        }
+    }
+
+    if (debug)
+    {
+        Pout<< "Added retired points: untouched = "
+            << nNewPoints - debugPointCounter;
+
+        debugPointCounter = nNewPoints;
+    }
+
+    // Grab auxiliary points
+    forAll (mp, mpI)
+    {
+        if (!mp[mpI].inCell())
+        {
+            // Grab a point
+            newPointsZeroVol[nNewPoints] = points[mp[mpI].pointID()];
+            newPointsMotion[nNewPoints] = mp[mpI].newPoint();
+
+            // Grab addressing
+            renumberPoints[mp[mpI].pointID()] = nNewPoints;
+            pointMap[nNewPoints] = mp[mpI].pointID();
+            nNewPoints++;
+        }
+    }
+
+    if (debug)
+    {
+        Pout<< " modified = "
+            << nNewPoints - debugPointCounter;
+
+        debugPointCounter = nNewPoints;
+    }
+
+    forAll (ap, apI)
+    {
+        if (!ap[apI].inCell())
+        {
+            // Grab a point
+            if (ap[apI].appended())
+            {
+                // Point appended directly; no motion
+                newPointsZeroVol[nNewPoints] = ap[apI].newPoint();
+            }
+            else
+            {
+                // Point added on top of another point
+                newPointsZeroVol[nNewPoints] = points[ap[apI].masterPointID()];
+            }
+
+            newPointsMotion[nNewPoints] = ap[apI].newPoint();
+
+            // Grab addressing
+            renumberPoints[np + apI] = nNewPoints;
+            pointMap[nNewPoints] = ap[apI].masterPointID();
+            nNewPoints++;
+        }
+    }
+
+    if (debug)
+    {
+        Pout<< " added = " << nNewPoints - debugPointCounter
+            << ".  Point count = "
+            << nNewPoints << endl;
+
+        debugPointCounter = nNewPoints;
+    }
+
+    // Reset the size of point map
+    pointMap.setSize(nNewPoints);
+
+    if (debug)
+    {
+        Pout<< "Added all points.  Final point count = "
+            << nNewPoints << nl << endl;
+    }
+
+    // Create a new list of faces
+    // Algorithm: go throught the list of original faces and
+    // distribute them to the cells, skipping the ones marked as
+    // removed.  Then add the new and modified faces to the cells.
+    // Renumber the faces using the point renumbering map.
+    // Gather the internal faces by looping through the cell list and
+    // collecting faces
+
+    const labelList& allOwn = mesh.faceOwner();
+    const labelList& allNei = mesh.faceNeighbour();
+
+    List<DynamicList<face> >
+        cf(cells.size() + ref.addedCells().size());
+
+    List<DynamicList<label> >
+        cfLabels(cells.size() + ref.addedCells().size());
+
+    // Insert untouched internal faces
+    for (label faceI = 0; faceI < mesh.nInternalFaces(); faceI++)
+    {
+        if (!removedFaces.found(faceI))
+        {
+            cf[allOwn[faceI]].append(faces[faceI]);
+            cfLabels[allOwn[faceI]].append(faceI);
+
+            cf[allNei[faceI]].append(faces[faceI]);
+            cfLabels[allNei[faceI]].append(faceI);
+        }
+    }
+
+    if (debug)
+    {
+        Pout<< "Inserted untouched faces into cells" << endl;
+    }
+
+    // Add the modified internal faces
+    const DynamicList<polyModifyFace>& mf = ref.modifiedFaces();
+
+    forAll (mf, mfI)
+    {
+        if (!mf[mfI].isInPatch() && !mf[mfI].onlyInZone())
+        {
+            if (debug)
+            {
+                // Check if the internal face is defined properly
+                if
+                (
+                    min(mf[mfI].owner(), mf[mfI].neighbour()) < 0
+                 || max(mf[mfI].owner(), mf[mfI].neighbour()) >= cf.size()
+                )
+                {
+                    FatalErrorInFunction
+                        << "Invalid modified face " << mf[mfI].faceID()
+                        << ".  Declared as internal but owner or neighbour "
+                        << "are invalid." << nl
+                        << "Owner: " << mf[mfI].owner()
+                        << " Neighbour: " << mf[mfI].neighbour()
+                        << " Max number of cells: " << cf.size()
+                        << abort(FatalError);
+                }
+            }
+
+            // Grab face and face label
+            cf[mf[mfI].owner()].append(mf[mfI].newFace());
+            cfLabels[mf[mfI].owner()].append(mf[mfI].faceID());
+
+            cf[mf[mfI].neighbour()].append(mf[mfI].newFace());
+            cfLabels[mf[mfI].neighbour()].append(mf[mfI].faceID());
+        }
+    }
+
+    if (debug)
+    {
+        Pout<< "Inserted modified faces into cells" << endl;
+    }
+
+    // Add the new faces
+    const DynamicList<polyAddFace>& af = ref.addedFaces();
+
+    forAll (af, afI)
+    {
+        if (!af[afI].isInPatch() && !af[afI].onlyInZone())
+        {
+            if (debug)
+            {
+                // Check if the internal face is defined properly
+                if
+                (
+                    min(af[afI].owner(), af[afI].neighbour()) < 0
+                 || max(af[afI].owner(), af[afI].neighbour()) >= cf.size()
+                )
+                {
+                    FatalErrorInFunction
+                        << "Invalid added face " << faces.size() + afI
+                        << ".  Declared as internal but owner or neighbour "
+                        << "are invalid." << nl
+                        << "Owner: " << af[afI].owner()
+                        << " Neighbour: " << af[afI].neighbour()
+                        << " Max number of cells: " << cf.size()
+                        << abort(FatalError);
+                }
+            }
+
+            // Grab face and face label
+            cf[af[afI].owner()].append(af[afI].newFace());
+            cfLabels[af[afI].owner()].append(faces.size() + afI);
+
+            cf[af[afI].neighbour()].append(af[afI].newFace());
+            cfLabels[af[afI].neighbour()].append(faces.size() + afI);
+        }
+    }
+
+    if (debug)
+    {
+        Pout<< "Inserted added faces into cells" << endl;
+    }
+
+    // All internal faces now exist on the list.  Create the new face
+    // list using upper triangular search
+
+    // Create partial point-cell addressing
+    List<DynamicList<label, primitiveMesh::facesPerPoint_> > PointCells
+    (
+        points.size() + ref.addedPoints().size()
+    );
+
+    boolListList usedCellFaces(cf.size());
+
+    forAll (cf, cellI)
+    {
+        if (!removedCells.found(cellI))
+        {
+            const DynamicList<face>&
+                curFaces = cf[cellI];
+
+            // Resize and reset the cell-face list at the same time
+            usedCellFaces[cellI].setSize(curFaces.size());
+            usedCellFaces[cellI] = false;
+
+            // Add the cell as a neighbour to all of the points
+            // of all of its faces
+            forAll (curFaces, faceI)
+            {
+                const labelList& curFacePoints = curFaces[faceI];
+
+                forAll (curFacePoints, pointI)
+                {
+                    bool found = false;
+
+                    DynamicList<label, primitiveMesh::facesPerPoint_>&
+                        curPointCells = PointCells[curFacePoints[pointI]];
+
+                    forAll (curPointCells, i)
+                    {
+                        if (curPointCells[i] == cellI)
+                        {
+                            // Cell already a neighbour of this point
+                            found = true;
+                            break;
+                        }
+                    }
+
+                    if (!found)
+                    {
+                        curPointCells.append(cellI);
+                    }
+                }
+            }
+        }
+        else
+        {
+            // Check if the removed cell has got any faces
+            if (cf[cellI].size() > 0)
+            {
+                FatalErrorInFunction
+                    << "Cell " << cellI << " is marked as removed but still "
+                    << "has faces.  Cell faces: " << cf[cellI]
+                    << abort(FatalError);
+            }
+        }
+    }
+
+    List<DynamicList<label> >
+        newCellFaces(cf.size());
+
+    faceList newFaces(faces.size() + ref.faceBalance());
+
+    // renumberFaces contains a new face label for every old and added face
+    labelList renumberFaces(faces.size() + ref.addedFaces().size(), -1);
+
+    // faceMap contains the old face label for every new face.  For
+    // inserted faces, the label will be -1.  Use with care!
+    labelList faceMap(faces.size() + ref.faceBalance(), -1);
+    label nNewFaces = 0;
+
+    // Create ordered list of faces
+
+    // Note:
+    // 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.
+    // Watch out.  Subtly different from createPolyMesh!
+
+    forAll (cf, cellI)
+    {
+        const DynamicList<face>&
+            curFaces = cf[cellI];
+        labelList neiCells(curFaces.size(), -1);
+        label nNeighbours = 0;
+
+        // For all faces ...
+        forAll (curFaces, faceI)
+        {
+            // Skip faces that have already been matched
+            if (usedCellFaces[cellI][faceI]) continue;
+
+            bool found = false;
+
+            const face& curFace = curFaces[faceI];
+
+            // Get the list of labels
+            const labelList& curPoints = curFace;
+
+            // For all points
+            forAll (curPoints, pointI)
+            {
+                // Get the list of cells sharing this point
+                const DynamicList<label, primitiveMesh::facesPerPoint_>&
+                    curNeighbours = PointCells[curPoints[pointI]];
+
+                // For all neighbours
+                forAll (curNeighbours, neiI)
+                {
+                    label curNei = curNeighbours[neiI];
+
+                    // Reject neighbours with the lower label
+                    if (curNei > cellI)
+                    {
+                        // Get the list of search faces
+                        const DynamicList<face>&
+                            searchFaces = cf[curNei];
+
+                        forAll (searchFaces, neiFaceI)
+                        {
+                            if (searchFaces[neiFaceI] == curFace)
+                            {
+                                // Match!!
+                                found = true;
+
+                                // Record the neighbour cell and face
+                                neiCells[faceI] = curNei;
+                                nNeighbours++;
+
+                                break;
+                            }
+                        }
+                        if (found) break;
+                    }
+                    if (found) break;
+                }
+                if (found) break;
+            } // End of current points
+        } // End of current faces
+
+        // Add the 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 = cf.size();
+
+            forAll (neiCells, ncI)
+            {
+                if (neiCells[ncI] > -1 && neiCells[ncI] < minNei)
+                {
+                    nextNei = ncI;
+                    minNei = neiCells[ncI];
+                }
+            }
+
+            if (nextNei > -1)
+            {
+                // Add the face to the list of faces
+                newFaces[nNewFaces] = curFaces[nextNei];
+
+                // Set cell-face and cell-neighbour-face to current face label
+                newCellFaces[cellI].append(nNewFaces);
+                newCellFaces[minNei].append(nNewFaces);
+
+                // Grab the renumbering index
+                renumberFaces[cfLabels[cellI][nextNei]] = nNewFaces;
+
+                if (cfLabels[cellI][nextNei] < faces.size())
+                {
+                    faceMap[nNewFaces] =
+                        cfLabels[cellI][nextNei];
+                }
+
+                // Stop the neighbour from being used again
+                neiCells[nextNei] = -1;
+
+                // Increment number of faces counter
+                nNewFaces++;
+            }
+            else
+            {
+                FatalErrorInFunction
+                    << "Error in internal face insertion"
+                    << abort(FatalError);
+            }
+        }
+    }
+
+    label debugFaceCounter = 0;
+
+    if (debug)
+    {
+        Pout<< "Added internal faces.  Face count = "
+            << nNewFaces << endl;
+
+        debugFaceCounter = nNewFaces;
+    }
+
+    // Redistribute modified and newly added patch faces per patch
+    List<DynamicList<label, 10> > patchModifiedFaces(boundary.size());
+    List<DynamicList<label, 10> > patchAddedFaces(boundary.size());
+
+    forAll (mf, mfI)
+    {
+        if (mf[mfI].isInPatch())
+        {
+            patchModifiedFaces[mf[mfI].patchID()].append(mfI);
+        }
+    }
+
+    forAll (af, afI)
+    {
+        if (af[afI].isInPatch())
+        {
+            patchAddedFaces[af[afI].patchID()].append(afI);
+        }
+    }
+
+    // For every patch add original patch faces which have not been removed
+    // Remember the new patch starts and sizes
+    labelList patchSizes(boundary.size(), 0);
+    labelList patchStarts(boundary.size(), -1);
+
+    forAll (boundary, patchI)
+    {
+        // Add original patch faces
+        const label curSize = boundary[patchI].size();
+        const label curStart = boundary[patchI].start();
+
+        const UList<face>& curFaces = boundary[patchI];
+
+        // Grab patch start
+        patchStarts[patchI] = nNewFaces;
+
+        for (label faceI = curStart; faceI < curStart + curSize; faceI++)
+        {
+            if (!removedFaces.found(faceI))
+            {
+                newFaces[nNewFaces] = curFaces[faceI - curStart];
+                renumberFaces[faceI] = nNewFaces;
+
+                faceMap[nNewFaces] = faceI;
+
+                // Add the face to the owner cell
+                if (allOwn[faceI] >= 0)
+                {
+                    newCellFaces[allOwn[faceI]].append(nNewFaces);
+                }
+
+                nNewFaces++;
+            }
+        }
+
+        if (debug)
+        {
+            Pout<< "Patch " << patchI
+                << ": added faces: untouched = "
+                << nNewFaces - debugFaceCounter;
+
+            debugFaceCounter = nNewFaces;
+        }
+
+        // Add new faces belonging to this patch
+        const DynamicList<label, 10>& modPatchFaces =
+            patchModifiedFaces[patchI];
+
+        forAll (modPatchFaces, faceI)
+        {
+            newFaces[nNewFaces] = mf[modPatchFaces[faceI]].newFace();
+            renumberFaces[mf[modPatchFaces[faceI]].faceID()] = nNewFaces;
+
+            faceMap[nNewFaces]= mf[modPatchFaces[faceI]].faceID();
+
+            label newOwner = mf[modPatchFaces[faceI]].owner();
+
+            // Add the face to the owner cell
+            if (newOwner >= 0)
+            {
+                newCellFaces[newOwner].append(nNewFaces);
+            }
+
+            nNewFaces++;
+        }
+
+        if (debug)
+        {
+            Pout<< " modified = " << nNewFaces - debugFaceCounter;
+
+            debugFaceCounter = nNewFaces;
+        }
+
+        // Add new faces belonging to this patch
+        const DynamicList<label, 10>& newPatchFaces = patchAddedFaces[patchI];
+
+        forAll (newPatchFaces, faceI)
+        {
+            newFaces[nNewFaces] = af[newPatchFaces[faceI]].newFace();
+            renumberFaces[faces.size() + newPatchFaces[faceI]] = nNewFaces;
+
+            label newOwner = af[newPatchFaces[faceI]].owner();
+
+            // Add the face to the owner cell
+            if (newOwner >= 0)
+            {
+                newCellFaces[newOwner].append(nNewFaces);
+            }
+
+            nNewFaces++;
+        }
+
+        if (debug)
+        {
+            Pout<< " added = " << nNewFaces - debugFaceCounter
+                << ".  Face count = " << nNewFaces << endl;
+
+            debugFaceCounter = nNewFaces;
+        }
+
+        // Grab the new patch size
+        patchSizes[patchI] = nNewFaces - patchStarts[patchI];
+    }
+
+    // Add freely-standing faces to the back of the list
+
+    // Freely-standing faces from the original mesh
+    // Insert untouched internal faces
+    for (label faceI = nOldFaces; faceI < faces.size(); faceI++)
+    {
+        if (!removedFaces.found(faceI))
+        {
+            newFaces[nNewFaces] = faces[faceI];
+            renumberFaces[faceI] = nNewFaces;
+            faceMap[nNewFaces]= faceI;
+            nNewFaces++;
+        }
+    }
+
+    if (debug)
+    {
+        Pout<< "Added zone-only faces: untouched = "
+            << nNewFaces - debugFaceCounter;
+
+            debugFaceCounter = nNewFaces;
+    }
+
+    // Freely-standing modified faces
+    forAll (mf, mfI)
+    {
+        if (mf[mfI].onlyInZone())
+        {
+            newFaces[nNewFaces] = mf[mfI].newFace();
+            renumberFaces[mf[mfI].faceID()] = nNewFaces;
+            faceMap[nNewFaces]= mf[mfI].faceID();
+            nNewFaces++;
+        }
+    }
+
+    if (debug)
+    {
+        Pout<< " modified = " << nNewFaces - debugFaceCounter;
+
+            debugFaceCounter = nNewFaces;
+    }
+
+    // Freely-standing added faces
+    forAll (af, afI)
+    {
+        if (af[afI].onlyInZone())
+        {
+            newFaces[nNewFaces] = af[afI].newFace();
+            renumberFaces[faces.size() + afI] = nNewFaces;
+            nNewFaces++;
+        }
+    }
+
+    if (debug)
+    {
+        Pout<< " added = " << nNewFaces - debugFaceCounter
+            << ".  Final face count = "
+            << nNewFaces << nl << endl;
+
+            debugFaceCounter = nNewFaces;
+    }
+
+    if (debug)
+    {
+        if (nNewFaces != faces.size() + ref.faceBalance())
+        {
+            FatalErrorInFunction
+                << "Error in face insertion.  Number of inserted faces: "
+                << nNewFaces << ".  Expected "
+                << faces.size() + ref.faceBalance()
+                << " faces."
+                << abort(FatalError);
+        }
+    }
+
+    // Face list and cell faces completed.
+    // Renumber the faces using the point renumber list
+    forAll (newFaces, faceI)
+    {
+        face oldFace = newFaces[faceI];
+        face& renumberedFace = newFaces[faceI];
+
+        forAll (renumberedFace, pointI)
+        {
+            renumberedFace[pointI] = renumberPoints[oldFace[pointI]];
+        }
+
+        if (debug)
+        {
+            // Check if the face has been mapped correctly
+            if
+            (
+                renumberedFace.size() == 0
+             || min(renumberedFace) < 0
+             || max(renumberedFace) >= newPointsZeroVol.size()
+            )
+            {
+                FatalErrorInFunction
+                    << "Face " << faceI << " in the new mesh is not "
+                    << "mapped correctly." << nl
+                    << "It uses a removed or a non-existing vertex or "
+                    << "has been skipped." << nl
+                    << "Face before mapping: " << oldFace << " with points "
+                    << oldFace.points(newPointsZeroVol) << nl
+                    << mesh.points().size() << nl
+                    << "Face after mapping: " << renumberedFace << nl
+                    << "Max new vertex index: "
+                    << newPointsZeroVol.size() - 1 << "." << nl
+                    << "Are there extra faces in the face list that do not "
+                    << "belong to a face zone?  This is not allowed."
+                    << abort(FatalError);
+            }
+        }
+    }
+
+
+
+    // Coupled face ordering
+    // ~~~~~~~~~~~~~~~~~~~~~
+
+    // Update faceMap for added faces which have master face
+    forAll (af, afI)
+    {
+        if (af[afI].isFaceMaster()) // Face mastered by another face
+        {
+            faceMap[renumberFaces[faces.size() + afI]] =
+                af[afI].masterFaceID();
+        }
+    }
+
+    // At this point we have
+    // - newFaces: faces in upper-triangular and patch order
+    // - patchSizes, patchStarts: valid on newFaces
+    // - newCellFaces: consistent cell-face addressing
+    // - renumberFaces: from old to new face
+    // - faceMap: from new to old face
+
+    // Calculate face map and rotation so coupled faces are matched
+    // correctly
+
+    // labelList localFaceMap(newFaces.size());
+    // Forward faceMap to polyPatch::order() (needed by cohesivePolyPatch)
+    labelList localFaceMap = faceMap;
+    labelList rotation(newFaces.size(), 0);
+
+    bool anyChange = reorderCoupledPatches
+    (
+        boundary,
+        patchStarts,
+        patchSizes,
+        newFaces,           // new faces
+        newPointsMotion,    // points after inflation
+
+        localFaceMap,       // for every face the new position
+        rotation            // amount face needs to be rotated
+    );
+
+    // Reorder everything referring to faces (not patchStarts/sizes since
+    // faces only get reshuffled inside patches)
+    if (anyChange)
+    {
+        // Reorder newFaces according to localFaceMap
+        inplaceReorder(localFaceMap, newFaces);
+
+        // Renumber newCellFaces so they refer to the new face ordering
+        forAll (newCellFaces, cellI)
+        {
+            DynamicList<label>& cFaces = newCellFaces[cellI];
+
+            cFaces.shrink();
+            inplaceRenumber(localFaceMap, cFaces);
+        }
+
+        // Renumber renumberFaces so they refer to the new face ordering
+        inplaceRenumber(localFaceMap, renumberFaces);
+
+        // Reorder faceMap
+        inplaceReorder(localFaceMap, faceMap);
+
+        // Rotate faces (rotation is already in new face indices).
+        forAll (rotation, faceI)
+        {
+            label rotate = rotation[faceI];
+
+            if (rotate != 0)
+            {
+                newFaces[faceI] = rotateFace(newFaces[faceI], rotate);
+            }
+        }
+    }
+
+
+    // Build the face-from maps
+
+    List<objectMap> faceFromPoint(af.size());
+    label nFaceFromPoint = 0;
+    List<objectMap> faceFromEdge(af.size());
+    label nFaceFromEdge = 0;
+
+    forAll (af, afI)
+    {
+        if (af[afI].isPointMaster())
+        {
+            if (debug)
+            {
+                // Check that the master point index is in range
+                if
+                (
+                    af[afI].masterPointID() < 0
+                 || af[afI].masterPointID() >= mesh.nPoints()
+                )
+                {
+                    FatalErrorInFunction
+                        << "Master point for face " << faces.size() + afI
+                        << " is out of range: " << af[afI].masterPointID()
+                        << ".\n  Number of valid master points: "
+                        << mesh.nPoints()
+                        << abort(FatalError);
+                }
+            }
+
+            if (af[afI].isInPatch())
+            {
+                // Grab faces neighbouring the point which are in the
+                // same patch as the newly added face.
+                const labelList& pf =
+                   mesh.pointFaces()[af[afI].masterPointID()];
+
+                labelList facesAroundPoint(pf.size());
+                label nfap = 0;
+
+                forAll (pf, pfI)
+                {
+                    label wp = boundary.whichPatch(pf[pfI]);
+                    if (wp == af[afI].patchID())
+                    {
+                        facesAroundPoint[nfap] = pf[pfI];
+                        nfap++;
+                    }
+                }
+
+                if (debug)
+                {
+                    if (nfap == 0)
+                    {
+                        FatalErrorInFunction
+                            << "No patch face neighbours found for added "
+                            << "patch face " << afI
+                            << ".\nThere are no faces from patch "
+                            << af[afI].patchID()
+                            << " around the master point "
+                            << af[afI].masterPointID()
+                            << ".\n Bad choice of master point: "
+                            << "error in mesh mapping."
+                            << abort(FatalError);
+                    }
+                }
+
+                facesAroundPoint.setSize(nfap);
+
+                faceFromPoint[nFaceFromPoint] =
+                    objectMap
+                    (
+                        renumberFaces[faces.size() + afI],
+                        facesAroundPoint
+                    );
+
+                nFaceFromPoint++;
+            }
+            else
+            {
+                // Grab internal faces around the point
+                const labelList& pf =
+                    mesh.pointFaces()[af[afI].masterPointID()];
+
+                labelList facesAroundPoint(pf.size());
+                label nfap = 0;
+
+                forAll (pf, pfI)
+                {
+                    if (mesh.isInternalFace(pf[pfI]))
+                    {
+                        facesAroundPoint[nfap] = pf[pfI];
+                        nfap++;
+                    }
+                }
+
+                if (debug)
+                {
+                    if (nfap == 0 && mesh.nInternalFaces() > 0)
+                    {
+                        FatalErrorInFunction
+                            << "No face neighbours found for added "
+                            << "internal face " << afI
+                            << ".\nThere are no internal faces "
+                            << "around the master point "
+                            << af[afI].masterPointID()
+                            << ".\n Bad choice of master point: "
+                            << "error in mesh mapping."
+                            << abort(FatalError);
+                    }
+                }
+
+                facesAroundPoint.setSize(nfap);
+
+                faceFromPoint[nFaceFromPoint] =
+                    objectMap
+                    (
+                        renumberFaces[faces.size() + afI],
+                        facesAroundPoint
+                    );
+
+                nFaceFromPoint++;
+            }
+        }
+        else if (af[afI].isEdgeMaster())
+        {
+            if (debug)
+            {
+                // Check that the master edge index is in range
+                if
+                (
+                    af[afI].masterEdgeID() < 0
+                 || af[afI].masterEdgeID() >= mesh.nEdges()
+                )
+                {
+                    FatalErrorInFunction
+                        << "Master edge for face " << faces.size() + afI
+                        << " is out of range: " << af[afI].masterEdgeID()
+                        << ".\n  Number of valid master edges: "
+                        << mesh.nEdges()
+                        << abort(FatalError);
+                }
+            }
+
+            if (af[afI].isInPatch())
+            {
+                // Grab faces neighbouring the point which are in the
+                // same patch as the newly added face Note: the
+                // addressing is now into the patch instead of the
+                // global face list
+                const labelList& pe =
+                   mesh.edgeFaces()[af[afI].masterEdgeID()];
+
+                labelList facesAroundEdge(pe.size());
+                label nfae = 0;
+
+                forAll (pe, peI)
+                {
+                    label wp = boundary.whichPatch(pe[peI]);
+                    if (wp == af[afI].patchID())
+                    {
+                        facesAroundEdge[nfae] = pe[peI];
+                        nfae++;
+                    }
+                }
+
+                if (debug)
+                {
+                    if (nfae == 0)
+                    {
+                        FatalErrorInFunction
+                            << "No patch face neighbours found for added "
+                            << "patch face " << afI
+                            << ".  Error in mesh mapping."
+                            << abort(FatalError);
+                    }
+                }
+
+                facesAroundEdge.setSize(nfae);
+
+                faceFromEdge[nFaceFromEdge] =
+                    objectMap
+                    (
+                        renumberFaces[faces.size() + afI],
+                        facesAroundEdge
+                    );
+
+                nFaceFromEdge++;
+            }
+            else
+            {
+                // Grab internal faces around the edge
+                const labelList& pe =
+                    mesh.edgeFaces()[af[afI].masterEdgeID()];
+
+                labelList facesAroundEdge(pe.size());
+                label nfae = 0;
+
+                forAll (pe, peI)
+                {
+                    if (mesh.isInternalFace(pe[peI]))
+                    {
+                        facesAroundEdge[nfae] = pe[peI];
+                        nfae++;
+                    }
+                }
+
+                if (debug)
+                {
+                    if (nfae == 0)
+                    {
+                        FatalErrorInFunction
+                            << "No patch face neighbours found for added "
+                            << "internal face " << afI
+                            << ".  Error in mesh mapping."
+                            << abort(FatalError);
+                    }
+                }
+
+                facesAroundEdge.setSize(nfae);
+
+                faceFromEdge[nFaceFromEdge] =
+                    objectMap
+                    (
+                        renumberFaces[faces.size() + afI],
+                        facesAroundEdge
+                    );
+
+                nFaceFromEdge++;
+            }
+        }
+        else if (af[afI].isFaceMaster()) // Face mastered by another face
+        {
+            faceMap[renumberFaces[faces.size() + afI]] =
+                af[afI].masterFaceID();
+        }
+    }
+
+    // Reset the size of face mapping lists
+    faceFromPoint.setSize(nFaceFromPoint);
+    faceFromEdge.setSize(nFaceFromEdge);
+
+    // Check face maps
+    if (debug)
+    {
+        boolList mappedFaces(faceMap.size(), false);
+
+        // Fill in faces mapped from the face map
+        forAll (faceMap, faceI)
+        {
+            if (faceMap[faceI] >= 0)
+            {
+                mappedFaces[faceI] = true;
+            }
+        }
+
+        // Fill in point and edge maps
+        forAll (faceFromPoint, faceI)
+        {
+            mappedFaces[faceFromPoint[faceI].index()] = true;
+        }
+
+        forAll (faceFromEdge, faceI)
+        {
+            mappedFaces[faceFromEdge[faceI].index()] = true;
+        }
+
+        // Check if all the faces are mapped
+        label nUnmappedFaces = 0;
+
+        forAll (mappedFaces, faceI)
+        {
+            if (!mappedFaces[faceI])
+            {
+                nUnmappedFaces++;
+            }
+        }
+
+        if (nUnmappedFaces > 0)
+        {
+            Pout<< "void polyMesh::morph(const batchPolyTopoChange& ref) : "
+                << "unmapped data for " << nUnmappedFaces << " faces." << endl;
+        }
+    }
+
+    labelHashSet flipFaceFlux(mf.size() + af.size());
+
+    // Build the flip flux map
+    forAll (mf, mfI)
+    {
+        if (mf[mfI].flipFaceFlux())
+        {
+            flipFaceFlux.insert(renumberFaces[mf[mfI].faceID()]);
+        }
+    }
+
+    forAll (af, afI)
+    {
+        if (af[afI].isFaceMaster() && af[afI].flipFaceFlux())
+        {
+            flipFaceFlux.insert(renumberFaces[faces.size() + afI]);
+        }
+    }
+
+    // Renumber the cells
+
+    cellList newCells(cells.size() + ref.cellBalance());
+
+    // renumberCells holds the new cell label for all old and added cells
+    labelList renumberCells(cells.size() + ref.addedCells().size(), -1);
+
+    // cellMap holds the old cell label for every preserved cell
+    labelList cellMap(cells.size() + ref.cellBalance(), -1);
+
+    label nNewCells = 0;
+
+    forAll (newCellFaces, cellI)
+    {
+        if (!removedCells.found(cellI))
+        {
+            if (newCellFaces[cellI].size() < 4)
+            {
+                FatalErrorInFunction
+                    << "Cell " << cellI << " has got three or less faces "
+                    << "and has not been removed.  "
+                    << "This is not a valid cell." << endl
+                    << "Cell faces: " << newCellFaces[cellI]
+                    << abort(FatalError);
+            }
+
+            // Make a cell
+            newCells[nNewCells].transfer(newCellFaces[cellI].shrink());
+
+            renumberCells[cellI] = nNewCells;
+
+            // Add the cell into cell map if it is preserved
+            if (cellI < nOldCells)
+            {
+                cellMap[nNewCells] = cellI;
+            }
+
+            nNewCells++;
+        }
+    }
+
+    if (debug)
+    {
+        Pout<< "Added all cells.  Final cell count = "
+            << nNewCells << nl << endl;
+    }
+
+    label nPreservedCells = cells.size() - removedCells.size();
+
+    // Build the cell-from maps
+
+    const DynamicList<polyAddCell>& ac = ref.addedCells();
+    const DynamicList<polyModifyCell>& mc = ref.modifiedCells();
+
+    List<objectMap> cellFromPoint(ac.size());
+    label nCellFromPoint = 0;
+
+    List<objectMap> cellFromEdge(ac.size());
+    label nCellFromEdge = 0;
+
+    List<objectMap> cellFromFace(ac.size());
+    label nCellFromFace = 0;
+
+    forAll (ac, acI)
+    {
+        if (ac[acI].isPointMaster())
+        {
+            if (debug)
+            {
+                // Check that the master point index is in range
+                if
+                (
+                    ac[acI].masterPointID() < 0
+                 || ac[acI].masterPointID() >= mesh.nPoints()
+                )
+                {
+                    FatalErrorInFunction
+                        << "Master point for cell " << nPreservedCells + acI
+                        << " is out of range: " << ac[acI].masterPointID()
+                        << ".\n  Number of valid master points: "
+                        << mesh.nPoints()
+                        << abort(FatalError);
+                }
+            }
+
+            cellFromPoint[nCellFromPoint] =
+                objectMap
+                (
+                    nPreservedCells + acI,
+                    mesh.pointCells()[ac[acI].masterPointID()]
+                );
+
+            nCellFromPoint++;
+        }
+        else if (ac[acI].isEdgeMaster())
+        {
+            if (debug)
+            {
+                // Check that the master edge index is in range
+                if
+                (
+                    ac[acI].masterEdgeID() < 0
+                 || ac[acI].masterEdgeID() >= mesh.nEdges()
+                )
+                {
+                    FatalErrorInFunction
+                        << "Master edge for cell " << nPreservedCells + acI
+                        << " is out of range: " << ac[acI].masterEdgeID()
+                        << ".\n  Number of valid master edges: "
+                        << mesh.nEdges()
+                        << abort(FatalError);
+                }
+            }
+
+            cellFromEdge[nCellFromEdge] =
+                objectMap
+                (
+                    nPreservedCells + acI,
+                    mesh.edgeCells()[ac[acI].masterEdgeID()]
+                );
+
+            nCellFromEdge++;
+        }
+        else if (ac[acI].isFaceMaster()) // Cell mastered by a face
+        {
+            if (debug)
+            {
+                // Check that the master face index is in range
+                if
+                (
+                    ac[acI].masterFaceID() < 0
+                 || ac[acI].masterFaceID() >= mesh.nFaces()
+                )
+                {
+                    FatalErrorInFunction
+                        << "Master face for cell " << nPreservedCells + acI
+                        << " is out of range: " << ac[acI].masterFaceID()
+                        << ".\n  Number of valid master faces: "
+                        << mesh.nFaces()
+                        << abort(FatalError);
+                }
+            }
+
+            labelList cellsAroundFace(2, label(-1));
+
+            cellsAroundFace[0] = mesh.faceOwner()[ac[acI].masterFaceID()];
+
+            if (mesh.isInternalFace(ac[acI].masterFaceID()))
+            {
+                cellsAroundFace[1] =
+                    mesh.faceNeighbour()[ac[acI].masterFaceID()];
+            }
+            else
+            {
+                cellsAroundFace.setSize(1);
+            }
+
+            cellFromFace[nCellFromFace] =
+                objectMap
+                (
+                    nPreservedCells + acI,
+                    cellsAroundFace
+                );
+
+            nCellFromFace++;
+        }
+        else if (ac[acI].isCellMaster()) // Cell mastered by another cell
+        {
+            cellMap[renumberCells[cells.size() + acI]] =
+                ac[acI].masterCellID();
+        }
+    }
+
+    // Reset the size of cell mapping lists
+    cellFromPoint.setSize(nCellFromPoint);
+    cellFromEdge.setSize(nCellFromEdge);
+    cellFromFace.setSize(nCellFromFace);
+
+    // Check cell maps
+    if (debug)
+    {
+        boolList mappedCells(newCells.size(), false);
+
+        // Fill in cells mapped from the cell map
+        forAll (cellMap, cellI)
+        {
+            if (cellMap[cellI] >= 0)
+            {
+                mappedCells[cellI] = true;
+            }
+        }
+
+        // Fill in point and edge maps
+        forAll (cellFromPoint, cellI)
+        {
+            mappedCells[cellFromPoint[cellI].index()] = true;
+        }
+
+        forAll (cellFromEdge, cellI)
+        {
+            mappedCells[cellFromEdge[cellI].index()] = true;
+        }
+
+        forAll (cellFromFace, cellI)
+        {
+            mappedCells[cellFromFace[cellI].index()] = true;
+        }
+
+        // Check if all the cells are mapped
+        label nUnmappedCells = 0;
+
+        forAll (mappedCells, cellI)
+        {
+            if (!mappedCells[cellI])
+            {
+                nUnmappedCells++;
+            }
+        }
+
+        if (nUnmappedCells > 0)
+        {
+            Pout<< "void polyMesh::morph(const batchPolyTopoChange& ref) : "
+                << "unmapped data for " << nUnmappedCells << " cells." << endl;
+        }
+    }
+
+
+    // Rebuild the mesh
+    // ~~~~~~~~~~~~~~~~
+
+    // Grab patch mesh point maps
+
+    List<Map<label> > oldPatchMeshPointMaps(boundary.size());
+    labelList oldPatchNMeshPoints(boundary.size());
+
+    forAll (boundary, patchI)
+    {
+        // Copy old face zone mesh point maps
+        oldPatchMeshPointMaps[patchI] = boundary[patchI].meshPointMap();
+        oldPatchNMeshPoints[patchI] = boundary[patchI].meshPoints().size();
+    }
+
+    // Re-do the point zones
+
+    // Make a map of points to be removed from zones
+    labelHashSet removePointFromZone(2*ref.modifiedPoints().size());
+
+    forAll (mp, mpI)
+    {
+        if (mp[mpI].removeFromZone())
+        {
+            removePointFromZone.insert(mp[mpI].pointID());
+        }
+    }
+
+    labelListList newPointZoneAddr(pointZones.size());
+    labelList nPointsInZone(pointZones.size(), 0);
+
+    forAll (pointZones, pzI)
+    {
+        // Get the list of old points
+        const labelList& oldAddr = pointZones[pzI];
+
+        // Create new addressing, over-estimating the size
+        labelList& newAddr = newPointZoneAddr[pzI];
+        label& curNPoints = nPointsInZone[pzI];
+
+        newAddr.setSize
+        (
+            oldAddr.size()
+          + ref.modifiedPoints().size()
+          + ref.addedPoints().size()
+        );
+
+        // Add the original points that have not been removed or re-zoned
+        forAll (oldAddr, pointI)
+        {
+            if
+            (
+                !removedPoints.found(oldAddr[pointI])
+             && !removePointFromZone.found(oldAddr[pointI])
+            )
+            {
+                // The point is still alive. Add its renumbered label
+                newAddr[curNPoints] = renumberPoints[oldAddr[pointI]];
+                curNPoints++;
+            }
+        }
+    }
+
+    labelList debugPointsInZone(pointZones.size(), 0);
+
+    if (debug)
+    {
+        Pout<< "Added zone points:  untouched = " << nPointsInZone;
+
+        debugPointsInZone = nPointsInZone;
+    }
+
+    // Distribute modified zone points
+    forAll (mp, mpI)
+    {
+        if (mp[mpI].isInZone())
+        {
+            const label zoneID = mp[mpI].zoneID();
+
+            newPointZoneAddr[zoneID][nPointsInZone[zoneID]] =
+                renumberPoints[mp[mpI].pointID()];
+
+            nPointsInZone[zoneID]++;
+        }
+    }
+
+    if (debug)
+    {
+        Pout<< " modified = " << nPointsInZone - debugPointsInZone;
+    }
+
+    // Distribute added zone points
+    forAll (ap, apI)
+    {
+        if (ap[apI].isInZone())
+        {
+            const label zoneID = ap[apI].zoneID();
+
+            newPointZoneAddr[zoneID][nPointsInZone[zoneID]] =
+                renumberPoints[points.size() + apI];
+
+            nPointsInZone[zoneID]++;
+        }
+    }
+
+    if (debug)
+    {
+        Pout<< " added = " << nPointsInZone - debugPointsInZone
+            << ".  Points per zone = " << nPointsInZone << endl;
+    }
+
+    // Reset the sizes of the point zone addressing
+    forAll (newPointZoneAddr, pzI)
+    {
+        newPointZoneAddr[pzI].setSize(nPointsInZone[pzI]);
+    }
+
+    // Build the point zone renumbering
+    labelListList pzRenumber(pointZones.size());
+
+    forAll (pointZones, pzI)
+    {
+        pointZone& oldZone = pointZones[pzI];
+        const labelList& newZoneAddr = newPointZoneAddr[pzI];
+
+        labelList& curPzRnb = pzRenumber[pzI];
+        curPzRnb.setSize(newZoneAddr.size());
+
+        forAll (newZoneAddr, pointI)
+        {
+            if (newZoneAddr[pointI] < pointMap.size())
+            {
+                curPzRnb[pointI] =
+                    oldZone.whichPoint(pointMap[newZoneAddr[pointI]]);
+            }
+            else
+            {
+                curPzRnb[pointI] = -1;
+            }
+        }
+    }
+
+
+    // Re-do the face zones
+
+    // Make a map of faces to be removed from zones
+    labelHashSet removeFaceFromZone(2*ref.modifiedFaces().size());
+
+    forAll (mf, mfI)
+    {
+        if (mf[mfI].removeFromZone())
+        {
+            removeFaceFromZone.insert(mf[mfI].faceID());
+        }
+    }
+
+    labelListList newFaceZoneAddr(faceZones.size());
+    boolListList newFaceZoneFaceFlip(faceZones.size());
+    labelList nFacesInZone(faceZones.size(), 0);
+
+    forAll (faceZones, fzI)
+    {
+        // Get the list of old faces
+        const labelList& oldAddr = faceZones[fzI];
+        const boolList& oldFlip = faceZones[fzI].flipMap();
+
+        // Create new addressing, over-estimating the size
+        labelList& newAddr = newFaceZoneAddr[fzI];
+        boolList& newFlip = newFaceZoneFaceFlip[fzI];
+        label& curNFaces = nFacesInZone[fzI];
+
+        newAddr.setSize
+        (
+            oldAddr.size()
+          + ref.modifiedFaces().size()
+          + ref.addedFaces().size()
+        );
+
+        newFlip.setSize(newAddr.size());
+        newFlip = false;
+
+        // Reset the face flip to false.  None of the preserved faces will
+        // be flipped
+
+        // Add the original faces that have not been removed or re-zoned
+        forAll (oldAddr, faceI)
+        {
+            if
+            (
+                !removedFaces.found(oldAddr[faceI])
+             && !removeFaceFromZone.found(oldAddr[faceI])
+            )
+            {
+                // The face is still alive. Add its renumbered label
+                newAddr[curNFaces] = renumberFaces[oldAddr[faceI]];
+                newFlip[curNFaces] = oldFlip[faceI];
+
+                curNFaces++;
+            }
+        }
+    }
+
+    labelList debugFacesInZone(faceZones.size(), 0);
+
+    if (debug)
+    {
+        Pout<< "Added zone faces: untouched = " << nFacesInZone;
+
+        debugFacesInZone = nFacesInZone;
+    }
+
+    // Distribute modified zone faces
+    forAll (mf, mfI)
+    {
+        if (mf[mfI].isInZone())
+        {
+            const label zoneID = mf[mfI].zoneID();
+
+            // Grab the face index
+            newFaceZoneAddr[zoneID][nFacesInZone[zoneID]] =
+                renumberFaces[mf[mfI].faceID()];
+
+            // Grab the face flip
+            newFaceZoneFaceFlip[zoneID][nFacesInZone[zoneID]] =
+                mf[mfI].zoneFlip();
+
+            nFacesInZone[zoneID]++;
+        }
+    }
+
+    if (debug)
+    {
+        Pout<< " modified = " << nFacesInZone - debugFacesInZone;
+
+        debugFacesInZone = nFacesInZone;
+    }
+
+    // Distribute added zone faces
+    forAll (af, afI)
+    {
+        if (af[afI].isInZone())
+        {
+            const label zoneID = af[afI].zoneID();
+
+            // Grab the face index
+            newFaceZoneAddr[zoneID][nFacesInZone[zoneID]] =
+                renumberFaces[faces.size() + afI];
+
+            newFaceZoneFaceFlip[zoneID][nFacesInZone[zoneID]] =
+                af[afI].zoneFlip();
+
+            nFacesInZone[zoneID]++;
+        }
+    }
+
+    if (debug)
+    {
+        Pout<< " added = " << nFacesInZone - debugFacesInZone
+            << ".  Faces per zone = " << nFacesInZone << endl;
+    }
+
+    // Reset the sizes of the face zone addressing and face flip
+    forAll (newFaceZoneAddr, fzI)
+    {
+        newFaceZoneAddr[fzI].setSize(nFacesInZone[fzI]);
+        newFaceZoneFaceFlip[fzI].setSize(nFacesInZone[fzI]);
+    }
+
+    // Build the face zone renumbering
+    labelListList fzFaceRenumber(faceZones.size());
+
+    List<Map<label> > oldFaceZoneMeshPointMaps(faceZones.size());
+
+    forAll (faceZones, fzI)
+    {
+        faceZone& oldZone = faceZones[fzI];
+
+        // Point renumbering
+        // Point renumbering gives the old point location of every new
+        // point in the face zone.  If the point is new to the zone,
+        // the index will be -1.
+        // The problem is that the renumbering cannot be built at this stage
+        // as the order of points in the new face zone is not yet known:
+        // (the new zone needs to be set on the updated list of faces to
+        // be able to create the mapping).  Therefore, the old meshPoint maps
+        // will be copied here and will be used later to re-create the
+        // addressing.
+
+        // Copy old face zone mesh point maps
+        oldFaceZoneMeshPointMaps[fzI] = faceZones[fzI]().meshPointMap();
+
+        // Face renumbering
+        const labelList& newZoneAddr = newFaceZoneAddr[fzI];
+
+        labelList& curFzFaceRnb = fzFaceRenumber[fzI];
+
+        curFzFaceRnb.setSize(newZoneAddr.size());
+
+        forAll (newZoneAddr, faceI)
+        {
+            // HJ, change: can this index legally be -1?
+            // HJ, 9/Jan/2009
+            if (newZoneAddr[faceI] > -1 && newZoneAddr[faceI] < faceMap.size())
+            {
+                curFzFaceRnb[faceI] =
+                    oldZone.whichFace(faceMap[newZoneAddr[faceI]]);
+            }
+            else
+            {
+                curFzFaceRnb[faceI] = -1;
+            }
+        }
+    }
+
+
+    // Re-do the cell zones
+
+    // Make a map of cells to be removed from zones
+    labelHashSet removeCellFromZone(2*ref.modifiedCells().size());
+
+    forAll (mc, mcI)
+    {
+        if (mc[mcI].removeFromZone())
+        {
+            removeCellFromZone.insert(mc[mcI].cellID());
+        }
+    }
+
+    labelListList newCellZoneAddr(cellZones.size());
+    labelList nCellsInZone(cellZones.size(), 0);
+
+    forAll (cellZones, czI)
+    {
+        // Get the list of old cells
+        const labelList& oldAddr = cellZones[czI];
+
+        // Create new addressing, over-estimating the size
+        labelList& newAddr = newCellZoneAddr[czI];
+        label& curNCells = nCellsInZone[czI];
+
+        newAddr.setSize
+        (
+            oldAddr.size()
+          + ref.modifiedCells().size()
+          + ref.addedCells().size()
+        );
+
+        // Add the original cells that have not been removed or re-zoned
+        forAll (oldAddr, cellI)
+        {
+            if
+            (
+                !removedCells.found(oldAddr[cellI])
+             && !removeCellFromZone.found(oldAddr[cellI])
+            )
+            {
+                // The cell is still alive. Add its renumbered label
+                newAddr[curNCells] = renumberCells[oldAddr[cellI]];
+                curNCells++;
+            }
+        }
+    }
+
+    labelList debugCellsInZone(cellZones.size(), 0);
+
+    if (debug)
+    {
+        Pout<< "Added zone cells: untouched = " << nCellsInZone;
+
+        debugCellsInZone = nCellsInZone;
+    }
+
+    // Distribute modified zone cells
+    forAll (mc, mcI)
+    {
+        if (mc[mcI].isInZone())
+        {
+            const label zoneID = mc[mcI].zoneID();
+
+            newCellZoneAddr[zoneID][nCellsInZone[zoneID]] =
+                renumberCells[mc[mcI].cellID()];
+
+            nCellsInZone[zoneID]++;
+        }
+    }
+
+    if (debug)
+    {
+        Pout<< " modified = " << nCellsInZone - debugCellsInZone;
+
+        debugCellsInZone = nCellsInZone;
+    }
+
+    // Distribute added zone cells
+    forAll (ac, acI)
+    {
+        if (ac[acI].isInZone())
+        {
+            const label zoneID = ac[acI].zoneID();
+
+            newCellZoneAddr[zoneID][nCellsInZone[zoneID]] =
+                renumberCells[cells.size() + acI];
+
+            nCellsInZone[zoneID]++;
+        }
+    }
+
+    if (debug)
+    {
+        Pout<< " added = " << nCellsInZone - debugCellsInZone
+            << ".  Cells per zone = " << nCellsInZone << endl;
+    }
+
+    // Reset the sizes of the cell zone addressing
+    forAll (newCellZoneAddr, czI)
+    {
+        newCellZoneAddr[czI].setSize(nCellsInZone[czI]);
+    }
+
+    // Build the cell zone renumbering
+    labelListList czRenumber(cellZones.size());
+
+    forAll (cellZones, czI)
+    {
+        cellZone& oldZone = cellZones[czI];
+        const labelList& newZoneAddr = newCellZoneAddr[czI];
+
+        labelList& curCzRnb = czRenumber[czI];
+
+        curCzRnb.setSize(newZoneAddr.size());
+
+        forAll (newZoneAddr, cellI)
+        {
+            if (newZoneAddr[cellI] < cellMap.size())
+            {
+                curCzRnb[cellI] =
+                    oldZone.whichCell(cellMap[newZoneAddr[cellI]]);
+            }
+            else
+            {
+                curCzRnb[cellI] = -1;
+            }
+        }
+    }
+
+
+    // Calculate (all)owner and (all)neighbour and reset the mesh.
+    {
+        labelList allOwn(newFaces.size(), -1);
+        labelList allNei(newFaces.size(), -1);
+
+        boolList markedFaces(newFaces.size(), false);
+
+        forAll (newCells, cellI)
+        {
+            // get reference to face labels for current cell
+            const cell& cellfaces = newCells[cellI];
+
+            forAll (cellfaces, faceI)
+            {
+                if (!markedFaces[cellfaces[faceI]])
+                {
+                    // First visit: owner
+                    allOwn[cellfaces[faceI]] = cellI;
+
+                    markedFaces[cellfaces[faceI]] = true;
+                }
+                else
+                {
+                    // Second visit: neighbour
+                    allNei[cellfaces[faceI]] = cellI;
+                }
+            }
+        }
+
+        // Count the number of real faces.
+        // Note: if there are unused faces in the mesh, they should be
+        // clustered at the end of the list
+
+        label nUsedFaces = allOwn.size();
+
+        forAll (allOwn, faceI)
+        {
+            if (allOwn[faceI] < 0)
+            {
+                nUsedFaces = faceI;
+                break;
+            }
+        }
+
+        // Truncate owner array to the number of used faces
+        // HJ, 23/Oct/2008
+        allOwn.setSize(nUsedFaces);
+
+        // Count internal faces
+        label nInternalFaces = allOwn.size();
+
+        forAll (allNei, faceI)
+        {
+            if (allNei[faceI] < 0)
+            {
+                nInternalFaces = faceI;
+                break;
+            }
+        }
+
+        // Truncate neighbour array to the size of internal faces
+        // HJ, 23/Oct/2008
+        allNei.setSize(nInternalFaces);
+
+        if (debug)
+        {
+            Pout<< " nOldPoints: " << points.size()
+                << " nPoints: " << newPointsZeroVol.size()
+                << " nUsedFaces: " << nUsedFaces
+                << " newFaces: " << newFaces.size()
+                << " allOwn: " << allOwn.size()
+                << " allNei: " << allNei.size()
+                << " patchSizes: " << patchSizes
+                << " patchStarts: " << patchStarts << endl;
+        }
+
+        // HJ, HACKED
+        mesh.resetPrimitives
+        (
+            autoPtr<pointField>(&newPointsZeroVol),
+            autoPtr<faceList>(&newFaces),
+            autoPtr<labelList>(&allOwn),
+            autoPtr<labelList>(&allNei),
+            patchSizes,
+            patchStarts,
+            false         // The mesh is not complete: no parallel comms
+                          // HJ, 27/Nov/2009
+        );
+    }
+
+
+    // Reset the zones
+
+    forAll (pointZones, pzI)
+    {
+        pointZones[pzI] = newPointZoneAddr[pzI];
+    }
+    // // OpenFOAM does not have an updateMesh mechanism.  HJ, 1/Aug/2023
+    // pointZones.updateMesh();
+
+    forAll (faceZones, fzI)
+    {
+        faceZones[fzI].resetAddressing
+        (
+            newFaceZoneAddr[fzI],
+            newFaceZoneFaceFlip[fzI]
+        );
+    }
+    // OpenFOAM does not have an updateMesh mechanism.  HJ, 1/Aug/2023
+    // faceZones.updateMesh();
+
+    forAll (cellZones, czI)
+    {
+        cellZones[czI] = newCellZoneAddr[czI];
+    }
+    // OpenFOAM does not have an updateMesh mechanism.  HJ, 1/Aug/2023
+    // cellZones.updateMesh();
+
+
+    // Create the patch mesh point renumbering
+
+    labelListList patchPointRenumber(boundary.size());
+
+    forAll (boundary, patchI)
+    {
+        const labelList& newPatchMeshPoints = boundary[patchI].meshPoints();
+
+        const Map<label>& oldZoneMeshPointMap = oldPatchMeshPointMaps[patchI];
+        const label oldSize = oldPatchNMeshPoints[patchI];
+
+        labelList& curPatchPointRnb = patchPointRenumber[patchI];
+
+        curPatchPointRnb.setSize(newPatchMeshPoints.size());
+
+        forAll (newPatchMeshPoints, pointI)
+        {
+            if (newPatchMeshPoints[pointI] < oldSize)
+            {
+                Map<label>::const_iterator ozmpmIter =
+                    oldZoneMeshPointMap.find
+                    (
+                        pointMap[newPatchMeshPoints[pointI]]
+                    );
+
+                if (ozmpmIter != oldZoneMeshPointMap.end())
+                {
+                    curPatchPointRnb[pointI] = ozmpmIter();
+                }
+                else
+                {
+                    curPatchPointRnb[pointI] = -1;
+                }
+            }
+            else
+            {
+                curPatchPointRnb[pointI] = -1;
+            }
+        }
+    }
+
+    // Create the face zone mesh point renumbering
+
+    labelListList fzPointRenumber(faceZones.size());
+
+    forAll (faceZones, fzI)
+    {
+        const labelList& newZoneMeshPoints = faceZones[fzI]().meshPoints();
+
+        const Map<label>& oldZoneMeshPointMap = oldFaceZoneMeshPointMaps[fzI];
+
+        labelList& curFzPointRnb = fzPointRenumber[fzI];
+
+        curFzPointRnb.setSize(newZoneMeshPoints.size());
+
+        forAll (newZoneMeshPoints, pointI)
+        {
+            if (newZoneMeshPoints[pointI] < pointMap.size())
+            {
+                Map<label>::const_iterator ozmpmIter =
+                    oldZoneMeshPointMap.find
+                    (
+                        pointMap[newZoneMeshPoints[pointI]]
+                    );
+
+                if (ozmpmIter != oldZoneMeshPointMap.end())
+                {
+                    curFzPointRnb[pointI] = ozmpmIter();
+                }
+                else
+                {
+                    curFzPointRnb[pointI] = -1;
+                }
+            }
+            else
+            {
+                curFzPointRnb[pointI] = -1;
+            }
+        }
+    }
+
+
+    if (debug)
+    {
+        Pout<< "polyTopoChanger::changeMesh" << nl
+            << '(' << nl
+            << "    const batchPolyTopoChange& ref" << nl
+            << ") : completed topological change." << nl << endl;
+    }
+
+    // Comatibility with direct poly topo change:
+    // - pointsFromPoints
+    // - facesFromFaces
+    // - cellsFromCells
+    // All currently inactive in a direct map and not used
+    // HJ, 1/Sep/2007
+    List<objectMap> pointsFromPoints;
+    List<objectMap> facesFromFaces;
+    List<objectMap> cellsFromCells;
+
+    // Patch reset map is currently dummy: does not support change in number
+    // of boundary patches
+    // HJ, 23/Apr/2018
+    // boolList resetPatchFlag(boundary.size(), false);
+
+    // Dummy old cell volumes
+    autoPtr<scalarField> oldCellVolumes;
+    
+    autoPtr<mapPolyMesh> topoChangeMap
+    (
+        new mapPolyMesh
+        (
+            mesh,
+            nOldPoints,
+            nOldFaces,
+            nOldCells,
+
+            pointMap,
+            pointsFromPoints,
+
+            faceMap,
+            faceFromPoint,
+            faceFromEdge,
+            facesFromFaces,
+
+            cellMap,
+            cellFromPoint,
+            cellFromEdge,
+            cellFromFace,
+            cellsFromCells,
+
+            renumberPoints,
+            renumberFaces,
+            renumberCells,
+
+            flipFaceFlux,
+
+            patchPointRenumber,
+
+            pzRenumber,
+            fzPointRenumber,
+            fzFaceRenumber,
+            czRenumber,
+
+            // resetPatchFlag,
+
+            newPointsMotion,
+            oldPatchStarts,
+            oldPatchNMeshPoints,
+            oldCellVolumes,
+            true                   // Re-use storage
+        )
+    );
+
+    return topoChangeMap;
+}
+
+
+Foam::autoPtr<Foam::mapPolyMesh> Foam::polyTopoChanger::changeMesh()
+{
+    bool localUpdate = changeTopology();
+
+    bool globalUpdate = returnReduce(localUpdate, orOp<bool>());
+
+    if (debug)
+    {
+        Pout<< "Local mesh update: " << localUpdate
+            << " global update: " << globalUpdate << endl;
+    }
+
+    // if (localUpdate)
+    {
+        autoPtr<mapPolyMesh> topoChangeMap = changeMesh
+        (
+            mesh_,
+            topoChangeRequest()()
+        );
+
+        // Mesh data needs to be updated before the update of polyMeshModifiers
+        // because polyMeshModifiers might need all the new polyMesh data (see
+        // below for further comments). VV, 19/Feb/2019
+        mesh_.updateMesh(topoChangeMap());
+
+        // Bugfix: call to polyTopoChanger::update must happen after
+        // polyMesh::updateMesh where all the relevant mesh bits for parallel
+        // comms are updated. First noticed when the syncying of pointLevel in
+        // refinement::updateMesh was not syncying properly. VV, 19/Feb/2019
+        update(topoChangeMap());
+
+        // Increment the morph index
+        morphIndex_++;
+
+        // Mark the mesh as changing
+        mesh_.topoChanging(true);
+
+        return topoChangeMap;
+    }
+    // else
+    // {
+    //     // If other processors perform topology change, communications
+    //     // between domains need to be executed.  HJ, 27/Nov/2009
+    //     if (globalUpdate)
+    //     {
+    //         // Sync couple patch update
+    //         syncCoupledPatches();
+
+    //         // Sync mesh update
+    //         mesh_.syncUpdateMesh();
+
+    //         // Mark the mesh as changing
+    //         mesh_.changing(true);
+    //     }
+
+    //     return autoPtr<mapPolyMesh>(new mapPolyMesh(mesh_));
+    // }
+}
+
+
+// ************************************************************************* //
diff --git a/src/dynamicMesh/refinement/polyhedralRefinement/polyhedralRefinement.C b/src/dynamicMesh/refinement/polyhedralRefinement/polyhedralRefinement.C
new file mode 100644
index 0000000000..65021a8cbb
--- /dev/null
+++ b/src/dynamicMesh/refinement/polyhedralRefinement/polyhedralRefinement.C
@@ -0,0 +1,2442 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | foam-extend: Open Source CFD
+   \\    /   O peration     | Version:     5.0
+    \\  /    A nd           | Web:         http://www.foam-extend.org
+     \\/     M anipulation  | For copyright notice see file Copyright
+-------------------------------------------------------------------------------
+License
+    This file is part of foam-extend.
+
+    foam-extend is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation, either version 3 of the License, or (at your
+    option) any later version.
+
+    foam-extend is distributed in the hope that it will be useful, but
+    WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with foam-extend.  If not, see <http://www.gnu.org/licenses/>.
+
+Author
+    Vuko Vukcevic, Wikki Ltd.  All rights reserved.
+
+\*---------------------------------------------------------------------------*/
+
+#include "polyhedralRefinement.H"
+#include "cellSet.H"
+#include "faceSet.H"
+#include "pointSet.H"
+#include "syncTools.H"
+#include "meshTools.H"
+#include "OFstream.H"
+#include "Time.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(polyhedralRefinement, 0);
+    addToRunTimeSelectionTable
+    (
+        polyMeshModifier,
+        polyhedralRefinement,
+        dictionary
+    );
+}
+
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+Foam::label Foam::polyhedralRefinement::getAnchorLevel
+(
+    const label faceI
+) const
+{
+    const face& f = mesh_.faces()[faceI];
+
+    if (f.size() <= 3)
+    {
+        return pointLevel_[f[findMaxLevel(f)]];
+    }
+    else
+    {
+        const label& ownLevel = cellLevel_[mesh_.faceOwner()[faceI]];
+
+        if (countAnchors(f, ownLevel) >= 3)
+        {
+            return ownLevel;
+        }
+        else if (countAnchors(f, ownLevel + 1) >= 3)
+        {
+            return ownLevel + 1;
+        }
+        else
+        {
+            return -1;
+        }
+    }
+}
+
+
+void Foam::polyhedralRefinement::createInternalFaces
+(
+    const labelListList& cellAnchorPoints,
+    const labelListList& cellAddedCells,
+    const labelList& cellMidPoint,
+    const labelList& faceMidPoint,
+    const labelList& faceAnchorLevel,
+    const labelList& edgeMidPoint,
+    const label cellI,
+
+    batchPolyTopoChange& ref
+) const
+{
+    // Find in every face the cellLevel + 1 points (from edge subdivision)
+    // and the anchor points
+
+    // Get current cell and its level
+    const cell& curCell = mesh_.cells()[cellI];
+    const label& cLevel = cellLevel_[cellI];
+
+    // Get mesh faces and face edges
+    const faceList& meshFaces = mesh_.faces();
+    const labelListList& meshFaceEdges = mesh_.faceEdges();
+
+    // Get mesh cell points
+    const labelListList& meshCellPoints = mesh_.cellPoints();
+
+    // Map from edge mid to anchor points
+    Map<edge> midPointToAnchors(24);
+    // Map from edge mid to face mids
+    Map<edge> midPointToFaceMids(24);
+
+    // Running count of number of internal faces added so far
+    label nFacesAdded = 0;
+
+    // Loop through faces of the cell
+    forAll(curCell, i)
+    {
+        // Get face index
+        const label& faceI = curCell[i];
+
+        // Get current face and its edges
+        const face& f = meshFaces[faceI];
+        const labelList& fEdges = meshFaceEdges[faceI];
+
+        // We are on the cellI side of face f. The face will have 1 or n
+        // cLevel points (where n is the number of points/edges of a face)
+        // and lots of higher numbered ones
+
+        // Index of face mid point
+        label faceMidPointI = -1;
+
+        // Get number of anchors for the face
+        const label nAnchors = countAnchors(f, cLevel);
+
+        if (nAnchors == 1)
+        {
+            // Only one anchor point. So the other side of the face has already
+            // been split using cLevel + 1 and cLevel + 2 points
+
+            // Find the one anchor
+            label anchorFp = -1;
+
+            // Loop through face points
+            forAll(f, fp)
+            {
+                if (pointLevel_[f[fp]] <= cLevel)
+                {
+                    // Point level is smaller than cLevel + 1, this is the
+                    // anchor point
+                    anchorFp = fp;
+                    break;
+                }
+            }
+
+            // Now the face mid point is the second cLevel + 1 point
+            label edgeMid = findLevel(f, f.fcIndex(anchorFp), true, cLevel + 1);
+            label faceMid = findLevel(f, f.fcIndex(edgeMid), true, cLevel + 1);
+
+            // Set face mid point index
+            faceMidPointI = f[faceMid];
+        }
+        else
+        {
+            // There is no face middle yet but the face will be split. Set face
+            // mid point index
+            faceMidPointI = faceMidPoint[faceI];
+        }
+
+
+        // Now loop over all the anchors (might be just one) and store
+        // the edge mids connected to it. storeMidPointInfo will collect
+        // all the info and combine it all
+        forAll(f, fp0)
+        {
+            // Get point index
+            const label& point0 = f[fp0];
+
+            if (pointLevel_[point0] <= cLevel)
+            {
+                // This is anchor point
+
+                // Walk forward to cLevel + 1 or edgeMidPoint of this level
+                label edgeMidPointI = -1;
+
+                const label fp1 = f.fcIndex(fp0);
+
+                if (pointLevel_[f[fp1]] <= cLevel)
+                {
+                    // Another anchor: edge will be split
+                    const label& edgeI = fEdges[fp0];
+
+                    edgeMidPointI = edgeMidPoint[edgeI];
+
+                    // Sanity check
+                    if (edgeMidPointI == -1)
+                    {
+                        const labelList& cPoints = meshCellPoints[cellI];
+
+                        FatalErrorInFunction
+                            << "cell:" << cellI << " cLevel:" << cLevel
+                            << " cell points:" << cPoints
+                            << " pointLevel:"
+                            << IndirectList<label>(pointLevel_, cPoints)()
+                            << " face:" << faceI
+                            << " f:" << f
+                            << " pointLevel:"
+                            << IndirectList<label>(pointLevel_, f)()
+                            << " faceAnchorLevel:" << faceAnchorLevel[faceI]
+                            << " faceMidPoint:" << faceMidPoint[faceI]
+                            << " faceMidPointI:" << faceMidPointI
+                            << " fp:" << fp0
+                            << abort(FatalError);
+                    }
+                }
+                else
+                {
+                    // Search forward in face to clevel + 1
+                    const label edgeMid = findLevel(f, fp1, true, cLevel + 1);
+
+                    edgeMidPointI = f[edgeMid];
+                }
+
+                label newFaceI = storeMidPointInfo
+                (
+                    cellAnchorPoints,
+                    cellAddedCells,
+                    cellMidPoint,
+                    edgeMidPoint,
+
+                    cellI,
+                    faceI,
+                    true,                   // mid point after anchor
+                    edgeMidPointI,          // edgemid
+                    point0,                 // anchor
+                    faceMidPointI,
+
+                    midPointToAnchors,
+                    midPointToFaceMids,
+                    ref
+                );
+
+                if (newFaceI != -1)
+                {
+                    ++nFacesAdded;
+                }
+
+
+                // Now walk backward
+
+                label fpMin1 = f.rcIndex(fp0);
+
+                if (pointLevel_[f[fpMin1]] <= cLevel)
+                {
+                    // Another anchor: edge will be split
+                    const label& edgeI = fEdges[fpMin1];
+
+                    edgeMidPointI = edgeMidPoint[edgeI];
+
+                    // Sanity check
+                    if (edgeMidPointI == -1)
+                    {
+                        const labelList& cPoints = meshCellPoints[cellI];
+
+                        FatalErrorInFunction
+                            << "cell:" << cellI << " cLevel:" << cLevel
+                            << " cell points:" << cPoints
+                            << " pointLevel:"
+                            << IndirectList<label>(pointLevel_, cPoints)()
+                            << " face:" << faceI
+                            << " f:" << f
+                            << " pointLevel:"
+                            << IndirectList<label>(pointLevel_, f)()
+                            << " faceAnchorLevel:" << faceAnchorLevel[faceI]
+                            << " faceMidPoint:" << faceMidPoint[faceI]
+                            << " faceMidPointI:" << faceMidPointI
+                            << " fp:" << fp0
+                            << abort(FatalError);
+                    }
+                }
+                else
+                {
+                    // Search back in face to clevel + 1
+                    const label edgeMid = findLevel(f, fpMin1, false, cLevel + 1);
+
+                    edgeMidPointI = f[edgeMid];
+                }
+
+                newFaceI = storeMidPointInfo
+                (
+                    cellAnchorPoints,
+                    cellAddedCells,
+                    cellMidPoint,
+                    edgeMidPoint,
+
+                    cellI,
+                    faceI,
+                    false,                  // mid point before anchor
+                    edgeMidPointI,          // edgemid
+                    point0,                 // anchor
+                    faceMidPointI,
+
+                    midPointToAnchors,
+                    midPointToFaceMids,
+                    ref
+                );
+
+                if (newFaceI != -1)
+                {
+                    ++nFacesAdded;
+                }
+            } // End for this anchor point
+        } // End for all face points
+    } // End for all cell faces
+}
+
+
+Foam::label Foam::polyhedralRefinement::getAnchorCell
+(
+    const labelListList& cellAnchorPoints,
+    const labelListList& cellAddedCells,
+    const label cellI,
+    const label faceI,
+    const label pointI
+) const
+{
+    // Check whether pointI is an anchor of cellI. If it is not, check whether
+    // any other point on the face is an anchor for the cell
+
+    if (cellAnchorPoints[cellI].size() > 0)
+    {
+        const label index = cellAnchorPoints[cellI].find(pointI);
+
+        if (index != -1)
+        {
+            return cellAddedCells[cellI][index];
+        }
+
+
+        // pointI is not an anchor for the cell. Maybe we already refined the
+        // face so check all the face vertices
+        const face& f = mesh_.faces()[faceI];
+
+        forAll(f, fp)
+        {
+            const label index = cellAnchorPoints[cellI].find(f[fp]);
+
+            if (index != -1)
+            {
+                return cellAddedCells[cellI][index];
+            }
+        }
+
+        // Problem: the point does not seem to be an anchor for cell
+
+        // Pick up points of the cell
+        const labelList& cPoints = mesh_.cellPoints()[cellI];
+
+        Perr<< "cell: " << cellI << ", points: " << endl;
+        forAll(cPoints, i)
+        {
+            const label pointI = cPoints[i];
+
+            Perr<< "    " << pointI << " coord: " << mesh_.points()[pointI]
+                << nl;
+        }
+
+        Perr<< "cell: " << cellI << " anchorPoints: " << cellAnchorPoints[cellI]
+            << endl;
+
+        FatalErrorInFunction
+            << "Could not find point " << pointI
+            << " in the anchorPoints for cell " << cellI << endl
+            << "Does your original mesh obey the 2:1 constraint and"
+            << " did you use consistentRefinement to make your cells to refine"
+            << " obey this constraint as well?"
+            << abort(FatalError);
+
+        return -1;
+    }
+    else
+    {
+        return cellI;
+    }
+}
+
+
+void Foam::polyhedralRefinement::setNewFaceNeighbours
+(
+    const labelListList& cellAnchorPoints,
+    const labelListList& cellAddedCells,
+    const label faceI,
+    const label pointI,
+
+    label& own,
+    label& nei
+) const
+{
+    // Get anchor cell for this anchor point on owner side
+    own = getAnchorCell
+    (
+        cellAnchorPoints,
+        cellAddedCells,
+        mesh_.faceOwner()[faceI],
+        faceI,
+        pointI
+    );
+
+    if (mesh_.isInternalFace(faceI))
+    {
+        // Get anchor cell for this anchor point on neighbour side
+        nei = getAnchorCell
+        (
+            cellAnchorPoints,
+            cellAddedCells,
+            mesh_.faceNeighbour()[faceI],
+            faceI,
+            pointI
+        );
+    }
+    else
+    {
+        // Boundary face: set neighbour to -1
+        nei = -1;
+    }
+}
+
+
+Foam::label Foam::polyhedralRefinement::findLevel
+(
+    const face& f,
+    const label startFp,
+    const bool searchForward,
+    const label wantedLevel
+) const
+{
+    label fp = startFp;
+
+    forAll(f, i)
+    {
+        label pointI = f[fp];
+
+        if (pointLevel_[pointI] < wantedLevel)
+        {
+            FatalErrorInFunction
+                << "face:" << f
+                << " level:" << IndirectList<label>(pointLevel_, f)()
+                << " startFp:" << startFp
+                << " wantedLevel:" << wantedLevel
+                << abort(FatalError);
+        }
+        else if (pointLevel_[pointI] == wantedLevel)
+        {
+            return fp;
+        }
+
+        if (searchForward)
+        {
+            fp = f.fcIndex(fp);
+        }
+        else
+        {
+            fp = f.rcIndex(fp);
+        }
+    }
+
+    FatalErrorInFunction
+        << "face:" << f
+        << " level:" << IndirectList<label>(pointLevel_, f)()
+        << " startFp:" << startFp
+        << " wantedLevel:" << wantedLevel
+        << abort(FatalError);
+
+    return -1;
+}
+
+
+Foam::label Foam::polyhedralRefinement::storeMidPointInfo
+(
+    const labelListList& cellAnchorPoints,
+    const labelListList& cellAddedCells,
+    const labelList& cellMidPoint,
+    const labelList& edgeMidPoint,
+    const label cellI,
+    const label faceI,
+    const bool faceOrder,
+    const label edgeMidPointI,
+    const label anchorPointI,
+    const label faceMidPointI,
+
+    Map<edge>& midPointToAnchors,
+    Map<edge>& midPointToFaceMids,
+    batchPolyTopoChange& ref
+) const
+{
+    // A single internal face is added per edge inbetween anchor points,
+    // i.e. one face per midPoint between anchor points. The information is
+    // stored on the midPoint and if we have enough information (finished
+    // collecting two anchors and two face mid points), we add the face.
+    // Note that this member function can get called anywhere from
+    // two times (two unrefined faces) to four times (two refined faces) so
+    // the first call that adds the information creates the face
+
+
+    // See if need to store anchors
+    bool changed = false;
+    bool haveTwoAnchors = false;
+
+    Map<edge>::iterator edgeMidFnd = midPointToAnchors.find(edgeMidPointI);
+
+    if (edgeMidFnd == midPointToAnchors.end())
+    {
+        midPointToAnchors.insert(edgeMidPointI, edge(anchorPointI, -1));
+    }
+    else
+    {
+        edge& e = edgeMidFnd();
+
+        if (anchorPointI != e[0])
+        {
+            if (e[1] == -1)
+            {
+                e[1] = anchorPointI;
+                changed = true;
+            }
+        }
+
+        if (e[0] != -1 && e[1] != -1)
+        {
+            haveTwoAnchors = true;
+        }
+    }
+
+    bool haveTwoFaceMids = false;
+
+    Map<edge>::iterator faceMidFnd = midPointToFaceMids.find(edgeMidPointI);
+
+    if (faceMidFnd == midPointToFaceMids.end())
+    {
+        midPointToFaceMids.insert(edgeMidPointI, edge(faceMidPointI, -1));
+    }
+    else
+    {
+        edge& e = faceMidFnd();
+
+        if (faceMidPointI != e[0])
+        {
+            if (e[1] == -1)
+            {
+                e[1] = faceMidPointI;
+                changed = true;
+            }
+        }
+
+        if (e[0] != -1 && e[1] != -1)
+        {
+            haveTwoFaceMids = true;
+        }
+    }
+
+    // Check if this call of storeMidPointInfo is the one that completed all
+    // the nessecary information
+
+    if (changed && haveTwoAnchors && haveTwoFaceMids)
+    {
+        const edge& anchors = midPointToAnchors[edgeMidPointI];
+        const edge& faceMids = midPointToFaceMids[edgeMidPointI];
+
+        label otherFaceMidPointI = faceMids.otherVertex(faceMidPointI);
+
+        // Create face consistent with anchorI being the owner.
+        // Note that the edges between the edge mid point and the face mids
+        // might be marked for splitting. Note that these edge splits cannot
+        // be between cell mid and face mids
+
+        DynamicList<label> newFaceVerts(4);
+        if (faceOrder == (mesh_.faceOwner()[faceI] == cellI))
+        {
+            newFaceVerts.append(faceMidPointI);
+
+            // Check and insert edge split if any
+            insertEdgeSplit
+            (
+                edgeMidPoint,
+                faceMidPointI,  // edge between faceMid and
+                edgeMidPointI,  // edgeMid
+                newFaceVerts
+            );
+
+            newFaceVerts.append(edgeMidPointI);
+
+            insertEdgeSplit
+            (
+                edgeMidPoint,
+                edgeMidPointI,
+                otherFaceMidPointI,
+                newFaceVerts
+            );
+
+            newFaceVerts.append(otherFaceMidPointI);
+            newFaceVerts.append(cellMidPoint[cellI]);
+        }
+        else
+        {
+            newFaceVerts.append(otherFaceMidPointI);
+
+            insertEdgeSplit
+            (
+                edgeMidPoint,
+                otherFaceMidPointI,
+                edgeMidPointI,
+                newFaceVerts
+            );
+
+            newFaceVerts.append(edgeMidPointI);
+
+            insertEdgeSplit
+            (
+                edgeMidPoint,
+                edgeMidPointI,
+                faceMidPointI,
+                newFaceVerts
+            );
+
+            newFaceVerts.append(faceMidPointI);
+            newFaceVerts.append(cellMidPoint[cellI]);
+        }
+
+        face newFace;
+        newFace.transfer(newFaceVerts.shrink());
+        newFaceVerts.clear();
+
+        label anchorCell0 = getAnchorCell
+        (
+            cellAnchorPoints,
+            cellAddedCells,
+            cellI,
+            faceI,
+            anchorPointI
+        );
+        label anchorCell1 = getAnchorCell
+        (
+            cellAnchorPoints,
+            cellAddedCells,
+            cellI,
+            faceI,
+            anchors.otherVertex(anchorPointI)
+        );
+
+        // Get mesh points
+        const pointField& meshPoints = mesh_.points();
+
+        label own, nei;
+        point ownPt, neiPt;
+
+        if (anchorCell0 < anchorCell1)
+        {
+            own = anchorCell0;
+            nei = anchorCell1;
+
+            ownPt = meshPoints[anchorPointI];
+            neiPt = meshPoints[anchors.otherVertex(anchorPointI)];
+
+        }
+        else
+        {
+            own = anchorCell1;
+            nei = anchorCell0;
+            newFace = newFace.reverseFace();
+
+            ownPt = meshPoints[anchors.otherVertex(anchorPointI)];
+            neiPt = meshPoints[anchorPointI];
+        }
+
+        if (debug)
+        {
+            point ownPt, neiPt;
+
+            if (anchorCell0 < anchorCell1)
+            {
+                ownPt = meshPoints[anchorPointI];
+                neiPt = meshPoints[anchors.otherVertex(anchorPointI)];
+            }
+            else
+            {
+                ownPt = meshPoints[anchors.otherVertex(anchorPointI)];
+                neiPt = meshPoints[anchorPointI];
+            }
+
+            checkInternalOrientation
+            (
+                ref,
+                cellI,
+                faceI,
+                ownPt,
+                neiPt,
+                newFace
+            );
+        }
+
+        return addInternalFace
+        (
+            ref,
+            faceI,
+            anchorPointI,
+            newFace,
+            own,
+            nei
+        );
+    }
+    else
+    {
+        return -1;
+    }
+}
+
+
+void Foam::polyhedralRefinement::insertEdgeSplit
+(
+    const labelList& edgeMidPoint,
+    const label p0,
+    const label p1,
+    DynamicList<label>& verts
+) const
+{
+    // Get number of points
+    const label nPoints = mesh_.nPoints();
+
+    if (p0 < nPoints && p1 < nPoints)
+    {
+        label edgeI = meshTools::findEdge(mesh_, p0, p1);
+
+        if (edgeI != -1 && edgeMidPoint[edgeI] != -1)
+        {
+            verts.append(edgeMidPoint[edgeI]);
+        }
+    }
+}
+
+
+// * * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * //
+
+void Foam::polyhedralRefinement::setRefinementInstruction
+(
+    batchPolyTopoChange& ref
+) const
+{
+    // Note: assumes that cellsToRefine_ are set prior to the function call
+
+    // Reset refinementLevelIndicator field. Note: the list is cleared in
+    // updateMesh member function after updating cell and point levels
+    if (refinementLevelIndicator_.empty())
+    {
+        // List has been resetted correctly, initialise it for this iteration
+        refinementLevelIndicator_.setSize(mesh_.nCells(), UNCHANGED);
+    }
+    else
+    {
+        // List has not been reset correctly, issue an error
+        FatalErrorInFunction
+            << "Refinement level indicator list has not been"
+            << " resetted properly." << nl
+            << "Either the call to updateMesh() after performing"
+            << " refinement has not been made or the call to"
+            << " setRefinementInstruction(...) and"
+            << " setUnrefinementInstruction(...) has not been made in"
+            << " correct order." << nl
+            << "Make sure to set refinement, set unrefinement and call"
+            << " updateMesh after performing the topo change."
+            << abort(FatalError);
+    }
+
+    if (debug)
+    {
+        Pout<< "polyhedralRefinement::setRefinementInstruction(...)" << nl
+            << "Allocating " << cellsToRefine_.size() << " cell midpoints."
+            << endl;
+    }
+
+
+    // PART 1: Mark cells for refinement and add points at their cell centres
+
+    // Get necessary mesh data
+    const faceList& meshFaces = mesh_.faces();
+    const cellList& meshCells = mesh_.cells();
+    const vectorField& meshCellCentres = mesh_.cellCentres();
+
+    // Mid point for refined cell (points at cell centres):
+    // Not refined = -1
+    // Shall be refined > -1 (label of added mid point)
+    labelList cellMidPoint(mesh_.nCells(), -1);
+
+    // Loop through cells to refine
+    forAll(cellsToRefine_, i)
+    {
+        // Get cell idnex
+        const label& cellI = cellsToRefine_[i];
+
+        cellMidPoint[cellI] = ref.setAction
+        (
+            polyAddPoint
+            (
+                meshCellCentres[cellI], // Point to add (cell centre)
+                -1,                     // Appended point: no master ID
+                -1,                     // Zone for point
+                true                    // Supports a cell
+            )
+        );
+    }
+
+    // Write out split cells as a cell set for debug
+    if (debug)
+    {
+        // Note: cellSet is actually a hash table of labels
+        cellSet splitCells(mesh_, "splitCells", cellsToRefine_.size());
+
+        forAll(cellMidPoint, cellI)
+        {
+            if (cellMidPoint[cellI] > -1)
+            {
+                // Cell is marked for refinement, insert into cellSet
+                splitCells.insert(cellI);
+            }
+        }
+
+        Pout<< "polyhedralRefinement::setRefinementInstruction(...)" << nl
+            << "Writing " << splitCells.size()
+            << " cells to split to cellSet " << splitCells.objectPath()
+            << endl;
+
+        splitCells.write();
+    }
+
+
+    // PART 2: Mark edges for refinement and add points to edge centres
+
+    if (debug)
+    {
+        Pout<< "polyhedralRefinement::setRefinementInstruction(...)" << nl
+            << "Allocating edge midpoints."
+            << endl;
+    }
+
+    // Refined edges are defined by having both their point levels lower than
+    // the cell level, i.e. if any cell that gets split uses this edge, the edge
+    // needs to be split as well
+
+    // Get necessary mesh data
+    const labelListList& meshCellEdges = mesh_.cellEdges();
+    const edgeList& meshEdges = mesh_.edges();
+
+    // Mid points for refined edge:
+    // No need to split edge = -1
+    // Label of introduced mid point > -1
+    labelList edgeMidPoint(mesh_.nEdges(), -1);
+
+    // Note: Loop over all cells instead of all edges
+    forAll(cellMidPoint, cellI)
+    {
+        // Point is marked for refinement, proceed to look at the edges
+        if (cellMidPoint[cellI] > -1)
+        {
+            // Get edges of this cell
+            const labelList& cEdges = meshCellEdges[cellI];
+
+            forAll(cEdges, i)
+            {
+                // Get edge index and edge
+                const label& edgeI = cEdges[i];
+                const edge& e = meshEdges[edgeI];
+
+                if
+                (
+                    pointLevel_[e[0]] <= cellLevel_[cellI]
+                 && pointLevel_[e[1]] <= cellLevel_[cellI]
+                )
+                {
+                    // Point levels of both edge points are <= cell level, mark
+                    // the edge for splitting
+                    edgeMidPoint[edgeI] = 12345;
+                }
+            }
+        }
+    }
+
+    // Synchronize edgeMidPoint across coupled patches. Note: use max so that
+    // any split takes precedence.
+    syncTools::syncEdgeList
+    (
+        mesh_,
+        edgeMidPoint,
+        maxEqOp<label>(),
+        labelMin
+    );
+
+    // Introduce edge points
+
+    // Get necessary mesh data
+    const pointField& meshPoints = mesh_.points();
+
+    // Memory management
+    {
+        // Phase 1: calculate midpoints and sync. This is necessary if we don't
+        // use binary format for writing and we slowly get differences.
+
+        // Allocate storage for edge points
+        pointField edgeMids(mesh_.nEdges(), point(-GREAT, -GREAT, -GREAT));
+
+        forAll(edgeMidPoint, edgeI)
+        {
+            if (edgeMidPoint[edgeI] > -1)
+            {
+                // Edge marked to be split. Get edge centre
+                edgeMids[edgeI] = meshEdges[edgeI].centre(meshPoints);
+            }
+        }
+
+        // Sync across processor boundaries
+        syncTools::syncEdgeList
+        (
+            mesh_,
+            edgeMids,
+            maxEqOp<vector>(),
+            point(-GREAT, -GREAT, -GREAT)
+        );
+
+        // Phase 2: introduce points at the synced locations.
+        forAll(edgeMidPoint, edgeI)
+        {
+            if (edgeMidPoint[edgeI] > -1)
+            {
+                edgeMidPoint[edgeI] = ref.setAction
+                (
+                    polyAddPoint
+                    (
+                        edgeMids[edgeI], // Point
+                        -1,              // Appended point, no master ID
+                        -1,              // Zone for point
+                        true             // Supports a cell
+                    )
+                );
+            }
+        }
+    } // End memory management for syncing/adding edge points
+
+    // Write out edge mid points for split edges for debugging
+    if (debug)
+    {
+        OFstream str(mesh_.time().path()/"edgeMidPoint.obj");
+
+        forAll(edgeMidPoint, edgeI)
+        {
+            if (edgeMidPoint[edgeI] > -1)
+            {
+                // Get edge and write its cell centre
+                const edge& e = meshEdges[edgeI];
+                meshTools::writeOBJ(str, e.centre(meshPoints));
+            }
+        }
+
+        Pout<< "polyhedralRefinement::setRefinementInstruction(...)" << nl
+            << "Writing centres of edges to split to file " << str.name()
+            << endl;
+    }
+
+
+    // PART 3: Calculate face level (after selected cells splitting)
+
+    if (debug)
+    {
+        Pout<< "polyhedralRefinement::setRefinementInstruction" << nl
+            << "Allocating face midpoints."
+            << endl;
+    }
+
+    // Face anchor level. There are guaranteed at least 3 points with level
+    // <= anchorLevel. These are the corner points.
+    labelList faceAnchorLevel(mesh_.nFaces());
+
+    for (label faceI = 0; faceI < mesh_.nFaces(); ++faceI)
+    {
+        faceAnchorLevel[faceI] = getAnchorLevel(faceI);
+    }
+
+    // Mid points for refined face (points at face centres):
+    // Not refined = -1
+    // Shall be refined > -1 (label of added mid point)
+    labelList faceMidPoint(mesh_.nFaces(), -1);
+
+    // Get necessary mesh data
+    const labelList& meshFaceOwner = mesh_.faceOwner();
+    const labelList& meshFaceNeighbour = mesh_.faceNeighbour();
+
+    const label nFaces = mesh_.nFaces();
+    const label nInternalFaces = mesh_.nInternalFaces();
+
+    // Internal faces: look at cells on both sides. Uniquely determined since
+    // the face itself is guaranteed to be same level as most refined neighbour
+    for (label faceI = 0; faceI < nInternalFaces; ++faceI)
+    {
+        // Note: no need to check whether the face has valid anchor level since
+        // all faces can be split
+        const label& own = meshFaceOwner[faceI];
+        const label& ownLevel = cellLevel_[own];
+        const label newOwnLevel = ownLevel + (cellMidPoint[own] > -1 ? 1 : 0);
+
+        const label& nei = meshFaceNeighbour[faceI];
+        const label& neiLevel = cellLevel_[nei];
+        const label newNeiLevel = neiLevel + (cellMidPoint[nei] > -1 ? 1 : 0);
+
+        if
+        (
+            newOwnLevel > faceAnchorLevel[faceI]
+         || newNeiLevel > faceAnchorLevel[faceI]
+        )
+        {
+            // New level is higher than the face anchor level, mark for
+            // splitting
+            faceMidPoint[faceI] = 12345;
+        }
+    }
+
+    // Coupled patches handled like internal faces except now all information
+    // from neighbour comes from across processor.
+    // Boundary faces are more complicated since the boundary face can
+    // be more refined than its owner (or neighbour for coupled patches)
+    // (does not happen if refining/unrefining only, but does e.g. when
+    // refinining and subsetting)
+
+    // Memory management
+    {
+        // Create list for swapping boundary data
+        labelList newNeiLevel(nFaces - nInternalFaces);
+
+        forAll(newNeiLevel, i)
+        {
+            const label& own = meshFaceOwner[i + nInternalFaces];
+            const label& ownLevel = cellLevel_[own];
+            const label newOwnLevel =
+                ownLevel + (cellMidPoint[own] > -1 ? 1 : 0);
+
+            newNeiLevel[i] = newOwnLevel;
+        }
+
+        // Swap the list which now contains data from the other side
+        syncTools::swapBoundaryFaceList(mesh_, newNeiLevel);
+
+        forAll(newNeiLevel, i)
+        {
+            // Get face index
+            const label faceI = i + nInternalFaces;
+
+            // Note: no need to check whether the face has valid anchor level
+            // since all faces can be split
+            const label& own = meshFaceOwner[faceI];
+            const label& ownLevel = cellLevel_[own];
+            const label newOwnLevel =
+                ownLevel + (cellMidPoint[own] > -1 ? 1 : 0);
+
+            if
+            (
+                newOwnLevel > faceAnchorLevel[faceI]
+             || newNeiLevel[i] > faceAnchorLevel[faceI]
+            )
+            {
+                // New level is higher than the face anchor level, mark for
+                // splitting
+                faceMidPoint[faceI] = 12345;
+            }
+        }
+    } // End memory management for syncing owner/neighbour face levels
+
+    // Note: synronisation of faceMidPoints across coupled patches is not
+    // necessary since we have exchanged the neighbour data above using
+    // swapBoundaryFaceList, thus the faceMidPoint has to be the same on both
+    // sides. VV, 5/Jan/2018.
+//    // Synchronize faceMidPoint across coupled patches
+//    syncTools::syncFaceList
+//    (
+//        mesh_,
+//        faceMidPoint,
+//        maxEqOp<label>(),
+//        false
+//    );
+
+
+    // Introduce face points
+
+    // Get face centres
+    const vectorField& meshFaceCentres = mesh_.faceCentres();
+
+    // Memory management
+    {
+        // Phase 1: determine mid points and sync. Note: the same procedure has
+        // been used for syncing edge mid points
+
+        // Allocate storage for boundary face points
+        pointField bFaceMids
+        (
+            nFaces - nInternalFaces,
+            point(-GREAT, -GREAT, -GREAT)
+        );
+
+        // Loop through boundary face mids
+        forAll(bFaceMids, i)
+        {
+            // Get face index
+            const label faceI = i + nInternalFaces;
+
+            if (faceMidPoint[faceI] > -1)
+            {
+                // This is a valid face mid, get the face centre
+                bFaceMids[i] = meshFaceCentres[faceI];
+            }
+        }
+
+        // Sync across coupled boundaries. Note: uses maximum of the components
+        // of the vector. This is completely arbitrary but it doesn't matter as
+        // long as we have same points on each side. VV, 5/Jan/2018.
+        syncTools::syncBoundaryFaceList
+        (
+            mesh_,
+            bFaceMids,
+            maxEqOp<vector>()
+        );
+
+        // Loop through faces
+        forAll(faceMidPoint, faceI)
+        {
+            if (faceMidPoint[faceI] > -1)
+            {
+                // Face marked to be split. Add the point at face centre and
+                // replace faceMidPoint with actual point label
+
+                faceMidPoint[faceI] = ref.setAction
+                (
+                    polyAddPoint
+                    (
+                        (
+                            faceI < nInternalFaces
+                          ? meshFaceCentres[faceI]
+                          : bFaceMids[faceI - nInternalFaces]
+                        ),    // Point
+                        -1,   // Appended point, no master ID
+                        -1,   // Zone for point
+                        true  // Supports a cell
+                    )
+                );
+            }
+        }
+    } // End memory management for syncing boundary data and adding face mids
+
+    // Write out split faces as a face set for debugging
+    if (debug)
+    {
+        // Create a faceSet with 3*cell sizes to prevent excessive resizing
+        faceSet splitFaces(mesh_, "splitFaces", 3*cellsToRefine_.size());
+
+        forAll(faceMidPoint, faceI)
+        {
+            if (faceMidPoint[faceI] > -1)
+            {
+                splitFaces.insert(faceI);
+            }
+        }
+
+        Pout<< "polyhedralRefinement::setRefinementInstruction(...)" << nl
+            << "Writing " << splitFaces.size()
+            << " faces to split to faceSet " << splitFaces.objectPath()
+            << endl;
+
+        splitFaces.write();
+    }
+
+
+    // Now we have all the information we need to perform the refinement and we
+    // no longer need to refer to cellsToRefine_. The information is:
+    // - cellMidPoint >= 0 : cell needs to be split
+    // - faceMidPoint >= 0 : face needs to be split
+    // - edgeMidPoint >= 0 : edge needs to be split
+
+
+    // PART 4: Get corner and anchor points for all cells
+
+    if (debug)
+    {
+        Pout<< "polyhedralRefinement::setRefinementInstruction(...)" << nl
+            << "Finding cell anchorPoints" << endl;
+    }
+
+    // Get anchor points for each cell: points that have the same or lower
+    // refinement level as the cell
+    List<DynamicList<label>> cellAnchorPointsDynamic(mesh_.nCells());
+
+    // Loop through all cells
+    forAll(cellMidPoint, cellI)
+    {
+        if (cellMidPoint[cellI] > -1)
+        {
+            // This cell shall be cut. Set capacity to 16 to prevent excessive
+            // resizing
+            cellAnchorPointsDynamic[cellI].setCapacity(16);
+        }
+    }
+
+    // Get necessary mesh data
+    const labelListList& meshPointCells = mesh_.pointCells();
+
+    // Loop through all points
+    forAll(pointLevel_, pointI)
+    {
+        // Get point cells
+        const labelList& pCells = meshPointCells[pointI];
+
+        // Loop through all cells sharing this point
+        forAll(pCells, pCellI)
+        {
+            // Get current cell index
+            const label& cellI = pCells[pCellI];
+
+            if
+            (
+                cellMidPoint[cellI] > -1
+             && pointLevel_[pointI] <= cellLevel_[cellI]
+            )
+            {
+                // This point cells is marked for refinement and its point level
+                // is smaller or equal to cell level, append the point
+                cellAnchorPointsDynamic[cellI].append(pointI);
+            }
+        }
+    }
+
+    // Loop through all cells and check whether at least 4 anchor points
+    // have been found (minimum requirement for a tet cell)
+
+    // Get cell points for error output
+    const labelListList& meshCellPoints = mesh_.cellPoints();
+
+    forAll(cellMidPoint, cellI)
+    {
+        if (cellMidPoint[cellI] > -1)
+        {
+            // Cell selected for refinement
+            if (cellAnchorPointsDynamic[cellI].size() < 4)
+            {
+                // Cell has less than 4 anchor points. Issue an error and report
+                // cell points
+                const labelList& cPoints = meshCellPoints[cellI];
+
+                FatalErrorInFunction
+                   << "Cell " << cellI
+                    << " of level " << cellLevel_[cellI]
+                    << " does not seem to have enough points of "
+                    << " lower level" << endl
+                    << "cellPoints:" << cPoints << endl
+                    << "pointLevels:"
+                    << IndirectList<label>(pointLevel_, cPoints)() << endl
+                    << abort(FatalError);
+            }
+        }
+    }
+
+    // Collect cellAnchorPoints into a List<labelList> instead of
+    // List<dynamicList>
+    labelListList cellAnchorPoints(mesh_.nCells());
+
+    forAll(cellAnchorPointsDynamic, cellI)
+    {
+        // Tranfer the dynamic list for each cell into an ordinary list
+        cellAnchorPoints[cellI].transfer(cellAnchorPointsDynamic[cellI]);
+    }
+
+    // PART 5: Add the cells
+
+    if (debug)
+    {
+        Pout<< "polyhedralRefinement::setRefinementInstruction(...)" << nl
+            << " Adding cells."
+            << endl;
+    }
+
+    // We should have exactly n new cells per each split cell, where n is the
+    // number of anchor points in a cell
+    labelListList cellAddedCells(mesh_.nCells());
+
+    // Get cell zone mesh
+    const cellZoneMesh& cellZones = mesh_.cellZones();
+
+    forAll(cellAnchorPoints, cellI)
+    {
+        // Check whether this is a split cell
+        if (cellMidPoint[cellI] > -1)
+        {
+            // Get cell anchors
+            const labelList& cAnchors = cellAnchorPoints[cellI];
+
+            // Set the total number of added cells to number of anchors
+            labelList& cAdded = cellAddedCells[cellI];
+            cAdded.setSize(cAnchors.size());
+
+            // Original cell has index 0
+            cAdded[0] = cellI;
+
+            // Update refinement level indicator field to 1 since this original
+            // cell will be refined
+            refinementLevelIndicator_[cellI] = REFINED;
+
+            // Add other cells
+            for (label i = 1; i < cAdded.size(); ++i)
+            {
+                cAdded[i] = ref.setAction
+                (
+                    polyAddCell
+                    (
+                        -1,                         // Master point
+                        -1,                         // Master edge
+                        -1,                         // Master face
+                        cellI,                      // Master cell
+                        cellZones.whichZone(cellI)  // Zone for cell
+                    )
+                );
+            }
+        }
+    }
+
+
+    // PART 6: Adding faces
+
+    // 6.1. Existing faces that get split (into n faces where n is the number of
+    //      points or edges)
+    // 6.2. Existing faces that do not get split but only edges get split
+    // 6.3. Existing faces that do not get split but get new owner/neighbour
+    // 6.4. New internal faces inside split cells.
+
+    if (debug)
+    {
+        Pout<< "polyhedralRefinement::setRefinementInstruction(...)" << nl
+            << " Marking faces to be handled"
+            << endl;
+    }
+
+    // Get all faces to split:
+    // a) All faces of a cell being split
+    // b) All faces that are being split
+    // c) Both faces of an edge that is being split
+    boolList facesToSplit(mesh_.nFaces(), false);
+
+    // Get edge faces
+    const labelListList& meshEdgeFaces = mesh_.edgeFaces();
+
+    // a) All faces of a cell that is being split
+    forAll(cellMidPoint, cellI)
+    {
+        if (cellMidPoint[cellI] > -1)
+        {
+            const cell& cFaces = meshCells[cellI];
+
+            forAll(cFaces, i)
+            {
+                facesToSplit[cFaces[i]] = true;
+            }
+        }
+    }
+
+    // b) All faces that are being split
+    forAll(faceMidPoint, faceI)
+    {
+        if (faceMidPoint[faceI] > -1)
+        {
+            facesToSplit[faceI] = true;
+        }
+    }
+
+    // c) Both faces of an edge that are being split
+    forAll(edgeMidPoint, edgeI)
+    {
+        if (edgeMidPoint[edgeI] > -1)
+        {
+            const labelList& eFaces = meshEdgeFaces[edgeI];
+
+            forAll(eFaces, i)
+            {
+                facesToSplit[eFaces[i]] = true;
+            }
+        }
+    }
+
+    // Note: after splitting a certain face during parts 6.1. to 6.4.,
+    // facesToSplit for that face will be set back to 0, i.e. marked as finished
+
+
+    // PART 6.1. Add/modify faces for each face being split
+
+    if (debug)
+    {
+        Pout<< "polyhedralRefinement::setRefinementInstruction(...)" << endl
+            << "Splitting faces..." << endl;
+    }
+
+    forAll(faceMidPoint, faceI)
+    {
+        if (faceMidPoint[faceI] > -1 && facesToSplit[faceI])
+        {
+            // Face has not been split.
+            // Note: although facesToSplit can't be different than 1 here and
+            // the second check can be ommitted, it is left for clarity
+
+            // Get the face
+            const face& f = meshFaces[faceI];
+
+            // Flag to control whether the original faceI has been used
+            // Note: original face gets modified, other n - 1 faces are added,
+            // where n is the number of points/edges of a face
+            bool modifiedFace = false;
+
+            // Get anchor level for the face
+            const label& anchorLevel = faceAnchorLevel[faceI];
+
+            // New face always has four points/edges for arbitrary polygon
+            face newFace(4);
+
+            // Loop through all points of original face
+            forAll(f, fp)
+            {
+                const label& pointI = f[fp];
+
+                if (pointLevel_[pointI] <= anchorLevel)
+                {
+                    // This point is anchor, start collecting face
+
+                    // Create dynamic list (because of append) for face vertices
+                    // and append the first (anchor) point
+                    DynamicList<label> faceVerts(4);
+                    faceVerts.append(pointI);
+
+                    // Walk forward to mid point.
+                    // - if next is +2 midpoint is +1
+                    // - if next is +1 it is midpoint
+                    // - if next is +0 there has to be edgeMidPoint
+
+                    // Appends all points from this point to face mid point
+                    walkFaceToMid
+                    (
+                        edgeMidPoint,
+                        anchorLevel,
+                        faceI,
+                        fp,
+                        faceVerts
+                    );
+
+                    // Append face mid point
+                    faceVerts.append(faceMidPoint[faceI]);
+
+                    // Append all points from face mid point to starting point
+                    walkFaceFromMid
+                    (
+                        edgeMidPoint,
+                        anchorLevel,
+                        faceI,
+                        fp,
+                        faceVerts
+                    );
+
+                    // Transfer dynamic list to a face (ordinary list)
+                    newFace.transfer(faceVerts);
+                    faceVerts.clear();
+
+                    // Set new owner/neighbour indices based on split cells
+                    label own, nei;
+                    setNewFaceNeighbours
+                    (
+                        cellAnchorPoints,
+                        cellAddedCells,
+                        faceI,
+                        pointI,           // Anchor point
+
+                        own,
+                        nei
+                    );
+
+
+                    if (debug)
+                    {
+                        // Get mesh cell centres
+                        const vectorField& meshCellCentres =
+                            mesh_.cellCentres();
+
+                        if (mesh_.isInternalFace(faceI))
+                        {
+                            const label oldOwn = meshFaceOwner[faceI];
+                            const label oldNei = meshFaceNeighbour[faceI];
+
+                            // Print info only with deep debug level
+                            if (debug > 1)
+                            {
+                                Pout<< "Split internal face: " << faceI
+                                    << ", verts: " << f
+                                    << ", into quad: " << newFace << nl
+                                    << "owner: " << oldOwn
+                                    << ", neighbour: " << oldNei << endl;
+                            }
+
+                            checkInternalOrientation
+                            (
+                                ref,
+                                oldOwn,
+                                faceI,
+                                meshCellCentres[oldOwn],
+                                meshCellCentres[oldNei],
+                                newFace
+                            );
+                        }
+                        else
+                        {
+                            const label oldOwn = meshFaceOwner[faceI];
+
+                            // Print info only with deep debug level
+                            if (debug > 1)
+                            {
+                                Pout<< "Split boundary face: " << faceI
+                                    << ", verts: " << f
+                                    << ", into quad: " << newFace << nl
+                                    << "owner: " << oldOwn << endl;
+                            }
+
+                            checkBoundaryOrientation
+                            (
+                                ref,
+                                oldOwn,
+                                faceI,
+                                meshCellCentres[oldOwn],
+                                meshFaceCentres[faceI],
+                                newFace
+                            );
+                        }
+                    } // End debug
+
+
+                    if (!modifiedFace)
+                    {
+                        // Modify first face
+                        modifiedFace = true;
+                        modifyFace(ref, faceI, newFace, own, nei);
+                    }
+                    else
+                    {
+                        // Add additional faces
+                        addFace(ref, faceI, newFace, own, nei);
+                    }
+                } // End point anchor check
+            } // End for all points
+
+            // Mark face as handled
+            facesToSplit[faceI] = false;
+        }
+    }
+
+
+    // PART 6.2. Modify faces that do not get split but have edges that are
+    // being split
+
+    if (debug)
+    {
+        Pout<< "polyhedralRefinement::setRefinementInstruction(...)" << nl
+            << "Modifying faces with split edges..."
+            << endl;
+    }
+
+    // Get face edges
+    const labelListList& meshFaceEdges = mesh_.faceEdges();
+
+    forAll(edgeMidPoint, edgeI)
+    {
+        if (edgeMidPoint[edgeI] > -1)
+        {
+            // This is an edge that is going to be split, get edge faces
+            const labelList& eFaces = meshEdgeFaces[edgeI];
+
+            // Loop through all faces of an edge
+            forAll(eFaces, i)
+            {
+                // Get face index
+                const label faceI = eFaces[i];
+
+                // Check whether this is not a face that has been marked for
+                // splitting and that the face has not been handled yet. The
+                // second check is necessary since we go through edge faces
+                // instead of just faces
+                if (faceMidPoint[faceI] < 0 && facesToSplit[faceI])
+                {
+                    // This is unsplit face that has not been handled
+
+                    // Get face and face edges
+                    const face& f = meshFaces[faceI];
+                    const labelList& fEdges = meshFaceEdges[faceI];
+
+                    // Create a dynamic list containing new face vertices
+                    DynamicList<label> newFaceVerts(f.size());
+
+                    // Append all original points and all edge mid points
+                    forAll(f, fp)
+                    {
+                        newFaceVerts.append(f[fp]);
+
+                        const label edgeI = fEdges[fp];
+
+                        if (edgeMidPoint[edgeI] > -1)
+                        {
+                            newFaceVerts.append(edgeMidPoint[edgeI]);
+                        }
+                    }
+
+                    face newFace;
+                    newFace.transfer(newFaceVerts.shrink());
+
+
+                    // The point with the lowest level should be an anchor
+                    // point of the neighbouring cells.
+                    const label anchorFp = findMinLevel(f);
+
+                    label own, nei;
+                    setNewFaceNeighbours
+                    (
+                        cellAnchorPoints,
+                        cellAddedCells,
+                        faceI,
+                        f[anchorFp],      // Anchor point
+
+                        own,
+                        nei
+                    );
+
+
+                    if (debug)
+                    {
+                        // Get mesh cell centres
+                        const vectorField& meshCellCentres =
+                            mesh_.cellCentres();
+
+                        if (mesh_.isInternalFace(faceI))
+                        {
+                            const label oldOwn = meshFaceOwner[faceI];
+                            const label oldNei = meshFaceNeighbour[faceI];
+
+                            checkInternalOrientation
+                            (
+                                ref,
+                                oldOwn,
+                                faceI,
+                                meshCellCentres[oldOwn],
+                                meshCellCentres[oldNei],
+                                newFace
+                            );
+                        }
+                        else
+                        {
+                            const label oldOwn = meshFaceOwner[faceI];
+
+                            checkBoundaryOrientation
+                            (
+                                ref,
+                                oldOwn,
+                                faceI,
+                                meshCellCentres[oldOwn],
+                                meshFaceCentres[faceI],
+                                newFace
+                            );
+                        }
+                    } // End debug
+
+                    // Modify the face
+                    modifyFace(ref, faceI, newFace, own, nei);
+
+                    // Mark face as handled
+                    facesToSplit[faceI] = false;
+
+                }// End if unsplit, unhandled face
+            } // End for all edge faces
+        } // End if edge has been cut
+    } // End for all edges
+
+
+    // PART 6.3.: Modify faces that do not get split but whose owner/neighbour
+    // change due to splitting
+
+    if (debug)
+    {
+        Pout<< "polyhedralRefinement::setRefinementInstruction(...)" << nl
+            << " Changing owner/neighbour for otherwise unaffected faces..."
+            << endl;
+    }
+
+    forAll(facesToSplit, faceI)
+    {
+        // All remaining unnaffected faces are the ones whose owner/neighbour
+        // changed
+        if (facesToSplit[faceI])
+        {
+            // Get the face
+            const face& f = meshFaces[faceI];
+
+            // The point with the lowest level should be an anchor point of the
+            // neighbouring cells
+            label anchorFp = findMaxLevel(f);
+
+            label own, nei;
+            setNewFaceNeighbours
+            (
+                cellAnchorPoints,
+                cellAddedCells,
+                faceI,
+                f[anchorFp],      // Anchor point
+
+                own,
+                nei
+            );
+
+            // Modify the face, changing owner and neighbour
+            modifyFace(ref, faceI, f, own, nei);
+
+            // Mark face as handled
+            facesToSplit[faceI] = false;
+        }
+    }
+
+
+    // PART 6.4. Add new internal faces inside split cells
+
+    // We have to find the splitting points between the anchor points. But the
+    // edges between the anchor points might have been split (into two, three or
+    // four edges)
+
+    if (debug)
+    {
+        Pout<< "polyhedralRefinement::setRefinementInstruction(...)" << nl
+            << " Adding new internal faces for split cells..."
+            << endl;
+    }
+
+    // Loop through cells
+    forAll(cellMidPoint, cellI)
+    {
+        if (cellMidPoint[cellI] > -1)
+        {
+            // Cell has been split, create internal faces
+            createInternalFaces
+            (
+                cellAnchorPoints,
+                cellAddedCells,
+                cellMidPoint,
+                faceMidPoint,
+                faceAnchorLevel,
+                edgeMidPoint,
+                cellI,
+                ref
+            );
+        }
+    }
+
+    // Debug: check minimum point index of added points, needs to be equal to
+    // number of points in the original mesh
+    if (debug)
+    {
+        label minPointI = labelMax;
+        label maxPointI = labelMin;
+
+        forAll(cellMidPoint, cellI)
+        {
+            if (cellMidPoint[cellI] > -1)
+            {
+                minPointI = min(minPointI, cellMidPoint[cellI]);
+                maxPointI = max(maxPointI, cellMidPoint[cellI]);
+            }
+        }
+        forAll(faceMidPoint, faceI)
+        {
+            if (faceMidPoint[faceI] > -1)
+            {
+                minPointI = min(minPointI, faceMidPoint[faceI]);
+                maxPointI = max(maxPointI, faceMidPoint[faceI]);
+            }
+        }
+        forAll(edgeMidPoint, edgeI)
+        {
+            if (edgeMidPoint[edgeI] > -1)
+            {
+                minPointI = min(minPointI, edgeMidPoint[edgeI]);
+                maxPointI = max(maxPointI, edgeMidPoint[edgeI]);
+            }
+        }
+
+        if (minPointI != labelMax && minPointI != mesh_.nPoints())
+        {
+            FatalErrorInFunction
+                << "Added point labels not consecutive to existing mesh points."
+                << nl
+                << "mesh_.nPoints():" << mesh_.nPoints()
+                << " minPointI: " << minPointI
+                << " maxPointI: " << maxPointI
+                << abort(FatalError);
+        }
+    }
+}
+
+
+void Foam::polyhedralRefinement::setUnrefinementInstruction
+(
+    batchPolyTopoChange& ref
+) const
+{
+    // Note: assumes that splitPointsToUnrefine_ are set prior to the function
+    // call
+
+    // Check whether the refinementLevelIndicator is valid
+    if (refinementLevelIndicator_.size() != mesh_.nCells())
+    {
+        FatalErrorInFunction
+            << "Refinement level indicator list has invalid size: "
+            << refinementLevelIndicator_.size()
+            << ", number of cells: " << mesh_.nCells()
+            << nl
+            << "Make sure to call setRefinementInstruction(...) before"
+            << " calling setPolyhedralRefinement(...)."
+            << abort(FatalError);
+    }
+
+    // Get point cells necessary for debug and face removal
+    const labelListList& meshPointCells = mesh_.pointCells();
+
+    if (debug)
+    {
+        Pout<< "polyhedralRefinement::setUnrefinementInstruction"
+            << "(batchPolyTopoChange& ref)"
+            << nl
+            << "Checking validity of cellLevel before setting unrefinement."
+            << endl;
+
+        forAll(cellLevel_, cellI)
+        {
+            if (cellLevel_[cellI] < 0)
+            {
+                FatalErrorInFunction
+                    << "Illegal cell level " << cellLevel_[cellI]
+                    << " for cell " << cellI
+                    << abort(FatalError);
+            }
+        }
+
+        // Write split points into a point set
+        pointSet pSet
+        (
+            mesh_,
+            "splitPoints",
+            labelHashSet(splitPointsToUnrefine_)
+        );
+        pSet.write();
+
+        // Write split point cells into a cell set
+        cellSet cSet
+        (
+            mesh_,
+            "splitPointCells",
+            splitPointsToUnrefine_.size()
+        );
+
+        forAll(splitPointsToUnrefine_, i)
+        {
+            // Get point cells and insert them into cell set
+            const labelList& pCells = meshPointCells[splitPointsToUnrefine_[i]];
+
+            forAll(pCells, j)
+            {
+                cSet.insert(pCells[j]);
+            }
+        }
+        cSet.write();
+
+        Pout<< "polyhedralRefinement::setUnrefinementInstruction"
+            << "(batchPolyTopoChange& ref)"
+            << nl
+            << "Writing " << pSet.size()
+            << " points and "
+            << cSet.size() << " cells for unrefinement to" << nl
+            << "pointSet " << pSet.objectPath() << nl
+            << "cellSet " << cSet.objectPath()
+            << endl;
+    }
+
+    // Update refinementLevelIndicator for all cells that will be unrefined
+    forAll(splitPointsToUnrefine_, i)
+    {
+        // Get point cells and mark them for unrefinement
+        const labelList& pCells = meshPointCells[splitPointsToUnrefine_[i]];
+
+        forAll(pCells, j)
+        {
+            refinementLevelIndicator_[pCells[j]] = UNREFINED;
+        }
+    }
+
+    // Create lists needed by face remover
+    labelList cellRegion;
+    labelList cellRegionMaster;
+    labelList facesToRemove;
+
+    // Memory management
+    {
+        // Collect split faces in the hash set, guess size to prevent excessive
+        // resizing
+        labelHashSet splitFaces(12*splitPointsToUnrefine_.size());
+
+        // Get point faces
+        const labelListList& meshPointFaces = mesh_.pointFaces();
+
+        forAll(splitPointsToUnrefine_, i)
+        {
+            // Loop through all faces of this point and insert face index
+            const labelList& pFaces = meshPointFaces[splitPointsToUnrefine_[i]];
+
+            forAll(pFaces, j)
+            {
+                splitFaces.insert(pFaces[j]);
+            }
+        }
+
+        // Check with faceRemover what faces will get removed. Note that this
+        // can be more (but never less) than splitFaces provided.
+        faceRemover_.compatibleRemoves
+        (
+            splitFaces.toc(),   // Pierced faces
+
+            cellRegion,         // Region merged into (-1 for no region)
+            cellRegionMaster,   // Master cell for region
+            facesToRemove       // List of faces to be removed
+        );
+
+        if (facesToRemove.size() != splitFaces.size())
+        {
+            FatalErrorInFunction
+                << "Either the initial set of split points to unrefine does not"
+                << " seem to be consistent or there are no mid points of"
+                << " refined cells."
+                << abort(FatalError);
+        }
+    }
+
+    // Find point region master for every cell region.  This is the central point
+    // from which the coarse cell will be made
+    // The property of the point region master is that all cells that touch it
+    // have the same cell region index
+    // HJ, 6/Sep/2019
+    labelList pointRegionMaster(cellRegionMaster.size(), label(-1));
+
+    // Get point-cell addressing
+    const labelListList& pc = mesh_.pointCells();
+
+    forAll (splitPointsToUnrefine_, i)
+    {
+        const labelList& curPc = pc[splitPointsToUnrefine_[i]];
+
+        label curRegion = -1;
+
+        forAll (curPc, curPcI)
+        {
+            if (curRegion == -1)
+            {
+                // First region found.  Grab it
+                curRegion = cellRegion[curPc[curPcI]];
+            }
+            else
+            {
+                // Region already found.  Check that all other cells that
+                // touch this point have the same region
+                if (curRegion != cellRegion[curPc[curPcI]])
+                {
+                    // Error: different region cells touching in split point
+                    // This is not a valid unrefinement pattern
+                    FatalErrorInFunction
+                        << "Different region cells touching in split point."
+                        << abort(FatalError);
+                }
+            }
+        }
+
+        // Record point region master
+        if (curRegion > -1)
+        {
+            pointRegionMaster[curRegion] = splitPointsToUnrefine_[i];
+        }
+        else
+        {
+            // Error: Cannot find region for point
+            FatalErrorInFunction
+                << "Different region cells touching in split point."
+                << abort(FatalError);
+        }
+    }
+
+    // Insert all commands to combine cells
+    faceRemover_.setRefinement
+    (
+        facesToRemove,
+        cellRegion,
+        // pointRegionMaster, // OpenFOAM does not support master point
+        cellRegionMaster,
+        ref
+    );
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::polyhedralRefinement::polyhedralRefinement
+(
+    const word& name,
+    const dictionary& dict,
+    const label index,
+    const polyTopoChanger& mme
+)
+:
+    refinement(name, dict, index, mme)
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+void Foam::polyhedralRefinement::setCellsToRefine
+(
+    const labelList& refinementCellCandidates
+)
+{
+    if (debug)
+    {
+        Info<< "polyhedralRefinement::setCellsToRefine"
+            << "(const labelList& refinementCellCandidates)" << nl
+            << "Setting cells to refine" << endl;
+    }
+
+    // Create a mark-up field for cells to refine
+    boolList refineCell(mesh_.nCells(), false);
+
+    // Roughly count how many cells we are going to end up with
+    label roughCellCountAfterRefinement = mesh_.nCells();
+
+    // Get cell points to count number of additional cells
+    const labelListList& meshCellPoints = mesh_.cellPoints();
+
+    // Mark initial refinement candidates for refinement only if the cell level
+    // is smaller than the maximum refinement level. Note: stop marking them if
+    // we exceed the rough cell count
+    forAll (refinementCellCandidates, i)
+    {
+        // Get cell index
+        const label& cellI = refinementCellCandidates[i];
+
+        if (roughCellCountAfterRefinement < maxCells_)
+        {
+            // Mark cell for refinement
+            refineCell[cellI] = true;
+
+            // Increment number of cells (nPoints - 1 new cells per cell)
+            roughCellCountAfterRefinement += meshCellPoints[cellI].size() - 1;
+        }
+    }
+
+    // Extend cells across faces using a specified number of refinement buffer
+    // layers
+    for (label i = 0; i < nRefinementBufferLayers_; ++i)
+    {
+        meshTools::extendMarkedCellsAcrossFaces(mesh_, refineCell);
+    }
+
+    // Remove all cells that would exceed the maximum refinement level
+    forAll (refineCell, cellI)
+    {
+        if (refineCell[cellI] && (cellLevel_[cellI] + 1 > maxRefinementLevel_))
+        {
+            refineCell[cellI] = false;
+        }
+    }
+
+    // Make sure that the refinement is face consistent (2:1 consistency) and
+    // point consistent (4:1 consistency) if necessary
+
+    // Counter for additional cells to refine due to consistency in each
+    // iteration and number of iterations
+    label nAddCells = 0;
+    label nIters = 0;
+    label nTotalAddCells = 0;
+
+    do
+    {
+        // Reset counter at the beginning of each iteration
+        nAddCells = 0;
+
+        if (edgeBasedConsistency_)
+        {
+            // Check for 4:1 edge based consistent refinement. Updates
+            // cellsToRefine and returns number of cells added in this iteration
+            nAddCells += edgeConsistentRefinement(refineCell);
+        }
+
+        // Check for 2:1 face based consistent refinement. Updates cellsToRefine
+        // and returns number of cells added in this iteration
+        nAddCells += faceConsistentRefinement(refineCell);
+
+        // Global reduction
+        reduce(nAddCells, sumOp<label>());
+
+        // Increment number of iterations and total number of added cells
+        ++nIters;
+        nTotalAddCells += nAddCells;
+
+	if (debug)
+        {
+            Info<< "Added " << nAddCells << " cells in iteration "
+                << nIters << nl;
+        }
+
+    } while (nAddCells > 0);
+
+    Info<< "Added " << nTotalAddCells // nTotalAddCells already reduced
+        << " cells in " << returnReduce(nIters, maxOp<label>())
+        << " iterations to obtain consistent refinement."
+        << endl;
+
+    // Collect all cells to refine in a dynamic list
+    DynamicList<label> cellsToRefineDynamic(mesh_.nCells());
+
+    forAll (refineCell, cellI)
+    {
+        if (refineCell[cellI])
+        {
+            // Cell marked for refinement, append it
+            cellsToRefineDynamic.append(cellI);
+        }
+    }
+
+    // Transfer the contents into the data member (ordinary list)
+    cellsToRefine_.transfer(cellsToRefineDynamic);
+
+    Info<< "Selected " << returnReduce(cellsToRefine_.size(), sumOp<label>())
+        << " cells to refine." << endl;
+}
+
+
+void Foam::polyhedralRefinement::setSplitPointsToUnrefine
+(
+    const labelList& unrefinementPointCandidates
+)
+{
+    if (debug)
+    {
+        Info<< "polyhedralRefinement::setSplitPointsToUnrefine"
+            << "(const labelList& unrefinementPointCandidates)" << nl
+            << "Setting split points to unrefine." << endl;
+    }
+
+    // Get necessary mesh data
+    const label nPoints = mesh_.nPoints();
+    const labelListList& meshCellPoints = mesh_.cellPoints();
+
+    // PART 1: Mark all split points in the mesh (points that can be unrefined)
+    boolList splitPointsMarkup(nPoints, false);
+
+    // Algorithm: split point is uniquely defined as a point that:
+    // 1. Has pointLevel_ > 0 (obviously),
+    // 2. A point that has the same pointLevel_ as ALL of the points of its
+    //    faces. In other words, for each point, we will look through all the
+    //    faces of the point. For each face, we will visit points and check the
+    //    point level of all of these points. All point levels must be the same
+    //    for this point candidate to be split point. This is quite useful since
+    //    there is no need to store the refinement history
+
+    // Get necessary mesh data
+    const faceList& meshFaces = mesh_.faces();
+    const labelListList& meshPointFaces = mesh_.pointFaces();
+
+    // Loop through all points
+    forAll (meshPointFaces, pointI)
+    {
+        // Get point level of this point
+        const label& centralPointLevel = pointLevel_[pointI];
+
+        if (centralPointLevel < 1)
+        {
+            // Point can't be unrefined as its level is either 0 or
+            // invalid. Continue immediately
+            continue;
+        }
+
+        // Flag to see whether this is a split point candidate
+        bool splitPointCandidate = true;
+
+        // Get face labels for this point
+        const labelList& pFaces = meshPointFaces[pointI];
+
+        // Loop through all point faces
+        forAll (pFaces, i)
+        {
+            // Get face index and the face
+            const label& faceI = pFaces[i];
+            const face& curFace = meshFaces[faceI];
+
+            // Loop through points of the face
+            forAll (curFace, j)
+            {
+                // Get point index
+                const label& pointJ = curFace[j];
+
+                if (pointLevel_[pointJ] != centralPointLevel)
+                {
+                    // Point levels are different, this can't be a split point,
+                    // set flag to false and break immediatelly
+                    splitPointCandidate = false;
+                    break;
+                }
+                // else: this is still potential split point candidate so
+                //       there's nothing to do
+            } // End for all points of this face
+
+            // Check whether this can't be a split point already and break out
+            // immediately
+            if (!splitPointCandidate)
+            {
+                break;
+            }
+        } // End for all point faces
+
+        // At this point, if the flag is still true, this is a split point
+        if (splitPointCandidate)
+        {
+            splitPointsMarkup[pointI] = true;
+        }
+    }
+
+    // Note: if there is no dynamic load balancing, points at the boundary
+    // cannot be split points by definition. However, in dynamic load balancing
+    // runs, it is possible that a split point ends on processor boundary, in
+    // which case we will simply avoid (actually delay) unrefining until this
+    // becomes internal point again. VV, 4/Jul/2018.
+    const label nInternalFaces = mesh_.nInternalFaces();
+    const label nFaces = mesh_.nFaces();
+
+    for (label faceI = nInternalFaces; faceI < nFaces; ++faceI)
+    {
+        // Get the face and make sure that the points are unmarked
+        const face& f = meshFaces[faceI];
+
+        forAll (f, fpI)
+        {
+            splitPointsMarkup[f[fpI]] = false;
+        }
+    }
+
+    // PART 2: Mark all unrefinement point candidates that are split points at
+    // the same time (basically the intersection of split points and candidates)
+
+    // Create markup field of split points to unrefine
+    // True: this is a split point which should be unrefined
+    // False: this is either not a split point or it shouldn't be unrefined
+    boolList splitPointsToUnrefine(nPoints, false);
+
+    // Loop through all unrefinement candidates
+    forAll (unrefinementPointCandidates, i)
+    {
+        // Get point index
+        const label& pointI = unrefinementPointCandidates[i];
+
+        if (splitPointsMarkup[pointI])
+        {
+            // This is a split point, mark it for unrefinement
+            splitPointsToUnrefine[pointI] = true;
+        }
+    }
+
+
+    // PART 3: Make sure that we skip unrefining around split points that
+    // possibly have cells around that will be refined
+
+    // Mark cells that need to be protected (will be refined in this iteration)
+    boolList protectedCell(mesh_.nCells(), false);
+
+    // Loop through cells to refine and mark them
+    forAll (cellsToRefine_, i)
+    {
+        protectedCell[cellsToRefine_[i]] = true;
+    }
+
+    // Extend protected cells across points using a specified number of
+    // unrefinement buffer layers
+    for (label i = 0; i < nUnrefinementBufferLayers_; ++i)
+    {
+        meshTools::extendMarkedCellsAcrossPoints(mesh_, protectedCell);
+    }
+
+    // Loop through all cells and if the cell should be protected, protect all
+    // of its points from unrefinement
+    forAll (protectedCell, cellI)
+    {
+        if (protectedCell[cellI])
+        {
+            // Get list of cell points for this protected cell
+            const labelList& cPoints = meshCellPoints[cellI];
+
+            // Loop through cell points and make sure that they are not marked
+            // for unrefinement
+            forAll (cPoints, j)
+            {
+                splitPointsToUnrefine[cPoints[j]] = false;
+            }
+        }
+    }
+
+
+    // PART 4: Ensure face consistent (2:1 constraint) and possibly point
+    // consistent (4:1 constraint) unrefinement
+
+    // Get necessary mesh data
+    const label nCells = mesh_.nCells();
+    const labelListList& meshPointCells = mesh_.pointCells();
+
+    // Count number of removed cells from unrefinement (cells that will not be
+    // unrefined) in each iteration and number of iterations
+    label nRemCells = 0;
+    label nIters = 0;
+    label nTotalRemCells = 0;
+
+    do
+    {
+        // First, create cells to unrefine (all cells sharing point to unrefine)
+        boolList cellsToUnrefine(nCells, false);
+
+        // Loop through all split points to unrefine
+        forAll (splitPointsToUnrefine, pointI)
+        {
+            if (splitPointsToUnrefine[pointI])
+            {
+                // This split point is marked for unrefinement, collect all of
+                // its cells
+                const labelList& pCells = meshPointCells[pointI];
+                forAll (pCells, i)
+                {
+                    cellsToUnrefine[pCells[i]] = true;
+                }
+            }
+        }
+
+        // Reset number of removed cells from unrefinement for this iteration
+        nRemCells = 0;
+
+        if (edgeBasedConsistency_)
+        {
+            // Check for 4:1 edge based consistent unrefinement. Updates
+            // cellsToUnrefine and returns number of removed cells from
+            // unrefinement in this iteration
+            nRemCells += edgeConsistentUnrefinement(cellsToUnrefine);
+        }
+
+        // Check for 2:1 face based consistent unrefinement. Updates
+        // cellsToUnrefine and returns number of removed cells from unrefinement
+        // in this iteration
+        nRemCells += faceConsistentUnrefinement(cellsToUnrefine);
+
+        // Global reduction
+        reduce(nRemCells, sumOp<label>());
+
+        // If we have removed at least one cell from unrefinement, we need to
+        // protect its split points as well from unrefinement
+        if (nRemCells > 0)
+        {
+            // Get point cells
+            const labelListList& meshPointCells = mesh_.pointCells();
+
+            // Loop through all split points to unrefine
+            forAll (splitPointsToUnrefine, pointI)
+            {
+                if (splitPointsToUnrefine[pointI])
+                {
+                    // This is a split point for unrefinement, get the cells
+                    const labelList& pCells = meshPointCells[pointI];
+
+                    // Loop through all point cells
+                    forAll (pCells, i)
+                    {
+                        if (!cellsToUnrefine[pCells[i]])
+                        {
+                            // Cell must not be refined, remove point from
+                            // unrefinement as well
+                            splitPointsToUnrefine[pointI] = false;
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+
+        // Increment number of iterations and number of total removed cells
+        ++nIters;
+        nTotalRemCells += nRemCells;
+
+        if (debug)
+        {
+            Info<< "Removed " << nRemCells << " cells in iteration "
+                << nIters << nl;
+        }
+
+    } while (nRemCells > 0);
+
+    Info<< "Removed " << nTotalRemCells // nTotalRemCells already reduced
+        << " cells in " << returnReduce(nIters, maxOp<label>())
+        << " iterations to obtain consistent unrefinement."
+        << endl;
+
+    // Collect all split points to unrefine in a dynamic list
+    DynamicList<label> splitPointsToUnrefineDynamic(nPoints);
+
+    forAll (splitPointsToUnrefine, pointI)
+    {
+        if (splitPointsToUnrefine[pointI])
+        {
+            // Split point marked for unrefinement, append it
+            splitPointsToUnrefineDynamic.append(pointI);
+        }
+    }
+
+    // Transfer the contents into the data member (ordinary list)
+    splitPointsToUnrefine_.transfer(splitPointsToUnrefineDynamic);
+
+    Info<< "Selected "
+        << returnReduce(splitPointsToUnrefine_.size(), sumOp<label>())
+        << " split points to unrefine." << endl;
+}
+
+
+// ************************************************************************* //
diff --git a/src/dynamicMesh/refinement/polyhedralRefinement/polyhedralRefinement.H b/src/dynamicMesh/refinement/polyhedralRefinement/polyhedralRefinement.H
new file mode 100644
index 0000000000..3a3f8140bb
--- /dev/null
+++ b/src/dynamicMesh/refinement/polyhedralRefinement/polyhedralRefinement.H
@@ -0,0 +1,246 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | foam-extend: Open Source CFD
+   \\    /   O peration     | Version:     5.0
+    \\  /    A nd           | Web:         http://www.foam-extend.org
+     \\/     M anipulation  | For copyright notice see file Copyright
+-------------------------------------------------------------------------------
+License
+    This file is part of foam-extend.
+
+    foam-extend is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation, either version 3 of the License, or (at your
+    option) any later version.
+
+    foam-extend is distributed in the hope that it will be useful, but
+    WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with foam-extend.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::polyhedralRefinement
+
+Description
+    Isotropic refinement of polyhedral cells using the mesh modifier engine
+
+    Each polyhedral cell is split by the following procedure:
+    1. Adding points at the edge centre, face centre and cell centre,
+    2. Adding cells n cells where n is the number of points of the cell,
+    3. Splitting each face into multiple faces going from:
+       existing corner point -> new edge centre point -> new face centre
+       point -> other new edge centre point (sharing the same corner point)
+    4. Adding internal faces going from:
+       new edge centre point -> new face centre point -> new cell centre
+       point -> other new face centre point (sharing the same edge)
+
+SourceFiles
+    polyhedralRefinement.C
+
+Author
+    Vuko Vukcevic, Wikki Ltd.  All rights reserved.
+    Rewrite, porting and changes by Hrvoje Jasak, Wikki Ltd.  All rights reserved.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef polyhedralRefinement_H
+#define polyhedralRefinement_H
+
+#include "refinement.H"
+#include "polyMesh.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                    Class polyhedralRefinement Declaration
+\*---------------------------------------------------------------------------*/
+
+class polyhedralRefinement
+:
+    public refinement
+{
+private:
+
+    // Private Member Functions
+
+        // Helper functions
+
+            //- Get least cell level such that the face has at least three
+            //  points smaller than the level
+            label getAnchorLevel(const label faceI) const;
+
+
+        // Local topology modification functions (operate on cells/faces)
+
+            //- Create all internal faces of split cellI into n cells
+            //   where n is the number of cell points
+            void createInternalFaces
+            (
+                const labelListList& cellAnchorPoints,
+                const labelListList& cellAddedCells,
+                const labelList& cellMidPoint,
+                const labelList& faceMidPoint,
+                const labelList& faceAnchorLevel,
+                const labelList& edgeMidPoint,
+                const label cellI,
+                batchPolyTopoChange& ref
+            ) const;
+
+
+        // Topological change helper functions
+
+            //- Get cell added to point of cellI (if any)
+            label getAnchorCell
+            (
+                const labelListList& cellAnchorPoints,
+                const labelListList& cellAddedCells,
+                const label cellI,
+                const label faceI,
+                const label pointI
+            ) const;
+
+            //- Set new owner and neighbour (in unspecified order) of pointI
+            //  on faceI
+            void setNewFaceNeighbours
+            (
+                const labelListList& cellAnchorPoints,
+                const labelListList& cellAddedCells,
+                const label faceI,
+                const label pointI,
+
+                label& own,
+                label& nei
+            ) const;
+
+            //- Find index of point with wantedLevel, starting from fp
+            label findLevel
+            (
+                const face& f,
+                const label startFp,
+                const bool searchForward,
+                const label wantedLevel
+            ) const;
+
+            //- Store in maps correspondence from midpoint to anchors and
+            //  faces. Used when creating internal faces
+            label storeMidPointInfo
+            (
+                const labelListList& cellAnchorPoints,
+                const labelListList& cellAddedCells,
+                const labelList& cellMidPoint,
+                const labelList& edgeMidPoint,
+                const label cellI,
+                const label faceI,
+                const bool faceOrder,
+                const label midPointI,
+                const label anchorPointI,
+                const label faceMidPointI,
+
+                Map<edge>& midPointToAnchors,
+                Map<edge>& midPointToFaceMids,
+                batchPolyTopoChange& ref
+            ) const;
+
+            //- If p0 and p1 are existing vertices check if edge is split
+            //  and insert splitPoint. Used with storing mid point
+            void insertEdgeSplit
+            (
+                const labelList& edgeMidPoint,
+                const label p0,
+                const label p1,
+                DynamicList<label>& verts
+            ) const;
+
+
+        // Copy control
+
+            //- Disallow default bitwise copy construct
+            polyhedralRefinement(const polyhedralRefinement&) = delete;
+
+            //- Disallow default bitwise assignment
+            void operator=(const polyhedralRefinement&) = delete;
+
+
+protected:
+
+    // Protected Pure Virtual Member Functions
+
+        // Global topology modification functions (operate on whole polyMesh)
+
+            //- Set refinement instruction
+            virtual void setRefinementInstruction
+            (
+                batchPolyTopoChange& ref
+            ) const;
+
+            //- Set unrefinement instruction
+            virtual void setUnrefinementInstruction
+            (
+                batchPolyTopoChange& ref
+            ) const;
+
+
+public:
+
+    //- Runtime type information
+    TypeName("polyhedralRefinement");
+
+
+    // Constructors
+
+        //- Construct from dictionary
+        polyhedralRefinement
+        (
+            const word& name,
+            const dictionary& dict,
+            const label index,
+            const polyTopoChanger& mme
+        );
+
+
+    //- Destructor
+    virtual ~polyhedralRefinement() = default;
+
+
+    // Member Functions
+
+        // Edit
+
+            //- Set cells to refine given a list of refinement
+            //  candidates. Refinement candidates are extended within the
+            //  function due to possible 4:1 conflicts and specified number of
+            //  buffer layers.
+            //  Note: must be called BEFORE setSplitPointsToUnrefine
+            virtual void setCellsToRefine
+            (
+                const labelList& refinementCellCandidates
+            );
+
+            //- Set split points to unrefine given a list of all mesh points
+            //  that are candidates for unrefinement. Split points are
+            //  determined as a subset of unrefinement candidates, avoiding
+            //  splitting points of cells that are going to be refined at the
+            //  same time and ensuring consistent unrefinement.
+            //  Note: must be called AFTER setCellsToRefine
+            virtual void setSplitPointsToUnrefine
+            (
+                const labelList& unrefinementPointCandidates
+            );
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/dynamicMesh/refinement/prismatic2DRefinement/prismatic2DRefinement.C b/src/dynamicMesh/refinement/prismatic2DRefinement/prismatic2DRefinement.C
new file mode 100644
index 0000000000..87595e58cb
--- /dev/null
+++ b/src/dynamicMesh/refinement/prismatic2DRefinement/prismatic2DRefinement.C
@@ -0,0 +1,2978 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | foam-extend: Open Source CFD
+   \\    /   O peration     | Version:     5.0
+    \\  /    A nd           | Web:         http://www.foam-extend.org
+     \\/     M anipulation  | For copyright notice see file Copyright
+-------------------------------------------------------------------------------
+License
+    This file is part of foam-extend.
+
+    foam-extend is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation, either version 3 of the License, or (at your
+    option) any later version.
+
+    foam-extend is distributed in the hope that it will be useful, but
+    WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with foam-extend.  If not, see <http://www.gnu.org/licenses/>.
+
+Author
+    Vuko Vukcevic, Wikki Ltd.  All rights reserved.
+
+\*---------------------------------------------------------------------------*/
+
+#include "prismatic2DRefinement.H"
+#include "cellSet.H"
+#include "faceSet.H"
+#include "pointSet.H"
+#include "emptyPolyPatch.H"
+#include "wedgePolyPatch.H"
+#include "addToRunTimeSelectionTable.H"
+#include "meshTools.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(prismatic2DRefinement, 0);
+    addToRunTimeSelectionTable
+    (
+        polyMeshModifier,
+        prismatic2DRefinement,
+        dictionary
+    );
+}
+
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+Foam::label Foam::prismatic2DRefinement::getAnchorLevel
+(
+    const label faceI,
+    const label nPoints
+) const
+{
+    // Get the face
+    const face& f = mesh_.faces()[faceI];
+
+    // Sanity check for expected number of points
+    if (nPoints != 3 && nPoints != 4)
+    {
+        FatalErrorInFunction
+            << "Trying to find anchor level with " << nPoints << " points"
+            << " smaller than anchor level. Only nPoints = 3 and 4 are"
+            << " supported."
+            << abort(FatalError);
+    }
+
+    // Sanity check: if we are expecting to find 4 points on a face which is not
+    // on special patch (empty or wedge) and we find a face with 3 points, issue
+    // an error
+    if (f.size() <= 3 && nPoints == 4)
+    {
+        FatalErrorInFunction
+            << "Expected to find at least 4 points with level lower than"
+            << " anchor level."
+            << nl
+            << "Make sure to call this function with nPoints = 4 only if"
+            << " you do not expect triangular faces."
+            << abort(FatalError);
+    }
+
+    if (f.size() <= nPoints)
+    {
+        return pointLevel_[f[findMaxLevel(f)]];
+    }
+    else
+    {
+        const label& ownLevel = cellLevel_[mesh_.faceOwner()[faceI]];
+
+        if (countAnchors(f, ownLevel) >= nPoints)
+        {
+            return ownLevel;
+        }
+        else if (countAnchors(f, ownLevel + 1) >= nPoints)
+        {
+            return ownLevel + 1;
+        }
+        else
+        {
+            return -1;
+        }
+    }
+}
+
+
+void Foam::prismatic2DRefinement::appendFaceSplitInfo
+(
+    const label& faceI,
+    const boolList& edgeOnPatchToCut,
+    const labelList& edgeMidPoint,
+    DynamicList<label>& splitFacesIntoTwo,
+    DynamicList<Pair<label> >& splitFacesEmptyEdges
+) const
+{
+    // First append the face into the list
+    splitFacesIntoTwo.append(faceI);
+
+    // Grab all edges of the face
+    const labelList& curEdges = mesh_.faceEdges()[faceI];
+
+    // Create placeholders for two edge levels. Initialise with -1
+    // for sanity checks later on
+    label specialPatchEdgeI = -1;
+    label specialPatchEdgeJ = -1;
+
+    // Count number of edges for sanity checks
+    label nEdgesOnSpecialPatch = 0;
+
+    // Collect the two edge labels found on the special patch (empty or wedge)
+    forAll (curEdges, i)
+    {
+        // Get edge index
+        const label edgeI = curEdges[i];
+
+        if (edgeOnPatchToCut[edgeI])
+        {
+            // This edge is on special patch (empty or wedge), check whether it
+            // is first, second or invalid
+            switch (nEdgesOnSpecialPatch)
+            {
+                case 0:
+                    specialPatchEdgeI = edgeI;
+                    break;
+                case 1:
+                    specialPatchEdgeJ = edgeI;
+                    break;
+                default:
+                    FatalErrorInFunction
+                        << "Found more than two edges on face " << faceI
+                        << " on the special patch (empty or wedge)."
+                        << nl
+                        << "Either this is not a valid 2D mesh or"
+                        << " we are visiting wrong faces."
+                        << abort(FatalError);
+            }
+
+            // Increment the counter
+            ++nEdgesOnSpecialPatch;
+
+        } // End if edge on special patch (empty or wedge)
+
+    } // End loop over all edges
+
+    // Debug: additional check whether the two edges are marked for
+    // refinement (they should be)
+    if (debug)
+    {
+        if (edgeMidPoint[specialPatchEdgeI] == -1)
+        {
+            FatalErrorInFunction
+                << "Empty patch edge with index: " << specialPatchEdgeI
+                << " not marked for splitting"
+                << nl
+                << "Check edgeMidPoint selection algorithm."
+                << abort(FatalError);
+        }
+
+        if (edgeMidPoint[specialPatchEdgeI] == -1)
+        {
+            FatalErrorInFunction
+                << "Empty patch edge with index: " << specialPatchEdgeJ
+                << " not marked for splitting"
+                << nl
+                << "Check edgeMidPoint selection algorithm."
+                << abort(FatalError);
+        }
+    }
+
+    // At this point, we should have the two edges we were looking
+    // for, collect them into the list with additional sanity check
+    if (specialPatchEdgeI > -1 && specialPatchEdgeJ > -1)
+    {
+        // Append the list of two edges in increasing order (just in
+        // case we end up needing this information
+        if (specialPatchEdgeI < specialPatchEdgeJ)
+        {
+            splitFacesEmptyEdges.append
+            (
+                Pair<label>(specialPatchEdgeI, specialPatchEdgeJ)
+            );
+        }
+        else
+        {
+            splitFacesEmptyEdges.append
+            (
+                Pair<label>(specialPatchEdgeJ, specialPatchEdgeI)
+            );
+        }
+    }
+    else
+    {
+        FatalErrorInFunction
+            << "Found invalid indices for edges on special patches:"
+            << nl
+            << "specialPatchEdgeI: " << specialPatchEdgeI
+            << ", specialPatchEdgeJ: " << specialPatchEdgeJ
+            << nl
+            << "Something went wrong. Check face edges."
+            << abort(FatalError);
+    }
+}
+
+
+void Foam::prismatic2DRefinement::setNewFaceNeighbours
+(
+    const HashTable
+    <
+        label,
+        Pair<label>,
+        Hash<FixedList<label, 2> >
+    >& pointCellToAddedCellMap,
+    const labelListList& cellAddedCells,
+    const label& faceI,
+    const label& pointI,
+
+    label& own,
+    label& nei
+) const
+{
+    // Get anchor cell for this anchor point on owner side
+    const label ownCellI = mesh_.faceOwner()[faceI];
+
+    // Get cell added cells for owner cell
+    const labelList& cAddedOwn = cellAddedCells[ownCellI];
+
+    // If the cell added cells list is not empty, return the necessary cell
+    // index fetched with pointCellToAddedCellMap
+    const Pair<label> pointOwnerCellPair(pointI, ownCellI);
+
+    if (cAddedOwn.empty())
+    {
+        // Cell added cells is empty for owner, fetch original owner
+        own = ownCellI;
+    }
+    else if (!pointCellToAddedCellMap.found(pointOwnerCellPair))
+    {
+        // Point-cell pair not found, meaning that we need to search for the
+        // closest point which has lower level than this point. This happens if
+        // we are splitting a face that has already been split but has different
+        // owner/neighbour levels (e.g. owner was refined, but the neighbour was
+        // not in the previous time step). It is possible that we end up with
+        // splitting this face with point levels e.g. (1 1 0 0). Therefore, we
+        // need to search for the point with minimum level on the edges sharing
+        // this point.
+
+        // Find point in the local faces addressing
+        const face& f = mesh_.faces()[faceI];
+        const label fpI = f.find(pointI);
+
+        if (fpI == -1)
+        {
+            FatalErrorInFunction
+                << "Point: " << pointI << " not found in face: " << f
+                << ", with face index: " << faceI
+                << nl
+                << "Point must belong to the face."
+                << nl
+                << "Error encounted when dealing with owner cell: "
+                << ownCellI
+                << abort(FatalError);
+        }
+
+        // Find the global point index with minimum edge connected level
+        const label anchorPointI = findMinEdgeConnectedLevel
+        (
+            fpI,                      // current face point
+            faceI,                    // face index
+            f,                        // face
+            mesh_.faceEdges()[faceI], // face edges
+            mesh_.edges()             // mesh edges
+        );
+
+        // If the point is the same as pointI, we did not find any valid point
+        if (anchorPointI == pointI)
+        {
+            FatalErrorInFunction
+                << "Could not find different adjacent anchor point."
+                << nl
+                << "pointI: " << pointI << " faceI: " << faceI
+                << "Error encounted when dealing with owner cell: "
+                << ownCellI
+                << abort(FatalError);
+        }
+
+        // Set owner cell
+        own = cAddedOwn
+        [
+            pointCellToAddedCellMap[Pair<label>(anchorPointI, ownCellI)]
+        ];
+    }
+    else
+    {
+        // Cell added cells is not empty and the mapping is found. Set owner
+        // from mapping
+        own = cAddedOwn[pointCellToAddedCellMap[pointOwnerCellPair]];
+    }
+
+    if (mesh_.isInternalFace(faceI))
+    {
+        // Get anchor cell for this anchor point on neighbour side
+        const label neiCellI = mesh_.faceNeighbour()[faceI];
+
+        // Get cell added cells for neighbour cell
+        const labelList& cAddedNei = cellAddedCells[neiCellI];
+
+        // If the cell added cells list is not empty, return the necessary cell
+        // index fetched with pointCellToAddedCellMap
+
+        const Pair<label> pointNeighbourCellPair(pointI, neiCellI);
+
+        if (cAddedNei.empty())
+        {
+            // Cell added cells is empty for neighbour, fetch original neighbour
+            nei = neiCellI;
+        }
+        else if (!pointCellToAddedCellMap.found(pointNeighbourCellPair))
+        {
+            // Point-cell pair not found, meaning that we need to search for the
+            // closest point which has lower level than this point. This happens
+            // if we are splitting a face that has already been split but has
+            // different owner/neighbour levels (e.g. owner was refined, but the
+            // neighbour was not in the previous time step). It is possible that
+            // we end up with splitting this face with point levels e.g. (1 1 0
+            // 0). Therefore, we need to search for the point with minimum level
+            // on the edges sharing this point.
+
+            // Find point in the local faces addressing
+            const face& f = mesh_.faces()[faceI];
+            const label fpI = f.find(pointI);
+
+            if (fpI == -1)
+            {
+                FatalErrorInFunction
+                    << "Point: " << pointI << " not found in face: " << f
+                    << ", with face index: " << faceI
+                    << nl
+                    << "Point must belong to the face."
+                    << nl
+                    << "Error encounted when dealing with neighbour cell: "
+                    << neiCellI
+                    << abort(FatalError);
+            }
+
+            // Find the global point index with minimum edge connected level
+            const label anchorPointI = findMinEdgeConnectedLevel
+            (
+                fpI,                      // current face point
+                faceI,                    // face index
+                f,                        // face
+                mesh_.faceEdges()[faceI], // face edges
+                mesh_.edges()             // mesh edges
+            );
+
+            // If the point is the same as pointI, we did not find any valid point
+            if (anchorPointI == pointI)
+            {
+                FatalErrorInFunction
+                    << "Could not find different adjacent anchor point."
+                    << nl
+                    << "pointI: " << pointI << " faceI: " << faceI
+                    << "Error encounted when dealing with neighbour cell: "
+                    << neiCellI
+                    << abort(FatalError);
+            }
+
+            // Set owner cell
+            nei = cAddedNei
+            [
+                pointCellToAddedCellMap[Pair<label>(anchorPointI, neiCellI)]
+            ];
+        }
+        else
+        {
+            // Cell added cells is not empty and the mapping is found. Set
+            // neighbour from mapping
+            nei = cAddedNei[pointCellToAddedCellMap[pointNeighbourCellPair]];
+        }
+    }
+    else
+    {
+        // Boundary face: set neighbour to -1
+        nei = -1;
+    }
+}
+
+
+Foam::label Foam::prismatic2DRefinement::findMinEdgeConnectedLevel
+(
+    const label& fpI,
+    const label& faceI,
+    const face& f,
+    const labelList& fEdges,
+    const edgeList& meshEdges
+) const
+{
+    // Get point index and initialize anchor point
+    const label& pointI = f[fpI];
+
+    label anchorPointI = pointI;
+
+    // Check the other point on edge starting with pointI
+    const label& edgeIndexAfterPoint = fEdges[fpI];
+    const edge& edgeAfter = meshEdges[edgeIndexAfterPoint];
+
+    // Get other point on edge after
+    const label& pointAfter = edgeAfter.otherVertex(pointI);
+
+    if (pointLevel_[pointAfter] < pointLevel_[anchorPointI])
+    {
+        anchorPointI = pointAfter;
+    }
+
+    // Check the other point on edge ending with pointI
+    const label& edgeIndexBeforePoint = fEdges[f.rcIndex(fpI)];
+    const edge& edgeBefore = meshEdges[edgeIndexBeforePoint];
+
+    // Get other point on edge before
+    const label& pointBefore = edgeBefore.otherVertex(pointI);
+
+    if (pointLevel_[pointBefore] < pointLevel_[anchorPointI])
+    {
+        anchorPointI = pointBefore;
+    }
+
+    return anchorPointI;
+}
+
+
+void Foam::prismatic2DRefinement::addFaceMids
+(
+    const labelList& faceMidPoint,
+    const boolList& faceOnPatchToCut,
+    const label& faceI,
+    const label& cellI,
+    face& newFace
+) const
+{
+    // b) faceMidPoint for this face
+    newFace[1] = faceMidPoint[faceI];
+
+    // c) faceMidPoint for the face on the other side
+    // The other face is uniquely defined as the other face of the same cell
+    // which is on special patch (empty or wedge)
+
+    // Get the cell
+    const cell& cFaces = mesh_.cells()[cellI];
+
+    // Loop through cell faces
+    forAll(cFaces, i)
+    {
+        // Get face index
+        const label& faceJ = cFaces[i];
+
+        if (faceOnPatchToCut[faceJ] && (faceI != faceJ))
+        {
+            // This is the face we're looking for, add its
+            // midpoint and double check if it is valid
+            if (faceMidPoint[faceJ] > -1)
+            {
+                newFace[2] = faceMidPoint[faceJ];
+                break;
+            }
+            else
+            {
+                FatalErrorInFunction
+                    << "Other face: "
+                    << faceJ
+                    << " has not been selected for splitting,"
+                    << " while the face on original side: "
+                    << faceI
+                    <<" has been selected."
+                    << abort(FatalError);
+            }
+        } // End if this is our face
+    } // End for all cell faces
+}
+
+
+void Foam::prismatic2DRefinement::checkNewFaceOrientation
+(
+    batchPolyTopoChange& ref,
+    const label& faceI,
+    const face& newFace
+) const
+{
+    // Get mesh cell centres
+    const vectorField& meshCellCentres = mesh_.cellCentres();
+
+    if (mesh_.isInternalFace(faceI))
+    {
+        // Get old owner/neighbour indices
+        const label oldOwn = mesh_.faceOwner()[faceI];
+        const label oldNei = mesh_.faceNeighbour()[faceI];
+
+        // Print info only with deep debug level
+        if (debug > 1)
+        {
+            Pout<< "Split infternal face: " << faceI
+                << ", into quad: " << newFace << nl
+                << "owner: " << oldOwn
+                << ", neighbour: " << oldNei << endl;
+        }
+
+        checkInternalOrientation
+        (
+            ref,
+            oldOwn,
+            faceI,
+            meshCellCentres[oldOwn],
+            meshCellCentres[oldNei],
+            newFace
+        );
+    }
+    else
+    {
+        // Get face centres and old owner
+        const vectorField& meshFaceCentres = mesh_.faceCentres();
+        const label oldOwn = mesh_.faceOwner()[faceI];
+
+        // Print info only with deep debug level
+        if (debug > 1)
+        {
+            Pout<< "Split boundary face: " << faceI
+                << ", into quad: " << newFace << nl
+                << "owner: " << oldOwn << endl;
+        }
+
+        checkBoundaryOrientation
+        (
+            ref,
+            oldOwn,
+            faceI,
+            meshCellCentres[oldOwn],
+            meshFaceCentres[faceI],
+            newFace
+        );
+    }
+}
+
+
+// * * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * //
+
+void Foam::prismatic2DRefinement::setRefinementInstruction
+(
+    batchPolyTopoChange& ref
+) const
+{
+    // Note: assumes that cellsToRefine_ are set prior to the function call
+
+    // Reset refinementLevelIndicator field. Note: the list is cleared in
+    // updateMesh member function after updating cell and point levels
+    if (refinementLevelIndicator_.empty())
+    {
+        // List has been reset correctly, initialise it for this iteration
+        refinementLevelIndicator_.setSize(mesh_.nCells(), UNCHANGED);
+    }
+    else
+    {
+        // List has not been reset correctly, issue an error
+        FatalErrorInFunction
+            << "Refinement level indicator list has not been"
+            << " reset properly." << nl
+            << "Either the call to updateMesh() after performing"
+            << " refinement has not been made or the call to"
+            << " setRefinementInstruction(...) and"
+            << " setUnrefinementInstruction(...) has not been made in"
+            << " correct order." << nl
+            << "Make sure to set refinement, set unrefinement and call"
+            << " updateMesh after performing the topo change."
+            << abort(FatalError);
+    }
+
+
+    // PART 1: Mark cells for refinement
+
+    // Bool list that marks cells which will be refined
+    boolList refineCellsMask(mesh_.nCells(), false);
+    forAll (cellsToRefine_, i)
+    {
+        // Simply mark the cell as refined, there are no additional points to
+        // add (in cell centre for example)
+        refineCellsMask[cellsToRefine_[i]] = true;
+    }
+
+    // Write out cells to refine as a cell set for debug
+    if (debug)
+    {
+        // Note: cellSet is actually a hash table of labels
+        cellSet splitCells(mesh_, "splitCells", cellsToRefine_.size());
+
+        forAll(refineCellsMask, cellI)
+        {
+            if (refineCellsMask[cellI])
+            {
+                // Cell is marked for refinement, insert into cellSet
+                splitCells.insert(cellI);
+            }
+        }
+
+        Pout<< "prismatic2DRefinement::setRefinementInstruction(...)" << nl
+            << "Writing " << splitCells.size()
+            << " cells to split to cellSet " << splitCells.objectPath()
+            << endl;
+
+        splitCells.write();
+    }
+
+
+    // PART 2: Mark edges for refinement and add points to edge centres
+
+    if (debug)
+    {
+        Pout<< "prismatic2DRefinement::setRefinementInstruction(...)" << nl
+            << "Allocating edge midpoints."
+            << endl;
+    }
+
+    // First mark faces and edges on special patches (empty or wedge). This data
+    // is used in PART 2 (collecting edges) and also PART 3 (collecting faces)
+    boolList faceOnPatchToCut(mesh_.nFaces(), false);
+    boolList edgeOnPatchToCut(mesh_.nEdges(), false);
+
+    // Get boundary
+    const polyBoundaryMesh& boundaryMesh = mesh_.boundaryMesh();
+
+    // Get face-edge addressing (for each face, a list of edges)
+    const labelListList& meshFaceEdges = mesh_.faceEdges();
+
+    // Loop through all patches
+    forAll (boundaryMesh, patchI)
+    {
+        // Get current patch
+        const polyPatch& curPatch = boundaryMesh[patchI];
+
+        // Check whether this patch is special (empty or wedge)
+        if (isA<emptyPolyPatch>(curPatch) || isA<wedgePolyPatch>(curPatch))
+        {
+            // Get start and end face labels
+            const label startFaceI = curPatch.start();
+            const label endFaceI = startFaceI + curPatch.size();
+
+            // Mark all the faces and edges on the patch
+            for (label faceI = startFaceI; faceI < endFaceI; ++faceI)
+            {
+                // Mark face
+                faceOnPatchToCut[faceI] = true;
+
+                // Get edges of this face
+                const labelList& curEdges = meshFaceEdges[faceI];
+
+                // Mark all edges
+                forAll (curEdges, i)
+                {
+                    edgeOnPatchToCut[curEdges[i]] = true;
+                }
+            }
+        }
+    }
+
+    // Now that we have marked faces and edges on special patches (empty or
+    // wedge), let's collect refined edges. Refined edges are defined by having
+    // both their point levels <= cell level, i.e. if any cell that gets split
+    // uses this edge and the edge is on special patch (empty or wedge), the
+    // edge needs to be split
+
+    // Get necessary mesh data
+    const labelListList& meshCellEdges = mesh_.cellEdges();
+    const edgeList& meshEdges = mesh_.edges();
+
+    // Mid points for refined edge:
+    // No need to split edge = -1
+    // Label of introduced mid point > -1
+    labelList edgeMidPoint(mesh_.nEdges(), -1);
+
+    // Note: Loop over refined cells
+    forAll (cellsToRefine_, i)
+    {
+        // Get cell index
+        const label& cellI = cellsToRefine_[i];
+
+        // Get edges of this cell
+        const labelList& cEdges = meshCellEdges[cellI];
+
+        forAll (cEdges, j)
+        {
+            // Get edge index and edge
+            const label& edgeI = cEdges[j];
+            const edge& e = meshEdges[edgeI];
+
+            if (edgeOnPatchToCut[edgeI])
+            {
+                // Edge is on special patch (empty or wedge), check whether it
+                // needs to be split
+                if
+                (
+                    pointLevel_[e[0]] <= cellLevel_[cellI]
+                 && pointLevel_[e[1]] <= cellLevel_[cellI]
+                )
+                {
+                    // Point levels of both edge points are <= cell level, mark
+                    // edge for splitting
+                    edgeMidPoint[edgeI] = 12345;
+                }
+            }
+            // Else nothing to do: can't split edges that are not on special
+            // patch (empty or wedge)
+        } // End for all edges of the refined cell
+    } // End for all cells
+
+    // Synchronize edgeMidPoint across coupled patches. Note: use max so that
+    // any split takes precedence.
+    syncTools::syncEdgeList
+    (
+        mesh_,
+        edgeMidPoint,
+        maxEqOp<label>(),
+        labelMin
+    );
+
+    // Now that the refinement trigger is synced, introduce edge points
+
+    // Get necessary mesh data
+    const pointField& meshPoints = mesh_.points();
+
+    // Memory management
+    {
+        // Phase 1: calculate midpoints and sync. This is necessary if we don't
+        // use binary format for writing and we slowly get differences.
+
+        // Allocate storage for edge points
+        pointField edgeMids(mesh_.nEdges(), point(-GREAT, -GREAT, -GREAT));
+
+        forAll(edgeMidPoint, edgeI)
+        {
+            if (edgeMidPoint[edgeI] > -1)
+            {
+                // Edge marked to be split. Get edge centre
+                edgeMids[edgeI] = meshEdges[edgeI].centre(meshPoints);
+            }
+        }
+
+        // Sync across processor boundaries
+        syncTools::syncEdgeList
+        (
+            mesh_,
+            edgeMids,
+            maxEqOp<vector>(),
+            point(-GREAT, -GREAT, -GREAT)
+        );
+
+        // Phase 2: introduce points at the synced locations.
+        forAll(edgeMidPoint, edgeI)
+        {
+            if (edgeMidPoint[edgeI] > -1)
+            {
+                edgeMidPoint[edgeI] = ref.setAction
+                (
+                    polyAddPoint
+                    (
+                        edgeMids[edgeI], // Point
+                        -1,              // Appended point, no master ID
+                        -1,              // Zone for point
+                        true             // Supports a cell
+                    )
+                );
+            }
+        }
+    } // End memory management for syncing/adding edge points
+
+    // Write out edge mid points for split edges for debugging
+    if (debug)
+    {
+        OFstream str(mesh_.time().path()/"edgeMidPoint.obj");
+
+        forAll(edgeMidPoint, edgeI)
+        {
+            if (edgeMidPoint[edgeI] > -1)
+            {
+                // Get edge and write its cell centre
+                const edge& e = meshEdges[edgeI];
+                meshTools::writeOBJ(str, e.centre(meshPoints));
+            }
+        }
+
+        Pout<< "prismatic2DRefinement::setRefinementInstruction(...)" << nl
+            << "Writing centres of edges to split to file " << str.name()
+            << endl;
+    }
+
+
+    // PART 3: Collect faces for refinement. Faces need to be collected in two
+    // distinct categories:
+    // 1. Faces found on special patches (empty or wedge) that will be split
+    //    into n faces (where n is the number of edges per face),
+    // 2. Faces not on special patches (empty or wedge) that will be always
+    //    split into two faces. For each of these faces, collect the two edges
+    //    found on opposing sides of the special patch (empty or wedge).
+
+    if (debug)
+    {
+        Pout<< "prismatic2DRefinement::setRefinementInstruction" << nl
+            << "Allocating face midpoints and collecting faces that are"
+            << " not on special patch (empty or wedge)."
+            << endl;
+    }
+
+    // Get face anchor level based on the face type. For split face found on
+    // special patch (empty or wedge), it is guaranteeed that we will have at
+    // least 3 points with level <= anchor level. For split face not on special
+    // (empty or wedge patch), it is guaranteed that we will have at least 4
+    // points with level <= anchor level. These are the corner points.
+    labelList faceAnchorLevel(mesh_.nFaces());
+    for (label faceI = 0; faceI < mesh_.nFaces(); ++faceI)
+    {
+        if (faceOnPatchToCut[faceI])
+        {
+            // Face on special patch, at least 3 points need to have
+            // level <= anchor level
+            faceAnchorLevel[faceI] = getAnchorLevel(faceI, 3);
+        }
+        else
+        {
+            // Face not on special patch, at least 4 points need to have
+            // level <= anchor level
+            faceAnchorLevel[faceI] = getAnchorLevel(faceI, 4);
+        }
+    }
+
+    // Split faces on special patches (empty or wedge) will be collected in
+    // faceMidPoint list:
+    // Not refined = -1
+    // Shall be refined > -1 (label of added mid point)
+    labelList faceMidPoint(mesh_.nFaces(), -1);
+
+    // Split faces not on special patches (empty or wedge) will be collected
+    // into splitFacesIntoTwo dynamic list. For each of these faces, we also
+    // need to collect its two edges that are found on special patch (empty or
+    // wedge)
+
+    // Allocate enough storage to prevent excessive resizing
+    const label nSplitFacesIntoTwo = 3*cellsToRefine_.size();
+    DynamicList<label> splitFacesIntoTwo(nSplitFacesIntoTwo);
+    DynamicList<Pair<label> > splitFacesEmptyEdges(nSplitFacesIntoTwo);
+
+    // Get necessary mesh data
+    const labelList& meshFaceOwner = mesh_.faceOwner();
+    const labelList& meshFaceNeighbour = mesh_.faceNeighbour();
+
+    const label nFaces = mesh_.nFaces();
+    const label nInternalFaces = mesh_.nInternalFaces();
+
+    // Internal faces: look at cells on both sides. Uniquely determined since
+    // the face itself is guaranteed to be same level as most refined neighbour
+    for (label faceI = 0; faceI < nInternalFaces; ++faceI)
+    {
+        // Get owner data
+        const label& own = meshFaceOwner[faceI];
+        const label& ownLevel = cellLevel_[own];
+        const label newOwnLevel = ownLevel + (refineCellsMask[own] ? 1 : 0);
+
+        // Get neighbour data
+        const label& nei = meshFaceNeighbour[faceI];
+        const label& neiLevel = cellLevel_[nei];
+        const label newNeiLevel = neiLevel + (refineCellsMask[nei] ? 1 : 0);
+
+        if
+        (
+            newOwnLevel > faceAnchorLevel[faceI]
+         || newNeiLevel > faceAnchorLevel[faceI]
+        )
+        {
+            // Note: this is internal face so we don't need to check whether the
+            // face is on special patch (empty or wedge). It can't be by
+            // definition
+
+            // Does two things:
+            // 1. Appends the face to splitFacesIntoTwo list
+            // 2. Append the two edges on special patch (empty or wedge) to
+            //    splitFaceEmptyEdges list
+            appendFaceSplitInfo
+            (
+                faceI,
+                edgeOnPatchToCut,
+                edgeMidPoint,
+                splitFacesIntoTwo,
+                splitFacesEmptyEdges
+            );
+        } // End whether the face needs to be considered (split)
+    } // End loop over all internal faces
+
+    // Coupled patches handled like internal faces except now all information
+    // from neighbour comes from across processor.
+    // Boundary faces are more complicated since the boundary face can
+    // be more refined than its owner (or neighbour for coupled patches)
+    // (does not happen if refining/unrefining only, but does e.g. when
+    // refinining and subsetting)
+
+    // Memory management
+    {
+        // Create list for swapping boundary data
+        labelList newNeiLevel(nFaces - nInternalFaces);
+
+        forAll(newNeiLevel, i)
+        {
+            const label& own = meshFaceOwner[i + nInternalFaces];
+            const label& ownLevel = cellLevel_[own];
+            const label newOwnLevel = ownLevel + (refineCellsMask[own] ? 1 : 0);
+
+            newNeiLevel[i] = newOwnLevel;
+        }
+
+        // Swap the list which now contains data from the other side
+        syncTools::swapBoundaryFaceList(mesh_, newNeiLevel);
+
+        forAll(newNeiLevel, i)
+        {
+            // Get face index
+            const label faceI = i + nInternalFaces;
+
+            // Get owner data (neighbour is available from before)
+            const label& own = meshFaceOwner[faceI];
+            const label& ownLevel = cellLevel_[own];
+            const label newOwnLevel = ownLevel + (refineCellsMask[own] ? 1 : 0);
+
+            if
+            (
+                newOwnLevel > faceAnchorLevel[faceI]
+             || newNeiLevel[i] > faceAnchorLevel[faceI]
+            )
+            {
+                if (faceOnPatchToCut[faceI])
+                {
+                    // This face is on the special patch (empty or wedge) and
+                    // will be split into n faces (n is the number of edges for
+                    // this face) and the face mid point will be added. Mark the
+                    // face for splitting
+                    faceMidPoint[faceI] = 12345;
+                }
+                else
+                {
+                    // Does two things:
+                    // 1. Appends the face to splitFacesIntoTwo list
+                    // 2. Append the two edges on special patch (empty or wedge)
+                    //    to splitFaceEmptyEdges list
+                    appendFaceSplitInfo
+                    (
+                        faceI,
+                        edgeOnPatchToCut,
+                        edgeMidPoint,
+                        splitFacesIntoTwo,
+                        splitFacesEmptyEdges
+                    );
+                } // End if the face is not on special patch (empty or wedge)
+            } // End whether the face needs to be considered
+        } // End loop over all boundary faces
+    } // End memory management for syncing owner/neighbour face levels
+
+
+    // Add face points. Note: no need to sync face mid points (as we did for
+    // edge mid points) since processor faces do not introduce new points, only
+    // faces on special patch (empty or wedge) do
+
+    // Get face centres
+    const vectorField& meshFaceCentres = mesh_.faceCentres();
+
+    // Loop through faces on special patches (empty or wedge) only
+    forAll (boundaryMesh, patchI)
+    {
+        // Get current patch
+        const polyPatch& curPatch = boundaryMesh[patchI];
+
+        // Check whether this patch is special (empty or wedge)
+        if (isA<emptyPolyPatch>(curPatch) || isA<wedgePolyPatch>(curPatch))
+        {
+            // Get start and face labels
+            const label startFaceI = curPatch.start();
+            const label endFaceI = startFaceI + curPatch.size();
+
+            // Loop through all special patch faces (global indexing)
+            for (label faceI = startFaceI; faceI < endFaceI; ++faceI)
+            {
+                if (faceMidPoint[faceI] > -1)
+                {
+                    // Face on special patch (empty or wedge) marked to be
+                    // split. Add the point at face centre and replace
+                    // faceMidPoint with new point label
+
+                    faceMidPoint[faceI] = ref.setAction
+                    (
+                        polyAddPoint
+                        (
+                            meshFaceCentres[faceI], // Point
+                            -1,                     // No master ID
+                            -1,                     // Zone for point
+                            true                    // Supports a cell
+                        )
+                    );
+                } // End if face marked for splitting
+            } // End loop over all faces on special patch (empty or wedge)
+        } // End if special patch check
+    } // End loop for all patches
+
+    // Write out all split faces as a face set for debugging
+    if (debug)
+    {
+        // Create faceSet containing all faces that need to be split into n
+        // faces (n is the number of edges on the face)
+        faceSet splitNFaces(mesh_, "splitNFaces", 3*cellsToRefine_.size());
+
+        forAll(faceMidPoint, faceI)
+        {
+            if (faceMidPoint[faceI] > -1)
+            {
+                splitNFaces.insert(faceI);
+            }
+        }
+
+        Pout<< "prismatic2DRefinement::setRefinementInstruction(...)" << nl
+            << "Writing " << splitNFaces.size()
+            << " faces to split in N to faceSet " << splitNFaces.objectPath()
+            << endl;
+
+        splitNFaces.write();
+
+        // Create faceSet containing all faces that need to be split into 2
+        // faces (faces not on special patch: empty or wedge)
+        faceSet splitTwoFaces(mesh_, "splitTwoFaces", 3*cellsToRefine_.size());
+
+        forAll (splitFacesIntoTwo, i)
+        {
+            // Insert face index into splitTwoFaces
+            splitTwoFaces.insert(splitFacesIntoTwo[i]);
+        }
+
+        Pout<< "prismatic2DRefinement::setRefinementInstruction(...)" << nl
+            << "Writing " << splitTwoFaces.size()
+            << " faces to split in two to faceSet "
+            << splitTwoFaces.objectPath() << endl;
+
+        splitTwoFaces.write();
+    }
+
+
+    // Now we have all the information we need to perform the refinement and we
+    // no longer need to refer to cellsToRefine_. The information is in:
+    // - refineCellsMask = true : cell needs to be split
+    // - edgeMidPoint >= 0     : edge on special patch that needs to be split
+    // - faceMidPoint >= 0     : face on special patch that needs to be split
+    //                           into n faces (where n is the number of edges)
+    // - splitFacesIntoTwo     : list of faces that need to be split into two
+    //                           (face not on special patch)
+    // - splitFacesEmptyEdges  : holds the two edges of the face which needs to
+    //                           be split into two
+
+
+    // PART 4: Get corner and anchor points for all cells
+
+    if (debug)
+    {
+        Pout<< "prismatic2DRefinement::setRefinementInstruction(...)" << nl
+            << "Finding cell anchorPoints" << endl;
+    }
+
+    // Get anchor points for each cell: points that have the same or lower
+    // refinement level as the cell
+    List<DynamicList<label>> cellAnchorPointsDynamic(mesh_.nCells());
+
+    // Loop through all cells
+    forAll(refineCellsMask, cellI)
+    {
+        if (refineCellsMask[cellI])
+        {
+            // The cell will be refined, set capacity to 8 to prevent excessive
+            // resizing
+            cellAnchorPointsDynamic[cellI].setCapacity(8);
+        }
+    }
+
+    // Get necessary mesh data
+    const labelListList& meshPointCells = mesh_.pointCells();
+
+    // Loop through all points
+    forAll(pointLevel_, pointI)
+    {
+        // Get point cells
+        const labelList& pCells = meshPointCells[pointI];
+
+        // Loop through all cells sharing this point
+        forAll(pCells, pCellI)
+        {
+            // Get current cell index
+            const label& cellI = pCells[pCellI];
+
+            if
+            (
+                refineCellsMask[cellI]
+             && pointLevel_[pointI] <= cellLevel_[cellI]
+            )
+            {
+                // This point cell is marked for refinement and its point level
+                // is smaller or equal to cell level, append the point
+                cellAnchorPointsDynamic[cellI].append(pointI);
+            }
+        }
+    }
+
+    // Loop through all cells and check whether at least 6 anchor points
+    // have been found (minimum requirement for a triangular prism)
+
+    // Collect cellAnchorPoint into a List<labelList> instead of
+    // List<dynamicList>
+    labelListList cellAnchorPoints(mesh_.nCells());
+
+    // Get cell points for error output
+    const labelListList& meshCellPoints = mesh_.cellPoints();
+
+    forAll(refineCellsMask, cellI)
+    {
+        // First some sanity checks
+        if (refineCellsMask[cellI])
+        {
+            // Cell selected for refinement
+            if (cellAnchorPointsDynamic[cellI].size() < 6)
+            {
+                // Cell has less than 6 anchor points. Issue an error and report
+                // cell points
+                const labelList& cPoints = meshCellPoints[cellI];
+
+                FatalErrorInFunction
+                    << "Cell " << cellI
+                    << " of level " << cellLevel_[cellI]
+                    << " does not seem to have enough points of "
+                    << " lower level" << endl
+                    << "cellPoints:" << cPoints << endl
+                    << "pointLevels:"
+                    << IndirectList<label>(pointLevel_, cPoints)() << endl
+                    << abort(FatalError);
+            }
+            else if (cellAnchorPointsDynamic[cellI].size() % 2 != 0)
+            {
+                // Cell has odd number of anchor points. This is not allowed and
+                // indicates an invalid mesh
+                const labelList& cPoints = meshCellPoints[cellI];
+
+                FatalErrorInFunction
+                    << "Cell " << cellI
+                    << " of level " << cellLevel_[cellI]
+                    << " has odd number of anchor points"
+                    << " (should be even for 2D mesh). "
+                    << "cellPoints:" << cPoints << endl
+                    << "pointLevels:"
+                    << IndirectList<label>(pointLevel_, cPoints)() << endl
+                    << abort(FatalError);
+            }
+        }
+
+        // Tranfer the dynamic list for each cell into an ordinary list
+        cellAnchorPoints[cellI].transfer(cellAnchorPointsDynamic[cellI]);
+    }
+
+
+    // PART 5: Add the cells
+
+    if (debug)
+    {
+        Pout<< "prismatic2DRefinement::setRefinementInstruction(...)" << nl
+            << " Adding cells."
+            << endl;
+    }
+
+    // We should have exactly n new cells per each split cell, where n is the
+    // number of anchor points in a cell divided by two. In order to determine
+    // owner/neighbours of new and modified faces, we need to know which cell
+    // came from which point. The mapping is not uniquely defined as in
+    // polyhedralRefinement when we had 1 point = 1 cell. Here, we have two
+    // points that correspond to a single cell, one on one side of the special
+    // patch and the other on other side. This information will be collected in
+    // a HashTable<label, Pair<label> >, where the key will be a pair of
+    // global point index and global cell index, while the value is local index
+    // into cellAddedCells list
+    labelListList cellAddedCells(mesh_.nCells());
+    HashTable<label, Pair<label>, Hash<FixedList<label, 2> > >
+        pointCellToAddedCellMap(6*cellsToRefine_.size());
+
+    // Get mesh data
+    const cellZoneMesh& cellZones = mesh_.cellZones();
+    const cellList& meshCells = mesh_.cells();
+    const faceList& meshFaces = mesh_.faces();
+    const labelListList& meshPointEdges = mesh_.pointEdges();
+
+
+    // Loop through all faces
+    forAll(faceMidPoint, faceI)
+    {
+        // Check whether this face needs to be split into n faces
+        if (faceMidPoint[faceI] > -1)
+        {
+            // This is a face that will be split and is on special patch (empty
+            // or wedge) by definition, get the cell index by looking at owner
+            // only
+            const label& cellI = meshFaceOwner[faceI];
+
+            // Get cell added cells
+            labelList& cAdded = cellAddedCells[cellI];
+
+            // Check whether the cell added cells are empty. This means that we
+            // haven't visited the first face yet. If it is not empty, we have
+            // already visited one face, which is enough
+            if (cAdded.empty())
+            {
+                // First face that hasn't been visited. Start adding cells
+                // point-by-point and keep track of mapping necessary for
+                // splitting other (not on special patch: empty or wedge) faces
+                // into two
+
+                // Set the total number of added cells to number of anchors
+                // divided by two. Note: number of anchors needs to be an even
+                // number (6 for triangular prism, 8 for hex, 10 for pentagonal
+                // prism, etc.)
+                const labelList& cAnchors = cellAnchorPoints[cellI];
+                cAdded.setSize(cAnchors.size()/2);
+
+                // Helper variable to distinguish between first and successive
+                // cells (first will have the original index)
+                label cellCounter = 0;
+
+                // Get current face
+                const face& f = meshFaces[faceI];
+
+                // Loop through face points
+                forAll (f, fpI)
+                {
+                    // Get point index
+                    const label& pointI = f[fpI];
+
+                    // Find anchor point in local list if present
+                    const label anchorI = cAnchors.find(pointI);
+
+                    if (anchorI != -1)
+                    {
+                        // This point is anchor, add the cell
+
+                        if (cellCounter == 0)
+                        {
+                            // This is first cell, simply set the existing index
+                            cAdded[cellCounter] = cellI;
+
+                            // Update refinement level indicator field to 1
+                            // since the original cell will be refined
+                            refinementLevelIndicator_[cellI] = REFINED;
+                        }
+                        else
+                        {
+                            // Other cells, need to add the cells
+                            cAdded[cellCounter] = ref.setAction
+                            (
+                                polyAddCell
+                                (
+                                    -1,                         // M. point
+                                    -1,                         // M. edge
+                                    -1,                         // M. face
+                                    cellI,                      // M. cell
+                                    cellZones.whichZone(cellI)  // M. zone
+                                )
+                            );
+                        }
+
+                        // Collect the point-cell mapping into local index
+                        // of cell added cells for point on this side
+                        pointCellToAddedCellMap.insert
+                        (
+                            Pair<label>(pointI, cellI),
+                            cellCounter
+                        );
+
+                        // This is only one side, we need to also collect
+                        // the other point on the other side. Get point edges
+                        // for this point
+                        const labelList& pEdges =
+                            meshPointEdges[pointI];
+
+                        // Loop through point edges
+                        forAll (pEdges, peI)
+                        {
+                            // Get the edge index
+                            const label& edgeI = pEdges[peI];
+
+                            if (!edgeOnPatchToCut[edgeI])
+                            {
+                                // Edge is not on special patch (empty or
+                                // wedge), therefore this is the edge we're
+                                // looking for. Collect the other point of the
+                                // edge
+                                const label pointJ =
+                                    meshEdges[edgeI].otherVertex(pointI);
+
+                                // Collect the point-cell mapping into local
+                                // index of cell added cells for this point
+                                pointCellToAddedCellMap.insert
+                                (
+                                    Pair<label>(pointJ, cellI),
+                                    cellCounter
+                                );
+                            }
+                        }
+
+                        // Now we have finished adding the cell and also
+                        // adding the necessary mapping for this added cell
+
+                        // Increment cell counter
+                        ++cellCounter;
+
+                    } // Else point is not anchor: nothing to do
+                } // End loop over all face points
+
+                // Sanity check: number of counted cells must be
+                // equal to size of cellAddedCells. This means that
+                // we have correctly marked the anchor points
+                if (cellCounter != cAdded.size())
+                {
+                    FatalErrorInFunction
+                        << "Problem while adding cells."
+                        << nl
+                        << "Going through base face on special patch"
+                        << " (empty or wedge) and adding cells, we collected: "
+                        << cellCounter << " cells."
+                        << nl
+                        << "While the number of anchor points is: "
+                        << cAnchors.size()
+                        << nl
+                        << "The number of added cells based on number of anchor"
+                        << " points is: "
+                        << cAdded.size()
+                        << nl
+                        << "Additional information: "
+                        << nl
+                        << "cellI: " << cellI << ", faceI: " << faceI
+                        << abort(FatalError);
+                }
+
+            } // End if cell added cells empty
+        } // End if face needs to be split into n
+    } // End loop over all faces
+
+
+    // PART 6: Adding faces
+
+    // 6.1. Existing faces on special patches (empty or wedge) that get split
+    //      (into n faces where n is the number of points or edges)
+    // 6.2. Existing faces not on special patches that get split into two
+    // 6.3. Existing faces that do not get split but only edges get split
+    // 6.4. Existing faces that do not get split but get new owner/neighbour
+    // 6.5. New internal faces inside split cells
+
+    if (debug)
+    {
+        Pout<< "prismatic2DRefinement::setRefinementInstruction(...)" << nl
+            << " Marking faces to be handled"
+            << endl;
+    }
+
+    // Get all faces to split:
+    // a) All faces of a cell being split
+    // b) All faces on special patch that are being split
+    // c) All faces not on special patch that are being split
+    // d) Both faces of an edge that is being split
+    // Note: although a bit redundant, loop over everything above
+    boolList facesToSplit(mesh_.nFaces(), false);
+
+    // Also collect all split faces which will be needed in 6.3
+    boolList allSplitFaces(mesh_.nFaces(), false);
+
+    // Get edge faces
+    const labelListList& meshEdgeFaces = mesh_.edgeFaces();
+
+    // a) All faces of a cell that is being split
+    forAll(refineCellsMask, cellI)
+    {
+        if (refineCellsMask[cellI])
+        {
+            const cell& cFaces = meshCells[cellI];
+
+            forAll(cFaces, i)
+            {
+                facesToSplit[cFaces[i]] = true;
+            }
+        }
+    }
+
+    // b) All faces on special patch that are being split
+    forAll(faceMidPoint, faceI)
+    {
+        if (faceMidPoint[faceI] > -1)
+        {
+            // Mark face in both lists
+            facesToSplit[faceI] = true; // Used through 6.1-6.5
+            allSplitFaces[faceI] = true; // Used in 6.3
+        }
+    }
+
+    // c) All faces not on special patch that are being split
+    forAll(splitFacesIntoTwo, i)
+    {
+        // Get face index
+        const label& faceI = splitFacesIntoTwo[i];
+
+        // Mark face in both lists
+        facesToSplit[faceI] = true;
+        allSplitFaces[faceI] = true;
+    }
+
+    // d) Both faces of an edge that is being split
+    forAll(edgeMidPoint, edgeI)
+    {
+        if (edgeMidPoint[edgeI] > -1)
+        {
+            const labelList& eFaces = meshEdgeFaces[edgeI];
+
+            forAll(eFaces, i)
+            {
+                facesToSplit[eFaces[i]] = true;
+            }
+        }
+    }
+
+    // Note: after splitting a certain face during parts 6.1. to 6.4.,
+    // facesToSplit for that face will be set back to 0, i.e. marked as finished
+
+
+    // PART 6.1. Add/modify faces for each face on special patch that is being
+    // split
+
+    if (debug)
+    {
+        Pout<< "prismatic2DRefinement::setRefinementInstruction(...)" << endl
+            << "Splitting faces on special patches (empty or wedge)..." << endl;
+    }
+
+    forAll(faceMidPoint, faceI)
+    {
+        if (faceMidPoint[faceI] > -1 && facesToSplit[faceI])
+        {
+            // Face has not been split.
+            // Note: although facesToSplit can't be different than 1 here and
+            // the second check can be ommitted, it is left for clarity
+
+            // Get the face
+            const face& f = meshFaces[faceI];
+
+            // Flag to control whether the original faceI has been used
+            // Note: original face gets modified, other n - 1 faces are added,
+            // where n is the number of points/edges of a face
+            bool modifiedFace = false;
+
+            // Get anchor level for the face
+            const label& anchorLevel = faceAnchorLevel[faceI];
+
+            // New face always has four points/edges for arbitrary polygon
+            face newFace(4);
+
+            // Loop through all points of original face
+            forAll(f, fpI)
+            {
+                const label& pointI = f[fpI];
+
+                if (pointLevel_[pointI] <= anchorLevel)
+                {
+                    // This point is anchor, start collecting face
+
+                    // Create dynamic list (because of append) for face vertices
+                    // and append the first (anchor) point
+                    DynamicList<label> faceVerts(4);
+                    faceVerts.append(pointI);
+
+                    // Walk forward to mid point.
+                    // - if next is +2 midpoint is +1
+                    // - if next is +1 it is midpoint
+                    // - if next is +0 there has to be edgeMidPoint
+
+                    // Appends all points from this point to face mid point
+                    walkFaceToMid
+                    (
+                        edgeMidPoint,
+                        anchorLevel,
+                        faceI,
+                        fpI,
+                        faceVerts
+                    );
+
+                    // Append face mid point
+                    faceVerts.append(faceMidPoint[faceI]);
+
+                    // Append all points from face mid point to starting point
+                    walkFaceFromMid
+                    (
+                        edgeMidPoint,
+                        anchorLevel,
+                        faceI,
+                        fpI,
+                        faceVerts
+                    );
+
+                    // Transfer dynamic list to a face (ordinary list)
+                    newFace.transfer(faceVerts);
+                    faceVerts.clear();
+
+                    // Set new owner/neighbour indices based on split cells
+                    label own, nei;
+                    setNewFaceNeighbours
+                    (
+                        pointCellToAddedCellMap,
+                        cellAddedCells,
+                        faceI,
+                        pointI, // Anchor point index
+
+                        own,
+                        nei
+                    );
+
+                    if (debug)
+                    {
+                        // Check orientation of the split face for debugging
+                        checkNewFaceOrientation(ref, faceI, newFace);
+                    }
+
+
+                    // Finally insert the modification/addition instruction into
+                    // the topo changer engine
+                    if (!modifiedFace)
+                    {
+                        // Modify first face
+                        modifiedFace = true;
+                        modifyFace(ref, faceI, newFace, own, nei);
+                    }
+                    else
+                    {
+                        // Add additional faces
+                        addFace(ref, faceI, newFace, own, nei);
+                    }
+                } // End point anchor check
+            } // End for all points
+
+            // Mark face as handled
+            facesToSplit[faceI] = false;
+
+        } // End if this face needs to be split
+    } // End for all faces
+
+
+    // PART 6.2. Add/modify faces for each face not on special patch that is
+    // being split into two
+
+    if (debug)
+    {
+        Pout<< "prismatic2DRefinement::setRefinementInstruction(...)" << nl
+            << "Splitting faces not on special patches (empty or wedge)..."
+            << endl;
+    }
+
+    // Loop through faces that are not on special patch. These will be split
+    // into two faces only
+    forAll (splitFacesIntoTwo, i)
+    {
+        // Get face index
+        const label& faceI = splitFacesIntoTwo[i];
+
+        // Check whether the face is marked for splitting. A bit redundant but
+        // will be left for clarity
+        if (facesToSplit[faceI])
+        {
+            // Face has not been split, grab the face
+            const face& f = meshFaces[faceI];
+
+            // Additional sanity check
+            if (f.size() != 4)
+            {
+                FatalErrorInFunction
+                    << "The original face has: " << f.size() << " points,"
+                    << " while it should have exactly 4 points in order"
+                    << " to split it in two."
+                    << " faceI: " << faceI
+                    << abort(FatalError);
+            }
+
+            // Flag to control whether the original faceI has been used
+            // Note: original face gets modified, other face gets added
+            bool modifiedFace = false;
+
+            // Get anchor level for the face
+            const label& anchorLevel = faceAnchorLevel[faceI];
+
+            // Mark visited points to avoid adding the face twice
+            boolList visitedPoint(f.size(), false);
+
+            // New face always has four points/edges for 2D face splitting of
+            // a face that is not on special patch
+            face newFace(4);
+
+            // Loop through all points of original face
+            forAll (f, fpI)
+            {
+                // Get point index
+                const label& pointI = f[fpI];
+
+                if
+                (
+                    !visitedPoint[fpI]
+                 && pointLevel_[pointI] <= anchorLevel
+                )
+                {
+                    // This point is anchor and it hasn't been visited yet,
+                    // start collecting face
+
+                    // Collect the new face in the following order:
+                    // 1. This point
+                    // 2. Edge mid points for the edge that contains this point
+                    //    and the edge that is on the other side
+                    // 3. Other point (on the other side)
+
+                    // 1. Set this point and mark it as visited
+                    newFace[0] = pointI;
+                    visitedPoint[fpI] = true;
+
+                    // 2. Get edge mid point for edge containing this point
+                    // Fetch the two edges on both sides
+                    const Pair<label>& edgesOnOppositeSides =
+                        splitFacesEmptyEdges[i];
+
+                    // Get the edge indices and edges
+                    const label& edgeIndexI = edgesOnOppositeSides.first();
+                    const label& edgeIndexJ = edgesOnOppositeSides.second();
+
+                    const edge& edgeI = meshEdges[edgeIndexI];
+                    const edge& edgeJ = meshEdges[edgeIndexJ];
+
+                    // Additional sanity check
+                    if
+                    (
+                        (edgeMidPoint[edgeIndexI] == -1)
+                     || (edgeMidPoint[edgeIndexJ] == -1)
+                    )
+                    {
+                        // Edges are not marked for refinement, issue an error
+                        FatalErrorInFunction
+                            << "Trying to split a face into two, but"
+                            << " edges on special patches (empty or wedge)"
+                            << " are not properly set."
+                            << nl
+                            << "Edge: " << edgeIndexI << " with new point: "
+                            << edgeMidPoint[edgeIndexI]
+                            << nl
+                            << "Edge: " << edgeIndexJ << " with new point: "
+                            << edgeMidPoint[edgeIndexJ]
+                            << abort(FatalError);
+                    }
+
+                    if ((edgeI.start() == pointI) || (edgeI.end() == pointI))
+                    {
+                        // Current point is on edgeI, set edgeI midpoint and
+                        // then edgeJ midpoint
+                        newFace[1] = edgeMidPoint[edgeIndexI];
+                        newFace[2] = edgeMidPoint[edgeIndexJ];
+                    }
+                    else if
+                    (
+                        (edgeJ.start() == pointI) || (edgeJ.end() == pointI)
+                    )
+                    {
+                        // Current is on edgeJ, set edgeJ midpoint and then
+                        // edgeI midpoint
+                        newFace[1] = edgeMidPoint[edgeIndexJ];
+                        newFace[2] = edgeMidPoint[edgeIndexI];
+                    }
+                    else
+                    {
+                        // Point not on either of edges, issue an error
+                        FatalErrorInFunction
+                            << "Trying to split a face into two, but"
+                            << " the point: " << pointI << " can't be found"
+                            << " on either of edges. "
+                            << nl
+                            << "Edge: " << edgeIndexI << " with new point: "
+                            << edgeMidPoint[edgeIndexI]
+                            << nl
+                            << "Edge: " << edgeIndexJ << " with new point: "
+                            << edgeMidPoint[edgeIndexJ]
+                            << abort(FatalError);
+                    }
+
+                    // At this point, we have added three points: original
+                    // point, first edge mid point and second edge mid point.
+
+                    // 3. Add the other point
+                    // Get point edges for this point
+                    const labelList& pEdges = meshPointEdges[pointI];
+
+                    // Loop through all edges
+                    forAll (pEdges, peI)
+                    {
+                        // Get the edge index
+                        const label& pointEdgeI = pEdges[peI];
+
+                        if (!edgeOnPatchToCut[pointEdgeI])
+                        {
+                            // Edge is not on special patch (empty or wedge),
+                            // therefore this is the edge we're looking for.
+                            // Collect the other point
+                            const label pointJ =
+                                meshEdges[pointEdgeI].otherVertex(pointI);
+
+                            // Insert the point into the face at the last
+                            // location
+                            newFace[3] = pointJ;
+
+                            // Mask local point index as visited by going
+                            // through the face again
+                            forAll (f, fpJ)
+                            {
+                                if (f[fpJ] == pointJ)
+                                {
+                                    // Found local index of the point, mask it
+                                    visitedPoint[fpJ] = true;
+                                }
+                            }
+                        }
+                    }
+
+                    // The face is now complete, set new owner/neighbour indices
+                    // based on split cells
+                    label own, nei;
+
+                    // Set new face owner/neighbour pair
+                    setNewFaceNeighbours
+                    (
+                        pointCellToAddedCellMap,
+                        cellAddedCells,
+                        faceI,
+                        pointI, // Anchor point index
+
+                        own,
+                        nei
+                    );
+
+                    // We need to revert the face if the edge between this point
+                    // and the next point is not split. This follows from
+                    // definition of face as ordered set of points (defining
+                    // orientation) and the splitting procedure. Note: edge
+                    // ordering in face is the same as point ordering so the
+                    // point index can be used as first face edge index
+                    if (edgeMidPoint[meshFaceEdges[faceI][fpI]] == -1)
+                    {
+                        newFace = newFace.reverseFace();
+                    }
+
+                    if (debug)
+                    {
+                        // Check orientation of the split face for debugging
+                        checkNewFaceOrientation(ref, faceI, newFace);
+                    }
+
+
+                    // Finally insert the modification/addition instruction into
+                    // the topo changer engine
+                    if (!modifiedFace)
+                    {
+                        // Modify first face
+                        modifiedFace = true;
+                        modifyFace(ref, faceI, newFace, own, nei);
+                    }
+                    else
+                    {
+                        // Add additional faces
+                        addFace(ref, faceI, newFace, own, nei);
+                    }
+                } // End if point is anchored and has not been visited
+            } // End loop over all face points
+
+            // Mark face as handled
+            facesToSplit[faceI] = false;
+
+        } // End if face is split
+    } // End for all faces that should be split into two
+
+
+    // PART 6.3. Modify faces that do not get split but have edges that are
+    // being split
+
+    if (debug)
+    {
+        Pout<< "prismatic2DRefinement::setRefinementInstruction(...)" << nl
+            << "Modifying faces with split edges..."
+            << endl;
+    }
+
+    forAll(edgeMidPoint, edgeI)
+    {
+        if (edgeMidPoint[edgeI] > -1)
+        {
+            // This is an edge that is going to be split, get edge faces
+            const labelList& eFaces = meshEdgeFaces[edgeI];
+
+            // Loop through all faces of an edge
+            forAll(eFaces, i)
+            {
+                // Get face index
+                const label faceI = eFaces[i];
+
+                // Check whether this is not a face that's been split and that
+                // the face has not been handled yet. The second check is
+                // necessary since we go through edge faces instead of just
+                // faces
+                if (!allSplitFaces[faceI] && facesToSplit[faceI])
+                {
+                    // This is unsplit face that has not been handled
+
+                    // Get face and face edges
+                    const face& f = meshFaces[faceI];
+                    const labelList& fEdges = meshFaceEdges[faceI];
+
+                    // Create a dynamic list containing new face vertices
+                    DynamicList<label> newFaceVerts(f.size());
+
+                    // Append all original points and all edge mid points
+                    forAll(f, fpI)
+                    {
+                        newFaceVerts.append(f[fpI]);
+
+                        const label edgeI = fEdges[fpI];
+
+                        if (edgeMidPoint[edgeI] > -1)
+                        {
+                            newFaceVerts.append(edgeMidPoint[edgeI]);
+                        }
+                    }
+
+                    // Create a face from dynamic list by transfer
+                    face newFace(newFaceVerts);
+
+
+                    // The point with the lowest level should be an anchor
+                    // point of the neighbouring cells.
+                    const label anchorFpI = findMinLevel(f);
+
+                    label own, nei;
+                    setNewFaceNeighbours
+                    (
+                        pointCellToAddedCellMap,
+                        cellAddedCells,
+                        faceI,
+                        f[anchorFpI], // Anchor point index
+
+                        own,
+                        nei
+                    );
+
+
+                    if (debug)
+                    {
+                        // Check orientation of the new face for debugging
+                        checkNewFaceOrientation(ref, faceI, newFace);
+                    }
+
+                    // Modify the face
+                    modifyFace(ref, faceI, newFace, own, nei);
+
+                    // Mark face as handled
+                    facesToSplit[faceI] = false;
+
+                } // End if unsplit, unhandled face
+            } // End for all edge faces
+        } // End if edge has been cut
+    } // End for all edges
+
+
+    // PART 6.4: Modify faces that do not get split but whose owner/neighbour
+    // change due to splitting
+
+    if (debug)
+    {
+        Pout<< "prismatic2DRefinement::setRefinementInstruction(...)" << nl
+            << " Changing owner/neighbour for otherwise unaffected faces..."
+            << endl;
+    }
+
+    forAll(facesToSplit, faceI)
+    {
+        // All remaining unnaffected faces are the ones whose owner/neighbour
+        // changed
+        if (facesToSplit[faceI])
+        {
+            // Get the face
+            const face& f = meshFaces[faceI];
+
+            // The point with the lowest level should be an anchor point of the
+            // neighbouring cells
+            label anchorFpI = findMinLevel(f);
+
+            label own, nei;
+            setNewFaceNeighbours
+            (
+                pointCellToAddedCellMap,
+                cellAddedCells,
+                faceI,
+                f[anchorFpI], // Anchor point
+
+                own,
+                nei
+            );
+
+            // Modify the face, changing owner and neighbour
+            modifyFace(ref, faceI, f, own, nei);
+
+            // Mark face as handled
+            facesToSplit[faceI] = false;
+
+        } // End if the face needs to be handled
+    } // End for all faces
+
+
+    // PART 6.5. Add new internal faces inside split cells
+
+    if (debug)
+    {
+        Pout<< "prismatic2DRefinement::setRefinementInstruction(...)" << nl
+            << " Adding new internal faces for split cells..."
+            << endl;
+    }
+
+    // Mark-up filed for visited cells (since we are going through faces)
+    boolList cellsToSplit(mesh_.nCells(), true);
+
+    // Loop through faces in the same way as we did when we were adding
+    // cells. This order is important since it ensures easy determination of
+    // owner/neighbour cells for new faces
+    forAll(faceMidPoint, faceI)
+    {
+        // Get owner of the face. For face on special patch (empty or wedge)
+        const label& cellI = meshFaceOwner[faceI];
+
+        // Check whether this face has been split and whether the cell has been
+        // handled (internal faces already created for this cell)
+        if (faceMidPoint[faceI] > -1 && cellsToSplit[cellI])
+        {
+            // Face is split and hasn't been visited yet. Get the face and edges
+            const face& f = meshFaces[faceI];
+            const labelList& fEdges = meshFaceEdges[faceI];
+
+            // Get anchor points for this cell and cell added cells
+            const labelList& cAnchors = cellAnchorPoints[cellI];
+            const labelList& cAdded = cellAddedCells[cellI];
+
+            // Count number of added faces (helper variable to determine
+            // owner/neighbour)
+            label nAddedFaces = 0;
+
+            // Loop through face points
+            forAll (f, fpI)
+            {
+                // Get point index
+                const label& pointI = f[fpI];
+
+                // If this point is not an anchor, it has already been handled
+                // (by going through anchors), skip
+                if (cAnchors.find(pointI) == -1)
+                {
+                    continue;
+                }
+
+                // Get corresponding edge index and edge (between fpI and
+                // fpI + 1) by definition of faceEdges
+                const label& edgeI = fEdges[fpI];
+                const edge& e = meshEdges[edgeI];
+
+                // Grab other point
+                const label& pointJ = e.otherVertex(pointI);
+
+                if (pointJ == -1)
+                {
+                    // If pointJ is equal to -1, this means that the pointI
+                    // was not found on edge, something went wrong
+                    FatalErrorInFunction
+                        << "Point: " << pointI << " not found on edge: "
+                        << edgeI << nl
+                        << "Looping through face points and face edges did"
+                        << " not ensure synchronous behaviour."
+                        << abort(FatalError);
+                }
+
+                // Create the new face
+                face newFace(4);
+
+                // Note: there are three possible variants:
+                //   i) Edge is split and the other point is anchor. Collection
+                //      of the face starts from edgeMidPoint
+                //  ii) Edge is split and the other point is not an
+                //      anchor. Collection of the face starts from other point
+                // iii) Edge is not split and the other point is not an
+                //      anchor. Collection of the face starts from other point
+                // Variants ii) and iii) can be handled together, while variant
+                // i) has to be handled separately.
+
+                // Whether the edge is split
+                const bool isEdgeSplit = edgeMidPoint[edgeI] > -1;
+
+                // Whether the other point is anchor or not
+                const bool isOtherEdgePointAnchor
+                    = cAnchors.find(pointJ) > -1;
+
+                // Check if the edge is split and whether the other edge point
+                // is an anchor
+                if (isEdgeSplit && isOtherEdgePointAnchor)
+                {
+                    // Variant i) Edge is split and other edge point is anchor
+
+                    // Create the new face and start collecting points
+                    // a) edgeMidPoint for this edge
+                    // b) faceMidPoint for this face
+                    // c) faceMidPoint for the face on the other side
+                    // d) edgeMidPoint for the edge on the other side
+
+                    // a) edgeMidPoint for this edge
+                    newFace[0] = edgeMidPoint[edgeI];
+
+                    // b) and c): adding both face mids
+                    addFaceMids
+                    (
+                        faceMidPoint,
+                        faceOnPatchToCut,
+                        faceI,
+                        cellI,
+                        newFace
+                    );
+
+                    // d) edgeMidPoint for the edge on the other side
+                    // The other edge is uniquely defined as the edge on special
+                    // patch (empty or wedge) sharing the same face as this edge
+
+                    // Get the edge faces
+                    const labelList& eFaces = meshEdgeFaces[edgeI];
+
+                    // Loop through edge faces
+                    forAll(eFaces, i)
+                    {
+                        // Get the face and check whether it is on special patch
+                        const label& faceK = eFaces[i];
+
+                        if (!faceOnPatchToCut[faceK])
+                        {
+                            // Found the face, need to search its edges
+                            const labelList& otherFaceEdges =
+                                meshFaceEdges[faceK];
+
+                            forAll(otherFaceEdges, j)
+                            {
+                                // Get the edge
+                                const label& edgeJ = otherFaceEdges[j];
+
+                                if (edgeOnPatchToCut[edgeJ] && (edgeI != edgeJ))
+                                {
+                                    // Edge is on special patch (empty or
+                                    // wedge), this must be the one we are
+                                    // looking for. Add its midpoint and double
+                                    // check if it is valid
+                                    if (edgeMidPoint[edgeJ] > -1)
+                                    {
+                                        newFace[3] = edgeMidPoint[edgeJ];
+                                        break;
+                                    }
+                                    else
+                                    {
+                                        FatalErrorInFunction
+                                            << "Other edge: "
+                                            << edgeJ
+                                            << " has not been selected for"
+                                            << " splitting, while the edge on"
+                                            << " original side: "
+                                            << edgeI
+                                            << " has been selected."
+                                            << abort(FatalError);
+                                    }
+                                } // End if this is our "other" edge
+                            } // End for all other (non special patch: empty or
+                              // wedge) face edges
+
+                            // Break out since we must have found the candidate
+                            break;
+
+                        } // End if face not on special patch (empty or wedge)
+
+                    } // End for all edge faces
+
+                } // End if this edge is split and the other point is anchor
+                else if (!isOtherEdgePointAnchor)
+                {
+                    // Variants ii) and iii). Either the edge is split and the
+                    // other point is not an anchor or the edge is not split and
+                    // the other point is not an anchor
+
+                    // Create the new face and start collecting points
+                    // a) other point of this edge
+                    // b) faceMidPoint for this face
+                    // c) faceMidPoint for the face on the other side
+                    // d) other point on the other side
+
+                    // a) other point of this edge
+                    newFace[0] = pointJ;
+
+                    // b) and c): adding both face mids
+                    addFaceMids
+                    (
+                        faceMidPoint,
+                        faceOnPatchToCut,
+                        faceI,
+                        cellI,
+                        newFace
+                    );
+
+                    // d) other point on the other side
+                    // The other point is uniquely defined as the other point of
+                    // the edge of this point which is not on special patch
+
+                    // Get point edges
+                    const labelList& pEdges = meshPointEdges[pointJ];
+
+                    // Loop through all edges
+                    forAll(pEdges, i)
+                    {
+                        // Get the edge index
+                        const label& edgeJ = pEdges[i];
+
+                        if (!edgeOnPatchToCut[edgeJ])
+                        {
+                            // Found our edge, set the point on the other side
+                            // of the edge as the last point in face
+                            newFace[3] = meshEdges[edgeJ].otherVertex(pointJ);
+                            break;
+                        }
+                    } // End loop over all point edges
+
+                } // End if the other point is not an anchor
+                else
+                {
+                    // The edge is not split and the other point is an
+                    // anchor. This should never happen
+                    FatalErrorInFunction
+                        << "Attempted to create internal face for an edge that"
+                        << " is not split and the other point that is an anchor."
+                        << nl
+                        << "Cell: " << cellI
+                        << ", point: " << pointI
+                        << ", other edge point: " << pointJ
+                        << nl
+                        << "Anchor points for cell are: " << cAnchors
+                        << abort(FatalError);
+                }
+
+                // Now we have the face defined, set owner and neighbour.
+                // Note: owner and neighbour are uniquely defined since we have
+                // gone through the face in the same way as we did while adding
+                // cells. This ensured easy definition of owner/neighbour cells
+                const label own = cAdded[nAddedFaces];
+                const label nei =
+                    nAddedFaces < cAdded.size() - 1
+                  ? cAdded[nAddedFaces + 1]
+                  : cAdded[0];
+
+                // According to the definition of adding faces, the first n - 1
+                // faces need to be reverted, while the last one is correctly
+                // oriented
+                if (nAddedFaces < cAdded.size() - 1)
+                {
+                    newFace = newFace.reverseFace();
+                }
+
+
+                // Debug: check orientation
+                if (debug)
+                {
+                    // Get owner/neighbour points
+                    point ownPt, neiPt;
+
+                    if (nAddedFaces < cAdded.size() - 1)
+                    {
+                        // Original owner/neighbour
+                        ownPt = meshPoints[pointI];
+                        neiPt = meshPoints[pointJ];
+                    }
+                    else
+                    {
+                        // Flipped owner/neighbour for last face
+                        ownPt = meshPoints[pointJ];
+                        neiPt = meshPoints[pointI];
+                    }
+
+                    checkInternalOrientation
+                    (
+                        ref,
+                        cellI,
+                        faceI,
+                        ownPt,
+                        neiPt,
+                        newFace
+                    );
+                }
+
+                // Finally, add the face. Note: ignoring return of new face
+                // index from ref.setAction(polyAddFace(...)) call
+                ref.setAction
+                (
+                    polyAddFace
+                    (
+                        newFace, // face
+                        own,     // owner
+                        nei,     // neighbour
+                        -1,      // master point
+                        -1,      // master edge
+                        0,       // master face for addition
+                        false,   // flux flip
+                        -1,      // patch for face
+                        -1,      // zone for face
+                        false    // face zone flip
+                    )
+                );
+
+                // Increment number of added faces
+                ++nAddedFaces;
+
+            } // End loop over all point (and edges) of the face
+
+            // Finished adding internal faces. Mark the cell as handled
+            cellsToSplit[cellI] = false;
+
+        } // End if face is split into n and cell has not been handled
+    } // End for all faces
+
+    // Debug: check minimum point index of added points, needs to be equal to
+    // number of points in the original mesh
+    if (debug)
+    {
+        label minPointI = labelMax;
+        label maxPointI = labelMin;
+
+        forAll(faceMidPoint, faceI)
+        {
+            if (faceMidPoint[faceI] > -1)
+            {
+                minPointI = min(minPointI, faceMidPoint[faceI]);
+                maxPointI = max(maxPointI, faceMidPoint[faceI]);
+            }
+        }
+        forAll(edgeMidPoint, edgeI)
+        {
+            if (edgeMidPoint[edgeI] > -1)
+            {
+                minPointI = min(minPointI, edgeMidPoint[edgeI]);
+                maxPointI = max(maxPointI, edgeMidPoint[edgeI]);
+            }
+        }
+
+        if (minPointI != labelMax && minPointI != mesh_.nPoints())
+        {
+            FatalErrorInFunction
+                << "Added point labels not consecutive to existing mesh points."
+                << nl
+                << "mesh_.nPoints():" << mesh_.nPoints()
+                << " minPointI: " << minPointI
+                << " maxPointI: " << maxPointI
+                << abort(FatalError);
+        }
+    }
+}
+
+
+void Foam::prismatic2DRefinement::setUnrefinementInstruction
+(
+    batchPolyTopoChange& ref
+) const
+{
+    // Note: assumes that splitPointsToUnrefine_ are set prior to the function
+    // call
+
+    // Check whether the refinementLevelIndicator is valid
+    if (refinementLevelIndicator_.size() != mesh_.nCells())
+    {
+        FatalErrorInFunction
+            << "Refinement level indicator list has invalid size: "
+            << refinementLevelIndicator_.size()
+            << ", number of cells: " << mesh_.nCells()
+            << nl
+            << "Make sure to call setRefinementInstruction(...) before"
+            << " calling setUnrefinementInstruction(...)."
+            << abort(FatalError);
+    }
+
+    // Get point cells necessary for debug and face removal
+    const labelListList& meshPointCells = mesh_.pointCells();
+
+    if (debug)
+    {
+        Pout<< "prismatic2DRefinement::setUnrefinementInstruction"
+            << "(batchPolyTopoChange& ref)"
+            << nl
+            << "Checking validity of cellLevel before setting unrefinement."
+            << endl;
+
+        forAll(cellLevel_, cellI)
+        {
+            if (cellLevel_[cellI] < 0)
+            {
+                FatalErrorInFunction
+                    << "Illegal cell level " << cellLevel_[cellI]
+                    << " for cell " << cellI
+                    << abort(FatalError);
+            }
+        }
+
+        // Write split points into a point set
+        pointSet pSet
+        (
+            mesh_,
+            "splitPoints",
+            labelHashSet(splitPointsToUnrefine_)
+        );
+        pSet.write();
+
+        // Write split point cells into a cell set
+        cellSet cSet
+        (
+            mesh_,
+            "splitPointCells",
+            splitPointsToUnrefine_.size()
+        );
+
+        forAll(splitPointsToUnrefine_, i)
+        {
+            // Get point cells and insert them into cell set
+            const labelList& pCells = meshPointCells[splitPointsToUnrefine_[i]];
+
+            forAll(pCells, j)
+            {
+                cSet.insert(pCells[j]);
+            }
+        }
+        cSet.write();
+
+        Pout<< "prismatic2DRefinement::setUnrefinementInstruction"
+            << "(batchPolyTopoChange& ref)"
+            << nl
+            << "Writing " << pSet.size()
+            << " points and "
+            << cSet.size() << " cells for unrefinement to" << nl
+            << "pointSet " << pSet.objectPath() << nl
+            << "cellSet " << cSet.objectPath()
+            << endl;
+    }
+
+    // Update refinementLevelIndicator for all cells that will be unrefined
+    forAll(splitPointsToUnrefine_, i)
+    {
+        // Get point cells and mark them for unrefinement
+        const labelList& pCells = meshPointCells[splitPointsToUnrefine_[i]];
+
+        forAll(pCells, j)
+        {
+            refinementLevelIndicator_[pCells[j]] = UNREFINED;
+        }
+    }
+
+    // Create lists needed by face remover
+    labelList cellRegion;
+    labelList cellRegionMaster;
+    labelList facesToRemove;
+
+    // Memory management
+    {
+        // Mark faces on special patches (empty or wedge) to exclude them
+        boolList faceOnPatchToCut(mesh_.nFaces(), false);
+
+        // Get boundary
+        const polyBoundaryMesh& boundaryMesh = mesh_.boundaryMesh();
+
+        // Loop through all patches
+        forAll (boundaryMesh, patchI)
+        {
+            // Get current patch
+            const polyPatch& curPatch = boundaryMesh[patchI];
+
+            // Check whether this patch is special (empty or wedge)
+            if (isA<emptyPolyPatch>(curPatch) || isA<wedgePolyPatch>(curPatch))
+            {
+                // Get start and end face labels
+                const label startFaceI = curPatch.start();
+                const label endFaceI = startFaceI + curPatch.size();
+
+                // Mark all the faces and edges on the patch
+                for (label faceI = startFaceI; faceI < endFaceI; ++faceI)
+                {
+                    // Mark face
+                    faceOnPatchToCut[faceI] = true;
+                }
+            }
+        }
+
+
+        // Collect split faces in the hash set, guess size to prevent excessive
+        // resizing
+        labelHashSet splitFaces(12*splitPointsToUnrefine_.size());
+
+        // Get point faces
+        const labelListList& meshPointFaces = mesh_.pointFaces();
+
+        forAll(splitPointsToUnrefine_, i)
+        {
+            // Loop through all faces of this point and insert face index
+            const labelList& pFaces = meshPointFaces[splitPointsToUnrefine_[i]];
+
+            forAll(pFaces, j)
+            {
+                // Get face index
+                const label& faceI = pFaces[j];
+
+                if (!faceOnPatchToCut[faceI])
+                {
+                    // Face is not on special patch, insert it into hash set
+                    splitFaces.insert(faceI);
+                }
+            }
+        }
+
+        // Check with faceRemover what faces will get removed. Note that this
+        // can be more (but never less) than splitFaces provided.
+        faceRemover_.compatibleRemoves
+        (
+            splitFaces.toc(),   // Pierced faces
+
+            cellRegion,         // Region merged into (-1 for no region)
+            cellRegionMaster,   // Master cell for region
+            facesToRemove       // List of faces to be removed
+        );
+
+        if (facesToRemove.size() != splitFaces.size())
+        {
+            FatalErrorInFunction
+                << "Either the initial set of split points to unrefine does not"
+                << " seem to be consistent or there are no mid points of"
+                << " refined cells."
+                << abort(FatalError);
+        }
+    }
+
+    // Find point region master for every cell region.  This is the central point
+    // from which the coarse cell will be made
+    // The property of the point region master is that all cells that touch it
+    // have the same cell region index
+    // HJ, 6/Sep/2019
+    labelList pointRegionMaster(cellRegionMaster.size(), label(-1));
+
+    // Get point-cell addressing
+    const labelListList& pc = mesh_.pointCells();
+
+    forAll (splitPointsToUnrefine_, i)
+    {
+        const labelList& curPc = pc[splitPointsToUnrefine_[i]];
+
+        label curRegion = -1;
+
+        forAll (curPc, curPcI)
+        {
+            if (curRegion == -1)
+            {
+                // First region found.  Grab it
+                curRegion = cellRegion[curPc[curPcI]];
+            }
+            else
+            {
+                // Region already found.  Check that all other cells that
+                // touch this point have the same region
+                if (curRegion != cellRegion[curPc[curPcI]])
+                {
+                    // Error: different region cells touching in split point
+                    // This is not a valid unrefinement pattern
+                    FatalErrorInFunction
+                        << "Different region cells touching in split point."
+                        << abort(FatalError);
+                }
+            }
+        }
+
+        // Record point region master
+        if (curRegion > -1)
+        {
+            pointRegionMaster[curRegion] = splitPointsToUnrefine_[i];
+        }
+        else
+        {
+            // Error: Cannot find region for point
+            FatalErrorInFunction
+                << "Different region cells touching in split point."
+                << abort(FatalError);
+        }
+    }
+
+    // Insert all commands to combine cells
+    faceRemover_.setRefinement
+    (
+        facesToRemove,
+        cellRegion,
+        // pointRegionMaster, // OpenFOAM does not support master point
+        cellRegionMaster,
+        ref
+    );
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::prismatic2DRefinement::prismatic2DRefinement
+(
+    const word& name,
+    const dictionary& dict,
+    const label index,
+    const polyTopoChanger& mme
+)
+:
+    refinement(name, dict, index, mme)
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::prismatic2DRefinement::~prismatic2DRefinement()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+void Foam::prismatic2DRefinement::setCellsToRefine
+(
+    const labelList& refinementCellCandidates
+)
+{
+    if (debug)
+    {
+        Info<< "prismatic2DRefinement::setCellsToRefine"
+            << "(const labelList& refinementCellCandidates)" << nl
+            << "Setting cells to refine" << endl;
+    }
+
+    // Create a mark-up field for cells to refine
+    boolList refineCell(mesh_.nCells(), false);
+
+    // Roughly count how many cells we are going to end up with
+    label roughCellCountAfterRefinement = mesh_.nCells();
+
+    // Get cell points to count number of additional cells
+    const labelListList& meshCellPoints = mesh_.cellPoints();
+
+    // Mark initial refinement candidates for refinement only if the cell level
+    // is smaller than the maximum refinement level. Note: stop marking them if
+    // we exceed the rough cell count
+    forAll (refinementCellCandidates, i)
+    {
+        // Get cell index
+        const label& cellI = refinementCellCandidates[i];
+
+        if (roughCellCountAfterRefinement < maxCells_)
+        {
+            // Mark cell for refinement
+            refineCell[cellI] = true;
+
+            // Increment number of cells (nPoints/2 - 1 new cells per cell)
+            roughCellCountAfterRefinement += meshCellPoints[cellI].size()/2 - 1;
+        }
+    }
+
+    // Extend cells across faces using a specified number of refinement buffer
+    // layers
+    for (label i = 0; i < nRefinementBufferLayers_; ++i)
+    {
+        meshTools::extendMarkedCellsAcrossFaces(mesh_, refineCell);
+    }
+
+    // Remove all cells that exceed the maximum refinement level
+    forAll (refineCell, cellI)
+    {
+        if (refineCell[cellI] && (cellLevel_[cellI] + 1 > maxRefinementLevel_))
+        {
+            refineCell[cellI] = false;
+        }
+    }
+
+    // Make sure that the refinement is face consistent (2:1 consistency) and
+    // point consistent (4:1 consistency) if necessary
+
+    // Counter for additional cells to refine due to consistency in each
+    // iteration and number of iterations
+    label nAddCells = 0;
+    label nIters = 0;
+    label nTotalAddCells = 0;
+
+    do
+    {
+        // Reset counter at the beginning of each iteration
+        nAddCells = 0;
+
+        if (edgeBasedConsistency_)
+        {
+            // Check for 4:1 edge based consistent refinement. Updates
+            // cellsToRefine and returns number of cells added in this iteration
+            nAddCells += edgeConsistentRefinement(refineCell);
+        }
+
+        // Check for 2:1 face based consistent refinement. Updates cellsToRefine
+        // and returns number of cells added in this iteration
+        nAddCells += faceConsistentRefinement(refineCell);
+
+        // Global reduction
+        reduce(nAddCells, sumOp<label>());
+
+        // Increment number of iterations and total number of added cells
+        ++nIters;
+        nTotalAddCells += nAddCells;
+
+    } while (nAddCells > 0);
+
+    Info<< "Added " << nTotalAddCells // nTotalAddCells already reduced
+        << " cells in " << returnReduce(nIters, maxOp<label>())
+        << " iterations to obtain consistent refinement."
+        << endl;
+
+    // Collect all cells to refine in a dynamic list
+    DynamicList<label> cellsToRefineDynamic(mesh_.nCells());
+
+    forAll (refineCell, cellI)
+    {
+        if (refineCell[cellI])
+        {
+            // Cell marked for refinement, append it
+            cellsToRefineDynamic.append(cellI);
+        }
+    }
+
+    // Transfer the contents into the data member (ordinary list)
+    cellsToRefine_.transfer(cellsToRefineDynamic);
+
+    Info<< "Selected " << returnReduce(cellsToRefine_.size(), sumOp<label>())
+        << " cells to refine." << endl;
+}
+
+
+void Foam::prismatic2DRefinement::setSplitPointsToUnrefine
+(
+    const labelList& unrefinementPointCandidates
+)
+{
+    if (debug)
+    {
+        Info<< "prismatic2DRefinement::setSplitPointsToUnrefine"
+            << "(const labelList& unrefinementPointCandidates)" << nl
+            << "Setting split points to unrefine." << endl;
+    }
+
+    // Get necessary mesh data
+    const label nPoints = mesh_.nPoints();
+    const labelListList& meshCellPoints = mesh_.cellPoints();
+
+    // PART 1: Mark all split points in the mesh (points that can be unrefined)
+    boolList splitPointsMarkup(nPoints, false);
+
+    // Algorithm: split point is uniquely defined as a point that:
+    // 1. Has pointLevel_ > 0 (obviously),
+    // 2. A point that has the same pointLevel_ as ALL of the points of its
+    //    edges. In other words, for each point, we will look through all the
+    //    edges of the point. For each edge, we will visit both points and
+    //    check point levels. All point levels must be the same for this point
+    //    candidate to be a split point. This is quite useful since there is no
+    //    need to store the refinement history
+
+    // Get necessary mesh data
+    const edgeList& meshEdges = mesh_.edges();
+    const labelListList& meshPointEdges = mesh_.pointEdges();
+
+    // Loop through all points
+    forAll (meshPointEdges, pointI)
+    {
+        // Get point level of this point
+        const label& centralPointLevel = pointLevel_[pointI];
+
+        if (centralPointLevel < 1)
+        {
+            // Point can't be unrefined as its level is either 0 or
+            // invalid. Continue immediately
+            continue;
+        }
+
+        // Flag to see whether this is a split point candidate
+        bool splitPointCandidate = true;
+
+        // Get all edge labels for this point
+        const labelList& pEdges = meshPointEdges[pointI];
+
+        // Loop through all point edges
+        forAll (pEdges, i)
+        {
+            // Get edge index and the edge
+            const label& edgeI = pEdges[i];
+            const edge& curEdge = meshEdges[edgeI];
+
+            // Loop through both points of the edge
+            forAll (curEdge, j)
+            {
+                // Get point index
+                const label& pointJ = curEdge[j];
+
+                if (pointLevel_[pointJ] != centralPointLevel)
+                {
+                    // Point levels are different, this can't be a split point,
+                    // set flag to false and break immediatelly
+                    splitPointCandidate = false;
+                    break;
+                }
+                // else: this is still potential split point candidate so
+                //       there's nothing to do
+            } // End for both points of this edge
+
+            // Check whether this can't be a split point already and break out
+            // immediately
+            if (!splitPointCandidate)
+            {
+                break;
+            }
+        } // End for all point faces
+
+        // At this point, if the flag is still true, this is a split point
+        if (splitPointCandidate)
+        {
+            splitPointsMarkup[pointI] = true;
+        }
+    }
+
+    // Note: if there is no dynamic load balancing, points at the processor
+    // boundary cannot be split points by definition. However, in dynamic load
+    // balancing runs, it is possible that a split point end on processor
+    // boundary, in which case we will simply avoid (actually delay) unrefining
+    // until this becomes internal point again. VV, 4/Jul/2018.
+
+    // Get boundary mesh and mesh faces
+    const polyBoundaryMesh& bMesh = mesh_.boundaryMesh();
+    const faceList& meshFaces = mesh_.faces();
+
+    // Loop through all patches
+    forAll (bMesh, patchI)
+    {
+        const polyPatch& patch = bMesh[patchI];
+
+        if (isA<processorPolyPatch>(patch))
+        {
+            // Get patch start
+            const label startIndex = patch.start();
+
+            // Loop through all the faces
+            forAll (patch, i)
+            {
+                // Get global face index and face
+                const label faceI = startIndex + i;
+                const face& f = meshFaces[faceI];
+
+                // Make sure that we don't split around point at all points of
+                // the processor patch faces
+                forAll (f, fpI)
+                {
+                    splitPointsMarkup[f[fpI]] = false;
+                }
+            }
+        }
+    }
+
+
+    // PART 2: Mark all unrefinement point candidates that are split points at
+    // the same time (basically the intersection of split points and candidates)
+
+    // Create markup field of split points to unrefine
+    // True: this is a split point which should be unrefined
+    // False: this is either not a split point or it shouldn't be unrefined
+    boolList splitPointsToUnrefine(nPoints, false);
+
+    // Loop through all unrefinement candidates
+    forAll (unrefinementPointCandidates, i)
+    {
+        // Get point index
+        const label& pointI = unrefinementPointCandidates[i];
+
+        if (splitPointsMarkup[pointI])
+        {
+            // This is a split point, mark it for unrefinement
+            splitPointsToUnrefine[pointI] = true;
+        }
+    }
+
+
+    // PART 3: Make sure that we skip unrefining around split points that
+    // possibly have cells around that will be refined
+
+    // Mark cells that need to be protected (will be refined in this iteration)
+    boolList protectedCell(mesh_.nCells(), false);
+
+    // Loop through cells to refine and mark them
+    forAll (cellsToRefine_, i)
+    {
+        protectedCell[cellsToRefine_[i]] = true;
+    }
+
+    // Extend protected cells across points using a specified number of
+    // unrefinement buffer layers
+    for (label i = 0; i < nUnrefinementBufferLayers_; ++i)
+    {
+        meshTools::extendMarkedCellsAcrossPoints(mesh_, protectedCell);
+    }
+
+    // Loop through all cells and if the cell should be protected, protect all
+    // of its points from unrefinement
+    forAll (protectedCell, cellI)
+    {
+        if (protectedCell[cellI])
+        {
+            // Get list of cell points for this protected cell
+            const labelList& cPoints = meshCellPoints[cellI];
+
+            // Loop through cell points and make sure that they are not marked
+            // for unrefinement
+            forAll (cPoints, j)
+            {
+                splitPointsToUnrefine[cPoints[j]] = false;
+            }
+        }
+    }
+
+
+    // PART 4: Ensure face consistent (2:1 constraint) and possibly edge
+    // consistent (4:1 constraint) unrefinement
+
+    // Get necessary mesh data
+    const label nCells = mesh_.nCells();
+    const labelListList& meshPointCells = mesh_.pointCells();
+
+    // Count number of removed cells from unrefinement (cells that will not be
+    // unrefined) in each iteration and number of iterations
+    label nRemCells = 0;
+    label nIters = 0;
+    label nTotalRemCells = 0;
+
+    do
+    {
+        // First, create cells to unrefine (all cells sharing point to unrefine)
+        boolList cellsToUnrefine(nCells, false);
+
+        // Loop through all split points to unrefine
+        forAll (splitPointsToUnrefine, pointI)
+        {
+            if (splitPointsToUnrefine[pointI])
+            {
+                // This split point is marked for unrefinement, collect all of
+                // its cells
+                const labelList& pCells = meshPointCells[pointI];
+                forAll (pCells, i)
+                {
+                    cellsToUnrefine[pCells[i]] = true;
+                }
+            }
+        }
+
+        // Reset number of removed cells from unrefinement for this iteration
+        nRemCells = 0;
+
+        if (edgeBasedConsistency_)
+        {
+            // Check for 4:1 edge based consistent unrefinement. Updates
+            // cellsToUnrefine and returns number of removed cells from
+            // unrefinement in this iteration
+            nRemCells += edgeConsistentUnrefinement(cellsToUnrefine);
+        }
+
+        // Check for 2:1 face based consistent unrefinement. Updates
+        // cellsToUnrefine and returns number of removed cells from unrefinement
+        // in this iteration
+        nRemCells += faceConsistentUnrefinement(cellsToUnrefine);
+
+        // Global reduction
+        reduce(nRemCells, sumOp<label>());
+
+        // If we have removed at least one cell from unrefinement, we need to
+        // protect its split points as well from unrefinement
+        if (nRemCells > 0)
+        {
+            // Get point cells
+            const labelListList& meshPointCells = mesh_.pointCells();
+
+            // Loop through all split points to unrefine
+            forAll (splitPointsToUnrefine, pointI)
+            {
+                if (splitPointsToUnrefine[pointI])
+                {
+                    // This is a split point for unrefinement, get the cells
+                    const labelList& pCells = meshPointCells[pointI];
+
+                    // Loop through all point cells
+                    forAll (pCells, i)
+                    {
+                        if (!cellsToUnrefine[pCells[i]])
+                        {
+                            // Cell must not be refined, remove point from
+                            // unrefinement as well
+                            splitPointsToUnrefine[pointI] = false;
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+
+        // Increment number of iterations and number of total removed cells
+        ++nIters;
+        nTotalRemCells += nRemCells;
+
+    } while (nRemCells > 0);
+
+    Info<< "Removed " << nTotalRemCells // nTotalRemCells already reduced
+        << " cells in " << returnReduce(nIters, maxOp<label>())
+        << " iterations to obtain consistent unrefinement."
+        << endl;
+
+    // Collect all split points to unrefine in a dynamic list
+    DynamicList<label> splitPointsToUnrefineDynamic(nPoints);
+
+    forAll (splitPointsToUnrefine, pointI)
+    {
+        if (splitPointsToUnrefine[pointI])
+        {
+            // Split point marked for unrefinement, append it
+            splitPointsToUnrefineDynamic.append(pointI);
+        }
+    }
+
+    // Transfer the contents into the data member (ordinary list)
+    splitPointsToUnrefine_.transfer(splitPointsToUnrefineDynamic);
+
+    Info<< "Selected "
+        << returnReduce(splitPointsToUnrefine_.size(), sumOp<label>())
+        << " split points to unrefine." << endl;
+}
+
+
+// ************************************************************************* //
diff --git a/src/dynamicMesh/refinement/prismatic2DRefinement/prismatic2DRefinement.H b/src/dynamicMesh/refinement/prismatic2DRefinement/prismatic2DRefinement.H
new file mode 100644
index 0000000000..368aaad2fb
--- /dev/null
+++ b/src/dynamicMesh/refinement/prismatic2DRefinement/prismatic2DRefinement.H
@@ -0,0 +1,254 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | foam-extend: Open Source CFD
+   \\    /   O peration     | Version:     5.0
+    \\  /    A nd           | Web:         http://www.foam-extend.org
+     \\/     M anipulation  | For copyright notice see file Copyright
+-------------------------------------------------------------------------------
+License
+    This file is part of foam-extend.
+
+    foam-extend is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation, either version 3 of the License, or (at your
+    option) any later version.
+
+    foam-extend is distributed in the hope that it will be useful, but
+    WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with foam-extend.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::prismatic2DRefinement
+
+Description
+    Isotropic refinement of prismatic cells in 2D using the mesh modifier
+    engine. Used for 2D cases instead of polyhedralRefinement which carries
+    unnecessary overhead in terms of number of cells since it splits the cell in
+    all directions.
+
+    Each prismatic cell is split by the following procedure:
+    1. Adding points at the face centres and edge centres of all faces found on
+       an special patch: empty or wedge.
+    2. Adding n cells per existing cell where n is the number of corner points
+       at the face on special patch (empty or wedge).
+    3. Splitting each of the faces on special patch (empty or wedge) into
+       multiple faces going from: existing corner point -> new edge centre point
+       -> new face centre point -> other new edge centre point (sharing the same
+       corner point)
+    4. Spliiting each of the faces not on an special patch (empty or wedge) into
+       two faces going from: existing corner point -> existing corner point on
+       the other side -> new edge centre point on the other side -> new edge
+       centre point on my side
+    4. Adding internal faces going from:
+       new edge centre point -> new face centre point -> new other face
+       centre point on the other side -> new other edge mid point on the other
+       side
+
+    It is an error to try and run this on anything except a 2D mesh.
+
+SourceFiles
+    prismatic2DRefinement.C
+
+Author
+    Vuko Vukcevic, Wikki Ltd.  All rights reserved.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef prismatic2DRefinement_H
+#define prismatic2DRefinement_H
+
+#include "refinement.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                    Class prismatic2DRefinement Declaration
+\*---------------------------------------------------------------------------*/
+
+class prismatic2DRefinement
+:
+    public refinement
+{
+private:
+
+    // Private Member Functions
+
+        // Helper functions
+
+            //- Get least cell level such that the face has at least nPoints
+            //  points smaller than the level
+            label getAnchorLevel
+            (
+                const label faceI,
+                const label nPoints
+            ) const;
+
+            //- Append given face into a dynamic list containing split faces
+            //  that will be split into two faces (third parameter). Additionaly
+            //  append information on which of the two edges of the face are on
+            //  special patch into a dynamic list (fourth parameter)
+            void appendFaceSplitInfo
+            (
+                const label& faceI,
+                const boolList& edgeOnEmptyPatch,
+                const labelList& edgeMidPoint,
+                DynamicList<label>& splitFacesIntoTwo,
+                DynamicList<Pair<label> >& splitFacesEmptyEdges
+            ) const;
+
+
+        // Topological change helper functions
+
+            //- Set new owner and neighbour given anchor pointI, faceI and the
+            //  necessary mapping
+            void setNewFaceNeighbours
+            (
+                const HashTable
+                <
+                    label,
+                    Pair<label>,
+                    Hash<FixedList<label, 2> >
+                >& pointCellToAddedCellMap,
+                const labelListList& cellAddedCells,
+                const label& faceI,
+                const label& pointI,
+
+                label& own,
+                label& nei
+            ) const;
+
+            //- Get index of point with minimum point level of a face across two
+            //  connected edges starting from a local point index.
+            //  Example: starting from point with level 1 in the upper left
+            //  corner, finds point index of the point with level 0 which is on
+            //  the same face, connected with edge to original point
+            //  1------1
+            //  |
+            //  |
+            //  0
+            //  Note: passing face edges and mesh edges as parameters to avoid
+            //  fetching them from mesh due to lazy evaluation
+            label findMinEdgeConnectedLevel
+            (
+                const label& fpI,
+                const label& faceI,
+                const face& f,
+                const labelList& fEdges,
+                const edgeList& meshEdges
+            ) const;
+
+            //- Store two face mids when adding internal faces
+            void addFaceMids
+            (
+                const labelList& faceMidPoint,
+                const boolList& faceOnEmptyPatch,
+                const label& faceI,
+                const label& cellI,
+                face& newFace
+            ) const;
+
+
+        // Debug functions
+
+            //- Check orientation of a split face
+            void checkNewFaceOrientation
+            (
+                batchPolyTopoChange& ref,
+                const label& faceI,
+                const face& newFace
+            ) const;
+
+
+        // Copy control
+
+            //- Disallow default bitwise copy construct
+            prismatic2DRefinement(const prismatic2DRefinement&) = delete;
+
+            //- Disallow default bitwise assignment
+            void operator=(const prismatic2DRefinement&) = delete;
+
+
+protected:
+
+    // Protected Pure Virtual Member Functions
+
+        // Global topology modification functions (operate on whole polyMesh)
+
+            //- Set refinement instruction
+            virtual void setRefinementInstruction
+            (
+                batchPolyTopoChange& ref
+            ) const;
+
+            //- Set unrefinement instruction
+            virtual void setUnrefinementInstruction
+            (
+                batchPolyTopoChange& ref
+            ) const;
+
+
+public:
+
+    //- Runtime type information
+    TypeName("prismatic2DRefinement");
+
+
+    // Constructors
+
+        //- Construct from dictionary
+        prismatic2DRefinement
+        (
+            const word& name,
+            const dictionary& dict,
+            const label index,
+            const polyTopoChanger& mme
+        );
+
+
+    //- Destructor
+    virtual ~prismatic2DRefinement();
+
+
+    // Member Functions
+
+        // Edit
+
+            //- Set cells to refine given a list of refinement
+            //  candidates. Refinement candidates are extended within the
+            //  function due to possible 4:1 conflicts and specified number of
+            //  buffer layers.
+            //  Note: must be called BEFORE setSplitPointsToUnrefine
+            virtual void setCellsToRefine
+            (
+                const labelList& refinementCellCandidates
+            );
+
+            //- Set split points to unrefine given a list of all mesh points
+            //  that are candidates for unrefinement. Split points are
+            //  determined as a subset of unrefinement candidates, avoiding
+            //  splitting points of cells that are going to be refined at the
+            //  same time and ensuring consistent unrefinement.
+            //  Note: must be called AFTER setCellsToRefine
+            void setSplitPointsToUnrefine
+            (
+                const labelList& unrefinementPointCandidates
+            );
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/dynamicMesh/refinement/refinement/refinement.C b/src/dynamicMesh/refinement/refinement/refinement.C
new file mode 100644
index 0000000000..75f8b2eaaa
--- /dev/null
+++ b/src/dynamicMesh/refinement/refinement/refinement.C
@@ -0,0 +1,1489 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | foam-extend: Open Source CFD
+   \\    /   O peration     | Version:     5.0
+    \\  /    A nd           | Web:         http://www.foam-extend.org
+     \\/     M anipulation  | For copyright notice see file Copyright
+-------------------------------------------------------------------------------
+License
+    This file is part of foam-extend.
+
+    foam-extend is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation, either version 3 of the License, or (at your
+    option) any later version.
+
+    foam-extend is distributed in the hope that it will be useful, but
+    WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with foam-extend.  If not, see <http://www.gnu.org/licenses/>.
+
+Author
+    Vuko Vukcevic, Wikki Ltd.  All rights reserved.
+    Hrvoje Jasak, Wikki Ltd.
+
+Notes
+    Generalisation of hexRef8 for polyhedral cells and refactorisation into mesh
+    modifier engine.
+
+\*---------------------------------------------------------------------------*/
+
+#include "refinement.H"
+#include "polyTopoChanger.H"
+#include "polyMesh.H"
+#include "batchPolyTopoChange.H"
+#include "syncTools.H"
+#include "meshTools.H"
+#include "polyAddFace.H"
+#include "polyAddPoint.H"
+#include "polyAddCell.H"
+#include "polyModifyFace.H"
+#include "mapPolyMesh.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(refinement, 0);
+
+
+}
+
+const Foam::scalar Foam::refinement::nonOrthThreshold_ = 70;
+
+
+// * * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * //
+
+void Foam::refinement::setInstance(const fileName& inst) const
+{
+    if (debug)
+    {
+        Pout<< "refinement::setInstance(const fileName& inst)"
+            << nl
+            << "Resetting file instance of refinement data to " << inst
+            << endl;
+    }
+
+    cellLevel_.instance() = inst;
+    pointLevel_.instance() = inst;
+}
+
+
+Foam::label Foam::refinement::addFace
+(
+    batchPolyTopoChange& ref,
+    const label faceI,
+    const face& newFace,
+    const label own,
+    const label nei
+) const
+{
+    // Set face information
+    label patchID, zoneID, zoneFlip;
+    meshTools::setFaceInfo(mesh_, faceI, patchID, zoneID, zoneFlip);
+
+    // Set new face index to -1
+    label newFaceI = -1;
+
+    if ((nei == -1) || (own < nei))
+    {
+        // Ordering is ok, add the face
+        newFaceI = ref.setAction
+        (
+            polyAddFace
+            (
+                newFace,                    // face
+                own,                        // owner
+                nei,                        // neighbour
+                -1,                         // master point
+                -1,                         // master edge
+                faceI,                      // master face for addition
+                false,                      // flux flip
+                patchID,                    // patch for face
+                zoneID,                     // zone for face
+                zoneFlip                    // face zone flip
+            )
+        );
+    }
+    else
+    {
+        // Ordering is flipped, reverse face and flip owner/neighbour
+        newFaceI = ref.setAction
+        (
+            polyAddFace
+            (
+                newFace.reverseFace(),      // face
+                nei,                        // owner
+                own,                        // neighbour
+                -1,                         // master point
+                -1,                         // master edge
+                faceI,                      // master face for addition
+                false,                      // flux flip
+                patchID,                    // patch for face
+                zoneID,                     // zone for face
+                zoneFlip                    // face zone flip
+            )
+        );
+    }
+
+    return newFaceI;
+}
+
+
+Foam::label Foam::refinement::addInternalFace
+(
+    batchPolyTopoChange& ref,
+    const label meshFaceI,
+    const label meshPointI,
+    const face& newFace,
+    const label own,
+    const label nei
+) const
+{
+    // Check whether this is an internal face
+    if (mesh_.isInternalFace(meshFaceI))
+    {
+        return ref.setAction
+        (
+            polyAddFace
+            (
+                newFace,                    // face
+                own,                        // owner
+                nei,                        // neighbour
+                -1,                         // master point
+                -1,                         // master edge
+                meshFaceI,                  // master face for addition
+                false,                      // flux flip
+                -1,                         // patch for face
+                -1,                         // zone for face
+                false                       // face zone flip
+            )
+        );
+    }
+    else
+    {
+        // This is not an internal face. Add face out of nothing
+        return ref.setAction
+        (
+            polyAddFace
+            (
+                newFace,                    // face
+                own,                        // owner
+                nei,                        // neighbour
+                -1,                         // master point
+                -1,                         // master edge
+                0,                          // master face for addition
+                false,                      // flux flip
+                -1,                         // patch for face
+                -1,                         // zone for face
+                false                       // face zone flip
+            )
+        );
+    }
+}
+
+
+void Foam::refinement::modifyFace
+(
+    batchPolyTopoChange& ref,
+    const label faceI,
+    const face& newFace,
+    const label own,
+    const label nei
+) const
+{
+    // Set face inforomation
+    label patchID, zoneID, zoneFlip;
+    meshTools::setFaceInfo(mesh_, faceI, patchID, zoneID, zoneFlip);
+
+    // Get owner/neighbour addressing and mesh faces
+    const labelList& owner = mesh_.faceOwner();
+    const labelList& neighbour = mesh_.faceNeighbour();
+
+    const faceList& meshFaces = mesh_.faces();
+
+    if
+    (
+        (own != owner[faceI])
+     || (
+            mesh_.isInternalFace(faceI)
+         && (nei != neighbour[faceI])
+        )
+     || (newFace != meshFaces[faceI])
+    )
+    {
+        // Either:
+        // 1. Owner index does not correspond to mesh owner,
+        // 2. Neighbour index does not correspond to mesh neighbour,
+        // 3. New face does not correspond to mesh face
+        // So we need to modify this face
+        if ((nei == -1) || (own < nei))
+        {
+            // Ordering is ok, add the face
+            ref.setAction
+            (
+                polyModifyFace
+                (
+                    newFace,            // modified face
+                    faceI,              // label of face being modified
+                    own,                // owner
+                    nei,                // neighbour
+                    false,              // face flip
+                    patchID,            // patch for face
+                    false,              // remove from zone
+                    zoneID,             // zone for face
+                    zoneFlip            // face flip in zone
+                )
+            );
+        }
+        else
+        {
+            // Ordering is flipped, reverse face and flip owner/neighbour
+            ref.setAction
+            (
+                polyModifyFace
+                (
+                    newFace.reverseFace(),  // modified face
+                    faceI,                  // label of face being modified
+                    nei,                    // owner
+                    own,                    // neighbour
+                    false,                  // face flip
+                    patchID,                // patch for face
+                    false,                  // remove from zone
+                    zoneID,                 // zone for face
+                    zoneFlip                // face flip in zone
+                )
+            );
+        }
+    }
+}
+
+
+void Foam::refinement::walkFaceToMid
+(
+    const labelList& edgeMidPoint,
+    const label cLevel,
+    const label faceI,
+    const label startFp,
+    DynamicList<label>& faceVerts
+) const
+{
+    // Get the face and its edges
+    const face& f = mesh_.faces()[faceI];
+    const labelList& fEdges = mesh_.faceEdges()[faceI];
+
+    label fp = startFp;
+
+    // Starting from fp store all (1 or 2) vertices until where the face
+    // gets split
+    while (true)
+    {
+        if (edgeMidPoint[fEdges[fp]] > -1)
+        {
+            // Edge is split, append its mid point
+            faceVerts.append(edgeMidPoint[fEdges[fp]]);
+        }
+
+        fp = f.fcIndex(fp);
+
+        if (pointLevel_[f[fp]] <= cLevel)
+        {
+            // Found next anchor. Already appended the split point just above
+            return;
+        }
+        else if (pointLevel_[f[fp]] == cLevel + 1)
+        {
+            // Mid level, append and return
+            faceVerts.append(f[fp]);
+
+            return;
+        }
+        else if (pointLevel_[f[fp]] == cLevel + 2)
+        {
+            // Store and continue to cLevel + 1
+            faceVerts.append(f[fp]);
+        }
+    }
+}
+
+
+void Foam::refinement::walkFaceFromMid
+(
+    const labelList& edgeMidPoint,
+    const label cLevel,
+    const label faceI,
+    const label startFp,
+    DynamicList<label>& faceVerts
+) const
+{
+    // Get the face and its edges
+    const face& f = mesh_.faces()[faceI];
+    const labelList& fEdges = mesh_.faceEdges()[faceI];
+
+    label fp = f.rcIndex(startFp);
+
+    while (true)
+    {
+        if (pointLevel_[f[fp]] <= cLevel)
+        {
+            // Anchor point, break
+            break;
+        }
+        else if (pointLevel_[f[fp]] == cLevel + 1)
+        {
+            // Mid level, append and break
+            faceVerts.append(f[fp]);
+            break;
+        }
+        else if (pointLevel_[f[fp]] == cLevel + 2)
+        {
+            // Continue to cLevel + 1
+        }
+        fp = f.rcIndex(fp);
+    }
+
+    // Store
+    while (true)
+    {
+        if (edgeMidPoint[fEdges[fp]] > -1)
+        {
+            // Edge is split, append its mid point
+            faceVerts.append(edgeMidPoint[fEdges[fp]]);
+        }
+
+        fp = f.fcIndex(fp);
+
+        if (fp == startFp)
+        {
+            break;
+        }
+        faceVerts.append(f[fp]);
+    }
+}
+
+
+Foam::label Foam::refinement::findMinLevel(const labelList& f) const
+{
+    // Initialise minimum level to large value
+    label minLevel = labelMax;
+
+    // Initialise point label at which min level is reached to -1
+    label pointIMin = -1;
+
+    forAll(f, fp)
+    {
+        const label& level = pointLevel_[f[fp]];
+
+        if (level < minLevel)
+        {
+            minLevel = level;
+            pointIMin = fp;
+        }
+    }
+
+    return pointIMin;
+}
+
+
+Foam::label Foam::refinement::findMaxLevel(const labelList& f) const
+{
+    // Initialise  maximum level to small value
+    label maxLevel = labelMin;
+
+    // Initialise point label at which max level is reached to -1
+    label pointIMax = -1;
+
+    forAll(f, fp)
+    {
+        const label& level = pointLevel_[f[fp]];
+
+        if (level > maxLevel)
+        {
+            maxLevel = level;
+            pointIMax = fp;
+        }
+    }
+
+    return pointIMax;
+}
+
+
+Foam::label Foam::refinement::countAnchors
+(
+    const labelList& f,
+    const label anchorLevel
+) const
+{
+    label nAnchors = 0;
+
+    forAll(f, fp)
+    {
+        if (pointLevel_[f[fp]] <= anchorLevel)
+        {
+            ++nAnchors;
+        }
+    }
+    return nAnchors;
+}
+
+void Foam::refinement::adjustRefLevel
+(
+    label& curNewCellLevel,
+    const label oldCellI
+)
+{
+    if (oldCellI == -1)
+    {
+        // This cell is inflated (does not originate from other cell), set
+        // cell level to -1
+        curNewCellLevel = -1;
+    }
+    else
+    {
+        // This cell has either been added based on another cell or it
+        // hasn't changed. Update new cell level according to refinement
+        // level indicator and old cell level
+
+        // Get refinement status of the old cell
+        const label& refStatus = refinementLevelIndicator_[oldCellI];
+
+        if (refStatus == UNREFINED)
+        {
+            // New cell has been obtained by unrefining other cells - this
+            // is the remaining "master" cell. Decrement cell level
+            curNewCellLevel = cellLevel_[oldCellI] - 1;
+        }
+        else if (refStatus == UNCHANGED)
+        {
+            // Cell hasn't been changed during this refinement, copy old
+            // cell level
+            curNewCellLevel = cellLevel_[oldCellI];
+        }
+        else if (refStatus == REFINED)
+        {
+            // Cell has been refined, increment cell level
+            curNewCellLevel = cellLevel_[oldCellI] + 1;
+        }
+        else
+        {
+            FatalErrorInFunction
+                << "Invalid refinement status detected: "
+                << refStatus << nl
+                << "Old cell index: " << oldCellI << abort(FatalError);
+        }
+    }
+}
+
+
+void Foam::refinement::checkInternalOrientation
+(
+    batchPolyTopoChange& ref,
+    const label cellI,
+    const label faceI,
+    const point& ownPt,
+    const point& neiPt,
+    const face& newFace
+) const
+{
+    const face compactFace(identity(newFace.size()));
+
+    // Get list of polyAddPoint objects
+    const DynamicList<polyAddPoint>& polyAddedPoints(ref.addedPoints());
+
+    // Create a list of all points
+    const label nOrigPoints = mesh_.nPoints();
+    pointField allPoints(nOrigPoints + polyAddedPoints.size());
+
+    // Set ordinary points first
+    const pointField& meshPoints = mesh_.points();
+    forAll (meshPoints, i)
+    {
+        allPoints[i] = meshPoints[i];
+    }
+
+    // Set newly added points next
+    forAll (polyAddedPoints, i)
+    {
+        allPoints[i + nOrigPoints] = polyAddedPoints[i].newPoint();
+    }
+
+    // Get compact points
+    const pointField compactPoints
+    (
+        IndirectList<point>(allPoints, newFace)()
+    );
+
+    const vector n(compactFace.unitNormal(compactPoints));
+    const vector dir(neiPt - ownPt);
+
+    // Check orientation error
+    if ((dir & n) < 0)
+    {
+        FatalErrorInFunction
+            << "cell:" << cellI << " old face:" << faceI
+            << " newFace:" << newFace << endl
+            << " coords:" << compactPoints
+            << " ownPt:" << ownPt
+            << " neiPt:" << neiPt
+            << abort(FatalError);
+    }
+
+    // Note: report significant non-orthogonality error
+    const scalar severeNonOrthogonalityThreshold =
+      ::cos
+        (
+            nonOrthThreshold_/180.0*constant::mathematical::pi
+        );
+
+    const vector fcToOwn(compactFace.centre(compactPoints) - ownPt);
+
+    // Note: normal vector already normalised
+    const scalar dDotN = (fcToOwn & n)/(mag(fcToOwn) + VSMALL);
+
+    if (dDotN > severeNonOrthogonalityThreshold)
+    {
+        WarningIn
+        (
+            "refinement::checkInternalOrientation(...)"
+        )
+            << "Detected severely non-orthogonal face with non-orthogonality: "
+            << ::acos(dDotN)/constant::mathematical::pi*180.0
+            << "cell:" << cellI << " old face:" << faceI
+            << " newFace:" << newFace << endl
+            << " coords:" << compactPoints
+            << " ownPt:" << ownPt
+            << " neiPt:" << neiPt
+            << " dDotN:" << dDotN
+            << endl;
+    }
+}
+
+
+void Foam::refinement::checkBoundaryOrientation
+(
+    batchPolyTopoChange& ref,
+    const label cellI,
+    const label faceI,
+    const point& ownPt,
+    const point& boundaryPt,
+    const face& newFace
+) const
+{
+    const face compactFace(identity(newFace.size()));
+
+    // Get list of polyAddPoint objects
+    const DynamicList<polyAddPoint>& polyAddedPoints(ref.addedPoints());
+
+    // Create a list of all points
+    const label nOrigPoints = mesh_.nPoints();
+    pointField allPoints(nOrigPoints + polyAddedPoints.size());
+
+    // Set ordinary points first
+    const pointField& meshPoints = mesh_.points();
+    forAll (meshPoints, i)
+    {
+        allPoints[i] = meshPoints[i];
+    }
+
+    // Set newly added points next
+    forAll (polyAddedPoints, i)
+    {
+        allPoints[i + nOrigPoints] = polyAddedPoints[i].newPoint();
+    }
+
+    // Get compact points
+    const pointField compactPoints
+    (
+        IndirectList<point>(allPoints, newFace)()
+    );
+
+    const vector n(compactFace.unitNormal(compactPoints));
+    const vector dir(boundaryPt - ownPt);
+
+    // Check orientation error
+    if ((dir & n) < 0)
+    {
+        FatalErrorInFunction
+            << "cell:" << cellI << " old face:" << faceI
+            << " newFace:" << newFace
+            << " coords:" << compactPoints
+            << " ownPt:" << ownPt
+            << " boundaryPt:" << boundaryPt
+            << abort(FatalError);
+    }
+
+    // Note: report significant non-orthogonality error
+    const scalar severeNonOrthogonalityThreshold =
+      ::cos
+        (
+            nonOrthThreshold_/180.0*constant::mathematical::pi
+        );
+
+    const vector fcToOwn(compactFace.centre(compactPoints) - ownPt);
+
+    // Note: normal vector already normalised
+    const scalar dDotN = (fcToOwn & n)/(mag(fcToOwn) + VSMALL);
+
+    if (dDotN > severeNonOrthogonalityThreshold)
+    {
+        WarningInFunction
+            << "Detected severely non-orthogonal face with non-orthogonality: "
+            << ::acos(dDotN)/constant::mathematical::pi*180.0
+            << "cell:" << cellI << " old face:" << faceI
+            << " newFace:" << newFace
+            << " coords:" << compactPoints
+            << " ownPt:" << ownPt
+            << " boundaryPt:" << boundaryPt
+            << " dDotN:" << dDotN
+            << endl;
+    }
+}
+
+
+Foam::label Foam::refinement::faceConsistentRefinement
+(
+    boolList& cellsToRefine
+) const
+{
+    // Count number of cells that will be added
+    label nAddCells = 0;
+
+    // Get necessary mesh data
+    const label nFaces = mesh_.nFaces();
+    const label nInternalFaces = mesh_.nInternalFaces();
+
+    const labelList& owner = mesh_.faceOwner();
+    const labelList& neighbour = mesh_.faceNeighbour();
+
+    // Loop through internal faces and check consistency
+    for (label faceI = 0; faceI < nInternalFaces; ++faceI)
+    {
+        // Get owner and neighbour labels
+        const label& own = owner[faceI];
+        const label& nei = neighbour[faceI];
+
+        // Get owner and neighbour cell levels
+        // Note: If the cell is marked for refinement, the level is current
+        // level + 1, otherwise it is equal to the current level
+        const label ownLevel =
+            cellsToRefine[own] ? cellLevel_[own] + 1 : cellLevel_[own];
+        const label neiLevel =
+            cellsToRefine[nei] ? cellLevel_[nei] + 1 : cellLevel_[nei];
+
+        if (ownLevel > (neiLevel + 1))
+        {
+            // Owner level is higher than neighbour level + 1, neighbour must be
+            // marked for refinement
+            cellsToRefine[nei] = true;
+            ++nAddCells;
+        }
+        else if (neiLevel > (ownLevel + 1))
+        {
+            // Neighbour level is higher than owner level + 1, owner must be
+            // marked for refinement
+            cellsToRefine[own] = true;
+            ++nAddCells;
+        }
+    }
+
+    // Create owner level for boundary faces to prepare for swapping on coupled
+    // boundaries
+    labelList ownLevel(nFaces - nInternalFaces);
+    forAll (ownLevel, i)
+    {
+        // Get owner of the face and update owner cell levels
+        const label& own = owner[i + nInternalFaces];
+        ownLevel[i] =
+            cellsToRefine[own] ? cellLevel_[own] + 1 : cellLevel_[own];
+    }
+
+    // Swap boundary face lists (coupled boundary update)
+    syncTools::swapBoundaryFaceList(mesh_, ownLevel);
+
+    // Note: now the ownLevel list actually contains the neighbouring level
+    // (from the other side), use alias (reference) for clarity from now on
+    const labelList& neiLevel = ownLevel;
+
+    // Loop through boundary faces
+    forAll (neiLevel, i)
+    {
+        // Get owner of the face and owner level
+        const label& own = owner[i + nInternalFaces];
+        const label curOwnLevel =
+            cellsToRefine[own] ? cellLevel_[own] + 1 : cellLevel_[own];
+
+        // Note: we are using more stringent 1:1 consistency across coupled
+        // boundaries in order to simplify handling of edge based consistency
+        // checks for parallel runs
+        // Bugfix related to PLB: Check whether owner is already marked for
+        // refinement. Will allow 2:1 consistency across certain processor faces
+        // where we have a new processor boundary. VV, 23/Jan/2019.
+        if
+        (
+            (neiLevel[i] > curOwnLevel)
+         && !cellsToRefine[own]
+        )
+        {
+            // Neighbour level is higher than owner level, owner must be
+            // marked for refinement
+            cellsToRefine[own] = true;
+            ++nAddCells;
+        }
+
+        // Note: other possibility (that owner level is higher than neighbour
+        // level) is taken into account on the other side automatically
+    }
+
+    // Return number of added cells
+    return nAddCells;
+}
+
+
+Foam::label Foam::refinement::edgeConsistentRefinement
+(
+    boolList& cellsToRefine
+) const
+{
+    // Count number of cells that will be added
+    label nAddCells = 0;
+
+    // Algorithm: loop over all edges and visit all unique cell pairs sharing
+    // this particular edge. Then, ensure 2:1 edge consistency by marking
+    // cell with lower level for refinement
+
+    // Get edge cells
+    const labelListList& meshEdgeCells = mesh_.edgeCells();
+
+    // Loop through all mesh edges
+    forAll (meshEdgeCells, edgeI)
+    {
+        // Get current edge cells
+        const labelList& curEdgeCells = meshEdgeCells[edgeI];
+
+        // Loop through all edge cells
+        forAll (curEdgeCells, i)
+        {
+            // Get first cell index
+            const label& cellI = curEdgeCells[i];
+
+            // Loop through remaining edge cells
+            for (label j = i + 1; j < curEdgeCells.size(); ++j)
+            {
+                // Get second cell index
+                const label& cellJ = curEdgeCells[j];
+
+                // Get levels of the two cells. If the cell is marked for
+                // refinement, the level is current level + 1, otherwise it is
+                // equal to the current level
+
+                // Note: cellsToRefine flag for both cellI and cellJ might
+                // change, this is why we need to recalculate cellI level here
+                const label cellILevel =
+                    cellsToRefine[cellI]
+                  ? cellLevel_[cellI] + 1
+                  : cellLevel_[cellI];
+
+                const label cellJLevel =
+                    cellsToRefine[cellJ]
+                  ? cellLevel_[cellJ] + 1
+                  : cellLevel_[cellJ];
+
+                if (cellILevel > cellJLevel + 1)
+                {
+                    // Level of cellI is higher than level of cellJ + 1, cellJ
+                    // must be marked for refinement
+                    cellsToRefine[cellJ] = true;
+                    ++nAddCells;
+                }
+                else if (cellJLevel > cellILevel + 1)
+                {
+                    // Level of cellJ is higher than level of cellI + 1, cellI
+                    // must be marked for refinement
+                    cellsToRefine[cellI] = true;
+                    ++nAddCells;
+                }
+            }
+        }
+    }
+
+    // Note: in order to avoid very difficult and time-consuming parallelisation
+    // of edge cell connectivity and edge cell values, we enforce a more
+    // stringent face-based consistency across processor boundaries. Basically,
+    // if a face-based consistency of 1:1 (not 2:1 as for ordinary faces) is
+    // ensured, the edge-based consistency becomes a local operation (I'm not
+    // 100% sure to be honest since there are countless variants when dealing
+    // with arbitrary polyhedral cells).
+    // See faceConsistentRefinement for details. VV, 17/Apr/2018.
+
+    // Return number of added cells
+    return nAddCells;
+}
+
+
+Foam::label Foam::refinement::faceConsistentUnrefinement
+(
+    boolList& cellsToUnrefine
+) const
+{
+    // Count number of removed cells from unrefinement
+    label nRemCells = 0;
+
+    // Get necessary mesh data
+    const label nFaces = mesh_.nFaces();
+    const label nInternalFaces = mesh_.nInternalFaces();
+
+    const labelList& owner = mesh_.faceOwner();
+    const labelList& neighbour = mesh_.faceNeighbour();
+
+    // Loop through internal faces and check consistency
+    for (label faceI = 0; faceI < nInternalFaces; ++faceI)
+    {
+        // Get owner and neighbour labels
+        const label& own = owner[faceI];
+        const label& nei = neighbour[faceI];
+
+        // Get owner and neighbour cell levels
+        // Note: If the cell is marked for unrefinement, the level is current
+        // level - 1, otherwise it is equal to the current level
+        const label ownLevel =
+            cellsToUnrefine[own] ? cellLevel_[own] - 1 : cellLevel_[own];
+        const label neiLevel =
+            cellsToUnrefine[nei] ? cellLevel_[nei] - 1 : cellLevel_[nei];
+
+        if (ownLevel < (neiLevel - 1))
+        {
+            // Owner level is smaller than neighbour level - 1, we must not
+            // unrefine owner
+
+            // Check whether the cell has not been marked for unrefinement
+            if (!cellsToUnrefine[own])
+            {
+                FatalErrorInFunction
+                    << "Cell not marked for unrefinement, indicating a"
+                    << " previous unnoticed problem with unrefinement."
+                    << nl
+                    << "Owner: " << own << ", neighbour: " << nei
+                    << nl
+                    << "Owner level: " << ownLevel
+                    << ", neighbour level: " << neiLevel << nl
+                    << "This is probably because the refinement and "
+                    << "unrefinement regions are very close." << nl
+                    << "Try increasing nUnrefinementBufferLayers. "
+                    << abort(FatalError);
+            }
+            else
+            {
+                cellsToUnrefine[own] = false;
+                ++nRemCells;
+            }
+        }
+        else if (neiLevel < (ownLevel - 1))
+        {
+            // Neighbour level is smaller than owner level - 1, we must not
+            // unrefine neighbour
+
+            // Check whether the cell has not been marked for unrefinement
+            if (!cellsToUnrefine[nei])
+            {
+                FatalErrorInFunction
+                    << "Cell not marked for unrefinement, indicating a"
+                    << " previous unnoticed problem with unrefinement."
+                    << nl
+                    << "Owner: " << own << ", neighbour: " << nei
+                    << nl
+                    << "Owner level: " << ownLevel
+                    << ", neighbour level: " << neiLevel << nl
+                    << "This is probably because the refinement and "
+                    << "unrefinement regions are very close." << nl
+                    << "Try increasing nUnrefinementBufferLayers. "
+                    << abort(FatalError);
+            }
+            else
+            {
+                cellsToUnrefine[nei] = false;
+                ++nRemCells;
+            }
+        }
+    }
+
+    // Create owner level for boundary faces to prepare for swapping on coupled
+    // boundaries
+    labelList ownLevel(nFaces - nInternalFaces);
+    forAll (ownLevel, i)
+    {
+        // Get owner of the face and update owner cell levels
+        const label& own = owner[i + nInternalFaces];
+        ownLevel[i] =
+            cellsToUnrefine[own] ? cellLevel_[own] - 1 : cellLevel_[own];
+    }
+
+    // Swap boundary face lists (coupled boundary update)
+    syncTools::swapBoundaryFaceList(mesh_, ownLevel);
+
+    // Note: now the ownLevel list actually contains the neighbouring level
+    // (from the other side), use alias (reference) for clarity from now on
+    const labelList& neiLevel = ownLevel;
+
+    // Loop through boundary faces
+    forAll (neiLevel, i)
+    {
+        // Get owner of the face and owner level
+        const label& own = owner[i + nInternalFaces];
+        const label curOwnLevel =
+            cellsToUnrefine[own] ? cellLevel_[own] - 1 : cellLevel_[own];
+
+        // Note: we are using more stringent 1:1 consistency across coupled
+        // boundaries in order to simplify handling of edge based consistency
+        // checks for parallel runs
+        if (curOwnLevel < neiLevel[i])
+        {
+            // Owner level is smaller than neighbour level, we must not
+            // unrefine owner
+
+            // Check whether the cell has not been marked for unrefinement
+            // Note: this "redundancy" check should not be performed if we are
+            // running with dynamic load balancing. If an ordinary face with
+            // standard consistency (2:1) becomes a processor face with more
+            // stringent consistency (1:1), the refinement still remains valid,
+            // even though the 1:1 consistency is not achieved for this time
+            // step. Doing further refinement will make sure that this does not
+            // exceed at least 2:1 consistency and therefore 2:1 edge
+            // consistency as well. Instead of issuing a FatalError, issue a
+            // Warning and wrap it into debug
+            if (!cellsToUnrefine[own])
+            {
+                if (debug)
+                {
+                    WarningInFunction
+                        << "Boundary cell not marked for unrefinement,"
+                        << " indicating a previous unnoticed problem with"
+                        << " unrefinement."
+                        << nl
+                        << "Owner: " << own
+                        << nl
+                        << "Owner level: " << curOwnLevel
+                        << ", neighbour level: " << neiLevel[i] << nl
+                        << "This is probably because the refinement and "
+                        << "unrefinement regions are very close." << nl
+                        << "Try increasing nUnrefinementBufferLayers. "
+                        << nl
+                        << "Another possibility is that you are running "
+                        << "with Dynamic Load Balancing, in which case "
+                        << "this should be fine."
+                        << endl;
+                }
+            }
+            else
+            {
+                cellsToUnrefine[own] = false;
+                ++nRemCells;
+            }
+        }
+
+        // Note: other possibility (that neighbour level is smaller than owner
+        // level) is taken into account on the other side automatically
+    }
+
+    // Return number of local cells removed from unrefinement
+    return nRemCells;
+}
+
+
+Foam::label Foam::refinement::edgeConsistentUnrefinement
+(
+    boolList& cellsToUnrefine
+) const
+{
+    // Count number of cells that will be removed
+    label nRemCells = 0;
+
+    // Algorithm: loop over all edges and visit all unique cell pairs sharing
+    // this particular edge. Then, ensure 2:1 edge consistency by protecting the
+    // cell with lower level from unrefinement
+
+    // Get edge cells
+    const labelListList& meshEdgeCells = mesh_.edgeCells();
+
+    // Loop through all mesh edges
+    forAll (meshEdgeCells, edgeI)
+    {
+        // Get current edge cells
+        const labelList& curEdgeCells = meshEdgeCells[edgeI];
+
+        // Loop through all edge cells
+        forAll (curEdgeCells, i)
+        {
+            // Get first cell index
+            const label& cellI = curEdgeCells[i];
+
+            // Loop through remaining edge cells
+            for (label j = i + 1; j < curEdgeCells.size(); ++j)
+            {
+                // Get second cell index
+                const label& cellJ = curEdgeCells[j];
+
+                // Get levels of the two cells. If the cell is marked for
+                // unrefinement, the level is current level - 1, otherwise it is
+                // equal to the current level
+
+                // Note: cellsToUnrefine flag for both cellI and cellJ might
+                // change, this is why we need to recalculate cellI level here
+                const label cellILevel =
+                    cellsToUnrefine[cellI]
+                  ? cellLevel_[cellI] - 1
+                  : cellLevel_[cellI];
+
+                const label cellJLevel =
+                    cellsToUnrefine[cellJ]
+                  ? cellLevel_[cellJ] - 1
+                  : cellLevel_[cellJ];
+
+                if (cellILevel < cellJLevel - 1)
+                {
+                    // Level of cellI is smaller than level of cellJ - 1, cellI
+                    // must be protected from unrefinement
+
+                    // Check whether the cell has not been marked for
+                    // unrefinement
+                    if (!cellsToUnrefine[cellI])
+                    {
+                        if (debug)
+                        {
+                            WarningInFunction
+                                << "Cell not marked for unrefinement, indicating a"
+                                << " previous unnoticed problem with unrefinement."
+                                << nl
+                                << "cellI: " << cellI << ", cellJ: " << cellJ
+                                << nl
+                                << "Level of cellI: " << cellILevel
+                                << ", level of cellJ: " << cellJLevel << nl
+                                << "This is probably because the refinement and "
+                                << "unrefinement regions are very close." << nl
+                                << "Try increasing nUnrefinementBufferLayers. "
+                                << endl;
+                        }
+                    }
+                    else
+                    {
+                        cellsToUnrefine[cellI] = false;
+                        ++nRemCells;
+                    }
+                }
+                else if (cellJLevel < cellILevel - 1)
+                {
+                    // Level of cellJ is smaller than level of cellI - 1, cellJ
+                    // must be protected from unrefinement
+
+                    // Check whether the cell has not been marked for
+                    // unrefinement
+                    if (!cellsToUnrefine[cellJ])
+                    {
+                        if (debug)
+                        {
+                            WarningInFunction
+                                << "Cell not marked for unrefinement, indicating a"
+                                << " previous unnoticed problem with unrefinement."
+                                << nl
+                                << "cellI: " << cellI << ", cellJ: " << cellJ
+                                << nl
+                                << "Level of cellI: " << cellILevel
+                                << ", level of cellJ: " << cellJLevel << nl
+                                << "This is probably because the refinement and "
+                                << "unrefinement regions are very close." << nl
+                                << "Try increasing nUnrefinementBufferLayers. "
+                                << endl;
+                        }
+                    }
+                    else
+                    {
+                        cellsToUnrefine[cellJ] = false;
+                        ++nRemCells;
+                    }
+                }
+            }
+        }
+    }
+
+    // Note: in order to avoid very difficult and time-consuming parallelisation
+    // of edge cell connectivity and edge cell values, we enforce a more
+    // stringent face-based consistency across processor boundaries. Basically,
+    // if a face-based consistency of 1:1 (not 2:1 as for ordinary faces) is
+    // ensured, the edge-based consistency becomes a local operation (I'm not
+    // 100% sure to be honest whether this is true all the time since there are
+    // countless variants when dealing with arbitrary polyhedral cells).
+    // See faceConsistentRefinement for details. VV, 3/Apr/2018.
+
+    // Return number of removed cells
+    return nRemCells;
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::refinement::refinement
+(
+    const word& name,
+    const dictionary& dict,
+    const label index,
+    const polyTopoChanger& mme
+)
+:
+    polyMeshModifier(name, index, mme, Switch(dict.lookup("active"))),
+    mesh_(mme.mesh()),
+    cellsToRefine_(),
+    splitPointsToUnrefine_(),
+    cellLevel_
+    (
+        IOobject
+        (
+            "cellLevel",
+            mesh_.facesInstance(),
+            polyMesh::meshSubDir,
+            mesh_,
+            IOobject::READ_IF_PRESENT,
+            IOobject::AUTO_WRITE
+        ),
+        labelField(mesh_.nCells(), 0)
+    ),
+    pointLevel_
+    (
+        IOobject
+        (
+            "pointLevel",
+            mesh_.facesInstance(),
+            polyMesh::meshSubDir,
+            mesh_,
+            IOobject::READ_IF_PRESENT,
+            IOobject::AUTO_WRITE
+        ),
+        labelField(mesh_.nPoints(), 0)
+    ),
+    refinementLevelIndicator_(0), // Must be empty before setting refinement
+    faceRemover_(mesh_, GREAT),   // Merge boundary faces wherever possible
+    maxCells_(readLabel(dict.lookup("maxCells"))),
+    maxRefinementLevel_(readLabel(dict.lookup("maxRefinementLevel"))),
+    edgeBasedConsistency_
+    (
+        dict.lookupOrDefault<Switch>("edgeBasedConsistency", true)
+    ),
+    nRefinementBufferLayers_
+    (
+        readScalar(dict.lookup("nRefinementBufferLayers"))
+    ),
+    nUnrefinementBufferLayers_
+    (
+        readScalar(dict.lookup("nUnrefinementBufferLayers"))
+    )
+{
+    Info<< "refinement::refinement: " << "Created pointLevel and cellLevel"
+        << endl;
+
+    // Check consistency between cellLevel and number of cells and pointLevel
+    // and number of points in the mesh
+    if
+    (
+        cellLevel_.size() != mesh_.nCells()
+     || pointLevel_.size() != mesh_.nPoints()
+    )
+    {
+        FatalErrorInFunction
+            << "Restarted from inconsistent cellLevel or pointLevel files."
+            << endl
+            << "Number of cells in mesh: " << mesh_.nCells()
+            << " does not equal size of cellLevel: " << cellLevel_.size() << nl
+            << "Number of points in mesh: " << mesh_.nPoints()
+            << " does not equal size of pointLevel: " << pointLevel_.size()
+            << abort(FatalError);
+    }
+
+    // Check specified number of maximum cells
+    if (maxCells_ < 1)
+    {
+        FatalErrorInFunction
+            << "Specified zero or negative maxCells."
+            << nl
+            << "This is not allowed."
+            << abort(FatalError);
+    }
+
+    // Check maximum refinement level
+    if (maxRefinementLevel_ < 0)
+    {
+        FatalErrorInFunction
+            << "Negative maxRefinementLevel specified."
+            << nl
+            << "This is not allowed."
+            << abort(FatalError);
+    }
+
+    // If the maximum refinementLevel is greater than 2 and the user insists on
+    // not using point based refinement strategy, issue a warning
+    if (!edgeBasedConsistency_ && maxRefinementLevel_ > 2)
+    {
+        WarningInFunction
+            << "You are not using point based consistency for dynamic"
+            << " refinement."
+            << nl
+            << "Since you are allowing more than two maximum refinement"
+            << " refinement levels, this might produce erroneous mesh due to"
+            << " 8:1 point conflicts."
+            << nl
+            << "In order to supress this message and use point based"
+            << " consistency checks, set edgeBasedConsistency to true."
+            << endl;
+    }
+
+    // Check number of refinement buffer layers
+    if (nRefinementBufferLayers_ < 0)
+    {
+        FatalErrorInFunction
+            << "Negative nRefinementBufferLayers specified."
+            << nl
+            << "This is not allowed."
+            << abort(FatalError);
+    }
+
+    // Check number of unrefinement buffer layers
+    if (nUnrefinementBufferLayers_ < 0)
+    {
+        FatalErrorInFunction
+            << "Negative nUnrefinementBufferLayers specified."
+            << nl
+            << "This is not allowed."
+            << abort(FatalError);
+    }
+
+    // Check whether the number of unrefinement buffer layers is smaller than
+    // number of refinement buffer layers + 2
+    if (nUnrefinementBufferLayers_ < nRefinementBufferLayers_ + 2)
+    {
+        WarningInFunction
+            << "Using " << nUnrefinementBufferLayers_
+            << " unrefinement buffer layers and " << nRefinementBufferLayers_
+            << " refinement buffer layers."
+            << nl
+            << "Make sure that the number of unrefinement buffer layers is "
+            << "at least nRefinementBufferLayers + 2" << nl
+            << "in order to avoid problems with edge level inconsistency when "
+            << "refinement and unrefinement are performed in same iteration."
+            << endl;
+    }
+}
+
+
+// * * * * * * * * * * * * * Public Member Functions * * * * * * * * * * * * //
+
+bool Foam::refinement::changeTopology() const
+{
+    if (!active())
+    {
+        // Modifier is inactive, skip topo change
+        if (debug)
+        {
+            Pout<< "bool refinement::changeTopology() const"
+                << "for object " << name() << " : "
+                << "Inactive" << endl;
+        }
+
+        return false;
+    }
+    else
+    {
+        return true;
+    }
+}
+
+
+void Foam::refinement::setRefinement(batchPolyTopoChange& ref) const
+{
+    // Set refinement and unrefinement
+    this->setRefinementInstruction(ref);
+    this->setUnrefinementInstruction(ref);
+
+    // Clear the list of cells to refine and split points to unrefine since the
+    // refinement/unrefinement instructions have been set
+    cellsToRefine_.clear();
+    splitPointsToUnrefine_.clear();
+}
+
+
+void Foam::refinement::modifyMotionPoints
+(
+    pointField& motionPoints
+) const
+{
+    if (debug)
+    {
+        Pout<< "void refinement::modifyMotionPoints("
+            << "pointField& motionPoints) const for object "
+            << name() << " : ";
+    }
+
+    if (debug)
+    {
+        Pout << "No motion point adjustment" << endl;
+    }
+}
+
+
+
+void Foam::refinement::updateMesh(const mapPolyMesh& map)
+{
+    if (debug)
+    {
+        Info<< "refinement::updateMesh(const mapPolyMesh&) "
+            << " for object " << name() << " : "
+            << "Updating cell and point levels."
+            << endl;
+    }
+
+    // Mesh has changed topologically, we need to update cell and point levels
+    // and optionally face removal object
+
+    // Get cell map: from current mesh cells to previous mesh cells
+    const labelList& cellMap = map.cellMap();
+
+    // Create new cell level
+    labelList newCellLevel(cellMap.size());
+
+    // Loop through all new cells
+    forAll (cellMap, newCellI)
+    {
+        adjustRefLevel(newCellLevel[newCellI], cellMap[newCellI]);
+    }
+
+    // Do cells from points: unrefinement
+    // Note: should other types be done as well?
+    // HJ, 9/Sep/2019
+    const List<objectMap>& cellsFromPoints =  map.cellsFromPointsMap();
+
+    forAll (cellsFromPoints, cfpI)
+    {
+        adjustRefLevel
+        (
+            newCellLevel[cellsFromPoints[cfpI].index()],
+            cellsFromPoints[cfpI].masterObjects()[0]
+        );
+    }
+
+    // Transfer the new cell level into the data member
+    cellLevel_.transfer(newCellLevel);
+
+    // Clear out refinementLevelIndicator_ field for next refinement step
+    refinementLevelIndicator_.clear();
+
+
+    // Point level will be updated based on already updated cell level. Level
+    // for newly added points has to be equal to the maximum cell level of
+    // surrounding points. At this point, mesh is fully topologically valid so
+    // it is safe to use pointCells
+
+    // Get point map: from current mesh points to previous mesh points
+    const labelList& pointMap = map.pointMap();
+
+    // Get point cell
+    const labelListList& meshPointCells = mesh_.pointCells();
+
+    // Create new point level
+    labelList newPointLevel(pointMap.size());
+
+    // Loop through all new points
+    forAll (pointMap, newPointI)
+    {
+        // Get index of the corresponding old point
+        const label& oldPointI = pointMap[newPointI];
+
+        if (oldPointI == -1)
+        {
+            // This point has been appended without any master point, use
+            // surrounding cells to determine new point level
+
+            // Get new cells surrounding this new point
+            const labelList& pCells = meshPointCells[newPointI];
+
+            // Find maximum cell level for this point
+            label maxCellLevel = 0;
+            forAll (pCells, i)
+            {
+                maxCellLevel = max(maxCellLevel, cellLevel_[pCells[i]]);
+            }
+
+            // Set new point level as the maximum of the surrounding cells
+            newPointLevel[newPointI] = maxCellLevel;
+        }
+        else
+        {
+            // This point is either old point or it has been added in terms of
+            // another point. New point level is equal to the old point level
+            newPointLevel[newPointI] = pointLevel_[oldPointI];
+        }
+    }
+
+    // Sync the new point level. Note: here, we assume that the call to
+    // updateMesh happened after polyBoundaryMesh::updateMesh where the
+    // processor data is fully rebuilt. If this is not the case, the point
+    // level will remain unsynced and will cause all kinds of trouble that
+    // are extremely difficult to spot. See the change in
+    // polyTopoChanger::changeMesh order of calling polyMesh::updateMesh and
+    // polyTopoChanger::update. VV, 19/Feb/2019.
+    syncTools::syncPointList
+    (
+        mesh_,
+        newPointLevel,
+        maxEqOp<label>(),
+        label(0)   // Null value
+    );
+
+    // Transfer the new point level into the data member
+    pointLevel_.transfer(newPointLevel);
+
+    // Mark files as changed
+    setInstance(mesh_.facesInstance());
+
+    // Update face remover
+    faceRemover_.updateMesh(map);
+}
+
+
+void Foam::refinement::write(Ostream& os) const
+{
+    os  << nl << type() << nl
+        << name() << nl
+        << maxCells_ << nl
+        << maxRefinementLevel_ << nl
+        << edgeBasedConsistency_ << nl
+        << nRefinementBufferLayers_ << nl
+        << nUnrefinementBufferLayers_ << endl;
+}
+
+
+void Foam::refinement::writeDict(Ostream& os) const
+{
+    // Write necessary data before writing dictionary
+    cellLevel_.write();
+    pointLevel_.write();
+
+    os  << nl << name() << nl << token::BEGIN_BLOCK << nl
+        << "    type " << type()
+        << token::END_STATEMENT << nl
+        << "    maxCells " << maxCells_
+        << token::END_STATEMENT << nl
+        << "    maxRefinementLevel " << maxRefinementLevel_
+        << token::END_STATEMENT << nl
+        << "    edgeBasedConsistency " << edgeBasedConsistency_
+        << token::END_STATEMENT << nl
+        << "    nRefinementBufferLayers " << nRefinementBufferLayers_
+        << token::END_STATEMENT << nl
+        << "    nUnrefinementBufferLayers " << nUnrefinementBufferLayers_
+        << token::END_STATEMENT << nl
+        << "    active " << active()
+        << token::END_STATEMENT << nl
+        << token::END_BLOCK << endl;
+}
+
+
+// ************************************************************************* //
diff --git a/src/dynamicMesh/refinement/refinement/refinement.H b/src/dynamicMesh/refinement/refinement/refinement.H
new file mode 100644
index 0000000000..a9754c5c85
--- /dev/null
+++ b/src/dynamicMesh/refinement/refinement/refinement.H
@@ -0,0 +1,392 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | foam-extend: Open Source CFD
+   \\    /   O peration     | Version:     5.0
+    \\  /    A nd           | Web:         http://www.foam-extend.org
+     \\/     M anipulation  | For copyright notice see file Copyright
+-------------------------------------------------------------------------------
+License
+    This file is part of foam-extend.
+
+    foam-extend is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation, either version 3 of the License, or (at your
+    option) any later version.
+
+    foam-extend is distributed in the hope that it will be useful, but
+    WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with foam-extend.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::refinement
+
+Description
+    Abstract base class for adaptive mesh refinement using the mesh modifier
+    engine. The class provides common interface and functionalities for 3D
+    polyhedral refinement and 2D prismatic refinement.
+
+    The common interface includes (pure virtuals) following member functions:
+    - setCellsToRefine
+    - setSplitPointsToUnrefine
+
+    With a lot of ordinary protected member functions which are used by both
+    derived classes.
+
+    Note: I've written it this way in order to avoid unnecesasry code
+    duplication, but I'm 99% sure that if someone else wants to write additional
+    refinement strategy (e.g. directional refinement) as derived class, the
+    interface will need to change.
+
+SourceFiles
+    refinement.C
+
+Author
+    Vuko Vukcevic, Wikki Ltd.  All rights reserved.
+
+Notes
+    Generalisation of hexRef8 for polyhedral cells and refactorisation using
+    polyMesh modifier engine.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef refinement_H
+#define refinement_H
+
+#include "polyMeshModifier.H"
+#include "labelIOField.H"
+#include "removeFaces.H"
+#include "batchPolyTopoChange.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                            Class refinement Declaration
+\*---------------------------------------------------------------------------*/
+
+class refinement
+:
+    public polyMeshModifier
+{
+protected:
+
+    // Protected enumeration for refinement status
+    enum refinementStatus
+    {
+        UNREFINED = -1,
+        UNCHANGED = 0,
+        REFINED = 1
+    };
+
+    static const scalar nonOrthThreshold_;
+
+    // Protected data
+
+        //- Reference to polyMesh for easy access in helper functions
+        const polyMesh& mesh_;
+
+
+        // Refinement control and handling
+
+            //- List of cells to refine in this time step
+            mutable labelList cellsToRefine_;
+
+            //- List of split point labels to unrefine in this time step
+            mutable labelList splitPointsToUnrefine_;
+
+            //- Cell refinement level
+            mutable labelIOField cellLevel_;
+
+            //- Point refinement level
+            mutable labelIOField pointLevel_;
+
+            //- Helper list for original (old) cells that will be refined or
+            //  unrefined. The list is updated in setPolyhedralRefinement and
+            //  setPolyhedralUnfereinement and is used in updateMesh to update
+            //  the cellLevel on the new mesh.
+            //  Values stored in the list are:
+            //  a) UNREFINED = -1 = cell is unrefined
+            //  b) UNCHANGED =  0 = cell is untouched
+            //  c) REFINED   = +1 = cell is refined
+            mutable labelList refinementLevelIndicator_;
+
+            //- Face remover engine
+            mutable removeFaces faceRemover_;
+
+            //- Maximum number of cells in the mesh. Note: not strictly enforced
+            label maxCells_;
+
+            //- Maximum number of refinement levels for a given cell
+            label maxRefinementLevel_;
+
+            //- Switch whether to use edge based consistency on refinement
+            Switch edgeBasedConsistency_;
+
+            //- Number of buffer layers for refinement
+            label nRefinementBufferLayers_;
+
+            //- Number of buffer layers for unrefinement, controlling how far
+            //  the unrefinement region needs to be from current refinement
+            //  region
+            label nUnrefinementBufferLayers_;
+
+
+    // Protected Pure Virtual Member Functions
+
+        // Global topology modification functions (operate on whole polyMesh)
+
+            //- Set refinement instruction
+            virtual void setRefinementInstruction
+            (
+                batchPolyTopoChange& ref
+            ) const = 0;
+
+            //- Set unrefinement instruction
+            virtual void setUnrefinementInstruction
+            (
+                batchPolyTopoChange& ref
+            ) const = 0;
+
+
+    // Protected Member Functions
+
+        // Useful helper functions used by derived classes
+
+            //- Set file instance for cellLevel_ and pointLevel_
+            void setInstance(const fileName& inst) const;
+
+
+        // Local topology modification functions (operate on cells/faces)
+
+            //- Adds a face on top of existing faceI. Reverses if nessecary
+            label addFace
+            (
+                batchPolyTopoChange& ref,
+                const label faceI,
+                const face& newFace,
+                const label own,
+                const label nei
+            ) const;
+
+            //- Adds internal face from point. No checks on reversal
+            label addInternalFace
+            (
+                batchPolyTopoChange& ref,
+                const label meshFaceI,
+                const label meshPointI,
+                const face& newFace,
+                const label own,
+                const label nei
+            ) const;
+
+            //- Modifies existing faceI for either new owner/neighbour or new
+            //  face points. Reverses if nessecary
+            void modifyFace
+            (
+                batchPolyTopoChange& ref,
+                const label faceI,
+                const face& newFace,
+                const label own,
+                const label nei
+            ) const;
+
+
+        // Topological change helper functions
+
+            //- Store vertices from startFp up to face split point.
+            //  Used when splitting face into n faces where n is the number of
+            //  points in a face (or number of edges)
+            void walkFaceToMid
+            (
+                const labelList& edgeMidPoint,
+                const label cLevel,
+                const label faceI,
+                const label startFp,
+                DynamicList<label>& faceVerts
+            ) const;
+
+            //- Same as walkFaceToMid but now walk back
+            void walkFaceFromMid
+            (
+                const labelList& edgeMidPoint,
+                const label cLevel,
+                const label faceI,
+                const label startFp,
+                DynamicList<label>& faceVerts
+            ) const;
+
+            //- Get index of point with minimum point level
+            label findMinLevel(const labelList& f) const;
+
+            //- Get index of point with maximum point level
+            label findMaxLevel(const labelList& f) const;
+
+            //- Count number of vertices <= anchorLevel for a given face
+            label countAnchors
+            (
+                const labelList& f,
+                const label anchorLevel
+            ) const;
+
+            //- Adjust cell refinement level after topo change
+            void adjustRefLevel
+            (
+                label& curNewCellLevel,
+                const label oldCellI
+            );
+
+
+        // Debug functions
+
+            //- Check orientation of added internal face
+            void checkInternalOrientation
+            (
+                batchPolyTopoChange& ref,
+                const label cellI,
+                const label faceI,
+                const point& ownPt,
+                const point& neiPt,
+                const face& newFace
+            ) const;
+
+            //- Check orientation of a new boundary face
+            void checkBoundaryOrientation
+            (
+                batchPolyTopoChange& ref,
+                const label cellI,
+                const label faceI,
+                const point& ownPt,
+                const point& boundaryPt,
+                const face& newFace
+            ) const;
+
+
+        // Refinement/unrefinement consistency checks
+
+            //- Updates cellsToRefine such that a face consistent 2:1 refinement
+            //  is obtained. Returns local number of cells changed
+            label faceConsistentRefinement(boolList& cellsToRefine) const;
+
+            //- Updates cellsToRefine such that an edge consistent 4:1 refinement
+            //  is obtained. Returns local number of cells changed
+            label edgeConsistentRefinement(boolList& cellsToRefine) const;
+
+            //- Updates cellsToUnrefine such that a face consistent 2:1
+            //  unrefinement is obtained. Returns local number of cells changed
+            label faceConsistentUnrefinement(boolList& cellsToUnrefine) const;
+
+            //- Updates cellsToUnrefine such that an edge consistent 4:1
+            //  unrefinement is obtained. Returns local number of cells changed
+            label edgeConsistentUnrefinement(boolList& cellsToUnrefine) const;
+
+
+        // Copy control
+
+            //- Disallow default bitwise copy construct
+            refinement(const refinement&);
+
+            //- Disallow default bitwise assignment
+            void operator=(const refinement&);
+
+
+public:
+
+    //- Runtime type information
+    TypeName("refinement");
+
+
+    // Constructors
+
+        //- Construct from dictionary
+        refinement
+        (
+            const word& name,
+            const dictionary& dict,
+            const label index,
+            const polyTopoChanger& mme
+        );
+
+
+    //- Destructor
+    virtual ~refinement() = default;
+
+
+    // Member Functions
+
+        // Access
+
+            //- Return refinement cell level
+            const labelIOField& cellLevel() const
+            {
+                return cellLevel_;
+            }
+
+            //- Return refinement point level
+            const labelIOField& pointLevel() const
+            {
+                return pointLevel_;
+            }
+
+
+        // Edit
+
+            //- Set cells to refine given a list of refinement
+            //  candidates. Refinement candidates are extended within the
+            //  function due to possible 4:1 conflicts and specified number of
+            //  buffer layers.
+            //  Note: must be called BEFORE setSplitPointsToUnrefine
+            virtual void setCellsToRefine
+            (
+                const labelList& refinementCellCandidates
+            ) = 0;
+
+            //- Set split points to unrefine given a list of all mesh points
+            //  that are candidates for unrefinement. Split points are
+            //  determined as a subset of unrefinement candidates, avoiding
+            //  splitting points of cells that are going to be refined at the
+            //  same time and ensuring consistent unrefinement.
+            //  Note: must be called AFTER setCellsToRefine
+            virtual void setSplitPointsToUnrefine
+            (
+                const labelList& unrefinementPointCandidates
+            ) = 0;
+
+
+        // Inherited interface from polyMeshModifier
+
+            //- Check for topology change
+            virtual bool changeTopology() const;
+
+            //- Insert the polyhedral refinement/unrefinement into the
+            //  topological change
+            virtual void setRefinement(batchPolyTopoChange&) const;
+
+            //- Modify motion points to comply with the topological change
+            virtual void modifyMotionPoints(pointField& motionPoints) const;
+
+            //- Force recalculation of locally stored data on topological change
+            virtual void updateMesh(const mapPolyMesh&);
+
+            //- Write
+            virtual void write(Ostream&) const;
+
+            //- Write dictionary
+            virtual void writeDict(Ostream&) const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/dynamicMesh/refinement/refinement/refinementTools.H b/src/dynamicMesh/refinement/refinement/refinementTools.H
new file mode 100644
index 0000000000..00f0a112e2
--- /dev/null
+++ b/src/dynamicMesh/refinement/refinement/refinementTools.H
@@ -0,0 +1,351 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | foam-extend: Open Source CFD
+   \\    /   O peration     | Version:     5.0
+    \\  /    A nd           | Web:         http://www.foam-extend.org
+     \\/     M anipulation  | For copyright notice see file Copyright
+-------------------------------------------------------------------------------
+License
+    This file is part of foam-extend.
+
+    foam-extend is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation, either version 3 of the License, or (at your
+    option) any later version.
+
+    foam-extend is distributed in the hope that it will be useful, but
+    WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with foam-extend.  If not, see <http://www.gnu.org/licenses/>.
+
+Namespace
+    Foam::refinementTools
+
+Description
+    Collection of static functions to do various simple mesh related things.
+
+SourceFiles
+    refinementTools.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef refinementTools_H
+#define refinementTools_H
+
+#include "vector.H"
+#include "label.H"
+#include "labelList.H"
+#include "pointField.H"
+#include "faceList.H"
+#include "cellList.H"
+#include "primitivePatch.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+class primitiveMesh;
+class polyMesh;
+
+/*---------------------------------------------------------------------------*\
+                    Namespace refinementTools Declaration
+\*---------------------------------------------------------------------------*/
+
+namespace refinementTools
+{
+    // Bit identifiers for octants (p=plus, m=min e.g. plusXminYminZ)
+
+    static const label mXmYmZ = 0;
+    static const label pXmYmZ = 1;
+    static const label mXpYmZ = 2;
+    static const label pXpYmZ = 3;
+
+    static const label mXmYpZ = 4;
+    static const label pXmYpZ = 5;
+    static const label mXpYpZ = 6;
+    static const label pXpYpZ = 7;
+
+    static const label mXmYmZMask = 1 << mXmYmZ;
+    static const label pXmYmZMask = 1 << pXmYmZ;
+    static const label mXpYmZMask = 1 << mXpYmZ;
+    static const label pXpYmZMask = 1 << pXpYmZ;
+
+    static const label mXmYpZMask = 1 << mXmYpZ;
+    static const label pXmYpZMask = 1 << pXmYpZ;
+    static const label mXpYpZMask = 1 << mXpYpZ;
+    static const label pXpYpZMask = 1 << pXpYpZ;
+
+
+    // Normal handling
+
+        //- Check if n is in same direction as normals of all faceLabels
+        bool visNormal
+        (
+            const vector& n,
+            const vectorField& faceNormals,
+            const labelList& faceLabels
+        );
+
+        //- Calculate point normals on a 'box' mesh (all edges aligned with
+        //  coordinate axes)
+        vectorField calcBoxPointNormals(const primitivePatch& pp);
+
+        //- Normalized edge vector
+        vector normEdgeVec(const primitiveMesh&, const label edgeI);
+
+
+    // OBJ writing
+
+        //- Write obj representation of point
+        void writeOBJ
+        (
+            Ostream& os,
+            const point& pt
+        );
+
+        //- Write obj representation of faces subset
+        void writeOBJ
+        (
+            Ostream& os,
+            const faceList&,
+            const pointField&,
+            const labelList& faceLabels
+        );
+
+        //- Write obj representation of faces
+        void writeOBJ
+        (
+            Ostream& os,
+            const faceList&,
+            const pointField&
+        );
+
+        //- Write obj representation of cell subset
+        void writeOBJ
+        (
+            Ostream& os,
+            const cellList&,
+            const faceList&,
+            const pointField&,
+            const labelList& cellLabels
+        );
+
+
+    // Cell/face/edge walking
+
+        //- Is edge used by cell
+        bool edgeOnCell
+        (
+            const primitiveMesh&,
+            const label cellI,
+            const label edgeI
+        );
+
+        //- Is edge used by face
+        bool edgeOnFace
+        (
+            const primitiveMesh&,
+            const label faceI,
+            const label edgeI
+        );
+
+        //- Is face used by cell
+        bool faceOnCell
+        (
+            const primitiveMesh&,
+            const label cellI,
+            const label faceI
+        );
+
+        //- Return edge among candidates that uses the two vertices.
+        label findEdge
+        (
+            const edgeList& edges,
+            const labelList& candidates,
+            const label v0,
+            const label v1
+        );
+
+        //- Return edge between two vertices. Returns -1 if no edge.
+        label findEdge
+        (
+            const primitiveMesh&,
+            const label v0,
+            const label v1
+        );
+
+        //- Return edge shared by two faces. Throws error if no edge found.
+        label getSharedEdge
+        (
+            const primitiveMesh&,
+            const label f0,
+            const label f1
+        );
+
+        //- Return face shared by two cells. Throws error if none found.
+        label getSharedFace
+        (
+            const primitiveMesh&,
+            const label cell0,
+            const label cell1
+        );
+
+        //- Get faces on cell using edgeI. Throws error if no two found.
+        void getEdgeFaces
+        (
+            const primitiveMesh&,
+            const label cellI,
+            const label edgeI,
+            label& face0,
+            label& face1
+        );
+
+        //- Return label of other edge (out of candidates edgeLabels)
+        //  connected to vertex but not edgeI. Throws error if none found.
+        label otherEdge
+        (
+            const primitiveMesh&,
+            const labelList& edgeLabels,
+            const label edgeI,
+            const label vertI
+        );
+
+        //- Return face on cell using edgeI but not faceI. Throws error
+        //  if none found.
+        label otherFace
+        (
+            const primitiveMesh&,
+            const label cellI,
+            const label faceI,
+            const label edgeI
+        );
+
+        //- Return cell on other side of face. Throws error
+        //  if face not internal.
+        label otherCell
+        (
+            const primitiveMesh&,
+            const label cellI,
+            const label faceI
+        );
+
+        //- Returns label of edge nEdges away from startEdge (in the direction
+        // of startVertI)
+        label walkFace
+        (
+            const primitiveMesh&,
+            const label faceI,
+            const label startEdgeI,
+            const label startVertI,
+            const label nEdges
+        );
+
+
+    // Constraints on position
+
+        //- Set the constrained components of position to mesh centre
+        void constrainToMeshCentre
+        (
+            const polyMesh& mesh,
+            point& pt
+        );
+        void constrainToMeshCentre
+        (
+            const polyMesh& mesh,
+            pointField& pt
+        );
+
+        //- Set the constrained components of directions/velocity to zero
+        void constrainDirection
+        (
+            const polyMesh& mesh,
+            const Vector<label>& dirs,
+            vector& d
+        );
+        void constrainDirection
+        (
+            const polyMesh& mesh,
+            const Vector<label>& dirs,
+            vectorField& d
+        );
+
+
+    // Hex only functionality
+
+        //- Given edge on hex find other 'parallel', non-connected edges.
+        void getParallelEdges
+        (
+            const primitiveMesh&,
+            const label cellI,
+            const label e0,
+            label&,
+            label&,
+            label&
+        );
+
+        //- Given edge on hex find all 'parallel' (i.e. non-connected)
+        //  edges and average direction of them
+        vector edgeToCutDir
+        (
+            const primitiveMesh&,
+            const label cellI,
+            const label edgeI
+        );
+
+        //- Reverse of edgeToCutDir: given direction find edge bundle and
+        //  return one of them.
+        label cutDirToEdge
+        (
+            const primitiveMesh&,
+            const label cellI,
+            const vector& cutDir
+        );
+
+
+    // Face information
+
+        //- Set face information: patch, zone and zone flip for a face
+        void setFaceInfo
+        (
+            const polyMesh& mesh,
+            const label faceI,
+            label& patchID,
+            label& zoneID,
+            label& zoneFlip
+        );
+
+
+    // Mark-up of mesh bits. Relocated from refinement polyMeshModifier
+
+        //- Extend marked cells across faces given a bool list of already marked
+        //  cells
+        void extendMarkedCellsAcrossFaces
+        (
+            const polyMesh& mesh,
+            boolList& markedCell
+        );
+
+        //- Extend marked cells across points given a bool list of already
+        //  marked cells
+        void extendMarkedCellsAcrossPoints
+        (
+            const polyMesh& mesh,
+            boolList& markedCell
+        );
+
+} // End namespace refinementTools
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/dynamicMesh/setUpdater/setUpdater.C b/src/dynamicMesh/setUpdater/setUpdater.C
index 5c93427521..19ffc8db45 100644
--- a/src/dynamicMesh/setUpdater/setUpdater.C
+++ b/src/dynamicMesh/setUpdater/setUpdater.C
@@ -27,7 +27,7 @@ License
 
 #include "setUpdater.H"
 #include "polyTopoChanger.H"
-#include "polyTopoChange.H"
+#include "batchPolyTopoChange.H"
 #include "addToRunTimeSelectionTable.H"
 #include "mapPolyMesh.H"
 #include "cellSet.H"
@@ -71,7 +71,7 @@ bool Foam::setUpdater::changeTopology() const
 }
 
 
-void Foam::setUpdater::setRefinement(polyTopoChange&) const
+void Foam::setUpdater::setRefinement(batchPolyTopoChange&) const
 {}
 
 
diff --git a/src/dynamicMesh/setUpdater/setUpdater.H b/src/dynamicMesh/setUpdater/setUpdater.H
index 3fd01c7909..3106403ab6 100644
--- a/src/dynamicMesh/setUpdater/setUpdater.H
+++ b/src/dynamicMesh/setUpdater/setUpdater.H
@@ -97,7 +97,7 @@ public:
 
         //- Insert the layer addition/removal instructions
         //  into the topological change
-        virtual void setRefinement(polyTopoChange&) const;
+        virtual void setRefinement(batchPolyTopoChange&) const;
 
         //- Modify motion points to comply with the topological change
         virtual void modifyMotionPoints(pointField& motionPoints) const;
diff --git a/src/dynamicMesh/slidingInterface/coupleSlidingInterface.C b/src/dynamicMesh/slidingInterface/coupleSlidingInterface.C
index 40ca37ea7e..5274c2705b 100644
--- a/src/dynamicMesh/slidingInterface/coupleSlidingInterface.C
+++ b/src/dynamicMesh/slidingInterface/coupleSlidingInterface.C
@@ -27,7 +27,7 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "slidingInterface.H"
-#include "polyTopoChange.H"
+#include "batchPolyTopoChange.H"
 #include "polyMesh.H"
 #include "primitiveMesh.H"
 #include "enrichedPatch.H"
@@ -69,7 +69,7 @@ const Foam::scalar Foam::slidingInterface::edgeCoPlanarTolDefault_ = 0.8;
 // - - missed master edge in cut
 // u - edge already used in cutting
 
-void Foam::slidingInterface::coupleInterface(polyTopoChange& ref) const
+void Foam::slidingInterface::coupleInterface(batchPolyTopoChange& ref) const
 {
     if (debug)
     {
diff --git a/src/dynamicMesh/slidingInterface/decoupleSlidingInterface.C b/src/dynamicMesh/slidingInterface/decoupleSlidingInterface.C
index 64fe0f573c..0c22ba2f24 100644
--- a/src/dynamicMesh/slidingInterface/decoupleSlidingInterface.C
+++ b/src/dynamicMesh/slidingInterface/decoupleSlidingInterface.C
@@ -29,7 +29,7 @@ License
 #include "slidingInterface.H"
 #include "polyMesh.H"
 #include "primitiveMesh.H"
-#include "polyTopoChange.H"
+#include "batchPolyTopoChange.H"
 #include "polyTopoChanger.H"
 #include "polyModifyFace.H"
 #include "polyModifyPoint.H"
@@ -38,7 +38,7 @@ License
 
 void Foam::slidingInterface::decoupleInterface
 (
-    polyTopoChange& ref
+    batchPolyTopoChange& ref
 ) const
 {
     if (debug)
diff --git a/src/dynamicMesh/slidingInterface/slidingInterface.C b/src/dynamicMesh/slidingInterface/slidingInterface.C
index cf25565ba1..e41eeef903 100644
--- a/src/dynamicMesh/slidingInterface/slidingInterface.C
+++ b/src/dynamicMesh/slidingInterface/slidingInterface.C
@@ -29,7 +29,7 @@ License
 #include "slidingInterface.H"
 #include "polyTopoChanger.H"
 #include "polyMesh.H"
-#include "polyTopoChange.H"
+#include "batchPolyTopoChange.H"
 #include "addToRunTimeSelectionTable.H"
 #include "plane.H"
 
@@ -367,7 +367,7 @@ bool Foam::slidingInterface::changeTopology() const
 }
 
 
-void Foam::slidingInterface::setRefinement(polyTopoChange& ref) const
+void Foam::slidingInterface::setRefinement(batchPolyTopoChange& ref) const
 {
     if (coupleDecouple_)
     {
diff --git a/src/dynamicMesh/slidingInterface/slidingInterface.H b/src/dynamicMesh/slidingInterface/slidingInterface.H
index f3ac02bf52..d5742cc904 100644
--- a/src/dynamicMesh/slidingInterface/slidingInterface.H
+++ b/src/dynamicMesh/slidingInterface/slidingInterface.H
@@ -264,19 +264,19 @@ private:
             bool projectPoints() const;
 
             //- Couple sliding interface
-            void coupleInterface(polyTopoChange& ref) const;
+            void coupleInterface(batchPolyTopoChange& ref) const;
 
             //- Clear projection
             void clearPointProjection() const;
 
             //- Clear old couple
-            void clearCouple(polyTopoChange& ref) const;
+            void clearCouple(batchPolyTopoChange& ref) const;
 
             //- Decouple interface (returns it to decoupled state)
             //  Note: this should not be used in normal operation of the
             //  sliding mesh, but only to return the mesh to its
             //  original state
-            void decoupleInterface(polyTopoChange& ref) const;
+            void decoupleInterface(batchPolyTopoChange& ref) const;
 
 
     // Static data members
@@ -364,7 +364,7 @@ public:
 
         //- Insert the layer addition/removal instructions
         //  into the topological change
-        virtual void setRefinement(polyTopoChange&) const;
+        virtual void setRefinement(batchPolyTopoChange&) const;
 
         //- Modify motion points to comply with the topological change
         virtual void modifyMotionPoints(pointField& motionPoints) const;
diff --git a/src/dynamicMesh/slidingInterface/slidingInterfaceClearCouple.C b/src/dynamicMesh/slidingInterface/slidingInterfaceClearCouple.C
index 8d5318dce9..bafd41ae65 100644
--- a/src/dynamicMesh/slidingInterface/slidingInterfaceClearCouple.C
+++ b/src/dynamicMesh/slidingInterface/slidingInterfaceClearCouple.C
@@ -27,7 +27,7 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "slidingInterface.H"
-#include "polyTopoChange.H"
+#include "batchPolyTopoChange.H"
 #include "polyMesh.H"
 #include "polyTopoChanger.H"
 #include "polyRemovePoint.H"
@@ -37,7 +37,7 @@ License
 
 void Foam::slidingInterface::clearCouple
 (
-    polyTopoChange& ref
+    batchPolyTopoChange& ref
 ) const
 {
     if (debug)
diff --git a/src/meshTools/Make/files b/src/meshTools/Make/files
index 4a571b5fc2..d7125f4b40 100644
--- a/src/meshTools/Make/files
+++ b/src/meshTools/Make/files
@@ -325,6 +325,8 @@ mappedPatches/mappedPolyPatch/mappedVariableThicknessWallPolyPatch.C
 mappedPatches/mappedPointPatch/mappedPointPatch.C
 mappedPatches/mappedPointPatch/mappedWallPointPatch.C
 
+batchPolyTopoChange/batchPolyTopoChange.C
+
 polyTopoChange/topoAction/topoActions.C
 polyTopoChange/polyTopoChange.C
 
diff --git a/src/meshTools/batchPolyTopoChange/batchPolyTopoChange.C b/src/meshTools/batchPolyTopoChange/batchPolyTopoChange.C
new file mode 100644
index 0000000000..3a53b69420
--- /dev/null
+++ b/src/meshTools/batchPolyTopoChange/batchPolyTopoChange.C
@@ -0,0 +1,417 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | foam-extend: Open Source CFD
+   \\    /   O peration     | Version:     5.0
+    \\  /    A nd           | Web:         http://www.foam-extend.org
+     \\/     M anipulation  | For copyright notice see file Copyright
+-------------------------------------------------------------------------------
+License
+    This file is part of foam-extend.
+
+    foam-extend is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation, either version 3 of the License, or (at your
+    option) any later version.
+
+    foam-extend is distributed in the hope that it will be useful, but
+    WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with foam-extend.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "batchPolyTopoChange.H"
+#include "polyMesh.H"
+#include "primitiveMesh.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+const Foam::label Foam::batchPolyTopoChange::minListSize = 100;
+const Foam::label Foam::batchPolyTopoChange::pointFraction = 10;
+const Foam::label Foam::batchPolyTopoChange::faceFraction = 10;
+const Foam::label Foam::batchPolyTopoChange::cellFraction = 10;
+
+namespace Foam
+{
+    defineTypeNameAndDebug(batchPolyTopoChange, 0);
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+// Construct from mesh reference
+Foam::batchPolyTopoChange::batchPolyTopoChange(const polyMesh& mesh)
+:
+    mesh_(mesh),
+    addedPoints_(minListSize),
+    modifiedPoints_(minListSize),
+    removedPoints_
+    (
+        Foam::max(mesh.points().size()/pointFraction, minListSize)
+    ),
+    addedFaces_(minListSize),
+    modifiedFaces_(minListSize),
+    removedFaces_(Foam::max(mesh.faces().size()/faceFraction, minListSize)),
+    addedCells_(minListSize),
+    removedCells_(Foam::max(mesh.nCells()/cellFraction, minListSize))
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+Foam::label Foam::batchPolyTopoChange::setAction(const topoAction& action)
+{
+    if (isType<polyAddPoint>(action))
+    {
+        addedPoints_.append(refCast<const polyAddPoint>(action));
+
+        return mesh_.points().size() + addedPoints_.size() - 1;
+    }
+    else if (isType<polyModifyPoint>(action))
+    {
+        const polyModifyPoint& pmp = refCast<const polyModifyPoint>(action);
+
+        if (debug)
+        {
+            if (removedPoints_.find(pmp.pointID()) != removedPoints_.end())
+            {
+                FatalErrorInFunction
+                    << "Modifying point " << pmp.pointID()
+                    << " for the second time or modifying a removed point.  "
+                    << "This is not allowed."
+                    << abort(FatalError);
+            }
+        }
+
+        modifiedPoints_.append(pmp);
+        removedPoints_.insert(pmp.pointID());
+
+        return -1;
+    }
+    else if (isType<polyRemovePoint>(action))
+    {
+        const polyRemovePoint& prp = refCast<const polyRemovePoint>(action);
+
+        if (debug)
+        {
+            if (removedPoints_.find(prp.pointID()) != removedPoints_.end())
+            {
+                FatalErrorInFunction
+                    << "Removing point " << prp.pointID()
+                    << " for the second time or removing a modified point.  "
+                    << "This is not allowed."
+                    << abort(FatalError);
+            }
+        }
+
+        removedPoints_.insert(prp.pointID());
+
+        return -1;
+    }
+    else if (isType<polyAddFace>(action))
+    {
+        addedFaces_.append(refCast<const polyAddFace>(action));
+
+        return mesh_.faces().size() + addedFaces_.size() - 1;
+    }
+    else if (isType<polyModifyFace>(action))
+    {
+        const polyModifyFace& pmf = refCast<const polyModifyFace>(action);
+
+        if (debug)
+        {
+            if (removedFaces_.find(pmf.faceID()) != removedFaces_.end())
+            {
+                FatalErrorInFunction
+                    << "Modifying face " << pmf.faceID()
+                    << " for the second time or modifying a removed face.  "
+                    << "This is not allowed."
+                    << abort(FatalError);
+            }
+        }
+
+        modifiedFaces_.append(pmf);
+        removedFaces_.insert(pmf.faceID());
+
+        return -1;
+    }
+    else if (isType<polyRemoveFace>(action))
+    {
+        const polyRemoveFace& prf = refCast<const polyRemoveFace>(action);
+
+        if (debug)
+        {
+            if (removedFaces_.find(prf.faceID()) != removedFaces_.end())
+            {
+                FatalErrorInFunction
+                    << "Removing face " << prf.faceID()
+                    << " for the second time or removing a modified face.  "
+                    << "This is not allowed."
+                    << abort(FatalError);
+            }
+        }
+
+        removedFaces_.insert(prf.faceID());
+
+        return -1;
+    }
+    else if (isType<polyAddCell>(action))
+    {
+        addedCells_.append(refCast<const polyAddCell>(action));
+
+        return mesh_.nCells() + addedCells_.size() - 1;
+    }
+    else if (isType<polyModifyCell>(action))
+    {
+        const polyModifyCell& pmc = refCast<const polyModifyCell>(action);
+
+        modifiedCells_.append(pmc);
+
+        return -1;
+    }
+    else if (isType<polyRemoveCell>(action))
+    {
+        const polyRemoveCell& prc = refCast<const polyRemoveCell>(action);
+
+        if (debug)
+        {
+            if (removedCells_.find(prc.cellID()) != removedCells_.end())
+            {
+                FatalErrorInFunction
+                    << "Removing cell " << prc.cellID()
+                    << " for the second time.  This is not allowed."
+                    << abort(FatalError);
+            }
+        }
+
+        removedCells_.insert(prc.cellID());
+
+        return -1;
+    }
+    else
+    {
+        FatalErrorInFunction
+            << "Unknown type of topoChange: " << action.type()
+            << abort(FatalError);
+
+        // Dummy return to keep compiler happy
+        return -1;
+    }
+}
+
+
+bool Foam::batchPolyTopoChange::check() const
+{
+    if (debug)
+    {
+        Info<< "Points: added = " << addedPoints_.size()
+            << " modified = " << modifiedPoints_.size()
+            << " removed = " << removedPoints_.size() - modifiedPoints_.size()
+            << " balance = " << pointBalance()
+            << endl;
+
+        Info<< "Faces: added = " << addedFaces_.size()
+            << " modified = " << modifiedFaces_.size()
+            << " removed = " << removedFaces_.size() - modifiedFaces_.size()
+            << " balance = " << faceBalance()
+            << endl;
+
+        Info<< "Cells: added = " << addedCells_.size()
+            << " modified = " << modifiedCells_.size()
+            << " removed = " << removedCells_.size() - modifiedCells_.size()
+            << " balance = " << cellBalance()
+            << endl;
+    }
+
+    label nErrors = 0;
+
+    // Check points
+
+    if (mesh_.points().size() + pointBalance() < 4)
+    {
+        WarningInFunction
+            << "Less than 4 points in the mesh.  This cannot be a valid mesh."
+            << endl;
+
+        nErrors++;
+    }
+
+    // Collect zone-only and removed points
+    labelHashSet zoneOnlyPoints(removedPoints_);
+
+    forAll (modifiedPoints_, mpI)
+    {
+        if (modifiedPoints_[mpI].inCell())
+        {
+            // Point is live; remove from lookup
+            zoneOnlyPoints.erase
+            (
+                zoneOnlyPoints.find(modifiedPoints_[mpI].pointID())
+            );
+        }
+    }
+
+    forAll (addedPoints_, apI)
+    {
+        if (!addedPoints_[apI].inCell())
+        {
+            zoneOnlyPoints.insert(mesh_.points().size() + apI);
+        }
+    }
+
+    // Check faces
+
+    label nFaceErrors = 0;
+    label nCurFaceError = 0;
+
+    // For all live modified and added faces, check that points are also live
+
+    // Collect zone-only faces
+    labelHashSet zoneOnlyFaces(removedFaces_);
+
+    // Modified faces
+    forAll (modifiedFaces_, mfI)
+    {
+        if (!modifiedFaces_[mfI].onlyInZone())
+        {
+            // Face is live; remove from lookup
+            zoneOnlyFaces.erase
+            (
+                zoneOnlyFaces.find(modifiedFaces_[mfI].faceID())
+            );
+
+            // Count errors in current face
+            nCurFaceError = 0;
+
+            const face& curFace = modifiedFaces_[mfI].newFace();
+
+            forAll (curFace, pointI)
+            {
+                if (zoneOnlyPoints.found(curFace[pointI]))
+                {
+                    nCurFaceError++;
+                }
+            }
+
+            if (nCurFaceError > 0)
+            {
+                if (debug)
+                {
+                    Info<< "Modified face no " << mfI << " is active but uses "
+                        << nCurFaceError << " zone-only or removed points.  "
+                        << "Face: " << curFace << "  Problem points:";
+
+                    forAll (curFace, pointI)
+                    {
+                        if (zoneOnlyPoints.found(curFace[pointI]))
+                        {
+                            Info  << " " << curFace[pointI];
+                        }
+                    }
+
+                    Info << endl;
+                }
+
+                nFaceErrors++;
+            }
+        }
+    }
+
+    // Added faces
+    forAll (addedFaces_, afI)
+    {
+        if (addedFaces_[afI].onlyInZone())
+        {
+            // Zone-only face; add to hash set
+            zoneOnlyFaces.insert(mesh_.faces().size() + afI);
+        }
+        else
+        {
+            // Count errors in current face
+            nCurFaceError = 0;
+
+            const face& curFace = addedFaces_[afI].newFace();
+
+            forAll (curFace, pointI)
+            {
+                if (zoneOnlyPoints.found(curFace[pointI]))
+                {
+                    nCurFaceError++;
+                }
+            }
+
+            if (nCurFaceError > 0)
+            {
+                if (debug)
+                {
+                    Info<< "Added face no " << afI << " is active but uses "
+                        << nCurFaceError << " zone-only or removed points.  "
+                        << "Face: " << curFace << "  Problem points:";
+
+                    forAll (curFace, pointI)
+                    {
+                        if (zoneOnlyPoints.found(curFace[pointI]))
+                        {
+                            Info  << " " << curFace[pointI];
+                        }
+                    }
+
+                    Info << endl;
+                }
+
+                nFaceErrors++;
+            }
+        }
+    }
+
+    // Check cells?
+
+    if (nErrors == 0)
+    {
+        if (debug)
+        {
+            Info << "batchPolyTopoChange OK" << endl;
+        }
+
+        return false;
+    }
+    else
+    {
+        if (debug)
+        {
+            Info<< "bool batchPolyTopoChange::check() const : "
+                << "Detected " << nErrors << " errors."
+                << endl;
+        }
+
+        return true;
+    }
+}
+
+
+void Foam::batchPolyTopoChange::clear()
+{
+    if (debug)
+    {
+        Info<< "void Foam::batchPolyTopoChange::clear() : "
+            << "clearing topological change request" << endl;
+    }
+
+    // Clear all contents
+    addedPoints_.clear();
+    modifiedPoints_.clear();
+    removedPoints_.clear();
+
+    addedFaces_.clear();
+    modifiedFaces_.clear();
+    removedFaces_.clear();
+
+    addedCells_.clear();
+    removedCells_.clear();
+}
+
+
+// ************************************************************************* //
diff --git a/src/meshTools/batchPolyTopoChange/batchPolyTopoChange.H b/src/meshTools/batchPolyTopoChange/batchPolyTopoChange.H
new file mode 100644
index 0000000000..ca8876b6a0
--- /dev/null
+++ b/src/meshTools/batchPolyTopoChange/batchPolyTopoChange.H
@@ -0,0 +1,256 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | foam-extend: Open Source CFD
+   \\    /   O peration     | Version:     5.0
+    \\  /    A nd           | Web:         http://www.foam-extend.org
+     \\/     M anipulation  | For copyright notice see file Copyright
+-------------------------------------------------------------------------------
+License
+    This file is part of foam-extend.
+
+    foam-extend is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation, either version 3 of the License, or (at your
+    option) any later version.
+
+    foam-extend is distributed in the hope that it will be useful, but
+    WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with foam-extend.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    batchPolyTopoChange
+
+Description
+    Class accumulates information on how to perform mesh refinement.
+    Once the refinement request is completed, polyMesh modifies the mesh
+    topology.
+
+SourceFiles
+    batchPolyTopoChange.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef batchPolyTopoChange_H
+#define batchPolyTopoChange_H
+
+#include "DynamicList.H"
+#include "HashSet.H"
+#include "polyAddPoint.H"
+#include "polyModifyPoint.H"
+#include "polyRemovePoint.H"
+#include "polyAddFace.H"
+#include "polyModifyFace.H"
+#include "polyRemoveFace.H"
+#include "polyAddCell.H"
+#include "polyModifyCell.H"
+#include "polyRemoveCell.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+class polyMesh;
+
+/*---------------------------------------------------------------------------*\
+                       Class batchPolyTopoChange Declaration
+\*---------------------------------------------------------------------------*/
+
+class batchPolyTopoChange
+{
+    // Private data
+
+        //- Reference to mesh to be refined
+        const polyMesh& mesh_;
+
+        //- Points to add
+        DynamicList<polyAddPoint> addedPoints_;
+
+        //- Points to modify
+        DynamicList<polyModifyPoint> modifiedPoints_;
+
+        //- Points to remove
+        labelHashSet removedPoints_;
+
+        //- Faces to add
+        DynamicList<polyAddFace> addedFaces_;
+
+        //- Faces to modify
+        DynamicList<polyModifyFace> modifiedFaces_;
+
+        //- Faces to remove
+        labelHashSet removedFaces_;
+
+        //- Number of cells to add
+        DynamicList<polyAddCell> addedCells_;
+
+        //- Cells to modify
+        DynamicList<polyModifyCell> modifiedCells_;
+
+        //- Cells to remove
+        labelHashSet removedCells_;
+
+
+    // Private Member Functions
+
+        //- Disallow default bitwise copy construct
+        batchPolyTopoChange(const batchPolyTopoChange&) = delete;
+
+        //- Disallow default bitwise assignment
+        void operator=(const batchPolyTopoChange&) = delete;
+
+
+    // Private static data
+
+        //- Minimum dynamic list size for object insertion
+        static const label minListSize;
+
+        //- Estimated fraction of removed points
+        static const label pointFraction;
+
+        //- Estimated fraction of removed faces
+        static const label faceFraction;
+
+        //- Estimated fraction of removed cells
+        static const label cellFraction;
+
+
+public:
+
+    //- Runtime type information
+    ClassName("batchPolyTopoChange");
+
+
+    // Constructors
+
+        //- Construct from mesh reference
+        batchPolyTopoChange(const polyMesh&);
+
+
+    //- Destructor
+    ~batchPolyTopoChange() = default;
+
+
+    // Member Functions
+
+        // Definition of topological change
+
+            //- Set topological action
+            label setAction(const topoAction& action);
+
+
+        // Topology morph data
+
+            //- Is point removed?
+            inline bool pointRemoved(const label pointI) const;
+
+            //- Is face removed?
+            inline bool faceRemoved(const label faceI) const;
+
+            //- Is cell removed?
+            inline bool cellRemoved(const label cellI) const;
+
+            //- Point balance (added - removed)
+            label pointBalance() const
+            {
+                return
+                    addedPoints_.size()
+                  + modifiedPoints_.size()
+                  - removedPoints_.size();
+            }
+
+            //- Face balance (added - removed)
+            label faceBalance() const
+            {
+                return
+                    addedFaces_.size()
+                  + modifiedFaces_.size()
+                  - removedFaces_.size();
+            }
+
+            //- Cell balance (added - removed)
+            label cellBalance() const
+            {
+                return addedCells_.size() - removedCells_.size();
+            }
+
+            //- Added points
+            const DynamicList<polyAddPoint>& addedPoints() const
+            {
+                return addedPoints_;
+            }
+
+            //- Modified points
+            const DynamicList<polyModifyPoint>& modifiedPoints() const
+            {
+                return modifiedPoints_;
+            }
+
+            //- Map of removed points
+            const labelHashSet& removedPoints() const
+            {
+                return removedPoints_;
+            }
+
+            //- Added faces
+            const DynamicList<polyAddFace>& addedFaces() const
+            {
+                return addedFaces_;
+            }
+
+            //- Modified faces
+            const DynamicList<polyModifyFace>& modifiedFaces() const
+            {
+                return modifiedFaces_;
+            }
+
+            //- Map of removed faces
+            const labelHashSet& removedFaces() const
+            {
+                return removedFaces_;
+            }
+
+            //- Added cells
+            const DynamicList<polyAddCell>& addedCells() const
+            {
+                return addedCells_;
+            }
+
+            //- Modified cells
+            const DynamicList<polyModifyCell>& modifiedCells() const
+            {
+                return modifiedCells_;
+            }
+
+            //- Map of removed cells
+            const labelHashSet& removedCells() const
+            {
+                return removedCells_;
+            }
+
+            //- Check for consistency and report status
+            //  Returns false for no error.
+            bool check() const;
+
+            //- Clear all contents
+            void clear();
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#include "batchPolyTopoChangeI.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/meshTools/batchPolyTopoChange/batchPolyTopoChangeI.H b/src/meshTools/batchPolyTopoChange/batchPolyTopoChangeI.H
new file mode 100644
index 0000000000..79c94c025b
--- /dev/null
+++ b/src/meshTools/batchPolyTopoChange/batchPolyTopoChangeI.H
@@ -0,0 +1,47 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | foam-extend: Open Source CFD
+   \\    /   O peration     | Version:     5.0
+    \\  /    A nd           | Web:         http://www.foam-extend.org
+     \\/     M anipulation  | For copyright notice see file Copyright
+-------------------------------------------------------------------------------
+License
+    This file is part of foam-extend.
+
+    foam-extend is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation, either version 3 of the License, or (at your
+    option) any later version.
+
+    foam-extend is distributed in the hope that it will be useful, but
+    WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with foam-extend.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+inline bool Foam::batchPolyTopoChange::pointRemoved(const label pointI) const
+{
+    return removedPoints().found(pointI);
+}
+
+
+inline bool Foam::batchPolyTopoChange::faceRemoved(const label faceI) const
+{
+    return removedFaces().found(faceI);
+}
+
+
+inline bool Foam::batchPolyTopoChange::cellRemoved(const label cellI) const
+{
+    return removedCells().found(cellI);
+}
+
+
+// ************************************************************************* //
diff --git a/src/meshTools/meshTools/meshTools.C b/src/meshTools/meshTools/meshTools.C
index 50ee9d8488..56fd949e34 100644
--- a/src/meshTools/meshTools/meshTools.C
+++ b/src/meshTools/meshTools/meshTools.C
@@ -30,6 +30,7 @@ License
 #include "polyMesh.H"
 #include "hexMatcher.H"
 #include "treeBoundBox.H"
+#include "syncTools.H"
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
@@ -878,4 +879,157 @@ Foam::label Foam::meshTools::cutDirToEdge
 }
 
 
+void Foam::meshTools::setFaceInfo
+(
+    const polyMesh& mesh,
+    const label faceI,
+    label& patchID,
+    label& zoneID,
+    label& zoneFlip
+)
+{
+    patchID = -1;
+
+    if (!mesh.isInternalFace(faceI))
+    {
+        patchID = mesh.boundaryMesh().whichPatch(faceI);
+    }
+
+    zoneID = mesh.faceZones().whichZone(faceI);
+
+    zoneFlip = false;
+
+    if (zoneID > -1)
+    {
+        const faceZone& fZone = mesh.faceZones()[zoneID];
+
+        zoneFlip = fZone.flipMap()[fZone.whichFace(faceI)];
+    }
+}
+
+
+void Foam::meshTools::extendMarkedCellsAcrossFaces
+(
+    const polyMesh& mesh,
+    boolList& markedCell
+)
+{
+    // Mark all faces for all marked cells
+    const label nFaces = mesh.nFaces();
+    boolList markedFace(nFaces, false);
+
+    // Get mesh cells
+    const cellList& meshCells = mesh.cells();
+
+    // Loop through all cells
+    forAll (markedCell, cellI)
+    {
+        if (markedCell[cellI])
+        {
+            // This cell is marked, get its faces
+            const cell& cFaces = meshCells[cellI];
+
+            forAll (cFaces, i)
+            {
+                markedFace[cFaces[i]] = true;
+            }
+        }
+    }
+
+    // Snyc the face list across processor boundaries
+    syncTools::syncFaceList(mesh, markedFace, orEqOp<bool>());//HJ
+
+    // Get necessary mesh data
+    const label nInternalFaces = mesh.nInternalFaces();
+    const labelList& owner = mesh.faceOwner();
+    const labelList& neighbour = mesh.faceNeighbour();
+
+    // Internal faces
+    for (label faceI = 0; faceI < nInternalFaces; ++faceI)
+    {
+        if (markedFace[faceI])
+        {
+            // Face is marked, mark both owner and neighbour
+            const label& own = owner[faceI];
+            const label& nei = neighbour[faceI];
+
+            // Mark owner and neighbour cells
+            markedCell[own] = true;
+            markedCell[nei] = true;
+        }
+    }
+
+    // Boundary faces
+    for (label faceI = nInternalFaces; faceI < nFaces; ++faceI)
+    {
+        if (markedFace[faceI])
+        {
+            // Face is marked, mark owner
+            const label& own = owner[faceI];
+
+            // Mark owner
+            markedCell[own] = true;
+        }
+    }
+}
+
+
+void Foam::meshTools::extendMarkedCellsAcrossPoints
+(
+    const polyMesh& mesh,
+    boolList& markedCell
+)
+{
+    // Mark all points for all marked cells
+    const label nPoints = mesh.nPoints();
+    boolList markedPoint(nPoints, false);
+
+    // Get cell points
+    const labelListList& meshCellPoints = mesh.cellPoints();
+
+    // Loop through all cells
+    forAll (markedCell, cellI)
+    {
+        if (markedCell[cellI])
+        {
+            // This cell is marked, get its points
+            const labelList& cPoints = meshCellPoints[cellI];
+
+            forAll (cPoints, i)
+            {
+                markedPoint[cPoints[i]] = true;
+            }
+        }
+    }
+
+    // Snyc point list across processor boundaries
+    syncTools::syncPointList
+    (
+        mesh,
+        markedPoint,
+        orEqOp<bool>(),
+        true // Default value
+        // true  // Apply separation for parallel cyclics  //HJ
+    );
+
+    // Get point cells
+    const labelListList& meshPointCells = mesh.pointCells();
+
+    // Loop through all points
+    forAll (markedPoint, pointI)
+    {
+        if (markedPoint[pointI])
+        {
+            // This point is marked, mark all of its cells
+            const labelList& pCells = meshPointCells[pointI];
+
+            forAll (pCells, i)
+            {
+                markedCell[pCells[i]] = true;
+            }
+        }
+    }
+}
+
+
 // ************************************************************************* //
diff --git a/src/meshTools/meshTools/meshTools.H b/src/meshTools/meshTools/meshTools.H
index 007d3b519d..04303e78c5 100644
--- a/src/meshTools/meshTools/meshTools.H
+++ b/src/meshTools/meshTools/meshTools.H
@@ -352,6 +352,37 @@ namespace meshTools
             const vector& cutDir
         );
 
+
+    // Face information
+
+        //- Set face information: patch, zone and zone flip for a face
+        void setFaceInfo
+        (
+            const polyMesh& mesh,
+            const label faceI,
+            label& patchID,
+            label& zoneID,
+            label& zoneFlip
+        );
+
+
+    // Mark-up of mesh bits. Relocated from refinement polyMeshModifier
+
+        //- Extend marked cells across faces given a bool list of already marked
+        //  cells
+        void extendMarkedCellsAcrossFaces
+        (
+            const polyMesh& mesh,
+            boolList& markedCell
+        );
+
+        //- Extend marked cells across points given a bool list of already
+        //  marked cells
+        void extendMarkedCellsAcrossPoints
+        (
+            const polyMesh& mesh,
+            boolList& markedCell
+        );
 } // End namespace meshTools
 
 
diff --git a/src/topoChangerFvMesh/Make/files b/src/topoChangerFvMesh/Make/files
index 8a0e7e686a..a4381293a4 100644
--- a/src/topoChangerFvMesh/Make/files
+++ b/src/topoChangerFvMesh/Make/files
@@ -11,4 +11,14 @@ movingConeTopoFvMesh/movingConeTopoFvMesh.C
 mixerFvMesh/mixerFvMesh.C
 */
 
+dynamicPolyRefinementFvMesh/dynamicPolyRefinementFvMesh.C
+dynamicPolyRefinementFvMesh/refinementSelection/refinementSelection/refinementSelection.C
+dynamicPolyRefinementFvMesh/refinementSelection/fieldBoundsRefinement/fieldBoundsRefinement.C
+dynamicPolyRefinementFvMesh/refinementSelection/minCellVolumeRefinement/minCellVolumeRefinement.C
+dynamicPolyRefinementFvMesh/refinementSelection/minCellSizeRefinement/minCellSizeRefinement.C
+dynamicPolyRefinementFvMesh/refinementSelection/minPatchDistanceRefinement/minPatchDistanceRefinement.C
+dynamicPolyRefinementFvMesh/refinementSelection/protectedInitialRefinement/protectedInitialRefinement.C
+dynamicPolyRefinementFvMesh/refinementSelection/minFaceArea2DRefinement/minFaceArea2DRefinement.C
+dynamicPolyRefinementFvMesh/refinementSelection/compositeRefinementSelection/compositeRefinementSelection.C
+
 LIB = $(FOAM_LIBBIN)/libtopoChangerFvMesh
diff --git a/src/topoChangerFvMesh/Make/options b/src/topoChangerFvMesh/Make/options
index e1f704d20e..8362887c0a 100644
--- a/src/topoChangerFvMesh/Make/options
+++ b/src/topoChangerFvMesh/Make/options
@@ -1,5 +1,6 @@
 EXE_INC = \
     -I$(LIB_SRC)/finiteVolume/lnInclude \
+    -I$(LIB_SRC)/optimisation/adjointOptimisation/adjoint/lnInclude \
     -I$(LIB_SRC)/fileFormats/lnInclude \
     -I$(LIB_SRC)/surfMesh/lnInclude \
     -I$(LIB_SRC)/meshTools/lnInclude \
@@ -8,6 +9,7 @@ EXE_INC = \
 
 LIB_LIBS = \
     -lfiniteVolume \
+    -l adjointOptimisation \
     -lfileFormats \
     -lsurfMesh \
     -lmeshTools \
diff --git a/src/topoChangerFvMesh/dynamicMotionSolverTopoFvMesh/dynamicMotionSolverTopoFvMesh.C b/src/topoChangerFvMesh/dynamicMotionSolverTopoFvMesh/dynamicMotionSolverTopoFvMesh.C
index 9f4fe646ca..132349d277 100644
--- a/src/topoChangerFvMesh/dynamicMotionSolverTopoFvMesh/dynamicMotionSolverTopoFvMesh.C
+++ b/src/topoChangerFvMesh/dynamicMotionSolverTopoFvMesh/dynamicMotionSolverTopoFvMesh.C
@@ -100,7 +100,7 @@ bool Foam::dynamicMotionSolverTopoFvMesh::update()
     // (TBD: should be in changeMesh if no inflation?)
     moving(false);
     // Do mesh changes (not using inflation - points added directly into mesh)
-    autoPtr<mapPolyMesh> topoChangeMap = topoChanger_.changeMesh(false);
+    autoPtr<mapPolyMesh> topoChangeMap = topoChanger_.changeMesh();
 
     if (topoChangeMap)
     {
diff --git a/src/topoChangerFvMesh/movingConeTopoFvMesh/movingConeTopoFvMesh.C b/src/topoChangerFvMesh/movingConeTopoFvMesh/movingConeTopoFvMesh.C
index 51221b8fad..d35a3161db 100644
--- a/src/topoChangerFvMesh/movingConeTopoFvMesh/movingConeTopoFvMesh.C
+++ b/src/topoChangerFvMesh/movingConeTopoFvMesh/movingConeTopoFvMesh.C
@@ -332,7 +332,7 @@ Foam::movingConeTopoFvMesh::~movingConeTopoFvMesh()
 bool Foam::movingConeTopoFvMesh::update()
 {
     // Do mesh changes (use inflation - put new points in topoChangeMap)
-    autoPtr<mapPolyMesh> topoChangeMap = topoChanger_.changeMesh(true);
+    autoPtr<mapPolyMesh> topoChangeMap = topoChanger_.changeMesh();
 
     // Calculate the new point positions depending on whether the
     // topological change has happened or not
diff --git a/src/topoChangerFvMesh/rawTopoChangerFvMesh/rawTopoChangerFvMesh.C b/src/topoChangerFvMesh/rawTopoChangerFvMesh/rawTopoChangerFvMesh.C
index 9c2dae8736..91326a22f8 100644
--- a/src/topoChangerFvMesh/rawTopoChangerFvMesh/rawTopoChangerFvMesh.C
+++ b/src/topoChangerFvMesh/rawTopoChangerFvMesh/rawTopoChangerFvMesh.C
@@ -83,8 +83,8 @@ bool Foam::rawTopoChangerFvMesh::update()
     moving(false);
     topoChanging(false);
 
-    // Do any topology changes. Sets topoChanging (through polyTopoChange)
-    autoPtr<mapPolyMesh> topoChangeMap = topoChanger_.changeMesh(true);
+    // Do any topology changes. Sets topoChanging (through batchPolyTopoChange)
+    autoPtr<mapPolyMesh> topoChangeMap = topoChanger_.changeMesh();
 
     const bool hasChanged = bool(topoChangeMap);
 

From 6f89203d806cc8d4dbb8d1259dec09e0d9a118c8 Mon Sep 17 00:00:00 2001
From: Hrvoje Jasak <h.jasak@wikki.co.uk>
Date: Tue, 22 Aug 2023 08:56:58 +0100
Subject: [PATCH 2/7] Added dynamicPolyRefinementFvMesh

---
 .../dynamicMeshDict                           |  73 ++++
 .../dynamicPolyRefinementFvMesh.C             | 366 ++++++++++++++++++
 .../dynamicPolyRefinementFvMesh.H             | 158 ++++++++
 .../compositeRefinementSelection.C            | 206 ++++++++++
 .../compositeRefinementSelection.H            | 112 ++++++
 .../fieldBoundsRefinement.C                   | 187 +++++++++
 .../fieldBoundsRefinement.H                   | 120 ++++++
 .../minCellSizeRefinement.C                   | 125 ++++++
 .../minCellSizeRefinement.H                   | 110 ++++++
 .../minCellVolumeRefinement.C                 | 125 ++++++
 .../minCellVolumeRefinement.H                 | 108 ++++++
 .../minFaceArea2DRefinement.C                 | 200 ++++++++++
 .../minFaceArea2DRefinement.H                 | 111 ++++++
 .../minPatchDistanceRefinement.C              | 154 ++++++++
 .../minPatchDistanceRefinement.H              | 108 ++++++
 .../protectedInitialRefinement.C              | 224 +++++++++++
 .../protectedInitialRefinement.H              | 130 +++++++
 .../refinementSelection/refinementSelection.C |  87 +++++
 .../refinementSelection/refinementSelection.H | 171 ++++++++
 19 files changed, 2875 insertions(+)
 create mode 100644 src/topoChangerFvMesh/dynamicPolyRefinementFvMesh/dynamicMeshDict
 create mode 100644 src/topoChangerFvMesh/dynamicPolyRefinementFvMesh/dynamicPolyRefinementFvMesh.C
 create mode 100644 src/topoChangerFvMesh/dynamicPolyRefinementFvMesh/dynamicPolyRefinementFvMesh.H
 create mode 100644 src/topoChangerFvMesh/dynamicPolyRefinementFvMesh/refinementSelection/compositeRefinementSelection/compositeRefinementSelection.C
 create mode 100644 src/topoChangerFvMesh/dynamicPolyRefinementFvMesh/refinementSelection/compositeRefinementSelection/compositeRefinementSelection.H
 create mode 100644 src/topoChangerFvMesh/dynamicPolyRefinementFvMesh/refinementSelection/fieldBoundsRefinement/fieldBoundsRefinement.C
 create mode 100644 src/topoChangerFvMesh/dynamicPolyRefinementFvMesh/refinementSelection/fieldBoundsRefinement/fieldBoundsRefinement.H
 create mode 100644 src/topoChangerFvMesh/dynamicPolyRefinementFvMesh/refinementSelection/minCellSizeRefinement/minCellSizeRefinement.C
 create mode 100644 src/topoChangerFvMesh/dynamicPolyRefinementFvMesh/refinementSelection/minCellSizeRefinement/minCellSizeRefinement.H
 create mode 100644 src/topoChangerFvMesh/dynamicPolyRefinementFvMesh/refinementSelection/minCellVolumeRefinement/minCellVolumeRefinement.C
 create mode 100644 src/topoChangerFvMesh/dynamicPolyRefinementFvMesh/refinementSelection/minCellVolumeRefinement/minCellVolumeRefinement.H
 create mode 100644 src/topoChangerFvMesh/dynamicPolyRefinementFvMesh/refinementSelection/minFaceArea2DRefinement/minFaceArea2DRefinement.C
 create mode 100644 src/topoChangerFvMesh/dynamicPolyRefinementFvMesh/refinementSelection/minFaceArea2DRefinement/minFaceArea2DRefinement.H
 create mode 100644 src/topoChangerFvMesh/dynamicPolyRefinementFvMesh/refinementSelection/minPatchDistanceRefinement/minPatchDistanceRefinement.C
 create mode 100644 src/topoChangerFvMesh/dynamicPolyRefinementFvMesh/refinementSelection/minPatchDistanceRefinement/minPatchDistanceRefinement.H
 create mode 100644 src/topoChangerFvMesh/dynamicPolyRefinementFvMesh/refinementSelection/protectedInitialRefinement/protectedInitialRefinement.C
 create mode 100644 src/topoChangerFvMesh/dynamicPolyRefinementFvMesh/refinementSelection/protectedInitialRefinement/protectedInitialRefinement.H
 create mode 100644 src/topoChangerFvMesh/dynamicPolyRefinementFvMesh/refinementSelection/refinementSelection/refinementSelection.C
 create mode 100644 src/topoChangerFvMesh/dynamicPolyRefinementFvMesh/refinementSelection/refinementSelection/refinementSelection.H

diff --git a/src/topoChangerFvMesh/dynamicPolyRefinementFvMesh/dynamicMeshDict b/src/topoChangerFvMesh/dynamicPolyRefinementFvMesh/dynamicMeshDict
new file mode 100644
index 0000000000..538cc39e5e
--- /dev/null
+++ b/src/topoChangerFvMesh/dynamicPolyRefinementFvMesh/dynamicMeshDict
@@ -0,0 +1,73 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | foam-extend: Open Source CFD                    |
+|  \\    /   O peration     | Version:     5.0                                |
+|   \\  /    A nd           | Web:         http://www.foam-extend.org         |
+|    \\/     M anipulation  | For copyright notice see file Copyright         |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    location    "constant";
+    object      dynamicMeshDict;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+dynamicFvMesh   dynamicPolyRefinementFvMesh;
+
+dynamicPolyRefinementFvMeshCoeffs
+{
+    // Dynamic mesh procedure controls
+
+    // Refine every refineInterval step
+    refineInterval   1;
+
+    // Unrefine every unrefineInterval step
+    unrefineInterval 1;
+
+    // Separate refinement/unrefinement steps. In case this is switched on,
+    // if both refinement and unrefinement should have been performed in a
+    // single step, unrefinement is skipped. Switched off by default, meaning
+    // that it should be safe to perform both at the same time
+    separateUpdates false;
+
+    // Refinement selection criteria
+    refinementSelection
+    {
+        // Refines all cells with 0.001 < alpha < 0.999, otherwise unrefines
+        // previously refined cells
+        type        fieldBoundsRefinement;
+        fieldName   alpha;
+        lowerBound  0.001;
+        upperBound  0.999;
+
+        // Whether to use cell-point-cell smoothing for selecting refinement
+        // candidates. Off by default
+        cellPointCellSmoothing off;
+    }
+
+    // Polyhedral refinement engine controls
+    active yes;
+
+    // Maximum number of cells to allow (not strictly controlled)
+    maxCells             2000000;
+
+    // Maximum refinement level
+    maxRefinementLevel   3;
+
+    // Number of buffer layers between refinement levels
+    nRefinementBufferLayers        1;
+
+    // Number of buffer layers for unrefinement in order to run away from the
+    // region that is getting refined at the same time in order to avoid point
+    // level inconsistencies
+    nUnrefinementBufferLayers      4;
+
+    // Whether to use edge based consistency check. Needed when one allows more
+    // than 2 refinement levels (automatically switched on)
+    edgeBasedConsistency           yes;
+}
+
+// ************************************************************************* //
diff --git a/src/topoChangerFvMesh/dynamicPolyRefinementFvMesh/dynamicPolyRefinementFvMesh.C b/src/topoChangerFvMesh/dynamicPolyRefinementFvMesh/dynamicPolyRefinementFvMesh.C
new file mode 100644
index 0000000000..b97713592c
--- /dev/null
+++ b/src/topoChangerFvMesh/dynamicPolyRefinementFvMesh/dynamicPolyRefinementFvMesh.C
@@ -0,0 +1,366 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | foam-extend: Open Source CFD
+   \\    /   O peration     | Version:     5.0
+    \\  /    A nd           | Web:         http://www.foam-extend.org
+     \\/     M anipulation  | For copyright notice see file Copyright
+-------------------------------------------------------------------------------
+License
+    This file is part of foam-extend.
+
+    foam-extend is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation, either version 3 of the License, or (at your
+    option) any later version.
+
+    foam-extend is distributed in the hope that it will be useful, but
+    WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with foam-extend.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "dynamicPolyRefinementFvMesh.H"
+#include "addToRunTimeSelectionTable.H"
+#include "refinementSelection.H"
+#include "prismatic2DRefinement.H"
+#include "polyhedralRefinement.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+defineTypeNameAndDebug(dynamicPolyRefinementFvMesh, 0);
+
+addToRunTimeSelectionTable
+(
+    dynamicFvMesh,
+    dynamicPolyRefinementFvMesh,
+    IOobject
+);
+
+}
+
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+void Foam::dynamicPolyRefinementFvMesh::readDict()
+{
+    // Read and check refinement and unrefinement intervals
+    refineInterval_ = readLabel(refinementDict_.lookup("refineInterval"));
+
+    if (refineInterval_ < 1)
+    {
+        FatalErrorInFunction
+            << "Illegal refineInterval found: " << refineInterval_ << nl
+            << "The refineInterval controls the refinement"
+            << " trigerring within a certain time step and should be > 0"
+            << exit(FatalError);
+    }
+
+    unrefineInterval_ = readLabel(refinementDict_.lookup("unrefineInterval"));
+
+    if (refineInterval_ < 1)
+    {
+        FatalErrorInFunction
+            << "Illegal unrefineInterval found: " << refineInterval_ << nl
+            << "The unrefineInterval controls the unrefinement"
+            << " trigerring within a certain time step and should be > 0"
+            << exit(FatalError);
+    }
+
+    // Read separate updates switch
+    separateUpdates_ =
+        refinementDict_.lookupOrDefault<Switch>("separateUpdates", false);
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::dynamicPolyRefinementFvMesh::dynamicPolyRefinementFvMesh
+(
+    const IOobject& io,
+    const word subDictName
+)
+:
+    topoChangerFvMesh(io),
+    refinementDict_
+    (
+        IOdictionary
+        (
+            IOobject
+            (
+                "dynamicMeshDict",
+                time().constant(),
+                *this,
+                IOobject::MUST_READ,
+                IOobject::NO_WRITE,
+                false
+            )
+        ).subDict(subDictName + "Coeffs")
+    ),
+    refineInterval_(readLabel(refinementDict_.lookup("refineInterval"))),
+    unrefineInterval_(readLabel(refinementDict_.lookup("unrefineInterval"))),
+    separateUpdates_
+    (
+        refinementDict_.lookupOrDefault<Switch>("separateUpdates", false)
+    ),
+    curTimeIndex_(-1),
+
+    // Note: initialize refinement selection algorithm after the refinement
+    // polyMeshModifier has been set. It is possible that the selection
+    // algorithm needs cellLevel and pointLevel (see e.g.
+    // protectedInitialRefinement)
+    refinementSelectionPtr_()
+{
+    // Check whether we read polyMeshModifiers from
+    // constant/polyMesh/meshModifiers file in the base class
+    if (!topoChanger_.empty())
+    {
+        // Already initialized, warn the user that we'll neglect it
+        WarningInFunction
+           << "Using controls from constant/dynamicMeshDict instead of"
+           << " constant/polyMesh/meshModifiers."
+           << nl
+           << "To supress this warning, delete meshModifiers file."
+           << endl;
+
+       // Clear the list
+       topoChanger_.clear();
+    }
+
+    // Only one topo changer engine
+    topoChanger_.setSize(1);
+
+    // Get number of valid geometric dimensions
+    const label nGeometricDirs = this->nGeometricD();
+
+    switch (nGeometricDirs)
+    {
+        case 3:
+            // Add the polyhedralRefinement engine for
+            // 3D isotropic refinement
+            Info<< "3D case detected. "
+                << "Adding polyhedralRefinement topology modifier" << endl;
+            topoChanger_.set
+            (
+                0,
+                new polyhedralRefinement
+                (
+                    "polyhedralRefinement",
+                    refinementDict_,
+                    0,
+                    topoChanger_
+                )
+            );
+            break;
+
+        case 2:
+            // Add the prismatic2DRefinement engine for
+            // 2D isotropic refinement
+            Info<< "2D case detected. "
+                << "Adding prismatic2DRefinement topology modifier" << endl;
+            topoChanger_.set
+            (
+                0,
+                new prismatic2DRefinement
+                (
+                    "prismatic2DRefinement",
+                    refinementDict_,
+                    0,
+                    topoChanger_
+                )
+            );
+            break;
+
+        case 1:
+            FatalErrorInFunction
+                << "1D case detected. No valid refinement strategy is"
+                <<  " available for 1D cases."
+                << abort(FatalError);
+            break;
+
+        default:
+            FatalErrorInFunction
+                << "Invalid number of geometric meshes detected: "
+                << nGeometricDirs
+                << nl << "It appears that this mesh is neither 1D, 2D or 3D."
+                << abort(FatalError);
+
+    }
+
+    // Write mesh and modifiers
+    topoChanger_.writeOpt() = IOobject::AUTO_WRITE;
+    topoChanger_.write();
+    write();
+
+    // Initialize refinement selection algorithm after modifiers
+    refinementSelectionPtr_ = refinementSelection::New(*this, refinementDict_);
+}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+bool Foam::dynamicPolyRefinementFvMesh::firstUpdate() const
+{
+    return curTimeIndex_ < time().timeIndex();
+}
+
+
+bool Foam::dynamicPolyRefinementFvMesh::update()
+{
+    // Re-read the data from dictionary for on-the-fly changes
+    readDict();
+
+    // Performing refinement/unrefinement when:
+    // 1. We are at the first time step
+    // 2. Only once per time step
+    // 3. Time step is a multiplier of specified refineInterval or
+    //    unrefineInterval
+
+    // Get time index
+    const label timeID = time().timeIndex();
+
+    // Check whether to perform refinement and/or unrefinement
+    const bool performRefinement = timeID % refineInterval_ == 0;
+
+    // Skip performing refinement/unrefinement in the same step if
+    // separateUpdates flag is switched on
+    bool performUnrefinement = timeID % unrefineInterval_ == 0;
+    if (performRefinement && separateUpdates_)
+    {
+        performUnrefinement = false;
+    }
+
+    if
+    (
+        timeID > 0
+     && curTimeIndex_ < timeID
+     && (performRefinement || performUnrefinement)
+    )
+    {
+        // Update current time index to skip multiple topo changes per single
+        // time step
+        curTimeIndex_ = time().timeIndex();
+
+        // Get reference to base class refinement polyMeshModifier
+        refinement& refModifier = refCast<refinement>(topoChanger_[0]);
+
+        // Create empty list for refinement candidates
+        labelList refCandidates;
+
+        // Collect refinement candidates from refinement selection algorithm in
+        // case the refinement should be performed in this time step
+        if (performRefinement)
+        {
+            // Note: return type is Xfer<labelList> so there's no copying (two
+            // transfers are occuring)
+            refCandidates =
+                refinementSelectionPtr_->refinementCellCandidates();
+
+                Info<< "Selected " << refCandidates.size()
+                << " refinement candidates."
+                << endl;
+        }
+        else
+        {
+            Info<< "Skipping refinement for this time-step..." << endl;
+        }
+
+        // Set cells to refine. Note: refinement needs to make sure that face
+        // and point consistent refinement is performed
+        refModifier.setCellsToRefine(refCandidates);
+
+        // Create empty list for unrefinement candidates
+        labelList unrefCandidates;
+
+        // Collect unrefinement candidates from refinement selection algorithm
+        // in case the unrefinement should be performed in this time step
+        if (performUnrefinement)
+        {
+            // Note: return type is Xfer<labelList> so there's no copying (two
+            // transfers are occuring)
+            unrefCandidates =
+                refinementSelectionPtr_->unrefinementPointCandidates();
+
+            Info<< "Selected " << unrefCandidates.size()
+                << " unrefinement candidates."
+                << endl;
+        }
+        else
+        {
+            Info<< "Skipping unrefinement for this time-step..." << endl;
+        }
+
+        // Set split points to unrefine around.
+        // Notes:
+        // 1. refinement needs to make sure that only a consistent set of split
+        //    points is used for unrefinement
+        // 2. Must be called after refinement::setCellsToRefine
+        refModifier.setSplitPointsToUnrefine(unrefCandidates);
+
+        // Activate the polyhedral refinement engine if there are some cells to
+        // refine or there are some split points to unrefine around
+        bool enableTopoChange =
+            !refCandidates.empty() || !unrefCandidates.empty();
+
+        // Note: must enable topo change for all processors since face and point
+        // consistent refinement must be ensured across coupled patches
+        reduce(enableTopoChange, orOp<bool>());
+
+        if (enableTopoChange)
+        {
+            refModifier.enable();
+        }
+        else
+        {
+            refModifier.disable();
+        }
+
+        // Perform refinement and unrefinement in one go
+        autoPtr<mapPolyMesh> topoChangeMap = topoChanger_.changeMesh();
+
+        // Output cell balance if the topo change has been performed
+        const label nOldCells =
+            returnReduce(topoChangeMap->nOldCells(), sumOp<label>());
+        const label sizeCellMap =
+            returnReduce(topoChangeMap->cellMap().size(), sumOp<label>());
+
+        // If the size of cell map is different than zero, we actually performed
+        // some topo changes
+        if (sizeCellMap)
+        {
+            Info<< "Successfully performed polyhedral refinement. "
+                << "Changed from " << nOldCells << " to " << sizeCellMap
+                << " cells." << endl;
+        }
+        else
+        {
+            Info<< "Refinement/unrefinement not performed in this time step "
+                << "since no cells were selected." << endl;
+        }
+
+        return true;
+
+        // Note: OpenFOAM does not have a morphing signalling
+        // return topoChangeMap->morphing();
+    }
+    else
+    {
+        // Update current time index to skip multiple topo change checks
+        // per time step
+        curTimeIndex_ = time().timeIndex();
+    }
+
+    Info<< "No refinement/unrefinement" << endl;
+
+    // No refinement/unrefinement at this time step. Return false
+    return false;
+}
+
+
+// ************************************************************************* //
diff --git a/src/topoChangerFvMesh/dynamicPolyRefinementFvMesh/dynamicPolyRefinementFvMesh.H b/src/topoChangerFvMesh/dynamicPolyRefinementFvMesh/dynamicPolyRefinementFvMesh.H
new file mode 100644
index 0000000000..5bc074213e
--- /dev/null
+++ b/src/topoChangerFvMesh/dynamicPolyRefinementFvMesh/dynamicPolyRefinementFvMesh.H
@@ -0,0 +1,158 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | foam-extend: Open Source CFD
+   \\    /   O peration     | Version:     5.0
+    \\  /    A nd           | Web:         http://www.foam-extend.org
+     \\/     M anipulation  | For copyright notice see file Copyright
+-------------------------------------------------------------------------------
+License
+    This file is part of foam-extend.
+
+    foam-extend is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation, either version 3 of the License, or (at your
+    option) any later version.
+
+    foam-extend is distributed in the hope that it will be useful, but
+    WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with foam-extend.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::dynamicPolyRefinementFvMesh
+
+Description
+    Adaptive mesh refinement for isotropic refinement of arbitrary polyhedral
+    cells in 3D and arbitrary prismatic cells in 2D.
+    Automatically switches between:
+    - 3D refinement uses polyhedralRefinement engine
+    - 2D refinement uses prismatic2DRefinement engine
+
+SourceFiles
+    dynamicPolyRefinementFvMesh.C
+
+Author
+    Vuko Vukcevic, Wikki Ltd.  All rights reserved
+    Rewrite and updates by Hrvoje Jasak, Wikki Ltd.  All rights reserved
+
+Notes
+    Generalisation and refactorisation of dynamicRefineMesh for polyhedral cells
+    in 3D and prismatic cells in 2D.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef dynamicPolyRefinementFvMesh_H
+#define dynamicPolyRefinementFvMesh_H
+
+#include "topoChangerFvMesh.H"
+#include "refinementSelection.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                Class dynamicPolyRefinementFvMesh Declaration
+\*---------------------------------------------------------------------------*/
+
+class dynamicPolyRefinementFvMesh
+:
+    public topoChangerFvMesh
+{
+protected:
+
+    // Protected data
+
+        //- Dictionary containing dynamic mesh coefficient controls
+        dictionary refinementDict_;
+
+
+private:
+
+    // Private data
+
+        //- Refinement interval
+        label refineInterval_;
+
+        //- Unrefinement interval
+        label unrefineInterval_;
+
+        //- Separate refinement/unrefinement: off by default, meaning that
+        //  refinement and unrefinement can be performed in the same step
+        Switch separateUpdates_;
+
+        //- Current time index (helper variable to skip multiple topo changes in
+        //  a single time step)
+        label curTimeIndex_;
+
+        //- Refinement selection algorithm that has two jobs:
+        //  1. Selects cells to refine from all cells
+        //  2. Selects split points that are ok to refine based on given set of
+        //     all split points
+        autoPtr<refinementSelection> refinementSelectionPtr_;
+
+
+    // Private Member Functions
+
+        //- Helper function for reading the dictionary and updating the data
+        void readDict();
+
+
+        // Copy control
+
+            //- Disallow default bitwise copy construct
+            dynamicPolyRefinementFvMesh
+            (
+                const dynamicPolyRefinementFvMesh&
+            ) = delete;
+
+            //- Disallow default bitwise assignment
+            void operator=(const dynamicPolyRefinementFvMesh&) = delete;
+
+
+public:
+
+    //- Runtime type information
+    TypeName("dynamicPolyRefinementFvMesh");
+
+
+    // Constructors
+
+        //- Construct from IOobject and optional name for the subdictionary
+        //  containing the refinement (and possibly other controls). The second
+        //  parameter is useful if we derive another dynamic mesh class from
+        //  this one instead of topoChangerFvMesh base class. VV, 17/May/2018.
+        dynamicPolyRefinementFvMesh
+        (
+            const IOobject& io,
+            const word subDictName = typeName
+        );
+
+
+    //- Destructor
+    virtual ~dynamicPolyRefinementFvMesh() = default;
+
+
+    // Member Functions
+
+        //- Is this the first update in the current time-step?
+        bool firstUpdate() const;
+
+        //- Update the mesh for topology change
+        virtual bool update();
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/topoChangerFvMesh/dynamicPolyRefinementFvMesh/refinementSelection/compositeRefinementSelection/compositeRefinementSelection.C b/src/topoChangerFvMesh/dynamicPolyRefinementFvMesh/refinementSelection/compositeRefinementSelection/compositeRefinementSelection.C
new file mode 100644
index 0000000000..0096f1ccf4
--- /dev/null
+++ b/src/topoChangerFvMesh/dynamicPolyRefinementFvMesh/refinementSelection/compositeRefinementSelection/compositeRefinementSelection.C
@@ -0,0 +1,206 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | foam-extend: Open Source CFD
+   \\    /   O peration     | Version:     5.0
+    \\  /    A nd           | Web:         http://www.foam-extend.org
+     \\/     M anipulation  | For copyright notice see file Copyright
+-------------------------------------------------------------------------------
+License
+    This file is part of foam-extend.
+
+    foam-extend is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation, either version 3 of the License, or (at your
+    option) any later version.
+
+    foam-extend is distributed in the hope that it will be useful, but
+    WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with foam-extend.  If not, see <http://www.gnu.org/licenses/>.
+
+Author
+    Vuko Vukcevic, Wikki Ltd.  All rights reserved.
+
+\*---------------------------------------------------------------------------*/
+
+#include "compositeRefinementSelection.H"
+#include "addToRunTimeSelectionTable.H"
+#include "volFields.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+defineTypeNameAndDebug(compositeRefinementSelection, 0);
+addToRunTimeSelectionTable
+(
+    refinementSelection,
+    compositeRefinementSelection,
+    dictionary
+);
+
+}
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::compositeRefinementSelection::compositeRefinementSelection
+(
+    const fvMesh& mesh,
+    const dictionary& dict
+)
+:
+    refinementSelection(mesh, dict),
+    baseRefinementSelections_()
+{
+    // Read basic refinement selections
+    PtrList<entry> baseRefSelectionEntries
+    (
+        coeffDict().lookup("baseRefinementSelections")
+    );
+
+    baseRefinementSelections_.setSize(baseRefSelectionEntries.size());
+
+    forAll (baseRefinementSelections_, brsI)
+    {
+        baseRefinementSelections_.set
+        (
+            brsI,
+            refinementSelection::New
+            (
+                mesh,
+                baseRefSelectionEntries[brsI].dict()
+            )
+        );
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor* * * * * * * * * * * * * * * * //
+
+Foam::compositeRefinementSelection::~compositeRefinementSelection()
+{}
+
+
+// * * * * * * * * * * * * Public Member Functions * * * * * * * * * * * * * //
+
+Foam::labelList
+Foam::compositeRefinementSelection::refinementCellCandidates() const
+{
+    // Final refinement cell candidates are defined as the intersection of all
+    // sets (obtained with different refinement selection algorithms)
+    // In order to define the intersection in a straightforward and efficient
+    // way, we will create a labelField for all cells counting the number of
+    // times this cell has been selected for refinement. If all selection
+    // algorithms have selected the cell, this cell is marked as a final
+    // refinement candidate.
+
+    // Create field counting the number of selections
+    labelField nSelections(mesh().nCells(), 0);
+
+    // Loop through all base refinement selections
+    forAll (baseRefinementSelections_, brsI)
+    {
+        // Get refinement candidates from this base selection algorithm. Note:
+        // list is transferred
+        const labelList curRefCandidates
+        (
+            baseRefinementSelections_[brsI].refinementCellCandidates()
+        );
+
+        // Increment the number of selections for selected cells
+        forAll (curRefCandidates, i)
+        {
+            ++nSelections[curRefCandidates[i]];
+        }
+    }
+
+    // Create storage for collection of final cell candidates. Assume that
+    // one fifth of the cells will be marked to prevent excessive resizing
+    DynamicList<label> refinementCandidates(mesh().nCells()/5);
+
+    // Get number of active selection algorithms
+    const label nBaseSelections = baseRefinementSelections_.size();
+
+    // Loop through all cells and collect final refinement candidates
+    forAll (nSelections, cellI)
+    {
+        if (nSelections[cellI] == nBaseSelections)
+        {
+            // Cell has been marked by all selection algorithms, append it
+            refinementCandidates.append(cellI);
+        }
+    }
+
+    // Print out some information
+    Info<< "Selection algorithm " << type() << " selected "
+        << returnReduce(refinementCandidates.size(), sumOp<label>())
+        << " cells as refinement candidates."
+        << endl;
+
+    return refinementCandidates;
+}
+
+
+Foam::labelList
+Foam::compositeRefinementSelection::unrefinementPointCandidates() const
+{
+    // Final unrefinement point candidates are defined as the intersection of
+    // all sets (obtained with different refinement selection algorithms) In
+    // order to define the intersection in a straightforward and efficient way,
+    // we will create a labelField for all points counting the number of times
+    // this point has been selected for unrefinement. If all selection
+    // algorithms have selected the point, this point is marked as a final
+    // unrefinement split point candidate.
+
+    // Create a field counting the number of selections
+    labelField nSelections(mesh().nPoints(), 0);
+
+    // Loop through all base refinement selections
+    forAll (baseRefinementSelections_, brsI)
+    {
+        // Get unrefinement candidates from this base selection algorithm. Note:
+        // list is transferred
+        const labelList curUnrefCandidates
+        (
+            baseRefinementSelections_[brsI].unrefinementPointCandidates()
+        );
+
+        // Increment the number of selections for selected points
+        forAll (curUnrefCandidates, i)
+        {
+            ++nSelections[curUnrefCandidates[i]];
+        }
+    }
+
+    // Create storage for collection of final point candidates. Assume that one
+    // tenth of the points will be marked to prevent excessive resizing
+    DynamicList<label> unrefinementCandidates(mesh().nPoints()/10);
+
+    // Get number of active selection algorithms
+    const label nBaseSelections = baseRefinementSelections_.size();
+
+    // Loop through all points and collect final unrefinement candidates
+    forAll (nSelections, pointI)
+    {
+        if (nSelections[pointI] == nBaseSelections)
+        {
+            // Point has been marked by all selection algorithms, append it
+            unrefinementCandidates.append(pointI);
+        }
+    }
+
+    // Print out some information
+    Info<< "Selection algorithm " << type() << " selected "
+        << returnReduce(unrefinementCandidates.size(), sumOp<label>())
+        << " points as unrefinement candidates."
+        << endl;
+
+    return unrefinementCandidates;
+}
+
+
+// ************************************************************************* //
diff --git a/src/topoChangerFvMesh/dynamicPolyRefinementFvMesh/refinementSelection/compositeRefinementSelection/compositeRefinementSelection.H b/src/topoChangerFvMesh/dynamicPolyRefinementFvMesh/refinementSelection/compositeRefinementSelection/compositeRefinementSelection.H
new file mode 100644
index 0000000000..813d3b4fa1
--- /dev/null
+++ b/src/topoChangerFvMesh/dynamicPolyRefinementFvMesh/refinementSelection/compositeRefinementSelection/compositeRefinementSelection.H
@@ -0,0 +1,112 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | foam-extend: Open Source CFD
+   \\    /   O peration     | Version:     5.0
+    \\  /    A nd           | Web:         http://www.foam-extend.org
+     \\/     M anipulation  | For copyright notice see file Copyright
+-------------------------------------------------------------------------------
+License
+    This file is part of foam-extend.
+
+    foam-extend is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation, either version 3 of the License, or (at your
+    option) any later version.
+
+    foam-extend is distributed in the hope that it will be useful, but
+    WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with foam-extend.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::compositeRefinementSelection
+
+Description
+    Selection of refinement cells based on an arbitrary number of combined
+    "basic" selection algorithms.
+
+SourceFiles
+    compositeRefinementSelection.C
+
+Author
+    Vuko Vukcevic, Wikki Ltd.  All rights reserved.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef compositeRefinementSelection_H
+#define compositeRefinementSelection_H
+
+#include "refinementSelection.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                   Class compositeRefinementSelection Declaration
+\*---------------------------------------------------------------------------*/
+
+class compositeRefinementSelection
+:
+    public refinementSelection
+{
+    // Private data
+
+        //- List of basic refinement selection algorithms
+        PtrList<refinementSelection> baseRefinementSelections_;
+
+
+    // Private Member Functions
+
+        //- Disallow default bitwise copy construct
+        compositeRefinementSelection(const compositeRefinementSelection&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const compositeRefinementSelection&);
+
+
+public:
+
+    //- Runtime type information
+    TypeName("compositeRefinementSelection");
+
+
+    // Constructors
+
+        //- Construct from components
+        compositeRefinementSelection
+        (
+            const fvMesh& mesh,
+            const dictionary& dict
+        );
+
+
+    //- Destructor
+    virtual ~compositeRefinementSelection();
+
+
+    // Member Functions
+
+        // Selection of refinement/unrefinement candidates
+
+            //- Return transferable list of cells to refine
+            virtual labelList refinementCellCandidates() const;
+
+            //- Return transferable list of split points to unrefine
+            virtual labelList unrefinementPointCandidates() const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/topoChangerFvMesh/dynamicPolyRefinementFvMesh/refinementSelection/fieldBoundsRefinement/fieldBoundsRefinement.C b/src/topoChangerFvMesh/dynamicPolyRefinementFvMesh/refinementSelection/fieldBoundsRefinement/fieldBoundsRefinement.C
new file mode 100644
index 0000000000..1e3e3781e2
--- /dev/null
+++ b/src/topoChangerFvMesh/dynamicPolyRefinementFvMesh/refinementSelection/fieldBoundsRefinement/fieldBoundsRefinement.C
@@ -0,0 +1,187 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | foam-extend: Open Source CFD
+   \\    /   O peration     | Version:     5.0
+    \\  /    A nd           | Web:         http://www.foam-extend.org
+     \\/     M anipulation  | For copyright notice see file Copyright
+-------------------------------------------------------------------------------
+License
+    This file is part of foam-extend.
+
+    foam-extend is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation, either version 3 of the License, or (at your
+    option) any later version.
+
+    foam-extend is distributed in the hope that it will be useful, but
+    WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with foam-extend.  If not, see <http://www.gnu.org/licenses/>.
+
+Author
+    Vuko Vukcevic, Wikki Ltd.  All rights reserved.
+
+\*---------------------------------------------------------------------------*/
+
+#include "fieldBoundsRefinement.H"
+#include "addToRunTimeSelectionTable.H"
+#include "volFields.H"
+#include "pointFields.H"
+#include "volPointInterpolation.H"
+#include "pointVolInterpolation.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+defineTypeNameAndDebug(fieldBoundsRefinement, 0);
+addToRunTimeSelectionTable
+(
+    refinementSelection,
+    fieldBoundsRefinement,
+    dictionary
+);
+
+}
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::fieldBoundsRefinement::fieldBoundsRefinement
+(
+    const fvMesh& mesh,
+    const dictionary& dict
+)
+:
+    refinementSelection(mesh, dict),
+    fieldName_(coeffDict().lookup("fieldName")),
+    lowerBound_(readScalar(coeffDict().lookup("lowerBound"))),
+    upperBound_(readScalar(coeffDict().lookup("upperBound"))),
+    cellPointCellSmoothing_
+    (
+        coeffDict().lookupOrDefault<Switch>("cellPointCellSmoothing", false)
+    )
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructor* * * * * * * * * * * * * * * * //
+
+Foam::fieldBoundsRefinement::~fieldBoundsRefinement()
+{}
+
+
+// * * * * * * * * * * * * Public Member Functions * * * * * * * * * * * * * //
+
+Foam::labelList
+Foam::fieldBoundsRefinement::refinementCellCandidates() const
+{
+    // Get the field
+    const volScalarField& vField =
+        mesh().lookupObject<volScalarField>(fieldName_);
+
+    // Create temporary for the field (sharing the reference to volume field)
+    tmp<volScalarField> tvf(vField);
+
+    // Use cell-point-cell interpolation to smooth out the field
+    if (cellPointCellSmoothing_)
+    {
+        // Create volume to point interpolation object
+        const volPointInterpolation& vpi = volPointInterpolation::New(mesh());
+
+        // Interpolate from cell centres to points
+        pointScalarField pField(vpi.interpolate(vField));
+
+        // Create point to volume interpolation object
+        const pointMesh& pMesh = pointMesh::New(mesh());
+        const pointVolInterpolation pvi(pMesh, mesh());
+
+        // Interpolate from points back to cell centres
+        tmp<volScalarField> tInterpolatedVf = pvi.interpolate(pField);
+
+        // Assign to the temporary object
+        tvf = tInterpolatedVf;
+    }
+
+    // Get const reference to (possibly smoothed volume field)
+    const volScalarField& vf = tvf();
+
+    // Create storage for collection of cells. Assume that one in five cells
+    // will be refined to prevent excessive resizing.
+    DynamicList<label> refinementCandidates(Foam::max(100, mesh().nCells()/5));
+
+    // Loop through internal field and collect cells to refine
+    const scalarField& vfIn = vf.internalField();
+
+    forAll (vfIn, cellI)
+    {
+        // Get current cell value
+        const scalar& cellValue = vfIn[cellI];
+
+        if (cellValue > lowerBound_ && cellValue < upperBound_)
+        {
+            // Cell value is within the bounds, append cell for potential
+            // refinement
+            refinementCandidates.append(cellI);
+        }
+    }
+
+    // Print out some information
+    Info<< "Selection algorithm " << type() << " selected "
+        << returnReduce(refinementCandidates.size(), sumOp<label>())
+        << " cells as refinement candidates."
+        << endl;
+
+    return refinementCandidates;
+}
+
+
+Foam::labelList
+Foam::fieldBoundsRefinement::unrefinementPointCandidates() const
+{
+    // Get the field
+    const volScalarField& vField =
+        mesh().lookupObject<volScalarField>(fieldName_);
+
+    // Create volume to point interpolation object
+    const volPointInterpolation& vpi = volPointInterpolation::New(mesh());
+
+    // Interpolate the volume field from cell centres to points and get the
+    // internal point field
+    pointScalarField pField(vpi.interpolate(vField));
+    const scalarField& pFieldIn = pField.internalField();
+
+    // Create storage for collection of candidates. Assume that one in ten
+    // mesh points will be unrefined to prevent excessive resizing
+    DynamicList<label> unrefinementCandidates
+    (
+        Foam::max(100, mesh().nPoints()/10)
+    );
+
+    // Loop through all split points and select candidates to unrefine
+    forAll (pField, pointI)
+    {
+        // Get point value
+        const scalar pointValue = pFieldIn[pointI];
+
+        if (pointValue > upperBound_ || pointValue < lowerBound_)
+        {
+            // Point value is outside of bounds, append point for potential
+            // unrefinement
+            unrefinementCandidates.append(pointI);
+        }
+    }
+
+    // Print out some information
+    Info<< "Selection algorithm " << type() << " selected "
+        << returnReduce(unrefinementCandidates.size(), sumOp<label>())
+        << " points as unrefinement candidates."
+        << endl;
+
+    return unrefinementCandidates;
+}
+
+
+// ************************************************************************* //
diff --git a/src/topoChangerFvMesh/dynamicPolyRefinementFvMesh/refinementSelection/fieldBoundsRefinement/fieldBoundsRefinement.H b/src/topoChangerFvMesh/dynamicPolyRefinementFvMesh/refinementSelection/fieldBoundsRefinement/fieldBoundsRefinement.H
new file mode 100644
index 0000000000..06a77995f3
--- /dev/null
+++ b/src/topoChangerFvMesh/dynamicPolyRefinementFvMesh/refinementSelection/fieldBoundsRefinement/fieldBoundsRefinement.H
@@ -0,0 +1,120 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | foam-extend: Open Source CFD
+   \\    /   O peration     | Version:     5.0
+    \\  /    A nd           | Web:         http://www.foam-extend.org
+     \\/     M anipulation  | For copyright notice see file Copyright
+-------------------------------------------------------------------------------
+License
+    This file is part of foam-extend.
+
+    foam-extend is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation, either version 3 of the License, or (at your
+    option) any later version.
+
+    foam-extend is distributed in the hope that it will be useful, but
+    WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with foam-extend.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::fieldBoundsRefinement
+
+Description
+    Selection of refinement cells based on a given scalar field bounds:
+    if a given (scalar) field is between lowerBound and upperBound, cell will
+    be marked for refinement.
+
+SourceFiles
+    fieldBoundsRefinement.C
+
+Author
+    Vuko Vukcevic, Wikki Ltd.  All rights reserved.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef fieldBoundsRefinement_H
+#define fieldBoundsRefinement_H
+
+#include "refinementSelection.H"
+#include "Switch.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                   Class fieldBoundsRefinement Declaration
+\*---------------------------------------------------------------------------*/
+
+class fieldBoundsRefinement
+:
+    public refinementSelection
+{
+    // Private data
+
+        //- Name of the field to refine
+        word fieldName_;
+
+        //- Lower bound for the field
+        scalar lowerBound_;
+
+        //- Upper bound for the field
+        scalar upperBound_;
+
+        //- Whether to use cell-point-cell interpolation to smooth out the field
+        //  before selection. Switched off by default
+        Switch cellPointCellSmoothing_;
+
+
+    // Private Member Functions
+
+        //- Disallow default bitwise copy construct
+        fieldBoundsRefinement(const fieldBoundsRefinement&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const fieldBoundsRefinement&);
+
+
+public:
+
+    //- Runtime type information
+    TypeName("fieldBoundsRefinement");
+
+
+    // Constructors
+
+        //- Construct from components
+        fieldBoundsRefinement(const fvMesh& mesh, const dictionary& dict);
+
+
+    //- Destructor
+    virtual ~fieldBoundsRefinement();
+
+
+    // Member Functions
+
+        // Selection of refinement/unrefinement candidates
+
+            //- Return transferable list of cells to refine
+            virtual labelList refinementCellCandidates() const;
+
+            //- Return transferable list of split points to unrefine
+            virtual labelList unrefinementPointCandidates() const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/topoChangerFvMesh/dynamicPolyRefinementFvMesh/refinementSelection/minCellSizeRefinement/minCellSizeRefinement.C b/src/topoChangerFvMesh/dynamicPolyRefinementFvMesh/refinementSelection/minCellSizeRefinement/minCellSizeRefinement.C
new file mode 100644
index 0000000000..fb1f9d77d3
--- /dev/null
+++ b/src/topoChangerFvMesh/dynamicPolyRefinementFvMesh/refinementSelection/minCellSizeRefinement/minCellSizeRefinement.C
@@ -0,0 +1,125 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | foam-extend: Open Source CFD
+   \\    /   O peration     | Version:     5.0
+    \\  /    A nd           | Web:         http://www.foam-extend.org
+     \\/     M anipulation  | For copyright notice see file Copyright
+-------------------------------------------------------------------------------
+License
+    This file is part of foam-extend.
+
+    foam-extend is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation, either version 3 of the License, or (at your
+    option) any later version.
+
+    foam-extend is distributed in the hope that it will be useful, but
+    WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with foam-extend.  If not, see <http://www.gnu.org/licenses/>.
+
+Author
+    Vuko Vukcevic, Wikki Ltd.  All rights reserved.
+
+\*---------------------------------------------------------------------------*/
+
+#include "minCellSizeRefinement.H"
+#include "addToRunTimeSelectionTable.H"
+#include "volFields.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+defineTypeNameAndDebug(minCellSizeRefinement, 0);
+addToRunTimeSelectionTable
+(
+    refinementSelection,
+    minCellSizeRefinement,
+    dictionary
+);
+
+}
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::minCellSizeRefinement::minCellSizeRefinement
+(
+    const fvMesh& mesh,
+    const dictionary& dict
+)
+:
+    refinementSelection(mesh, dict),
+    minDelta_(readScalar(coeffDict().lookup("minCellSize")))
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructor* * * * * * * * * * * * * * * * //
+
+Foam::minCellSizeRefinement::~minCellSizeRefinement()
+{}
+
+
+// * * * * * * * * * * * * Public Member Functions * * * * * * * * * * * * * //
+
+Foam::labelList
+Foam::minCellSizeRefinement::refinementCellCandidates() const
+{
+    // Get cell sizes: cube root of cell volume (assuming cube cells)
+    const scalarField cellSize = pow(mesh().V().field(), 1.0/3.0);
+
+    // Create storage for collection of cells. Assume that almost all of the
+    // cells will be marked to prevent excessive resizing.
+    DynamicList<label> refinementCandidates(mesh().nCells());
+
+    // Loop through cells and collect refinement candidates
+    forAll (cellSize, cellI)
+    {
+        if (cellSize[cellI] > minDelta_)
+        {
+            // Cell is larger than the specified minimum, append cell for
+            // potential refinement
+            refinementCandidates.append(cellI);
+        }
+    }
+
+    // Print out some information
+    Info<< "Selection algorithm " << type() << " selected "
+        << returnReduce(refinementCandidates.size(), sumOp<label>())
+        << " cells as refinement candidates."
+        << endl;
+
+    return refinementCandidates;
+}
+
+
+Foam::labelList
+Foam::minCellSizeRefinement::unrefinementPointCandidates() const
+{
+    // Mark all points as unrefinement candidates since only split points may be
+    // considered for actual unrefinement and since this refinement criterion
+    // will be usually used in combination with others. VV, 15/Mar/2018.
+
+    // All points are unrefinement candidates
+    labelList unrefinementCandidates(mesh().nPoints());
+
+    forAll (unrefinementCandidates, pointI)
+    {
+        unrefinementCandidates[pointI] = pointI;
+    }
+
+    // Print out some information
+    Info<< "Selection algorithm " << type() << " selected "
+        << returnReduce(unrefinementCandidates.size(), sumOp<label>())
+        << " points as unrefinement candidates."
+        << endl;
+
+    return unrefinementCandidates;
+}
+
+
+// ************************************************************************* //
diff --git a/src/topoChangerFvMesh/dynamicPolyRefinementFvMesh/refinementSelection/minCellSizeRefinement/minCellSizeRefinement.H b/src/topoChangerFvMesh/dynamicPolyRefinementFvMesh/refinementSelection/minCellSizeRefinement/minCellSizeRefinement.H
new file mode 100644
index 0000000000..5e3a878376
--- /dev/null
+++ b/src/topoChangerFvMesh/dynamicPolyRefinementFvMesh/refinementSelection/minCellSizeRefinement/minCellSizeRefinement.H
@@ -0,0 +1,110 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | foam-extend: Open Source CFD
+   \\    /   O peration     | Version:     5.0
+    \\  /    A nd           | Web:         http://www.foam-extend.org
+     \\/     M anipulation  | For copyright notice see file Copyright
+-------------------------------------------------------------------------------
+License
+    This file is part of foam-extend.
+
+    foam-extend is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation, either version 3 of the License, or (at your
+    option) any later version.
+
+    foam-extend is distributed in the hope that it will be useful, but
+    WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with foam-extend.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::minCellSizeRefinement
+
+Description
+    Selection of refinement cells based on a minimum cell size. Assumes that
+    cells are mostly cubic and compares the minimum cell size with V^1/3, where
+    V is the cell volume. If the cell size is larger than the specified one,
+    cell gets selected for refinement.
+
+SourceFiles
+    minCellSizeRefinement.C
+
+Author
+    Vuko Vukcevic, Wikki Ltd.  All rights reserved.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef minCellSizeRefinement_H
+#define minCellSizeRefinement_H
+
+#include "refinementSelection.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                   Class minCellSizeRefinement Declaration
+\*---------------------------------------------------------------------------*/
+
+class minCellSizeRefinement
+:
+    public refinementSelection
+{
+    // Private data
+
+        //- Minimum cell size
+        scalar minDelta_;
+
+
+    // Private Member Functions
+
+        //- Disallow default bitwise copy construct
+        minCellSizeRefinement(const minCellSizeRefinement&) = delete;
+
+        //- Disallow default bitwise assignment
+        void operator=(const minCellSizeRefinement&) = delete;
+
+
+public:
+
+    //- Runtime type information
+    TypeName("minCellSizeRefinement");
+
+
+    // Constructors
+
+        //- Construct from components
+        minCellSizeRefinement(const fvMesh& mesh, const dictionary& dict);
+
+
+    //- Destructor
+    virtual ~minCellSizeRefinement();
+
+
+    // Member Functions
+
+        // Selection of refinement/unrefinement candidates
+
+            //- Return transferable list of cells to refine
+            virtual labelList refinementCellCandidates() const;
+
+            //- Return transferable list of split points to unrefine
+            virtual labelList unrefinementPointCandidates() const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/topoChangerFvMesh/dynamicPolyRefinementFvMesh/refinementSelection/minCellVolumeRefinement/minCellVolumeRefinement.C b/src/topoChangerFvMesh/dynamicPolyRefinementFvMesh/refinementSelection/minCellVolumeRefinement/minCellVolumeRefinement.C
new file mode 100644
index 0000000000..9c3bc8b7ec
--- /dev/null
+++ b/src/topoChangerFvMesh/dynamicPolyRefinementFvMesh/refinementSelection/minCellVolumeRefinement/minCellVolumeRefinement.C
@@ -0,0 +1,125 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | foam-extend: Open Source CFD
+   \\    /   O peration     | Version:     5.0
+    \\  /    A nd           | Web:         http://www.foam-extend.org
+     \\/     M anipulation  | For copyright notice see file Copyright
+-------------------------------------------------------------------------------
+License
+    This file is part of foam-extend.
+
+    foam-extend is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation, either version 3 of the License, or (at your
+    option) any later version.
+
+    foam-extend is distributed in the hope that it will be useful, but
+    WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with foam-extend.  If not, see <http://www.gnu.org/licenses/>.
+
+Author
+    Vuko Vukcevic, Wikki Ltd.  All rights reserved.
+
+\*---------------------------------------------------------------------------*/
+
+#include "minCellVolumeRefinement.H"
+#include "addToRunTimeSelectionTable.H"
+#include "volFields.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+defineTypeNameAndDebug(minCellVolumeRefinement, 0);
+addToRunTimeSelectionTable
+(
+    refinementSelection,
+    minCellVolumeRefinement,
+    dictionary
+);
+
+}
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::minCellVolumeRefinement::minCellVolumeRefinement
+(
+    const fvMesh& mesh,
+    const dictionary& dict
+)
+:
+    refinementSelection(mesh, dict),
+    minCellV_(readScalar(coeffDict().lookup("minCellVolume")))
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructor* * * * * * * * * * * * * * * * //
+
+Foam::minCellVolumeRefinement::~minCellVolumeRefinement()
+{}
+
+
+// * * * * * * * * * * * * Public Member Functions * * * * * * * * * * * * * //
+
+Foam::labelList
+Foam::minCellVolumeRefinement::refinementCellCandidates() const
+{
+    // Get mesh volumes
+    const scalarField& cellV = mesh().V().field();
+
+    // Create storage for collection of cells. Assume that almost all of the
+    // cells will be marked to prevent excessive resizing.
+    DynamicList<label> refinementCandidates(mesh().nCells());
+
+    // Loop through cells and collect refinement candidates
+    forAll (cellV, cellI)
+    {
+        if (cellV[cellI] > minCellV_)
+        {
+            // Cell is larger than the specified minimum, append cell for
+            // potential refinement
+            refinementCandidates.append(cellI);
+        }
+    }
+
+    // Print out some information
+    Info<< "Selection algorithm " << type() << " selected "
+        << returnReduce(refinementCandidates.size(), sumOp<label>())
+        << " cells as refinement candidates."
+        << endl;
+
+    return refinementCandidates;
+}
+
+
+Foam::labelList
+Foam::minCellVolumeRefinement::unrefinementPointCandidates() const
+{
+    // Mark all points as unrefinement candidates since only split points may be
+    // considered for actual unrefinement and since this refinement criterion
+    // will be usually used in combination with others. VV, 15/Mar/2018.
+
+    // All points are unrefinement candidates
+    labelList unrefinementCandidates(mesh().nPoints());
+
+    forAll (unrefinementCandidates, pointI)
+    {
+        unrefinementCandidates[pointI] = pointI;
+    }
+
+    // Print out some information
+    Info<< "Selection algorithm " << type() << " selected "
+        << returnReduce(unrefinementCandidates.size(), sumOp<label>())
+        << " points as unrefinement candidates."
+        << endl;
+
+    return unrefinementCandidates;
+}
+
+
+// ************************************************************************* //
diff --git a/src/topoChangerFvMesh/dynamicPolyRefinementFvMesh/refinementSelection/minCellVolumeRefinement/minCellVolumeRefinement.H b/src/topoChangerFvMesh/dynamicPolyRefinementFvMesh/refinementSelection/minCellVolumeRefinement/minCellVolumeRefinement.H
new file mode 100644
index 0000000000..a16d000f65
--- /dev/null
+++ b/src/topoChangerFvMesh/dynamicPolyRefinementFvMesh/refinementSelection/minCellVolumeRefinement/minCellVolumeRefinement.H
@@ -0,0 +1,108 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | foam-extend: Open Source CFD
+   \\    /   O peration     | Version:     5.0
+    \\  /    A nd           | Web:         http://www.foam-extend.org
+     \\/     M anipulation  | For copyright notice see file Copyright
+-------------------------------------------------------------------------------
+License
+    This file is part of foam-extend.
+
+    foam-extend is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation, either version 3 of the License, or (at your
+    option) any later version.
+
+    foam-extend is distributed in the hope that it will be useful, but
+    WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with foam-extend.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::minCellVolumeRefinement
+
+Description
+    Selection of refinement cells based on a minimum cell volume. All cells
+    with volume larger than specified minimum get selected.
+
+SourceFiles
+    minCellVolumeRefinement.C
+
+Author
+    Vuko Vukcevic, Wikki Ltd.  All rights reserved.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef minCellVolumeRefinement_H
+#define minCellVolumeRefinement_H
+
+#include "refinementSelection.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                   Class minCellVolumeRefinement Declaration
+\*---------------------------------------------------------------------------*/
+
+class minCellVolumeRefinement
+:
+    public refinementSelection
+{
+    // Private data
+
+        //- Minimum cell volume
+        scalar minCellV_;
+
+
+    // Private Member Functions
+
+        //- Disallow default bitwise copy construct
+        minCellVolumeRefinement(const minCellVolumeRefinement&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const minCellVolumeRefinement&);
+
+
+public:
+
+    //- Runtime type information
+    TypeName("minCellVolumeRefinement");
+
+
+    // Constructors
+
+        //- Construct from components
+        minCellVolumeRefinement(const fvMesh& mesh, const dictionary& dict);
+
+
+    //- Destructor
+    virtual ~minCellVolumeRefinement();
+
+
+    // Member Functions
+
+        // Selection of refinement/unrefinement candidates
+
+            //- Return transferable list of cells to refine
+            virtual labelList refinementCellCandidates() const;
+
+            //- Return transferable list of split points to unrefine
+            virtual labelList unrefinementPointCandidates() const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/topoChangerFvMesh/dynamicPolyRefinementFvMesh/refinementSelection/minFaceArea2DRefinement/minFaceArea2DRefinement.C b/src/topoChangerFvMesh/dynamicPolyRefinementFvMesh/refinementSelection/minFaceArea2DRefinement/minFaceArea2DRefinement.C
new file mode 100644
index 0000000000..62c7a8b12a
--- /dev/null
+++ b/src/topoChangerFvMesh/dynamicPolyRefinementFvMesh/refinementSelection/minFaceArea2DRefinement/minFaceArea2DRefinement.C
@@ -0,0 +1,200 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | foam-extend: Open Source CFD
+   \\    /   O peration     | Version:     5.0
+    \\  /    A nd           | Web:         http://www.foam-extend.org
+     \\/     M anipulation  | For copyright notice see file Copyright
+-------------------------------------------------------------------------------
+License
+    This file is part of foam-extend.
+
+    foam-extend is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation, either version 3 of the License, or (at your
+    option) any later version.
+
+    foam-extend is distributed in the hope that it will be useful, but
+    WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with foam-extend.  If not, see <http://www.gnu.org/licenses/>.
+
+Author
+    Vuko Vukcevic, Wikki Ltd.  All rights reserved.
+
+\*---------------------------------------------------------------------------*/
+
+#include "minFaceArea2DRefinement.H"
+#include "addToRunTimeSelectionTable.H"
+#include "volFields.H"
+#include "emptyPolyPatch.H"
+#include "wedgePolyPatch.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+defineTypeNameAndDebug(minFaceArea2DRefinement, 0);
+addToRunTimeSelectionTable
+(
+    refinementSelection,
+    minFaceArea2DRefinement,
+    dictionary
+);
+
+}
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::minFaceArea2DRefinement::minFaceArea2DRefinement
+(
+    const fvMesh& mesh,
+    const dictionary& dict
+)
+:
+    refinementSelection(mesh, dict),
+    minFaceA_(readScalar(coeffDict().lookup("minFaceArea")))
+{
+    // It is an error to use this selection algorithm for 3D or 1D cases
+    if (mesh.nGeometricD() != 2)
+    {
+        FatalErrorIn
+        (
+            "minFaceArea2DRefinement::minFaceArea2DRefinement"
+            "\n("
+            "\n    const fvMesh& mesh,"
+            "\n    const dictionary& dict,"
+            "\n)"
+        )   << "You are trying to use minFaceArea2DRefinement selection"
+            << " algorithm for a case which is not 2D case."
+            << nl
+            << "This is not allowed."
+            << abort(FatalError);
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor* * * * * * * * * * * * * * * * //
+
+Foam::minFaceArea2DRefinement::~minFaceArea2DRefinement()
+{}
+
+
+// * * * * * * * * * * * * Public Member Functions * * * * * * * * * * * * * //
+
+Foam::labelList
+Foam::minFaceArea2DRefinement::refinementCellCandidates() const
+{
+    // Get face areas (from polyMesh)
+    const scalarField faceArea = mag(mesh().faceAreas());
+
+    // Mark empty or wedge faces
+    boolList faceOnEmptyPatch(mesh().nFaces(), false);
+
+    // Loop through all patches
+    const polyBoundaryMesh& bMesh = mesh().boundaryMesh();
+    forAll (bMesh, patchI)
+    {
+        const polyPatch& curPatch = bMesh[patchI];
+
+        if (isA<emptyPolyPatch>(curPatch) || isA<wedgePolyPatch>(curPatch))
+        {
+            // Faces on this patch need to be marked
+            const label startFaceI = curPatch.start();
+            const label endFaceI = startFaceI + curPatch.size();
+
+            // Loop through all the faces and marke them
+            for (label faceI = startFaceI; faceI < endFaceI; ++faceI)
+            {
+                faceOnEmptyPatch[faceI] = true;
+            }
+        }
+    }
+
+
+    // Create field that contains maximum face area on empty patch per cell
+    scalarField maxEmptyPatchFaceArea(mesh().nCells(), 0.0);
+
+    // Get cells from the mesh
+    const cellList& cells = mesh().cells();
+
+    forAll (cells, cellI)
+    {
+        // Get current cell
+        const cell& cellFaces = cells[cellI];
+
+        // Loop through faces of the cell
+        forAll (cellFaces, i)
+        {
+            // Get face index
+            const label& faceI = cellFaces[i];
+
+            if (faceOnEmptyPatch[faceI])
+            {
+                // This face is on empty patch, set maximum face area to the new
+                // value if it's larger than the old value
+                maxEmptyPatchFaceArea[cellI] =
+                    max
+                    (
+                        maxEmptyPatchFaceArea[cellI],
+                        faceArea[faceI]
+                    );
+            }
+        }
+    }
+
+
+    // Create storage for collection of cells. Assume that almost all of the
+    // cells will be marked to prevent excessive resizing.
+    DynamicList<label> refinementCandidates(mesh().nCells());
+
+    // Loop through cells and collect refinement candidates
+    forAll (maxEmptyPatchFaceArea, cellI)
+    {
+        if (maxEmptyPatchFaceArea[cellI] > minFaceA_)
+        {
+            // Face area on empty patch is larger than the specified minimum,
+            // append cell for potential refinement
+            refinementCandidates.append(cellI);
+        }
+    }
+
+    // Print out some information
+    Info<< "Selection algorithm " << type() << " selected "
+        << returnReduce(refinementCandidates.size(), sumOp<label>())
+        << " cells as refinement candidates."
+        << endl;
+
+    return refinementCandidates;
+}
+
+
+Foam::labelList
+Foam::minFaceArea2DRefinement::unrefinementPointCandidates() const
+{
+    // Mark all points as unrefinement candidates since only split points may be
+    // considered for actual unrefinement and since this refinement criterion
+    // will be usually used in combination with others. VV, 4/Sep/2018.
+
+    // All points are unrefinement candidates
+    labelList unrefinementCandidates(mesh().nPoints());
+
+    forAll (unrefinementCandidates, pointI)
+    {
+        unrefinementCandidates[pointI] = pointI;
+    }
+
+    // Print out some information
+    Info<< "Selection algorithm " << type() << " selected "
+        << returnReduce(unrefinementCandidates.size(), sumOp<label>())
+        << " points as unrefinement candidates."
+        << endl;
+
+    return unrefinementCandidates;
+}
+
+
+// ************************************************************************* //
diff --git a/src/topoChangerFvMesh/dynamicPolyRefinementFvMesh/refinementSelection/minFaceArea2DRefinement/minFaceArea2DRefinement.H b/src/topoChangerFvMesh/dynamicPolyRefinementFvMesh/refinementSelection/minFaceArea2DRefinement/minFaceArea2DRefinement.H
new file mode 100644
index 0000000000..fada573061
--- /dev/null
+++ b/src/topoChangerFvMesh/dynamicPolyRefinementFvMesh/refinementSelection/minFaceArea2DRefinement/minFaceArea2DRefinement.H
@@ -0,0 +1,111 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | foam-extend: Open Source CFD
+   \\    /   O peration     | Version:     5.0
+    \\  /    A nd           | Web:         http://www.foam-extend.org
+     \\/     M anipulation  | For copyright notice see file Copyright
+-------------------------------------------------------------------------------
+License
+    This file is part of foam-extend.
+
+    foam-extend is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation, either version 3 of the License, or (at your
+    option) any later version.
+
+    foam-extend is distributed in the hope that it will be useful, but
+    WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with foam-extend.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::minFaceArea2DRefinement
+
+Description
+    Selection of refinement cells based on a minimum face area of empty (or
+    wedge) patches. All cells containing a face on empty (or wedge) patch larger
+    than specified minimum area get selected.
+
+    Useful as a 2D substitute for minCellVolume selection for wedge geometries.
+
+SourceFiles
+    minFaceArea2DRefinement.C
+
+Author
+    Vuko Vukcevic, Wikki Ltd.  All rights reserved.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef minFaceArea2DRefinement_H
+#define minFaceArea2DRefinement_H
+
+#include "refinementSelection.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                   Class minFaceArea2DRefinement Declaration
+\*---------------------------------------------------------------------------*/
+
+class minFaceArea2DRefinement
+:
+    public refinementSelection
+{
+    // Private data
+
+        //- Minimum face area on empty (or wedge) patches
+        scalar minFaceA_;
+
+
+    // Private Member Functions
+
+        //- Disallow default bitwise copy construct
+        minFaceArea2DRefinement(const minFaceArea2DRefinement&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const minFaceArea2DRefinement&);
+
+
+public:
+
+    //- Runtime type information
+    TypeName("minFaceArea2DRefinement");
+
+
+    // Constructors
+
+        //- Construct from components
+        minFaceArea2DRefinement(const fvMesh& mesh, const dictionary& dict);
+
+
+    //- Destructor
+    virtual ~minFaceArea2DRefinement();
+
+
+    // Member Functions
+
+        // Selection of refinement/unrefinement candidates
+
+            //- Return transferable list of cells to refine
+            virtual labelList refinementCellCandidates() const;
+
+            //- Return transferable list of split points to unrefine
+            virtual labelList unrefinementPointCandidates() const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/topoChangerFvMesh/dynamicPolyRefinementFvMesh/refinementSelection/minPatchDistanceRefinement/minPatchDistanceRefinement.C b/src/topoChangerFvMesh/dynamicPolyRefinementFvMesh/refinementSelection/minPatchDistanceRefinement/minPatchDistanceRefinement.C
new file mode 100644
index 0000000000..96abf9ba7f
--- /dev/null
+++ b/src/topoChangerFvMesh/dynamicPolyRefinementFvMesh/refinementSelection/minPatchDistanceRefinement/minPatchDistanceRefinement.C
@@ -0,0 +1,154 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | foam-extend: Open Source CFD
+   \\    /   O peration     | Version:     5.0
+    \\  /    A nd           | Web:         http://www.foam-extend.org
+     \\/     M anipulation  | For copyright notice see file Copyright
+-------------------------------------------------------------------------------
+License
+    This file is part of foam-extend.
+
+    foam-extend is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation, either version 3 of the License, or (at your
+    option) any later version.
+
+    foam-extend is distributed in the hope that it will be useful, but
+    WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with foam-extend.  If not, see <http://www.gnu.org/licenses/>.
+
+Author
+    Vuko Vukcevic, Wikki Ltd.  All rights reserved.
+
+\*---------------------------------------------------------------------------*/
+
+#include "minPatchDistanceRefinement.H"
+#include "addToRunTimeSelectionTable.H"
+#include "volFields.H"
+#include "patchWave.H"
+#include "polyPatchID.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+defineTypeNameAndDebug(minPatchDistanceRefinement, 0);
+addToRunTimeSelectionTable
+(
+    refinementSelection,
+    minPatchDistanceRefinement,
+    dictionary
+);
+
+}
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::minPatchDistanceRefinement::minPatchDistanceRefinement
+(
+    const fvMesh& mesh,
+    const dictionary& dict
+)
+:
+    refinementSelection(mesh, dict),
+    minPatchDistance_(readScalar(coeffDict().lookup("minPatchDistance")))
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructor* * * * * * * * * * * * * * * * //
+
+Foam::minPatchDistanceRefinement::~minPatchDistanceRefinement()
+{}
+
+
+// * * * * * * * * * * * * Public Member Functions * * * * * * * * * * * * * //
+
+Foam::labelList
+Foam::minPatchDistanceRefinement::refinementCellCandidates() const
+{
+    // Note: recalculate distance every time due to probable topo changes
+
+    // Read patch names from dictionary
+    const wordList patchNames(coeffDict().lookup("distancePatches"));
+
+    // Collect patchIDs into a hash set
+    labelHashSet patchIDs(patchNames.size());
+    forAll (patchNames, patchI)
+    {
+        // Get polyPatchID
+        const polyPatchID pID(patchNames[patchI], mesh().boundaryMesh());
+
+        if (pID.active())
+        {
+            patchIDs.insert(pID.index());
+        }
+        else
+        {
+            FatalIOErrorInFunction(coeffDict())
+                << "Cannot find patch " << patchNames[patchI]
+                << " in the mesh." << nl
+                << "Available patches are: " << mesh().boundaryMesh().names()
+                << abort(FatalIOError);
+        }
+    }
+
+    // Calculate distance from specified patches and do not correct for accurate
+    // near wall distance (false argument)
+    patchWave waveDistance(mesh(), patchIDs, false);
+    const scalarField& patchDistance = waveDistance.distance();
+
+    // Create storage for collection of cells. Assume that almost all of the
+    // cells will be marked to prevent excessive resizing.
+    DynamicList<label> refinementCandidates(mesh().nCells());
+
+    // Loop through cells and collect refinement candidates
+    forAll (patchDistance, cellI)
+    {
+        if (patchDistance[cellI] > minPatchDistance_)
+        {
+            // Cell is far from the patches, append it for potential refinement
+            refinementCandidates.append(cellI);
+        }
+    }
+
+    // Print out some information
+    Info<< "Selection algorithm " << type() << " selected "
+        << returnReduce(refinementCandidates.size(), sumOp<label>())
+        << " cells as refinement candidates."
+        << endl;
+
+    return refinementCandidates;
+}
+
+
+Foam::labelList
+Foam::minPatchDistanceRefinement::unrefinementPointCandidates() const
+{
+    // Mark all points as unrefinement candidates since only split points may be
+    // considered for actual unrefinement and since this refinement criterion
+    // will be usually used in combination with others. VV, 15/Mar/2018.
+
+    // All points are unrefinement candidates
+    labelList unrefinementCandidates(mesh().nPoints());
+
+    forAll (unrefinementCandidates, pointI)
+    {
+        unrefinementCandidates[pointI] = pointI;
+    }
+
+    // Print out some information
+    Info<< "Selection algorithm " << type() << " selected "
+        << returnReduce(unrefinementCandidates.size(), sumOp<label>())
+        << " points as unrefinement candidates."
+        << endl;
+
+    return unrefinementCandidates;
+}
+
+
+// ************************************************************************* //
diff --git a/src/topoChangerFvMesh/dynamicPolyRefinementFvMesh/refinementSelection/minPatchDistanceRefinement/minPatchDistanceRefinement.H b/src/topoChangerFvMesh/dynamicPolyRefinementFvMesh/refinementSelection/minPatchDistanceRefinement/minPatchDistanceRefinement.H
new file mode 100644
index 0000000000..27ac3bde21
--- /dev/null
+++ b/src/topoChangerFvMesh/dynamicPolyRefinementFvMesh/refinementSelection/minPatchDistanceRefinement/minPatchDistanceRefinement.H
@@ -0,0 +1,108 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | foam-extend: Open Source CFD
+   \\    /   O peration     | Version:     5.0
+    \\  /    A nd           | Web:         http://www.foam-extend.org
+     \\/     M anipulation  | For copyright notice see file Copyright
+-------------------------------------------------------------------------------
+License
+    This file is part of foam-extend.
+
+    foam-extend is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation, either version 3 of the License, or (at your
+    option) any later version.
+
+    foam-extend is distributed in the hope that it will be useful, but
+    WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with foam-extend.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::minPatchDistanceRefinement
+
+Description
+    Selection of refinement cells based on a minimum distance from a set of
+    patches. All cells farther away from the minimum distance get selected.
+
+SourceFiles
+    minPatchDistanceRefinement.C
+
+Author
+    Vuko Vukcevic, Wikki Ltd.  All rights reserved.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef minPatchDistanceRefinement_H
+#define minPatchDistanceRefinement_H
+
+#include "refinementSelection.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                   Class minPatchDistanceRefinement Declaration
+\*---------------------------------------------------------------------------*/
+
+class minPatchDistanceRefinement
+:
+    public refinementSelection
+{
+    // Private data
+
+        //- Minimum distance to patch
+        scalar minPatchDistance_;
+
+
+    // Private Member Functions
+
+        //- Disallow default bitwise copy construct
+        minPatchDistanceRefinement(const minPatchDistanceRefinement&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const minPatchDistanceRefinement&);
+
+
+public:
+
+    //- Runtime type information
+    TypeName("minPatchDistanceRefinement");
+
+
+    // Constructors
+
+        //- Construct from components
+        minPatchDistanceRefinement(const fvMesh& mesh, const dictionary& dict);
+
+
+    //- Destructor
+    virtual ~minPatchDistanceRefinement();
+
+
+    // Member Functions
+
+        // Selection of refinement/unrefinement candidates
+
+            //- Return transferable list of cells to refine
+            virtual labelList refinementCellCandidates() const;
+
+            //- Return transferable list of split points to unrefine
+            virtual labelList unrefinementPointCandidates() const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/topoChangerFvMesh/dynamicPolyRefinementFvMesh/refinementSelection/protectedInitialRefinement/protectedInitialRefinement.C b/src/topoChangerFvMesh/dynamicPolyRefinementFvMesh/refinementSelection/protectedInitialRefinement/protectedInitialRefinement.C
new file mode 100644
index 0000000000..730a488621
--- /dev/null
+++ b/src/topoChangerFvMesh/dynamicPolyRefinementFvMesh/refinementSelection/protectedInitialRefinement/protectedInitialRefinement.C
@@ -0,0 +1,224 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | foam-extend: Open Source CFD
+   \\    /   O peration     | Version:     5.0
+    \\  /    A nd           | Web:         http://www.foam-extend.org
+     \\/     M anipulation  | For copyright notice see file Copyright
+-------------------------------------------------------------------------------
+License
+    This file is part of foam-extend.
+
+    foam-extend is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation, either version 3 of the License, or (at your
+    option) any later version.
+
+    foam-extend is distributed in the hope that it will be useful, but
+    WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with foam-extend.  If not, see <http://www.gnu.org/licenses/>.
+
+Author
+    Vuko Vukcevic, Wikki Ltd.  All rights reserved.
+
+\*---------------------------------------------------------------------------*/
+
+#include "protectedInitialRefinement.H"
+#include "labelIOField.H"
+#include "zeroGradientFvPatchFields.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+defineTypeNameAndDebug(protectedInitialRefinement, 0);
+addToRunTimeSelectionTable
+(
+    refinementSelection,
+    protectedInitialRefinement,
+    dictionary
+);
+
+}
+
+// * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * * //
+
+Foam::tmp<Foam::volScalarField>
+Foam::protectedInitialRefinement::cellLevelAsField() const
+{
+    // Get cell level
+    const labelIOField& cLevel = mesh().lookupObject<labelIOField>("cellLevel");
+
+    // Create cell level field as volScalarField
+    tmp<volScalarField> tcellLevelField
+    (
+        new volScalarField
+        (
+            IOobject
+            (
+                "cellLevel",
+                mesh().time().timeName(),
+                mesh(),
+                IOobject::NO_READ,
+                IOobject::NO_WRITE
+            ),
+            mesh(),
+            dimensionedScalar("zero", dimless, 0.0),
+            zeroGradientFvPatchScalarField::typeName
+        )
+    );
+
+    scalarField& cellLevelFieldIn = tcellLevelField->internalFieldRef();
+
+    // Set the field
+    forAll (cLevel, cellI)
+    {
+        cellLevelFieldIn[cellI] = cLevel[cellI];
+    }
+    tcellLevelField->correctBoundaryConditions();
+
+    return tcellLevelField;
+}
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::protectedInitialRefinement::protectedInitialRefinement
+(
+    const fvMesh& mesh,
+    const dictionary& dict
+)
+:
+    refinementSelection(mesh, dict),
+    initialCellLevel_
+    (
+        IOobject
+        (
+            "initialCellLevel",
+            mesh.time().timeName(),
+            mesh,
+            IOobject::READ_IF_PRESENT,
+            IOobject::AUTO_WRITE
+        ),
+        cellLevelAsField()()
+    ),
+    // Note: conversion from label to scalar
+    minProtectedLevel_
+    (
+        coeffDict().lookupOrDefault<label>("minProtectedLevel", 0)
+    )
+{
+    Info<< "Will not allow initial refinement below level: "
+        << minProtectedLevel_ << endl;
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor* * * * * * * * * * * * * * * * //
+
+Foam::protectedInitialRefinement::~protectedInitialRefinement()
+{}
+
+
+// * * * * * * * * * * * * Public Member Functions * * * * * * * * * * * * * //
+
+Foam::labelList
+Foam::protectedInitialRefinement::refinementCellCandidates() const
+{
+    // All cells are candidates for refinement
+    labelList refinementCandidates(mesh().nCells());
+    forAll (refinementCandidates, cellI)
+    {
+        refinementCandidates[cellI] = cellI;
+    }
+
+    // Print out some information
+    Info<< "Selection algorithm " << type() << " selected "
+        << returnReduce(refinementCandidates.size(), sumOp<label>())
+        << " (all) cells as refinement candidates."
+        << endl;
+
+    return refinementCandidates;
+}
+
+
+Foam::labelList
+Foam::protectedInitialRefinement::unrefinementPointCandidates() const
+{
+    // Create mark-up field for points that are found on initially refined cells
+    // Note: this can be done more intelligently by either cacheing until load
+    // balancing actually occurs or holding pointLevel as data member and
+    // updating it on load balancing. The overall overhead compared to AMR and
+    // DLB is really small, so there's no need to worry about this yet.
+    // VV, 10/July/2018
+    boolList pointsOnRefinedCells(mesh().nPoints(), false);
+
+    // Get initial cell level and mesh data
+    const scalarField& initialCellLevelIn = initialCellLevel_.internalField();
+    const labelListList& meshCellPoints = mesh().cellPoints();
+
+    // Loop through all cells and count number of protected points
+    label nProtectedPoints = 0;
+
+    // Get current cell level
+    const labelIOField& curCellLevel =
+        mesh().lookupObject<labelIOField>("cellLevel");
+
+    forAll (initialCellLevelIn, cellI)
+    {
+        const scalar& cl = initialCellLevelIn[cellI];
+        const scalar& curcl = curCellLevel[cellI];
+
+        if
+        (
+            (cl > SMALL)
+         && (curcl - minProtectedLevel_ < 0.5)
+        )
+        {
+            // Cell has been refined during meshing and the original level is
+            // equal to the current level, mark all of its points
+            const labelList& curCellPoints = meshCellPoints[cellI];
+
+            forAll (curCellPoints, i)
+            {
+                // Get marker for this point
+                bool& ptOnRefCell = pointsOnRefinedCells[curCellPoints[i]];
+
+                if (!ptOnRefCell)
+                {
+                    // This points has not been marked yet, mark it and
+                    // increment the counter for protected points
+                    ptOnRefCell = true;
+                    ++nProtectedPoints;
+                }
+            }
+        }
+    }
+
+    // Create the list for unrefinement candidates
+    labelList unrefinementCandidates(mesh().nPoints() - nProtectedPoints);
+    label nUnrefPoints = 0;
+
+    forAll (pointsOnRefinedCells, pointI)
+    {
+        if (!pointsOnRefinedCells[pointI])
+        {
+            // This point is an unrefinement candidate, set it and increment
+            unrefinementCandidates[nUnrefPoints++] = pointI;
+        }
+    }
+
+    // Print out some information
+    Info<< "Selection algorithm " << type() << " selected "
+        << returnReduce(unrefinementCandidates.size(), sumOp<label>())
+        << " points as unrefinement candidates."
+        << endl;
+
+    return unrefinementCandidates;
+}
+
+
+// ************************************************************************* //
diff --git a/src/topoChangerFvMesh/dynamicPolyRefinementFvMesh/refinementSelection/protectedInitialRefinement/protectedInitialRefinement.H b/src/topoChangerFvMesh/dynamicPolyRefinementFvMesh/refinementSelection/protectedInitialRefinement/protectedInitialRefinement.H
new file mode 100644
index 0000000000..18e83f3279
--- /dev/null
+++ b/src/topoChangerFvMesh/dynamicPolyRefinementFvMesh/refinementSelection/protectedInitialRefinement/protectedInitialRefinement.H
@@ -0,0 +1,130 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | foam-extend: Open Source CFD
+   \\    /   O peration     | Version:     5.0
+    \\  /    A nd           | Web:         http://www.foam-extend.org
+     \\/     M anipulation  | For copyright notice see file Copyright
+-------------------------------------------------------------------------------
+License
+    This file is part of foam-extend.
+
+    foam-extend is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation, either version 3 of the License, or (at your
+    option) any later version.
+
+    foam-extend is distributed in the hope that it will be useful, but
+    WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with foam-extend.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::protectedInitialRefinement
+
+Description
+    This refinement strategy is just a protection to avoid unrefining cells that
+    are refined during the snappyHexMesh meshing process. It's intended use is
+    alongside some other refinement strategy as a part of a composite scheme.
+    Therefore: refinementCellCandidates returns all cells as refinement
+    candidates, while unrefinementPointCandidates returns all points that don't
+    touch any of the initially refined cells.
+
+    Since snappyHexMesh writes down cellLevel and pointLevel, cells refined in
+    during meshing could be unrefined, but this is not what we would like to
+    achieve (after all, if we have included refinement regions in meshing, then
+    we probably had a good reason for it).
+
+SourceFiles
+    protectedInitialRefinement.C
+
+Author
+    Vuko Vukcevic, Wikki Ltd.  All rights reserved.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef protectedInitialRefinement_H
+#define protectedInitialRefinement_H
+
+#include "refinementSelection.H"
+#include "volFields.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                 Class protectedInitialRefinement Declaration
+\*---------------------------------------------------------------------------*/
+
+class protectedInitialRefinement
+:
+    public refinementSelection
+{
+    // Private data
+
+        //- Initial cellLevel as volScalarField in order to simplify data
+        //  transfer for dynamic load balancing
+        volScalarField initialCellLevel_;
+
+        //- Minimum refinement level to protect
+        scalar minProtectedLevel_;
+
+
+    // Private Member Functions
+
+        // Copy control
+
+            //- Disallow default bitwise copy construct
+            protectedInitialRefinement(const protectedInitialRefinement&);
+
+            //- Disallow default bitwise assignment
+            void operator=(const protectedInitialRefinement&);
+
+
+        // Constructor helper
+
+            //- Create and return volScalarField from cellLevel
+            tmp<volScalarField> cellLevelAsField() const;
+
+
+public:
+
+    //- Runtime type information
+    TypeName("protectedInitialRefinement");
+
+
+    // Constructors
+
+        //- Construct from components
+        protectedInitialRefinement(const fvMesh& mesh, const dictionary& dict);
+
+
+    //- Destructor
+    virtual ~protectedInitialRefinement();
+
+
+    // Member Functions
+
+        // Selection of refinement/unrefinement candidates
+
+            //- Return transferable list of cells to refine
+            virtual labelList refinementCellCandidates() const;
+
+            //- Return transferable list of split points to unrefine
+            virtual labelList unrefinementPointCandidates() const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/topoChangerFvMesh/dynamicPolyRefinementFvMesh/refinementSelection/refinementSelection/refinementSelection.C b/src/topoChangerFvMesh/dynamicPolyRefinementFvMesh/refinementSelection/refinementSelection/refinementSelection.C
new file mode 100644
index 0000000000..11fe5dbccb
--- /dev/null
+++ b/src/topoChangerFvMesh/dynamicPolyRefinementFvMesh/refinementSelection/refinementSelection/refinementSelection.C
@@ -0,0 +1,87 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | foam-extend: Open Source CFD
+   \\    /   O peration     | Version:     5.0
+    \\  /    A nd           | Web:         http://www.foam-extend.org
+     \\/     M anipulation  | For copyright notice see file Copyright
+-------------------------------------------------------------------------------
+License
+    This file is part of foam-extend.
+
+    foam-extend is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation, either version 3 of the License, or (at your
+    option) any later version.
+
+    foam-extend is distributed in the hope that it will be useful, but
+    WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with foam-extend.  If not, see <http://www.gnu.org/licenses/>.
+
+Author
+    Vuko Vukcevic, Wikki Ltd.  All rights reserved.
+
+\*---------------------------------------------------------------------------*/
+
+#include "refinementSelection.H"
+#include "fvMesh.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+defineTypeNameAndDebug(refinementSelection, 0);
+defineRunTimeSelectionTable(refinementSelection, dictionary);
+
+}
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::refinementSelection::refinementSelection
+(
+    const fvMesh& mesh,
+    const dictionary& dict
+)
+:
+    mesh_(mesh),
+    coeffDict_(dict.subDict("refinementSelection"))
+{}
+
+
+// * * * * * * * * * * * * * * * * * Selectors * * * * * * * * * * * * * * * //
+
+Foam::autoPtr<Foam::refinementSelection> Foam::refinementSelection::New
+(
+    const fvMesh& mesh,
+    const dictionary& dict
+)
+{
+    // Get subdictionary from the dictionary
+    const dictionary coeffDict(dict.subDict("refinementSelection"));
+
+    // Get the name of the desired refinement selection algorithm
+    const word refinementSelectionTypeName(coeffDict.lookup("type"));
+    Info<< "Creating refinementSelection " << refinementSelectionTypeName << endl;
+
+    auto* ctorPtr =
+        dictionaryConstructorTable(refinementSelectionTypeName);
+
+    if (!ctorPtr)
+    {
+        FatalErrorInLookup
+        (
+            "refinementSelection",
+            refinementSelectionTypeName,
+            *dictionaryConstructorTablePtr_
+        ) << exit(FatalError);
+    }
+
+    return autoPtr<refinementSelection>(ctorPtr(mesh, dict));
+}
+
+
+// ************************************************************************* //
diff --git a/src/topoChangerFvMesh/dynamicPolyRefinementFvMesh/refinementSelection/refinementSelection/refinementSelection.H b/src/topoChangerFvMesh/dynamicPolyRefinementFvMesh/refinementSelection/refinementSelection/refinementSelection.H
new file mode 100644
index 0000000000..1540f433ea
--- /dev/null
+++ b/src/topoChangerFvMesh/dynamicPolyRefinementFvMesh/refinementSelection/refinementSelection/refinementSelection.H
@@ -0,0 +1,171 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | foam-extend: Open Source CFD
+   \\    /   O peration     | Version:     5.0
+    \\  /    A nd           | Web:         http://www.foam-extend.org
+     \\/     M anipulation  | For copyright notice see file Copyright
+-------------------------------------------------------------------------------
+License
+    This file is part of foam-extend.
+
+    foam-extend is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation, either version 3 of the License, or (at your
+    option) any later version.
+
+    foam-extend is distributed in the hope that it will be useful, but
+    WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with foam-extend.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::refinementSelection
+
+Description
+    An abstract base class for providing an interface for refinement selection
+    algorithms. The interface provides two functionalities:
+
+    1. Selects candidate cells to refine based on chosen criteria through
+       refinementCellCandidates() member function. Returns a list of all cells
+       that satisfy given criteria,
+    2. Selects candidate split points to unrefine based on chosen criteria
+       through unrefinementPointCandidates() member function. Returns a list of
+       all points (not just split points!) that satisfy the criteria.
+
+    Note: Here, we do not check that the unrefinement point candidates do not
+    clash the points of cells marked as candidates for refinement. This is taken
+    care of in polyhedralRefinement class.
+
+SourceFiles
+    refinementSelection.C
+
+Author
+    Vuko Vukcevic, Wikki Ltd.  All rights reserved.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef refinementSelection_H
+#define refinementSelection_H
+
+#include "dictionary.H"
+#include "labelList.H"
+#include "autoPtr.H"
+#include "runTimeSelectionTables.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// Forward declaration of classes
+class fvMesh;
+
+/*---------------------------------------------------------------------------*\
+                   Class refinementSelection Declaration
+\*---------------------------------------------------------------------------*/
+
+class refinementSelection
+{
+    // Private data
+
+        //- Const reference to fvMesh
+        const fvMesh& mesh_;
+
+        //- Refinement selection dictionary (subdictionary of
+        //  dynamicPolyRefinementFvMeshCoeffs dictionary)
+        const dictionary coeffDict_;
+
+
+    // Private Member Functions
+
+        //- Disallow default bitwise copy construct
+        refinementSelection(const refinementSelection&) = delete;
+
+        //- Disallow default bitwise assignment
+        void operator=(const refinementSelection&) = delete;
+
+
+protected:
+
+    // Protected member functions
+
+        // Access functions for derived classes
+
+            //- Const access to the fvMesh
+            const fvMesh& mesh() const
+            {
+                return mesh_;
+            }
+
+            //- Const access to the coefficient dictionary
+            const dictionary& coeffDict() const
+            {
+                return coeffDict_;
+            }
+
+
+public:
+
+    //- Runtime type information
+    TypeName("refinementSelection");
+
+
+    // Declare run-time constructor selection table
+
+        declareRunTimeSelectionTable
+        (
+            autoPtr,
+            refinementSelection,
+            dictionary,
+            (
+                const fvMesh& mesh,
+                const dictionary& dict
+            ),
+            (mesh, dict)
+        );
+
+
+    // Constructors
+
+        //- Construct from components
+        refinementSelection(const fvMesh& mesh, const dictionary& dict);
+
+
+    // Selectors
+
+        //- Return an autoPtr to the selected refinementSelection
+        static autoPtr<refinementSelection> New
+        (
+            const fvMesh& mesh,
+            const dictionary& dict
+        );
+
+
+    //- Destructor
+    virtual ~refinementSelection() = default;
+
+
+    // Member Functions
+
+        // Selection of refinement/unrefinement candidates
+
+            //- Return transferable list of refinement cell candidates
+            virtual labelList refinementCellCandidates() const = 0;
+
+            //- Return transferable list of unrefinement split point candidates
+            virtual labelList unrefinementPointCandidates() const = 0;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

From 4e50ecdd92d6a4896f412dc9e7d68cd465af626b Mon Sep 17 00:00:00 2001
From: Hrvoje Jasak <h.jasak@wikki.co.uk>
Date: Tue, 29 Aug 2023 12:03:13 +0100
Subject: [PATCH 3/7] Changed build order of libraries: optimisation and
 topoChangerFvMesh

---
 src/Allwmake | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/src/Allwmake b/src/Allwmake
index 96071901af..aca4709b25 100755
--- a/src/Allwmake
+++ b/src/Allwmake
@@ -75,7 +75,7 @@ wmake $targetType lagrangian/distributionModels
 parallel/Allwmake $targetType $*
 
 wmake $targetType dynamicFvMesh
-wmake $targetType topoChangerFvMesh
+#HJ wmake $targetType topoChangerFvMesh
 
 wmake $targetType sampling
 transportModels/Allwmake $targetType $*
@@ -130,6 +130,9 @@ wmake $targetType rigidBodyMeshMotion
 wmake $targetType atmosphericModels
 wmake $targetType optimisation/adjointOptimisation/adjoint
 
+# Moved by HJ
+wmake $targetType topoChangerFvMesh
+
 
 # interfaceTracking libs
 dynamicFaMesh/Allwmake $targetType $*

From 4659b66358c1438af9f948b4e7483a273164d5d4 Mon Sep 17 00:00:00 2001
From: Hrvoje Jasak <h.jasak@wikki.co.uk>
Date: Thu, 7 Sep 2023 10:07:24 +0100
Subject: [PATCH 4/7] Bugfix for old cell volume handling

---
 .../polyTopoChangerChangeMesh.C               | 30 +++++++---
 src/finiteVolume/fvMesh/fvMesh.C              | 57 +++++++++++--------
 2 files changed, 55 insertions(+), 32 deletions(-)

diff --git a/src/dynamicMesh/polyTopoChange/polyTopoChanger/polyTopoChangerChangeMesh.C b/src/dynamicMesh/polyTopoChange/polyTopoChanger/polyTopoChangerChangeMesh.C
index 30f2bdce0e..893a28254e 100644
--- a/src/dynamicMesh/polyTopoChange/polyTopoChanger/polyTopoChangerChangeMesh.C
+++ b/src/dynamicMesh/polyTopoChange/polyTopoChanger/polyTopoChangerChangeMesh.C
@@ -257,6 +257,13 @@ Foam::autoPtr<Foam::mapPolyMesh> Foam::polyTopoChanger::changeMesh
     const label nOldFaces = mesh.nFaces();
     const label nOldCells = mesh.nCells();
 
+    // Grab old cell volumes for mpm
+    autoPtr<scalarField> oldCellVolumes
+    (
+        new scalarField(mesh.cellVolumes())
+    );
+    
+    
     // Keep the old patch start labels
     labelList oldPatchStarts(boundary.size());
     forAll (boundary, patchi)
@@ -2168,12 +2175,24 @@ Foam::autoPtr<Foam::mapPolyMesh> Foam::polyTopoChanger::changeMesh
         }
 
         // HJ, HACKED
+        // mesh.resetPrimitives
+        // (
+        //     autoPtr<pointField>(&newPointsZeroVol),
+        //     autoPtr<faceList>(&newFaces),
+        //     autoPtr<labelList>(&allOwn),
+        //     autoPtr<labelList>(&allNei),
+        //     patchSizes,
+        //     patchStarts,
+        //     false         // The mesh is not complete: no parallel comms
+        //                   // HJ, 27/Nov/2009
+        // );
+
         mesh.resetPrimitives
         (
-            autoPtr<pointField>(&newPointsZeroVol),
-            autoPtr<faceList>(&newFaces),
-            autoPtr<labelList>(&allOwn),
-            autoPtr<labelList>(&allNei),
+            autoPtr<pointField>::New(std::move(newPointsZeroVol)),
+            autoPtr<faceList>::New(std::move(newFaces)),
+            autoPtr<labelList>::New(std::move(allOwn)),
+            autoPtr<labelList>::New(std::move(allNei)),
             patchSizes,
             patchStarts,
             false         // The mesh is not complete: no parallel comms
@@ -2314,9 +2333,6 @@ Foam::autoPtr<Foam::mapPolyMesh> Foam::polyTopoChanger::changeMesh
     // of boundary patches
     // HJ, 23/Apr/2018
     // boolList resetPatchFlag(boundary.size(), false);
-
-    // Dummy old cell volumes
-    autoPtr<scalarField> oldCellVolumes;
     
     autoPtr<mapPolyMesh> topoChangeMap
     (
diff --git a/src/finiteVolume/fvMesh/fvMesh.C b/src/finiteVolume/fvMesh/fvMesh.C
index 3b8de62d6a..4643f03b0a 100644
--- a/src/finiteVolume/fvMesh/fvMesh.C
+++ b/src/finiteVolume/fvMesh/fvMesh.C
@@ -1010,34 +1010,41 @@ void Foam::fvMesh::updateMesh(const mapPolyMesh& mpm)
 
     if (VPtr_)
     {
-        // Grab old time volumes if the time has been incremented
-        // This will update V0, V00
-        storeOldVol(mpm.oldCellVolumes());
+        if (mpm.hasOldCellVolumes())
+        {
+            // Grab old time volumes if the time has been incremented
+            // This will update V0, V00
+            storeOldVol(mpm.oldCellVolumes());
 
-        // Few checks
-        if (VPtr_ && (VPtr_->size() != mpm.nOldCells()))
-        {
-            FatalErrorInFunction
-                << "V:" << VPtr_->size()
-                << " not equal to the number of old cells "
-                << mpm.nOldCells()
-                << exit(FatalError);
+            // Few checks
+            if (VPtr_ && (VPtr_->size() != mpm.nOldCells()))
+            {
+                FatalErrorInFunction
+                    << "V:" << VPtr_->size()
+                        << " not equal to the number of old cells "
+                        << mpm.nOldCells()
+                        << exit(FatalError);
+            }
+            if (V0Ptr_ && (V0Ptr_->size() != mpm.nOldCells()))
+            {
+                FatalErrorInFunction
+                    << "V0:" << V0Ptr_->size()
+                        << " not equal to the number of old cells "
+                        << mpm.nOldCells()
+                        << exit(FatalError);
+            }
+            if (V00Ptr_ && (V00Ptr_->size() != mpm.nOldCells()))
+            {
+                FatalErrorInFunction
+                    << "V0:" << V00Ptr_->size()
+                        << " not equal to the number of old cells "
+                        << mpm.nOldCells()
+                        << exit(FatalError);
+            }
         }
-        if (V0Ptr_ && (V0Ptr_->size() != mpm.nOldCells()))
+        else
         {
-            FatalErrorInFunction
-                << "V0:" << V0Ptr_->size()
-                << " not equal to the number of old cells "
-                << mpm.nOldCells()
-                << exit(FatalError);
-        }
-        if (V00Ptr_ && (V00Ptr_->size() != mpm.nOldCells()))
-        {
-            FatalErrorInFunction
-                << "V0:" << V00Ptr_->size()
-                << " not equal to the number of old cells "
-                << mpm.nOldCells()
-                << exit(FatalError);
+            deleteDemandDrivenData(VPtr_);
         }
     }
 

From dcd1ac4a74fb92effeb7ab372dd31541ce27c68c Mon Sep 17 00:00:00 2001
From: Hrvoje Jasak <h.jasak@wikki.co.uk>
Date: Fri, 22 Sep 2023 16:11:00 +0100
Subject: [PATCH 5/7] Added dynamic mesh to scalarTransportFoam

---
 .../solvers/basic/scalarTransportFoam/Make/options  |  7 ++++++-
 .../basic/scalarTransportFoam/scalarTransportFoam.C | 13 ++++++++++++-
 2 files changed, 18 insertions(+), 2 deletions(-)

diff --git a/applications/solvers/basic/scalarTransportFoam/Make/options b/applications/solvers/basic/scalarTransportFoam/Make/options
index acbe7a6475..b0110a45c5 100644
--- a/applications/solvers/basic/scalarTransportFoam/Make/options
+++ b/applications/solvers/basic/scalarTransportFoam/Make/options
@@ -1,10 +1,15 @@
 EXE_INC = \
     -I$(LIB_SRC)/finiteVolume/lnInclude \
     -I$(LIB_SRC)/meshTools/lnInclude \
-    -I$(LIB_SRC)/sampling/lnInclude
+    -I$(LIB_SRC)/sampling/lnInclude \
+    -I$(LIB_SRC)/dynamicMesh/lnInclude \
+    -I$(LIB_SRC)/dynamicFvMesh/lnInclude
 
 EXE_LIBS = \
     -lfiniteVolume \
     -lfvOptions \
     -lmeshTools \
+    -ldynamicMesh \
+    -ldynamicFvMesh \
+    -ltopoChangerFvMesh \
     -lsampling
diff --git a/applications/solvers/basic/scalarTransportFoam/scalarTransportFoam.C b/applications/solvers/basic/scalarTransportFoam/scalarTransportFoam.C
index 6b2f030db8..b97b12b3d8 100644
--- a/applications/solvers/basic/scalarTransportFoam/scalarTransportFoam.C
+++ b/applications/solvers/basic/scalarTransportFoam/scalarTransportFoam.C
@@ -56,6 +56,7 @@ Description
 \*---------------------------------------------------------------------------*/
 
 #include "fvCFD.H"
+#include "dynamicFvMesh.H"
 #include "fvOptions.H"
 #include "simpleControl.H"
 
@@ -71,7 +72,7 @@ int main(int argc, char *argv[])
     #include "addCheckCaseOptions.H"
     #include "setRootCaseLists.H"
     #include "createTime.H"
-    #include "createMesh.H"
+    #include "createDynamicFvMesh.H"
 
     simpleControl simple(mesh);
 
@@ -87,6 +88,16 @@ int main(int argc, char *argv[])
     {
         Info<< "Time = " << runTime.timeName() << nl << endl;
 
+        // Do any mesh changes
+        mesh.controlledUpdate();
+
+        if (mesh.changing())
+        {
+            // Calculate absolute flux
+            // from the mapped surface velocity
+            phi = mesh.Sf() & fvc::interpolate(U);
+        }
+
         while (simple.correctNonOrthogonal())
         {
             fvScalarMatrix TEqn

From 11f3ea8c3242552441b8b261b66f958bece34595 Mon Sep 17 00:00:00 2001
From: Kutalmis Bercin <kutalmis.bercin@esi-group.com>
Date: Mon, 12 Feb 2024 16:54:21 +0000
Subject: [PATCH 6/7] COMP: avoid type conversions ambiguous to Clang

---
 .../minCellSizeRefinement/minCellSizeRefinement.C               | 2 +-
 .../minFaceArea2DRefinement/minFaceArea2DRefinement.C           | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/topoChangerFvMesh/dynamicPolyRefinementFvMesh/refinementSelection/minCellSizeRefinement/minCellSizeRefinement.C b/src/topoChangerFvMesh/dynamicPolyRefinementFvMesh/refinementSelection/minCellSizeRefinement/minCellSizeRefinement.C
index fb1f9d77d3..1e36fc069c 100644
--- a/src/topoChangerFvMesh/dynamicPolyRefinementFvMesh/refinementSelection/minCellSizeRefinement/minCellSizeRefinement.C
+++ b/src/topoChangerFvMesh/dynamicPolyRefinementFvMesh/refinementSelection/minCellSizeRefinement/minCellSizeRefinement.C
@@ -70,7 +70,7 @@ Foam::labelList
 Foam::minCellSizeRefinement::refinementCellCandidates() const
 {
     // Get cell sizes: cube root of cell volume (assuming cube cells)
-    const scalarField cellSize = pow(mesh().V().field(), 1.0/3.0);
+    const scalarField cellSize(pow(mesh().V().field(), 1.0/3.0));
 
     // Create storage for collection of cells. Assume that almost all of the
     // cells will be marked to prevent excessive resizing.
diff --git a/src/topoChangerFvMesh/dynamicPolyRefinementFvMesh/refinementSelection/minFaceArea2DRefinement/minFaceArea2DRefinement.C b/src/topoChangerFvMesh/dynamicPolyRefinementFvMesh/refinementSelection/minFaceArea2DRefinement/minFaceArea2DRefinement.C
index 62c7a8b12a..2551b859ed 100644
--- a/src/topoChangerFvMesh/dynamicPolyRefinementFvMesh/refinementSelection/minFaceArea2DRefinement/minFaceArea2DRefinement.C
+++ b/src/topoChangerFvMesh/dynamicPolyRefinementFvMesh/refinementSelection/minFaceArea2DRefinement/minFaceArea2DRefinement.C
@@ -89,7 +89,7 @@ Foam::labelList
 Foam::minFaceArea2DRefinement::refinementCellCandidates() const
 {
     // Get face areas (from polyMesh)
-    const scalarField faceArea = mag(mesh().faceAreas());
+    const scalarField faceArea(mag(mesh().faceAreas()));
 
     // Mark empty or wedge faces
     boolList faceOnEmptyPatch(mesh().nFaces(), false);

From 66be8e15999fee1677661e4c06f5d6525e37bc77 Mon Sep 17 00:00:00 2001
From: Kutalmis Bercin <kutalmis.bercin@esi-group.com>
Date: Wed, 21 Feb 2024 16:43:50 +0000
Subject: [PATCH 7/7] WIP: extrudeMesh: fix compilation error

---
 .../mesh/generation/extrude/extrudeMesh/extrudeMesh.C     | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/applications/utilities/mesh/generation/extrude/extrudeMesh/extrudeMesh.C b/applications/utilities/mesh/generation/extrude/extrudeMesh/extrudeMesh.C
index aed6edfbea..afd8a4a91c 100644
--- a/applications/utilities/mesh/generation/extrude/extrudeMesh/extrudeMesh.C
+++ b/applications/utilities/mesh/generation/extrude/extrudeMesh/extrudeMesh.C
@@ -43,6 +43,7 @@ Description
 #include "argList.H"
 #include "Time.H"
 #include "polyTopoChange.H"
+#include "batchPolyTopoChange.H"
 #include "polyTopoChanger.H"
 #include "edgeCollapser.H"
 #include "perfectInterface.H"
@@ -1059,7 +1060,8 @@ int main(int argc, char *argv[])
         );
 
         // Topo change container
-        polyTopoChange meshMod(mesh);
+        //polyTopoChange meshMod(mesh);
+        batchPolyTopoChange meshMod(mesh);
 
         perfectStitcher.setRefinement
         (
@@ -1085,7 +1087,9 @@ int main(int argc, char *argv[])
         );
 
         // Construct new mesh from polyTopoChange.
-        autoPtr<mapPolyMesh> map = meshMod.changeMesh(mesh, false);
+        //autoPtr<mapPolyMesh> map = meshMod.changeMesh(mesh, false);
+        polyTopoChanger XXX (mesh, IOobject::NO_READ);
+        autoPtr<mapPolyMesh> map = XXX.changeMesh(mesh, meshMod);
 
         // Update fields
         mesh.updateMesh(map());