From 76d10790e3e49190e16ee49bafa4b4eeb08f7438 Mon Sep 17 00:00:00 2001
From: pkuLmq <1900011062@pku.edu.cn>
Date: Sun, 31 Jul 2022 16:15:55 +0800
Subject: [PATCH 01/10] add AMR

---
 AMR_tidy/Make/files                           |   14 +
 AMR_tidy/Make/options                         |   22 +
 .../dynamicRefineFvMeshNew/dynamicMeshDict    |  152 +
 .../dynamicRefineFvMeshNew.C                  | 1850 +++++++++
 .../dynamicRefineFvMeshNew.H                  |  299 ++
 .../multiCritRefinement.C                     |  637 +++
 .../multiCritRefinement.H                     |  205 +
 AMR_tidy/hexRef/hexRef.C                      | 3619 +++++++++++++++++
 AMR_tidy/hexRef/hexRef.H                      |  665 +++
 AMR_tidy/hexRef/hexRef2/hexRef2.C             | 2177 ++++++++++
 AMR_tidy/hexRef/hexRef2/hexRef2.H             |  226 +
 AMR_tidy/hexRef/hexRef4/hexRef4.C             | 2546 ++++++++++++
 AMR_tidy/hexRef/hexRef4/hexRef4.H             |  215 +
 AMR_tidy/hexRef/hexRef4Axi/hexRef4Axi.C       | 2572 ++++++++++++
 AMR_tidy/hexRef/hexRef4Axi/hexRef4Axi.H       |  215 +
 AMR_tidy/hexRef/hexRef8/hexRef8.C             | 2366 +++++++++++
 AMR_tidy/hexRef/hexRef8/hexRef8.H             |  234 ++
 AMR_tidy/hexRef/hexRefData.C                  |  343 ++
 AMR_tidy/hexRef/hexRefData.H                  |  137 +
 AMR_tidy/hexRef/hexRefNew.C                   |  198 +
 AMR_tidy/hexRef/refinementHistory.C           | 1793 ++++++++
 AMR_tidy/hexRef/refinementHistory.H           |  426 ++
 22 files changed, 20911 insertions(+)
 create mode 100644 AMR_tidy/Make/files
 create mode 100644 AMR_tidy/Make/options
 create mode 100644 AMR_tidy/dynamicRefineFvMeshNew/dynamicMeshDict
 create mode 100644 AMR_tidy/dynamicRefineFvMeshNew/dynamicRefineFvMeshNew.C
 create mode 100644 AMR_tidy/dynamicRefineFvMeshNew/dynamicRefineFvMeshNew.H
 create mode 100644 AMR_tidy/dynamicRefineFvMeshNew/multiCritRefinement.C
 create mode 100644 AMR_tidy/dynamicRefineFvMeshNew/multiCritRefinement.H
 create mode 100644 AMR_tidy/hexRef/hexRef.C
 create mode 100644 AMR_tidy/hexRef/hexRef.H
 create mode 100644 AMR_tidy/hexRef/hexRef2/hexRef2.C
 create mode 100644 AMR_tidy/hexRef/hexRef2/hexRef2.H
 create mode 100644 AMR_tidy/hexRef/hexRef4/hexRef4.C
 create mode 100644 AMR_tidy/hexRef/hexRef4/hexRef4.H
 create mode 100644 AMR_tidy/hexRef/hexRef4Axi/hexRef4Axi.C
 create mode 100644 AMR_tidy/hexRef/hexRef4Axi/hexRef4Axi.H
 create mode 100644 AMR_tidy/hexRef/hexRef8/hexRef8.C
 create mode 100644 AMR_tidy/hexRef/hexRef8/hexRef8.H
 create mode 100644 AMR_tidy/hexRef/hexRefData.C
 create mode 100644 AMR_tidy/hexRef/hexRefData.H
 create mode 100644 AMR_tidy/hexRef/hexRefNew.C
 create mode 100644 AMR_tidy/hexRef/refinementHistory.C
 create mode 100644 AMR_tidy/hexRef/refinementHistory.H

diff --git a/AMR_tidy/Make/files b/AMR_tidy/Make/files
new file mode 100644
index 00000000..66c8f4ce
--- /dev/null
+++ b/AMR_tidy/Make/files
@@ -0,0 +1,14 @@
+hexRef/hexRef.C
+hexRef/hexRefData.C
+hexRef/refinementHistory.C
+hexRef/hexRefNew.C
+
+hexRef/hexRef8/hexRef8.C
+hexRef/hexRef4/hexRef4.C
+hexRef/hexRef4Axi/hexRef4Axi.C
+hexRef/hexRef2/hexRef2.C
+
+dynamicRefineFvMeshNew/multiCritRefinement.C
+dynamicRefineFvMeshNew/dynamicRefineFvMeshNew.C
+
+LIB = $(FOAM_USER_LIBBIN)/libnewdynamicFvMesh
diff --git a/AMR_tidy/Make/options b/AMR_tidy/Make/options
new file mode 100644
index 00000000..7b24eb1f
--- /dev/null
+++ b/AMR_tidy/Make/options
@@ -0,0 +1,22 @@
+EXE_INC = -std=c++14\
+    -I$(LIB_SRC)/triSurface/lnInclude \
+    -I$(LIB_SRC)/meshTools/lnInclude \
+    -I$(LIB_SRC)/dynamicFvMesh/lnInclude \
+    -I$(LIB_SRC)/dynamicMesh/lnInclude \
+    -I$(LIB_SRC)/finiteVolume/lnInclude \
+    -I$(LIB_SRC)/parallel/decompose/decompositionMethods/lnInclude \
+    -I$(LIB_SRC)/finiteVolume/lnInclude \
+    -I$(LIB_SRC)/triSurface/lnInclude \
+    -I$(LIB_SRC)/mesh/extrudeModel/lnInclude
+
+LIB_LIBS = \
+    -ltriSurface \
+    -lmeshTools \
+    -ldynamicMesh \
+    -ldynamicFvMesh \
+    -lfiniteVolume \
+    -lextrudeModel \
+    -ldecompositionMethods \
+    -L$(FOAM_LIBBIN)/dummy \
+    -lmetisDecomp -lptscotchDecomp -lscotchDecomp
+    
diff --git a/AMR_tidy/dynamicRefineFvMeshNew/dynamicMeshDict b/AMR_tidy/dynamicRefineFvMeshNew/dynamicMeshDict
new file mode 100644
index 00000000..7c020ccd
--- /dev/null
+++ b/AMR_tidy/dynamicRefineFvMeshNew/dynamicMeshDict
@@ -0,0 +1,152 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  dev                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    object      dynamicMeshDict;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+dynamicFvMesh      dynamicRefineFvMesh;
+// dynamicFvMesh    staticFvMesh;
+
+multiCritRefinementControls
+{
+    enableMultiCritRefinementControl  true;
+    
+    fields // must be scalarFields
+    (
+        //alpha (min max refineLevel)
+        // refine cells where alpha in [0.01:0.99] with maximal 2 refinement layers
+        alpha.water
+        {
+            minValue  0.01;
+            maxValue  0.99;
+            refineLevel 2;
+            nAddLayers  2; // add two cell layers at the refinement border
+        }
+    );
+    
+    interface // must be a scalarField (only one dictionary!)
+    (
+        alpha.water // refine interface (found based on snGrad of alpha > 0.1) 
+        {
+            innerRefLayers 2; // describes how many cell layers inside phase alpha are to be refined
+            outerRefLayers 5; // describes how many cell layers outside phase alpha are to be refined
+            
+            // optional settings:
+            maxRefineLevel 4; // max refinement layers; Default: maxRefinement from dynamicRefineFvMeshCoeffs is used
+            // to get slower than 2:1 refinement; add #nAddLayers between each refinement level at the interface
+            nAddLayers 1; //Default: 0 
+        }
+    );
+    
+    gradients // must be scalars
+    (
+        // arguments as in 'fields'
+        // min/max values are based on mag(fvc::grad(volScalarField)) * cellVolume
+        O2_1
+        {
+            fielName O2;   //default: dictName -> 02_1
+            minValue 1.5;
+            maxValue 3.0;
+            refineLevel 1;
+            nAddLayers 0;  //default: 0
+        }
+
+        O2_2
+        {
+            fielName O2;
+            minValue 1.75;
+            maxValue 2.5;
+            refineLevel 2;
+            nAddLayers 0;  //default: 0
+        }
+    );
+    
+    curls // must be vectors
+    (
+        // arguments as in 'fields'
+        // min/max values are based on mag(fvc::curl(volVectorField))
+        U   (0.5 1 2)
+        { 
+            minValue 0.5;
+            maxValue 1.0;
+            refineLevel 2;
+            nAddLayers 0;  //default: 0
+        }
+    );
+    
+    regions
+    (
+        boxToCell
+        {
+            minLevel 1;
+            
+            box (-1 0.001 0.002)(1 0.005 0.003);
+        }
+        
+    );
+}
+
+// Refinement
+dynamicRefineFvMeshCoeffs
+{
+    // Refine every refineInterval timesteps
+    refineInterval 3;
+
+    // Maximum refinement level (starts from 0)
+    maxRefinement 3;
+
+    // Maximum cell limit (approximate)
+    maxCells 1000000;
+
+                   
+    field gamma;    // volScalarField to base refinement on, or
+                    // multiCritRefinementField; 
+                    // to use multiple criteria specified in 
+                    // multiCritRefinementControls
+
+    // Which cells to un/refine: based on point values (simple averaging).
+    // - refine pointCells of point value inbetween minLevel..maxLevel
+    // - unrefine pointCells that are within nBufferLayers of points marked
+    //   for refinement.
+    minLevel 0.01;
+    maxLevel 0.99;
+
+    nBufferLayers 4;
+
+    // Refine field inbetween lower..upper
+    lowerRefineLevel 0.5; // do not change
+    upperRefineLevel 3.5; // maxRefinement+0.5
+    unrefineLevel   -0.5;  // If value < unrefineLevel unrefine
+
+    // Newly introduced patch points optionally get projected onto a surface
+    //projectSurfaces ("fixedWalls4.stl");
+    //projectPatches (fixedWalls);
+    // Maximum project distance
+    //projectDistance 1;
+
+    // Fluxes to adapt. For newly created faces or split faces the flux
+    // gets estimated from an interpolated volVectorField ('velocity')
+    // First is name of the flux to adapt, second is velocity that will
+    // be interpolated and inner-producted with the face area vector.
+    correctFluxes ((phi U));
+
+    // List of non-flux surface<Type>Fields to be mapped
+    // only for new internal faces (AMR refine)
+    mapSurfaceFields
+    (
+        Uf
+        Uf_0
+    );
+}
+
+// ************************************************************************* //
diff --git a/AMR_tidy/dynamicRefineFvMeshNew/dynamicRefineFvMeshNew.C b/AMR_tidy/dynamicRefineFvMeshNew/dynamicRefineFvMeshNew.C
new file mode 100644
index 00000000..d1548a60
--- /dev/null
+++ b/AMR_tidy/dynamicRefineFvMeshNew/dynamicRefineFvMeshNew.C
@@ -0,0 +1,1850 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "dynamicRefineFvMeshNew.H"
+#include "addToRunTimeSelectionTable.H"
+#include "surfaceInterpolate.H"
+#include "volFields.H"
+#include "polyTopoChange.H"
+#include "surfaceFields.H"
+#include "syncTools.H"
+#include "pointFields.H"
+#include "sigFpe.H"
+#include "cellSet.H"
+#include "wedgePolyPatch.H"
+#include "emptyPolyPatch.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(dynamicRefineFvMeshNew, 0);
+    addToRunTimeSelectionTable(dynamicFvMesh, dynamicRefineFvMeshNew, IOobject);
+
+
+    // Helper class for accessing max cell level of faces accross processor patches
+    template<class Type>
+    class combineMaxOp
+    {
+        public:
+        void operator()(Type& x, const Type& y) const
+        {
+            x = max(x, y);
+        }
+    };
+}
+
+// * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
+
+Foam::label Foam::dynamicRefineFvMeshNew::count
+(
+    const PackedBoolList& l,
+    const unsigned int val
+)
+{
+    label n = 0;
+    forAll(l, i)
+    {
+        if (l.get(i) == val)
+        {
+            n++;
+        }
+
+        // debug also serves to get-around Clang compiler trying to optimsie
+        // out this forAll loop under O3 optimisation
+        if (debug)
+        {
+            Info<< "n=" << n << endl;
+        }
+    }
+
+    return n;
+}
+
+
+void Foam::dynamicRefineFvMeshNew::calculateProtectedCells
+(
+    PackedBoolList& unrefineableCell
+) const
+{
+    if (protectedCell_.empty())
+    {
+        unrefineableCell.clear();
+        return;
+    }
+
+    const labelList& cellLevel = meshCutter_->cellLevel();
+
+    unrefineableCell = protectedCell_;
+
+    // Get neighbouring cell level
+    labelList neiLevel(nFaces()-nInternalFaces());
+
+    for (label facei = nInternalFaces(); facei < nFaces(); facei++)
+    {
+        neiLevel[facei-nInternalFaces()] = cellLevel[faceOwner()[facei]];
+    }
+    syncTools::swapBoundaryFaceList(*this, neiLevel);
+
+
+    while (true)
+    {
+        // Pick up faces on border of protected cells
+        boolList seedFace(nFaces(), false);
+
+        forAll(faceNeighbour(), facei)
+        {
+            label own = faceOwner()[facei];
+            bool ownProtected = unrefineableCell.get(own);
+            label nei = faceNeighbour()[facei];
+            bool neiProtected = unrefineableCell.get(nei);
+
+            if (ownProtected && (cellLevel[nei] > cellLevel[own]))
+            {
+                seedFace[facei] = true;
+            }
+            else if (neiProtected && (cellLevel[own] > cellLevel[nei]))
+            {
+                seedFace[facei] = true;
+            }
+        }
+        for (label facei = nInternalFaces(); facei < nFaces(); facei++)
+        {
+            label own = faceOwner()[facei];
+            bool ownProtected = unrefineableCell.get(own);
+            if
+            (
+                ownProtected
+             && (neiLevel[facei-nInternalFaces()] > cellLevel[own])
+            )
+            {
+                seedFace[facei] = true;
+            }
+        }
+
+        syncTools::syncFaceList(*this, seedFace, orEqOp<bool>());
+
+
+        // Extend unrefineableCell
+        bool hasExtended = false;
+
+        for (label facei = 0; facei < nInternalFaces(); facei++)
+        {
+            if (seedFace[facei])
+            {
+                label own = faceOwner()[facei];
+                if (unrefineableCell.get(own) == 0)
+                {
+                    unrefineableCell.set(own, 1);
+                    hasExtended = true;
+                }
+
+                label nei = faceNeighbour()[facei];
+                if (unrefineableCell.get(nei) == 0)
+                {
+                    unrefineableCell.set(nei, 1);
+                    hasExtended = true;
+                }
+            }
+        }
+        for (label facei = nInternalFaces(); facei < nFaces(); facei++)
+        {
+            if (seedFace[facei])
+            {
+                label own = faceOwner()[facei];
+                if (unrefineableCell.get(own) == 0)
+                {
+                    unrefineableCell.set(own, 1);
+                    hasExtended = true;
+                }
+            }
+        }
+
+        if (!returnReduce(hasExtended, orOp<bool>()))
+        {
+            break;
+        }
+    }
+}
+
+
+void Foam::dynamicRefineFvMeshNew::readDict()
+{
+    dictionary refineDict
+    (
+        IOdictionary
+        (
+            IOobject
+            (
+                "dynamicMeshDict",
+                time().constant(),
+                *this,
+                IOobject::MUST_READ_IF_MODIFIED,
+                IOobject::NO_WRITE,
+                false
+            )
+        ).subDict(typeName + "Coeffs")
+    );
+
+    List<Pair<word>> fluxVelocities = List<Pair<word>>
+    (
+        refineDict.lookup("correctFluxes")
+    );
+    // Rework into hashtable.
+    correctFluxes_.resize(fluxVelocities.size());
+    forAll(fluxVelocities, i)
+    {
+        correctFluxes_.insert(fluxVelocities[i][0], fluxVelocities[i][1]);
+    };
+
+    if (refineDict.found("mapSurfaceFields"))
+    {
+        List<word> surfFlds = List<word>
+        (
+            refineDict.lookup("mapSurfaceFields")
+        );
+        // Rework into hashtable.
+        correctFluxes_.resize(surfFlds.size());
+        forAll(surfFlds, i)
+        {
+            mapSurfaceFields_.insert(surfFlds[i], surfFlds[i]);
+        };
+    }
+
+    dumpLevel_ = Switch(refineDict.lookup("dumpLevel"));
+}
+
+
+// Refines cells, maps fields and recalculates (an approximate) flux
+Foam::autoPtr<Foam::mapPolyMesh>
+Foam::dynamicRefineFvMeshNew::refine
+(
+    const labelList& cellsToRefine
+)
+{
+    // Mesh changing engine.
+    polyTopoChange meshMod(*this);
+
+    // Play refinement commands into mesh changer.
+    meshCutter_->setRefinement(cellsToRefine, meshMod);
+
+    // Create mesh (with inflation), return map from old to new mesh.
+    //autoPtr<mapPolyMesh> map = meshMod.changeMesh(*this, true);
+    autoPtr<mapPolyMesh> map = meshMod.changeMesh(*this, false);
+
+    Info<< "Refined from "
+        << returnReduce(map().nOldCells(), sumOp<label>())
+        << " to " << globalData().nTotalCells() << " cells." << endl;
+
+    if (debug)
+    {
+        // Check map.
+        for (label facei = 0; facei < nInternalFaces(); facei++)
+        {
+            label oldFacei = map().faceMap()[facei];
+
+            if (oldFacei >= nInternalFaces())
+            {
+                FatalErrorInFunction
+                    << "New internal face:" << facei
+                    << " fc:" << faceCentres()[facei]
+                    << " originates from boundary oldFace:" << oldFacei
+                    << abort(FatalError);
+            }
+        }
+    }
+
+    //    // Remove the stored tet base points
+    //    tetBasePtIsPtr_.clear();
+    //    // Remove the cell tree
+    //    cellTreePtr_.clear();
+
+    // Update fields
+    updateMesh(map);
+    
+
+
+    // Move mesh
+    /*
+    pointField newPoints;
+    if (map().hasMotionPoints())
+    {
+        newPoints = map().preMotionPoints();
+    }
+    else
+    {
+        newPoints = points();
+    }
+    movePoints(newPoints);
+    */
+
+    // Correct the flux for modified/added faces. All the faces which only
+    // have been renumbered will already have been handled by the mapping.
+    {
+        const labelList& faceMap = map().faceMap();
+        const labelList& reverseFaceMap = map().reverseFaceMap();
+
+        // Storage for any master faces. These will be the original faces
+        // on the coarse cell that get split into four (or rather the
+        // master face gets modified and three faces get added from the master)
+        labelHashSet masterFaces(4*cellsToRefine.size());
+
+
+        forAll(faceMap, facei)
+        {
+            label oldFacei = faceMap[facei];
+
+            if (oldFacei >= 0)
+            {
+                label masterFacei = reverseFaceMap[oldFacei];
+
+                if (masterFacei < 0)
+                {
+                    FatalErrorInFunction
+                        << "Problem: should not have removed faces"
+                        << " when refining."
+                        << nl << "face:" << facei << abort(FatalError);
+                }
+                else if (masterFacei != facei)
+                {
+                    masterFaces.insert(masterFacei);
+                }
+            }
+        }
+
+        if (debug)
+        {
+            Pout<< "Found " << masterFaces.size() << " split faces " << endl;
+        }
+
+        HashTable<surfaceScalarField*> fluxes
+        (
+            lookupClass<surfaceScalarField>()
+        );
+
+        forAllIter(HashTable<surfaceScalarField*>, fluxes, iter)
+        {
+            if (!correctFluxes_.found(iter.key()))
+            {
+                WarningInFunction
+                    << "Cannot find surfaceScalarField " << iter.key()
+                    << " in user-provided flux mapping table "
+                    << correctFluxes_ << endl
+                    << "    The flux mapping table is used to recreate the"
+                    << " flux on newly created faces." << endl
+                    << "    Either add the entry if it is a flux or use ("
+                    << iter.key() << " none) to suppress this warning."
+                    << endl;
+                continue;
+            }
+
+            const word& UName = correctFluxes_[iter.key()];
+
+            if (UName == "none")
+            {
+                continue;
+            }
+
+            if (UName == "NaN")
+            {
+                Pout<< "Setting surfaceScalarField " << iter.key()
+                    << " to NaN" << endl;
+
+                surfaceScalarField& phi = *iter();
+
+                sigFpe::fillNan(phi.primitiveFieldRef());
+
+                continue;
+            }
+
+            if (debug)
+            {
+                Pout<< "Mapping flux " << iter.key()
+                    << " using interpolated flux " << UName
+                    << endl;
+            }
+
+            surfaceScalarField& phi = *iter();
+            const surfaceScalarField phiU
+            (
+                fvc::interpolate
+                (
+                    lookupObject<volVectorField>(UName)
+                )
+              & Sf()
+            );
+
+            // Recalculate new internal faces.
+            for (label facei = 0; facei < nInternalFaces(); facei++)
+            {
+                label oldFacei = faceMap[facei];
+
+                if (oldFacei == -1)
+                {
+                    // Inflated/appended
+                    phi[facei] = phiU[facei];
+                }
+                else if (reverseFaceMap[oldFacei] != facei)
+                {
+                    // face-from-masterface
+                    phi[facei] = phiU[facei];
+                }
+            }
+
+            // Recalculate new boundary faces.
+            surfaceScalarField::Boundary& phiBf =
+                phi.boundaryFieldRef();
+            forAll(phiBf, patchi)
+            {
+                fvsPatchScalarField& patchPhi = phiBf[patchi];
+                const fvsPatchScalarField& patchPhiU =
+                    phiU.boundaryField()[patchi];
+
+                label facei = patchPhi.patch().start();
+
+                forAll(patchPhi, i)
+                {
+                    label oldFacei = faceMap[facei];
+
+                    if (oldFacei == -1)
+                    {
+                        // Inflated/appended
+                        patchPhi[i] = patchPhiU[i];
+                    }
+                    else if (reverseFaceMap[oldFacei] != facei)
+                    {
+                        // face-from-masterface
+                        patchPhi[i] = patchPhiU[i];
+                    }
+
+                    facei++;
+                }
+            }
+
+            // Update master faces
+            forAllConstIter(labelHashSet, masterFaces, iter)
+            {
+                label facei = iter.key();
+
+                if (isInternalFace(facei))
+                {
+                    phi[facei] = phiU[facei];
+                }
+                else
+                {
+                    label patchi = boundaryMesh().whichPatch(facei);
+
+                    if (!isA<emptyPolyPatch>(boundaryMesh()[patchi]))
+                    {
+                        label i = facei - boundaryMesh()[patchi].start();
+
+                        const fvsPatchScalarField& patchPhiU =
+                            phiU.boundaryField()[patchi];
+
+                        fvsPatchScalarField& patchPhi = phiBf[patchi];
+
+                        patchPhi[i] = patchPhiU[i];
+                    }
+                }
+            }
+        }
+    }
+
+    //- map non-flux surface<Type>Fields for newly created internal faces
+    const labelList& faceMap = map().faceMap();
+    mapNewInternalFaces<scalar>( faceMap );
+    mapNewInternalFaces<vector>( faceMap );
+
+    // Update numbering of cells/vertices.
+    meshCutter_->updateMesh(map);
+
+    // Update numbering of protectedCell_
+    if (protectedCell_.size())
+    {
+        PackedBoolList newProtectedCell(nCells());
+
+        forAll(newProtectedCell, celli)
+        {
+            label oldCelli = map().cellMap()[celli];
+            newProtectedCell.set(celli, protectedCell_.get(oldCelli));
+        }
+        protectedCell_.transfer(newProtectedCell);
+    }
+
+    // Debug: Check refinement levels (across faces only)
+    meshCutter_->checkRefinementLevels(-1, labelList(0));
+
+    return map;
+}
+
+
+Foam::autoPtr<Foam::mapPolyMesh>
+Foam::dynamicRefineFvMeshNew::unrefine
+(
+    const labelList& splitElems
+)
+{
+    polyTopoChange meshMod(*this);
+
+    // Play refinement commands into mesh changer.
+    meshCutter_->setUnrefinement(splitElems, meshMod);
+
+
+    // Save information on faces that will be combined
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    // Find the faceMidPoints on cells to be combined.
+    // for each face resulting of split of face into four store the
+    // midpoint
+    Map<label> faceToSplitPoint(0);
+    meshCutter_->calcFaceToSplitPoint(splitElems, faceToSplitPoint);
+
+
+    // Change mesh and generate map.
+    //autoPtr<mapPolyMesh> map = meshMod.changeMesh(*this, true);
+    autoPtr<mapPolyMesh> map = meshMod.changeMesh(*this, false);
+
+    Info<< "Unrefined from "
+        << returnReduce(map().nOldCells(), sumOp<label>())
+        << " to " << globalData().nTotalCells() << " cells."
+        << endl;
+
+    // Update fields
+    updateMesh(map);
+
+
+    // Move mesh
+    /*
+    pointField newPoints;
+    if (map().hasMotionPoints())
+    {
+        newPoints = map().preMotionPoints();
+    }
+    else
+    {
+        newPoints = points();
+    }
+    movePoints(newPoints);
+    */
+
+    // Correct the flux for modified faces.
+    {
+        const labelList& reversePointMap = map().reversePointMap();
+        const labelList& reverseFaceMap = map().reverseFaceMap();
+
+        HashTable<surfaceScalarField*> fluxes
+        (
+            lookupClass<surfaceScalarField>()
+        );
+
+        forAllIter(HashTable<surfaceScalarField*>, fluxes, iter)
+        {
+            if (!correctFluxes_.found(iter.key()))
+            {
+                WarningInFunction
+                    << "Cannot find surfaceScalarField " << iter.key()
+                    << " in user-provided flux mapping table "
+                    << correctFluxes_ << endl
+                    << "    The flux mapping table is used to recreate the"
+                    << " flux on newly created faces." << endl
+                    << "    Either add the entry if it is a flux or use ("
+                    << iter.key() << " none) to suppress this warning."
+                    << endl;
+                continue;
+            }
+
+            const word& UName = correctFluxes_[iter.key()];
+
+            if (UName == "none")
+            {
+                continue;
+            }
+
+            if (debug)
+            {
+                Info<< "Mapping flux " << iter.key()
+                    << " using interpolated flux " << UName
+                    << endl;
+            }
+
+            surfaceScalarField& phi = *iter();
+            surfaceScalarField::Boundary& phiBf =
+                phi.boundaryFieldRef();
+
+            const surfaceScalarField phiU
+            (
+                fvc::interpolate
+                (
+                    lookupObject<volVectorField>(UName)
+                )
+              & Sf()
+            );
+
+
+            forAllConstIter(Map<label>, faceToSplitPoint, iter)
+            {
+                label oldFacei = iter.key();
+                label oldPointi = iter();
+
+                if (reversePointMap[oldPointi] < 0)
+                {
+                    // midpoint was removed. See if face still exists.
+                    label facei = reverseFaceMap[oldFacei];
+
+                    if (facei >= 0)
+                    {
+                        if (isInternalFace(facei))
+                        {
+                            phi[facei] = phiU[facei];
+                        }
+                        else
+                        {
+                            label patchi = boundaryMesh().whichPatch(facei);
+
+                            if (!isA<emptyPolyPatch>(boundaryMesh()[patchi]))
+                            {
+                                label i = facei - boundaryMesh()[patchi].start();
+
+                                const fvsPatchScalarField& patchPhiU =
+                                    phiU.boundaryField()[patchi];
+                                fvsPatchScalarField& patchPhi = phiBf[patchi];
+                                patchPhi[i] = patchPhiU[i];
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+
+    // Update numbering of cells/vertices.
+    meshCutter_->updateMesh(map);
+
+    // Update numbering of protectedCell_
+    if (protectedCell_.size())
+    {
+        PackedBoolList newProtectedCell(nCells());
+
+        forAll(newProtectedCell, celli)
+        {
+            label oldCelli = map().cellMap()[celli];
+            if (oldCelli >= 0)
+            {
+                newProtectedCell.set(celli, protectedCell_.get(oldCelli));
+            }
+        }
+        protectedCell_.transfer(newProtectedCell);
+    }
+
+    // Debug: Check refinement levels (across faces only)
+    meshCutter_->checkRefinementLevels(-1, labelList(0));
+
+    return map;
+}
+
+
+Foam::scalarField
+Foam::dynamicRefineFvMeshNew::maxPointField(const scalarField& pFld) const
+{
+    scalarField vFld(nCells(), -GREAT);
+
+    forAll(pointCells(), pointi)
+    {
+        const labelList& pCells = pointCells()[pointi];
+
+        forAll(pCells, i)
+        {
+            vFld[pCells[i]] = max(vFld[pCells[i]], pFld[pointi]);
+        }
+    }
+    return vFld;
+}
+
+Foam::scalarField
+Foam::dynamicRefineFvMeshNew::maxCellField(const volScalarField& vFld) const
+{
+    scalarField pFld(nPoints(), -GREAT);
+
+    forAll(pointCells(), pointi)
+    {
+        const labelList& pCells = pointCells()[pointi];
+
+        forAll(pCells, i)
+        {
+            pFld[pointi] = max(pFld[pointi], vFld[pCells[i]]);
+        }
+    }
+    return pFld;
+}
+
+/*
+Foam::scalarField
+Foam::dynamicRefineFvMeshNew::minCellField(const volScalarField& vFld) const
+{
+    scalarField pFld(nPoints(), -GREAT);
+
+    forAll(pointCells(), pointi)
+    {
+        const labelList& pCells = pointCells()[pointi];
+
+        forAll(pCells, i)
+        {
+            pFld[pointi] = max(pFld[pointi], vFld[pCells[i]]);
+        }
+    }
+    return pFld;
+}
+*/
+
+// Simple (non-parallel) interpolation by averaging.
+Foam::scalarField
+Foam::dynamicRefineFvMeshNew::cellToPoint(const scalarField& vFld) const
+{
+    scalarField pFld(nPoints());
+
+    forAll(pointCells(), pointi)
+    {
+        const labelList& pCells = pointCells()[pointi];
+
+        scalar sum = 0.0;
+        forAll(pCells, i)
+        {
+            sum += vFld[pCells[i]];
+        }
+        pFld[pointi] = sum/pCells.size();
+    }
+    return pFld;
+}
+
+
+Foam::scalarField Foam::dynamicRefineFvMeshNew::error
+(
+    const scalarField& fld,
+    const scalar minLevel,
+    const scalar maxLevel
+) const
+{
+    scalarField c(fld.size(), -1);
+
+    forAll(fld, i)
+    {
+        scalar err = min(fld[i]-minLevel, maxLevel-fld[i]);
+
+        if (err >= 0)
+        {
+            c[i] = err;
+        }
+    }
+    return c;
+}
+
+
+void Foam::dynamicRefineFvMeshNew::selectRefineCandidates
+(
+    const scalar lowerRefineLevel,
+    const scalar upperRefineLevel,
+    const scalarField& vFld,
+    PackedBoolList& candidateCell
+) const
+{
+////////////////////////////////////////////////////////////////////////
+// Batzdorf
+/* 
+    //-
+    // Get error per cell. Is -1 (not to be refined) to >0 (to be refined,
+    // higher more desirable to be refined).
+    scalarField cellError
+    (
+        maxPointField
+        (
+            error
+            (
+                cellToPoint(vFld),
+                lowerRefineLevel,
+                upperRefineLevel
+            )
+        )
+    );
+
+    // Mark cells that are candidates for refinement.
+    forAll(cellError, celli)
+    {
+        if (cellError[celli] > 0)
+        {
+            candidateCell.set(celli, 1);
+        }
+    }
+*/
+    //+
+    forAll(vFld, cellI)
+    {
+        if ((vFld[cellI] >= lowerRefineLevel) && (vFld[cellI] <= upperRefineLevel))
+        {
+            candidateCell.set(cellI, 1);
+        }
+    }
+////////////////////////////////////////////////////////////////////////  
+}
+
+
+Foam::labelList Foam::dynamicRefineFvMeshNew::selectRefineCells
+(
+    const label maxCells,
+    const label maxRefinement,
+    const PackedBoolList& candidateCell
+) const
+{
+    // Every refined cell causes 7 extra cells
+    label nTotToRefine = (maxCells - globalData().nTotalCells()) / 7;
+
+    const labelList& cellLevel = meshCutter_->cellLevel();
+
+    // Mark cells that cannot be refined since they would trigger refinement
+    // of protected cells (since 2:1 cascade)
+    PackedBoolList unrefineableCell;
+    calculateProtectedCells(unrefineableCell);
+
+    // Count current selection
+    label nLocalCandidates = count(candidateCell, 1);
+    label nCandidates = returnReduce(nLocalCandidates, sumOp<label>());
+
+    // Collect all cells
+    DynamicList<label> candidates(nLocalCandidates);
+
+    if (nCandidates < nTotToRefine)
+    {
+        forAll(candidateCell, celli)
+        {
+            if
+            (
+                cellLevel[celli] < maxRefinement
+             && candidateCell.get(celli)
+             && (
+                    unrefineableCell.empty()
+                 || !unrefineableCell.get(celli)
+                )
+            )
+            {
+                candidates.append(celli);
+            }
+        }
+    }
+    else
+    {
+        // Sort by error? For now just truncate.
+        for (label level = 0; level < maxRefinement; level++)
+        {
+            forAll(candidateCell, celli)
+            {
+                if
+                (
+                    cellLevel[celli] == level
+                 && candidateCell.get(celli)
+                 && (
+                        unrefineableCell.empty()
+                     || !unrefineableCell.get(celli)
+                    )
+                )
+                {
+                    candidates.append(celli);
+                }
+            }
+
+            if (returnReduce(candidates.size(), sumOp<label>()) > nTotToRefine)
+            {
+                break;
+            }
+        }
+    }
+
+    // Guarantee 2:1 refinement after refinement
+    labelList consistentSet
+    (
+        meshCutter_->consistentRefinement
+        (
+            candidates.shrink(),
+            true               // Add to set to guarantee 2:1
+        )
+    );
+
+    Info<< "Selected " << returnReduce(consistentSet.size(), sumOp<label>())
+        << " cells for refinement out of " << globalData().nTotalCells()
+        << "." << endl;
+
+    return consistentSet;
+}
+
+// YO- This is here only to preserve compatibility with the official release.
+//     It is not used by the refinement procedure, but some utilities such as
+//     decomposePar rely on it.
+Foam::labelList Foam::dynamicRefineFvMeshNew::selectUnrefinePoints
+(
+    const scalar unrefineLevel,
+    const PackedBoolList& markedCell,
+    const scalarField& pFld
+) const
+{
+    // All points that can be unrefined
+    const labelList splitPoints(meshCutter_->getSplitElems());
+
+    DynamicList<label> newSplitPoints(splitPoints.size());
+
+    forAll(splitPoints, i)
+    {
+        label pointi = splitPoints[i];
+
+        if (pFld[pointi] < unrefineLevel)
+        {
+            // Check that all cells are not marked
+            const labelList& pCells = pointCells()[pointi];
+
+            bool hasMarked = false;
+
+            forAll(pCells, pCelli)
+            {
+                if (markedCell.get(pCells[pCelli]))
+                {
+                    hasMarked = true;
+                    break;
+                }
+            }
+
+            if (!hasMarked)
+            {
+                newSplitPoints.append(pointi);
+            }
+        }
+    }
+
+
+    newSplitPoints.shrink();
+
+    // Guarantee 2:1 refinement after unrefinement
+    labelList consistentSet
+    (
+        meshCutter_->consistentUnrefinement
+        (
+            newSplitPoints,
+            false
+        )
+    );
+    Info<< "Selected " << returnReduce(consistentSet.size(), sumOp<label>())
+        << " split points out of a possible "
+        << returnReduce(splitPoints.size(), sumOp<label>())
+        << "." << endl;
+
+    return consistentSet;
+}
+//-YO
+
+void Foam::dynamicRefineFvMeshNew::extendMarkedCells
+(
+    PackedBoolList& markedCell
+) const
+{
+    // Mark faces using any marked cell
+    boolList markedFace(nFaces(), false);
+
+    forAll(markedCell, celli)
+    {
+        if (markedCell.get(celli))
+        {
+            const cell& cFaces = cells()[celli];
+
+            forAll(cFaces, i)
+            {
+                markedFace[cFaces[i]] = true;
+            }
+        }
+    }
+
+    syncTools::syncFaceList(*this, markedFace, orEqOp<bool>());
+
+    // Update cells using any markedFace
+    for (label facei = 0; facei < nInternalFaces(); facei++)
+    {
+        if (markedFace[facei])
+        {
+            markedCell.set(faceOwner()[facei], 1);
+            markedCell.set(faceNeighbour()[facei], 1);
+        }
+    }
+    for (label facei = nInternalFaces(); facei < nFaces(); facei++)
+    {
+        if (markedFace[facei])
+        {
+            markedCell.set(faceOwner()[facei], 1);
+        }
+    }
+}
+
+
+void Foam::dynamicRefineFvMeshNew::checkEightAnchorPoints
+(
+    PackedBoolList& protectedCell,
+    label& nProtected
+) const
+{
+    const labelList& cellLevel = meshCutter_->cellLevel();
+    const labelList& pointLevel = meshCutter_->pointLevel();
+
+    labelList nAnchorPoints(nCells(), 0);
+
+    forAll(pointLevel, pointi)
+    {
+        const labelList& pCells = pointCells(pointi);
+
+        forAll(pCells, pCelli)
+        {
+            label celli = pCells[pCelli];
+
+            if (pointLevel[pointi] <= cellLevel[celli])
+            {
+                // Check if cell has already 8 anchor points -> protect cell
+                if (nAnchorPoints[celli] == 8)
+                {
+                    if (protectedCell.set(celli, true))
+                    {
+                        nProtected++;
+                    }
+                }
+
+                if (!protectedCell[celli])
+                {
+                    nAnchorPoints[celli]++;
+                }
+            }
+        }
+    }
+
+
+    forAll(protectedCell, celli)
+    {
+        if (!protectedCell[celli] && nAnchorPoints[celli] != 8)
+        {
+            protectedCell.set(celli, true);
+            nProtected++;
+        }
+    }
+}
+
+
+template <class T>
+void Foam::dynamicRefineFvMeshNew::mapNewInternalFaces
+(
+    const labelList& faceMap
+)
+{
+    typedef GeometricField<T, fvsPatchField, surfaceMesh> GeoField;
+    HashTable< GeoField*> sFlds(this->objectRegistry::lookupClass<GeoField>());
+
+    const unallocLabelList& owner = this->owner();
+    const unallocLabelList& neighbour = this->neighbour();
+    const dimensionedScalar deltaN = 1e-8 / pow(average(this->V()), 1.0 / 3.0);
+
+    forAllIter(typename HashTable<GeoField*>, sFlds, iter)
+    {
+
+        GeoField& sFld = *iter();
+        if (mapSurfaceFields_.found(iter.key()))
+        {   
+            if (debug)
+            {
+                Info << "dynamicRefineFvMeshNew::mapNewInternalFaces(): " <<iter.key()<< endl;
+            }
+
+            Field<T> tsFld(this->nFaces(), pTraits<T>::zero);
+            forAll(sFld.internalField(), iFace)
+            {
+                tsFld[iFace] = sFld.internalField()[iFace];
+            }
+            forAll(sFld.boundaryField(), iPatch)
+            {
+                label globalIdx = this->boundaryMesh()[iPatch].start();
+                forAll(sFld.boundaryField()[iPatch], facei)
+                {
+                    tsFld[facei+globalIdx] = sFld.boundaryField()[iPatch][facei];
+                }
+            }
+
+            //- loop over all faces
+            for (label facei = 0; facei < nInternalFaces(); facei++)
+            {
+                label oldFacei = faceMap[facei];
+
+                //- map surface field on newly generated faces
+                if (oldFacei == -1)
+                {
+                    //- find owner and neighbour cell
+                    cell faceOwner = this->cells()[owner[facei]];
+                    cell faceNeighbour = this->cells()[neighbour[facei]];
+
+                    //- loop over all owner/neighbour cell faces
+                    //- and find already mapped ones (master-faces):
+                    T tmpValue = pTraits<T>::zero;
+                    scalar magFld = 0;
+                    label counter = 0;
+
+                    //- simple averaging of all neighbour master-faces
+                    forAll(faceOwner, iFace)
+                    {
+                        //- faces on empty patches are not counted
+                        label facePatchId = boundaryMesh().whichPatch(faceOwner[iFace]);
+                        bool isNonEmptyBoundFace = !( this->boundaryMesh()[0].start() < faceOwner[iFace]  
+                                                 && isA<emptyPolyPatch>(boundaryMesh()[facePatchId]));
+
+                        //- is master face and not on empty boundary
+                        if ( faceMap[faceOwner[iFace]] != -1 && isNonEmptyBoundFace)
+                        {
+
+                            tmpValue += tsFld[faceOwner[iFace]];
+                            magFld += mag(tsFld[faceOwner[iFace]]);
+                            counter++;
+                        }
+                    }
+
+                    forAll(faceNeighbour, iFace)
+                    {
+                        //- faces on empty patches are not counted
+                        label facePatchId = boundaryMesh().whichPatch(faceNeighbour[iFace]);
+                        bool isNonEmptyBoundFace = !( this->boundaryMesh()[0].start() < faceNeighbour[iFace]  
+                                                 && isA<emptyPolyPatch>(boundaryMesh()[facePatchId]));
+
+                        //- is master face and not on empty boundary
+                        if ( faceMap[faceNeighbour[iFace]] != -1 && isNonEmptyBoundFace)
+                        {
+
+                            tmpValue = tmpValue + tsFld[faceNeighbour[iFace]];
+                            magFld += mag(tsFld[faceNeighbour[iFace]]);
+                            counter++;
+                        }
+                    }
+
+                    if(counter > 0)
+                    {
+                        if 
+                        (   
+                            GeometricField<T, fvsPatchField, surfaceMesh>::typeName 
+                                == "surfaceScalarField"
+                        )
+                        {
+                            tmpValue /= counter;
+                        }                            
+                        else if 
+                        (    
+                            GeometricField<T, fvsPatchField, surfaceMesh>::typeName 
+                                == "surfaceVectorField"
+                        )
+                        {
+                            magFld /= counter;
+                            tmpValue *= magFld/(mag(tmpValue)+deltaN.value());
+                        }
+                        else
+                        {
+                            FatalErrorInFunction
+                                << "mapping implementation only valid for"
+                                << " scalar and vector fields! \n Field "
+                                << sFld.name() << " is of type: "
+                                << GeometricField<T, fvsPatchField, surfaceMesh>::typeName 
+                                << abort(FatalError);
+                        }
+                    }
+
+                    sFld[facei] = tmpValue;
+                }
+            }
+        }
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::dynamicRefineFvMeshNew::dynamicRefineFvMeshNew(const IOobject& io)
+:
+    dynamicFvMesh(io),
+    meshCutter_(hexRef::New(*this)),
+    dumpLevel_(false),
+    nRefinementIterations_(0),
+    protectedCell_(nCells(), 0),
+    multiCritRefinement_(Foam::multiCritRefinement(meshCutter_->cellLevel(), *this))
+{
+    // Read static part of dictionary
+    readDict();
+
+    const labelList& cellLevel = meshCutter_->cellLevel();
+    const labelList& pointLevel = meshCutter_->pointLevel();
+
+    // Set cells that should not be refined.
+    // This is currently any cell which does not have 8 anchor points or
+    // uses any face which does not have 4 anchor points.
+    // Note: do not use cellPoint addressing
+    // Note: Axisymmetric meshes are handled differently!
+
+    // Count number of points <= cellLevel
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    labelList nAnchors(nCells(), 0);
+
+    label nProtected = 0;
+
+    forAll(pointCells(), pointi)
+    {
+        const labelList& pCells = pointCells()[pointi];
+
+        forAll(pCells, i)
+        {
+            label celli = pCells[i];
+
+            if (!protectedCell_.get(celli))
+            {
+                if (pointLevel[pointi] <= cellLevel[celli])
+                {
+                    nAnchors[celli]++;
+
+                    if (nAnchors[celli] > 8)
+                    {
+                        protectedCell_.set(celli, 1);
+                        nProtected++;
+                    }
+                }
+            }
+        }
+    }
+
+
+    // Count number of points <= faceLevel
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    // Bit tricky since proc face might be one more refined than the owner since
+    // the coupled one is refined.
+
+    {
+        labelList neiLevel(nFaces());
+
+        for (label facei = 0; facei < nInternalFaces(); facei++)
+        {
+            neiLevel[facei] = cellLevel[faceNeighbour()[facei]];
+        }
+        for (label facei = nInternalFaces(); facei < nFaces(); facei++)
+        {
+            neiLevel[facei] = cellLevel[faceOwner()[facei]];
+        }
+        syncTools::swapFaceList(*this, neiLevel);
+
+
+        boolList protectedFace(nFaces(), false);
+
+        forAll(faceOwner(), facei)
+        {
+            label faceLevel = max
+            (
+                cellLevel[faceOwner()[facei]],
+                neiLevel[facei]
+            );
+
+            const face& f = faces()[facei];
+
+            label nAnchors = 0;
+
+            forAll(f, fp)
+            {
+                if (pointLevel[f[fp]] <= faceLevel)
+                {
+                    nAnchors++;
+
+                    if (nAnchors > 4)
+                    {
+                        protectedFace[facei] = true;
+                        break;
+                    }
+                }
+            }
+        }
+
+        syncTools::syncFaceList(*this, protectedFace, orEqOp<bool>());
+
+        for (label facei = 0; facei < nInternalFaces(); facei++)
+        {
+            if (protectedFace[facei])
+            {
+                protectedCell_.set(faceOwner()[facei], 1);
+                nProtected++;
+                protectedCell_.set(faceNeighbour()[facei], 1);
+                nProtected++;
+            }
+        }
+        for (label facei = nInternalFaces(); facei < nFaces(); facei++)
+        {
+            if (protectedFace[facei])
+            {
+                protectedCell_.set(faceOwner()[facei], 1);
+                nProtected++;
+            }
+        }
+
+        bool isAxisym = (nGeometricD() == 2 && nSolutionD() == 3);
+
+        if (!isAxisym)
+        {
+            // Also protect any cells that are less than hex
+            forAll(cells(), celli)
+            {
+                const cell& cFaces = cells()[celli];
+
+                if (cFaces.size() < 6)
+                {
+                    if (protectedCell_.set(celli, 1))
+                    {
+                        nProtected++;
+                    }
+                }
+                else
+                {
+                    forAll(cFaces, cFacei)
+                    {
+                        if (faces()[cFaces[cFacei]].size() < 4)
+                        {
+                            if (protectedCell_.set(celli, 1))
+                            {
+                                nProtected++;
+                            }
+                            break;
+                        }
+                    }
+                }
+            }
+
+            // Check cells for 8 corner points
+            checkEightAnchorPoints(protectedCell_, nProtected);
+        }
+        else
+        {
+            PackedBoolList cellIsAxisPrism(nCells(), false);
+            label nAxisPrims = 0;
+
+            // Do not protect prisms on the axis
+            forAll(cells(), celli)
+            {
+                const cell& cFaces = cells()[celli];
+
+                if (cFaces.size() == 5)
+                {
+                    forAll(cFaces, cFacei)
+                    {
+                        label facei = cFaces[cFacei];
+                        if
+                        (
+                            !isInternalFace(facei)
+                        && faces()[facei].size() != 4
+                        )
+                        {
+                            label patchi = boundaryMesh().whichPatch(facei);
+                            if (isA<wedgePolyPatch>(boundaryMesh()[patchi]))
+                            {
+                                if (protectedCell_.set(celli, 1))
+                                {
+                                    nProtected++;
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                    if (!protectedCell_.get(celli))
+                    {
+                        cellIsAxisPrism.set(celli, 1);
+                        nAxisPrims++;
+                    }
+                }
+                else if (cFaces.size() < 5)
+                {
+                    if (protectedCell_.set(celli, 1))
+                    {
+                        nProtected++;
+                    }
+                }
+            }
+
+            // Check cells for 8 corner points
+            checkEightAnchorPoints(protectedCell_, nProtected);
+
+            // Unprotect prism cells on the axis
+            protectedCell_ -= cellIsAxisPrism;
+            nProtected -= nAxisPrims;
+
+
+
+            // YO
+            // Unprotect cells that have a refinement history
+            const labelList& visibleCells = meshCutter_->history().visibleCells();
+            forAll(visibleCells, celli)
+            {
+                if (visibleCells[celli] >= 0)
+                {
+                    if (protectedCell_[celli])
+                    {
+                        protectedCell_.unset(celli);
+                        nProtected--;
+                    }
+                }
+            }
+
+            // Look for former prisms cells on level 0. Since they do not have
+            // a refinement history, they will be incorrectly protected.
+            // In order to find former prisms, look for protectedCells with
+            // exactly 2 points on the axis. If the number of refined
+            // neighbours matches with the number of faces in excess of 5,
+            // the cell is (most probably) a former prism.
+
+            {
+                // First, look for a wedge polyPatch, in order to get the wedge
+                // plane normal and axis.
+                vector axis(0,0,0);
+                vector centreNormal(0,0,0);
+                bool foundWedge = false;
+
+                forAll(boundaryMesh(), patchi)
+                {
+                    if (isA<wedgePolyPatch>(boundaryMesh()[patchi]))
+                    {
+                        foundWedge = true;
+
+                        const wedgePolyPatch& wedgePatch =
+                            refCast<const wedgePolyPatch>
+                            (
+                                boundaryMesh()[patchi]
+                            );
+
+                        axis = wedgePatch.axis();
+                        centreNormal = wedgePatch.centreNormal();
+                        break;
+                    }
+                }
+
+                if (!foundWedge)
+                {
+                    FatalErrorInFunction
+                        << "Number of geometric dimensions and solution dimensions "
+                        << "correspond to an axisymmetric case, but no wedgePolyPatch "
+                        << " found in boundaryMesh." << nl
+                        << exit(FatalError);
+                }
+
+                // Get radial direction on the mesh
+                vector radialVector = axis ^ centreNormal;
+
+                // Translate as a component. Since wedge meshes should be constrained
+                // around one of the planes XY, XZ or YZ, we can directly get the
+                // distance to the axis
+
+                direction dir = 0;
+                scalar maxComp = mag(radialVector[0]);
+
+                if (mag(radialVector[1]) > maxComp)
+                {
+                    dir = 1;
+                    maxComp = mag(radialVector[1]);
+                }
+                if (mag(radialVector[2]) > maxComp)
+                {
+                    dir = 2;
+                }
+
+                // Use the level0Edge length to calculate a safety margin for
+                // detecting points on the axis.
+                // We should be able to rely on level0, since we only check
+                // unrefined cells.
+                scalar tolerance = meshCutter_->level0EdgeLength() * 1e-6;
+
+                const labelListList& cellPoints = primitiveMesh::cellPoints();
+
+                // Get max level across faces
+                labelList maxFaceLevel(nFaces());
+                const labelList& cellLevel = meshCutter_->cellLevel();
+
+                forAll(maxFaceLevel, facei)
+                {
+                    maxFaceLevel[facei] = cellLevel[faceOwner()[facei]];
+                }
+
+                forAll(faceNeighbour(), facei)
+                {
+                    maxFaceLevel[facei] = max(maxFaceLevel[facei], cellLevel[faceNeighbour()[facei]]);
+                }
+                syncTools::syncFaceList(*this, maxFaceLevel, combineMaxOp<label>());
+
+                forAll(protectedCell_, celli)
+                {
+                    if (protectedCell_[celli])
+                    {
+                        // Check if the cell has exactly 2 points on the axis
+                        label numPointsOnAxis = 0;
+                        const labelList& cPoints = cellPoints[celli];
+                        forAll(cPoints, pointi)
+                        {
+                            if (mag(points()[cPoints[pointi]][dir]) < tolerance)
+                            {
+                                numPointsOnAxis++;
+                            }
+                        }
+
+                        if (numPointsOnAxis == 2)
+                        {
+                            // Calculate number of higher level neighbour cells.
+                            // Use cellFaces instead of cellCells to deal with
+                            // processor patches.
+                            label thisCellLevel = cellLevel[celli];
+                            label numNeighboursWithHigherLevel = 0;
+
+                            const labelList& cellFaces = cells()[celli];
+                            forAll(cellFaces, cellFacei)
+                            {
+                                if (thisCellLevel < maxFaceLevel[cellFaces[cellFacei]])
+                                {
+                                    numNeighboursWithHigherLevel++;
+                                }
+                            }
+
+                            // If the cell was a neighbour to refined cells, then each
+                            // pair of refined neighbours introduces an additional face
+                            if (2*(cellFaces.size()-5) == numNeighboursWithHigherLevel)
+                            {
+                                protectedCell_.unset(celli);
+                                nProtected--;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        //-YO
+    }
+
+
+
+    if (returnReduce(nProtected, sumOp<label>()) == 0)
+    {
+        protectedCell_.clear();
+    }
+    else
+    {
+
+        cellSet protectedCells(*this, "protectedCells", nProtected);
+        forAll(protectedCell_, celli)
+        {
+            if (protectedCell_[celli])
+            {
+                protectedCells.insert(celli);
+            }
+        }
+
+        Info<< "Detected " << returnReduce(nProtected, sumOp<label>())
+            << " cells that are protected from refinement."
+            << " Writing these to cellSet "
+            << protectedCells.name()
+            << "." << endl;
+
+        protectedCells.write();
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::dynamicRefineFvMeshNew::~dynamicRefineFvMeshNew()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+bool Foam::dynamicRefineFvMeshNew::update()
+{
+    // Re-read dictionary. Choosen since usually -small so trivial amount
+    // of time compared to actual refinement. Also very useful to be able
+    // to modify on-the-fly.
+    dictionary refineDict
+    (
+        IOdictionary
+        (
+            IOobject
+            (
+                "dynamicMeshDict",
+                time().constant(),
+                *this,
+                IOobject::MUST_READ_IF_MODIFIED,
+                IOobject::NO_WRITE,
+                false
+            )
+        ).subDict(typeName + "Coeffs")
+    );
+
+    label refineInterval = readLabel(refineDict.lookup("refineInterval"));
+
+    bool hasChanged = false;
+
+    if (refineInterval == 0)
+    {
+        topoChanging(hasChanged);
+
+        return false;
+    }
+    else if (refineInterval < 0)
+    {
+        FatalErrorInFunction
+            << "Illegal refineInterval " << refineInterval << nl
+            << "The refineInterval setting in the dynamicMeshDict should"
+            << " be >= 1." << nl
+            << exit(FatalError);
+    }
+
+
+
+
+    // Note: cannot refine at time 0 since no V0 present since mesh not
+    //       moved yet.
+
+    if (time().timeIndex() > 0 && time().timeIndex() % refineInterval == 0)
+    {
+
+        {
+            // reads multiple refinement criteria if subdict multiCritRefinementControls
+            // in dynamicMeshDict is present or else does nothing
+            // calculates the multiCritRefinementField which needs to be set as field in
+            // dynamicRefineFvMeshNewCoeffs.field multiCritRefinementField;
+            multiCritRefinement_.updateRefinementField();
+        }
+
+        label maxCells = readLabel(refineDict.lookup("maxCells"));
+
+        if (maxCells <= 0)
+        {
+            FatalErrorInFunction
+                << "Illegal maximum number of cells " << maxCells << nl
+                << "The maxCells setting in the dynamicMeshDict should"
+                << " be > 0." << nl
+                << exit(FatalError);
+        }
+
+        label maxRefinement = readLabel(refineDict.lookup("maxRefinement"));
+
+        if (maxRefinement <= 0)
+        {
+            FatalErrorInFunction
+                << "Illegal maximum refinement level " << maxRefinement << nl
+                << "The maxCells setting in the dynamicMeshDict should"
+                << " be > 0." << nl
+                << exit(FatalError);
+        }
+
+        const word fieldName(refineDict.lookup("field"));
+
+        const volScalarField& vFld = lookupObject<volScalarField>(fieldName);
+
+        const scalar lowerRefineLevel =
+            readScalar(refineDict.lookup("lowerRefineLevel"));
+        const scalar upperRefineLevel =
+            readScalar(refineDict.lookup("upperRefineLevel"));
+        const scalar unrefineLevel = refineDict.lookupOrDefault<scalar>
+        (
+            "unrefineLevel",
+            GREAT
+        );
+        const label nBufferLayers =
+            readLabel(refineDict.lookup("nBufferLayers"));
+
+        // Cells marked for refinement or otherwise protected from unrefinement.
+        PackedBoolList refineCell(nCells());
+
+        // Determine candidates for refinement (looking at field only)
+        selectRefineCandidates
+        (
+            lowerRefineLevel,
+            upperRefineLevel,
+            vFld,
+            refineCell
+        );
+
+        if (globalData().nTotalCells() < maxCells)
+        {
+            // Select subset of candidates. Take into account max allowable
+            // cells, refinement level, protected cells.
+            labelList cellsToRefine
+            (
+                selectRefineCells
+                (
+                    maxCells,
+                    maxRefinement,
+                    refineCell
+                )
+            );
+
+            label nCellsToRefine = returnReduce
+            (
+                cellsToRefine.size(), sumOp<label>()
+            );
+
+            if (nCellsToRefine > 0)
+            {
+                // Refine/update mesh and map fields
+                autoPtr<mapPolyMesh> map = refine(cellsToRefine);
+
+                // Update refineCell. Note that some of the marked ones have
+                // not been refined due to constraints.
+                {
+                    const labelList& cellMap = map().cellMap();
+                    const labelList& reverseCellMap = map().reverseCellMap();
+
+                    PackedBoolList newRefineCell(cellMap.size());
+
+                    forAll(cellMap, celli)
+                    {
+                        label oldCelli = cellMap[celli];
+
+                        if (oldCelli < 0)
+                        {
+                            newRefineCell.set(celli, 1);
+                        }
+                        else if (reverseCellMap[oldCelli] != celli)
+                        {
+                            newRefineCell.set(celli, 1);
+                        }
+                        else
+                        {
+                            newRefineCell.set(celli, refineCell.get(oldCelli));
+                        }
+                    }
+                    refineCell.transfer(newRefineCell);
+                }
+
+                // Extend with a buffer layer to prevent neighbouring points
+                // being unrefined.
+                for (label i = 0; i < nBufferLayers; i++)
+                {
+                    extendMarkedCells(refineCell);
+                }
+
+                hasChanged = true;
+            }
+        }
+
+
+        {
+            // Select unrefineable points that are not marked in refineCell
+            labelList elemsToUnrefine
+            (
+                meshCutter_->selectUnrefineElems
+                (
+                    unrefineLevel,
+                    refineCell,
+                    maxCellField(vFld)
+                )
+            );
+
+            label nSplitElems = returnReduce
+            (
+                elemsToUnrefine.size(),
+                sumOp<label>()
+            );
+
+            if (nSplitElems > 0)
+            {
+                // Refine/update mesh
+                unrefine(elemsToUnrefine);
+
+                hasChanged = true;
+            }
+
+        }
+
+        if ((nRefinementIterations_ % 10) == 0)
+        {
+            // Compact refinement history occassionally (how often?).
+            // Unrefinement causes holes in the refinementHistory.
+            const_cast<refinementHistory&>(meshCutter()->history()).compact();
+        }
+        nRefinementIterations_++;
+    }
+
+    topoChanging(hasChanged);
+    if (hasChanged)
+    {
+        // Reset moving flag (if any). If not using inflation we'll not move,
+        // if are using inflation any follow on movePoints will set it.
+        moving(false);
+    }
+
+    return hasChanged;
+}
+
+
+bool Foam::dynamicRefineFvMeshNew::writeObject
+(
+    IOstream::streamFormat fmt,
+    IOstream::versionNumber ver,
+    IOstream::compressionType cmp
+) const
+{
+    // Force refinement data to go to the current time directory.
+    const_cast<hexRef&>(meshCutter_()).setInstance(time().timeName());
+
+    bool writeOk =
+    (
+        dynamicFvMesh::writeObject(fmt, ver, cmp)
+     && meshCutter_->write()
+    );
+
+    if (dumpLevel_)
+    {
+        volScalarField scalarCellLevel
+        (
+            IOobject
+            (
+                "cellLevel",
+                time().timeName(),
+                *this,
+                IOobject::NO_READ,
+                IOobject::AUTO_WRITE,
+                false
+            ),
+            *this,
+            dimensionedScalar("level", dimless, 0)
+        );
+
+        const labelList& cellLevel = meshCutter_->cellLevel();
+
+        forAll(cellLevel, celli)
+        {
+            scalarCellLevel[celli] = cellLevel[celli];
+        }
+
+        writeOk = writeOk && scalarCellLevel.write();
+    }
+
+    return writeOk;
+}
+
+
+// ************************************************************************* //
diff --git a/AMR_tidy/dynamicRefineFvMeshNew/dynamicRefineFvMeshNew.H b/AMR_tidy/dynamicRefineFvMeshNew/dynamicRefineFvMeshNew.H
new file mode 100644
index 00000000..6b686d20
--- /dev/null
+++ b/AMR_tidy/dynamicRefineFvMeshNew/dynamicRefineFvMeshNew.H
@@ -0,0 +1,299 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::dynamicRefineFvMesh
+
+Description
+    A fvMesh with built-in multi-criteria refinement.
+
+    Determines which cells to refine/unrefine and does all in update().
+
+
+    dynamicRefineFvMeshCoeffs
+    {    
+        refineInterval  1;              // How often to refine
+
+        field           alpha.water;    // Field to be refinement on
+                                        // use multiCritRefinementField together 
+                                        // with multiCritRefinementControls
+
+        lowerRefineLevel 0.001;         // Refine field inbetween lower..upper
+        upperRefineLevel 0.999;
+
+        
+        // unrefineLevel   10;          // If value < unrefineLevel 
+                                        // (default=GREAT) unrefine
+
+        nBufferLayers   1;              // Have slower than 2:1 refinement
+
+        maxRefinement   2;              // Refine cells only up to maxRefinement 
+                                        // levels
+
+        maxCells        200000;         // Stop refinement if maxCells reached
+
+        // Flux field and corresponding velocity field. Fluxes on changed
+        // faces get recalculated by interpolating the velocity. Use 'none'
+        // on surfaceScalarFields that do not need to be reinterpolated, use
+        // NaN to detect use of mapped variable
+        correctFluxes
+        (
+            (phi none)  //NaN)   //none)
+            (nHatf none)         //none)
+            (rho*phi none)       //none)
+            (ghf none)  //NaN)   //none)
+        );
+
+        // only for new internal faces (AMR refine)
+        mapSurfaceFields_               // List of non-flux surface<Type>Fields 
+        (                               // to be mapped
+            Uf
+            Uf_0
+        );
+
+        dumpLevel       true;            // Write the refinement level as a 
+                                         // volScalarField
+    }
+
+
+SourceFiles
+    dynamicRefineFvMesh.C
+
+Authors:
+    File adapted in 2018 by: 
+    Daniel Rettenmaier <rettenmaier@tu-darmstadt.de>
+    Daniel Deising <deising@mma.tu-darmstadt.de>
+    Changes: 
+        + Flux Mapping on refined internal faces
+        + Multiple refinement criteria
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef dynamicRefineFvMeshNew_H
+#define dynamicRefineFvMeshNew_H
+
+#include "dynamicFvMesh.H"
+#include "hexRef.H"
+#include "PackedBoolList.H"
+#include "Switch.H"
+
+#include "multiCritRefinement.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                     Class dynamicRefineFvMeshNew Declaration
+\*---------------------------------------------------------------------------*/
+
+class dynamicRefineFvMeshNew
+:
+    public dynamicFvMesh
+{
+protected:
+
+        //- Mesh cutting engine
+        autoPtr<hexRef> meshCutter_;
+
+        //- Dump cellLevel for postprocessing
+        Switch dumpLevel_;
+
+        //- Fluxes to map
+        HashTable<word> correctFluxes_;
+
+        //- SurfaceFiels to map
+        HashTable<word> mapSurfaceFields_;
+
+        //- Number of refinement/unrefinement steps done so far.
+        label nRefinementIterations_;
+
+        //- Protected cells (usually since not hexes)
+        PackedBoolList protectedCell_;
+
+        //- handles the multi criterion refinment logic
+        multiCritRefinement multiCritRefinement_;
+
+
+    // Protected Member Functions
+
+        //- Count set/unset elements in packedlist.
+        static label count(const PackedBoolList&, const unsigned int);
+
+        //- Calculate cells that cannot be refined since would trigger
+        //  refinement of protectedCell_ (since 2:1 refinement cascade)
+        void calculateProtectedCells(PackedBoolList& unrefineableCell) const;
+
+        //- Read the projection parameters from dictionary
+        void readDict();
+
+
+        //- Refine cells. Update mesh and fields.
+        autoPtr<mapPolyMesh> refine(const labelList&);
+
+        //- Unrefine cells. Gets passed in centre points of cells to combine.
+        autoPtr<mapPolyMesh> unrefine(const labelList&);
+
+
+        // Selection of cells to un/refine
+
+            //- Calculates approximate value for refinement level so
+            //  we don't go above maxCell
+            scalar getRefineLevel
+            (
+                const label maxCells,
+                const label maxRefinement,
+                const scalar refineLevel,
+                const scalarField&
+            ) const;
+
+            //- Get per cell max of connected point
+            scalarField maxPointField(const scalarField&) const;
+
+            //- Get point max of connected cell
+            scalarField maxCellField(const volScalarField&) const;
+
+            scalarField cellToPoint(const scalarField& vFld) const;
+
+            scalarField error
+            (
+                const scalarField& fld,
+                const scalar minLevel,
+                const scalar maxLevel
+            ) const;
+
+            //- Select candidate cells for refinement
+            virtual void selectRefineCandidates
+            (
+                const scalar lowerRefineLevel,
+                const scalar upperRefineLevel,
+                const scalarField& vFld,
+                PackedBoolList& candidateCell
+            ) const;
+
+            //- Subset candidate cells for refinement
+            virtual labelList selectRefineCells
+            (
+                const label maxCells,
+                const label maxRefinement,
+                const PackedBoolList& candidateCell
+            ) const;
+
+// YO- This is here only to preserve compatibility with the official release.
+//     It is not used by the refinement procedure, but some utilities such as
+//     decomposePar rely on it.
+            //- Select points that can be unrefined.
+            virtual labelList selectUnrefinePoints
+            (
+                const scalar unrefineLevel,
+                const PackedBoolList& markedCell,
+                const scalarField& pFld
+            ) const;
+// YO
+
+            //- Extend markedCell with cell-face-cell.
+            void extendMarkedCells(PackedBoolList& markedCell) const;
+
+            //- Check all cells have 8 anchor points
+            void checkEightAnchorPoints
+            (
+                PackedBoolList& protectedCell,
+                label& nProtected
+            ) const;
+
+            //- map non-flux surface<Type>Fields 
+            // for new internal faces (AMR refine)
+            template <class T>
+            void mapNewInternalFaces(const labelList& faceMap);
+
+private:
+
+        //- Disallow default bitwise copy construct
+        dynamicRefineFvMeshNew(const dynamicRefineFvMeshNew&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const dynamicRefineFvMeshNew&);
+
+public:
+
+    //- Runtime type information
+    TypeName("dynamicRefineFvMeshNew");
+
+
+    // Constructors
+
+        //- Construct from IOobject
+        explicit dynamicRefineFvMeshNew(const IOobject& io);
+
+
+    //- Destructor
+    virtual ~dynamicRefineFvMeshNew();
+
+
+    // Member Functions
+
+        //- Direct access to the refinement engine
+        const autoPtr<hexRef>& meshCutter() const
+        {
+            return meshCutter_;
+        }
+
+        //- Cells which should not be refined/unrefined
+        const PackedBoolList& protectedCell() const
+        {
+            return protectedCell_;
+        }
+
+        //- Cells which should not be refined/unrefined
+        PackedBoolList& protectedCell()
+        {
+            return protectedCell_;
+        }
+
+        //- Update the mesh for both mesh motion and topology change
+        virtual bool update();
+
+
+    // Writing
+
+        //- Write using given format, version and compression
+        virtual bool writeObject
+        (
+            IOstream::streamFormat fmt,
+            IOstream::versionNumber ver,
+            IOstream::compressionType cmp
+        ) const;
+
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/AMR_tidy/dynamicRefineFvMeshNew/multiCritRefinement.C b/AMR_tidy/dynamicRefineFvMeshNew/multiCritRefinement.C
new file mode 100644
index 00000000..556763c1
--- /dev/null
+++ b/AMR_tidy/dynamicRefineFvMeshNew/multiCritRefinement.C
@@ -0,0 +1,637 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "multiCritRefinement.H"
+
+// * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+bool Foam::multiCritRefinement::readMultiCritRefinementDict()
+{
+    dictionary dynamicMeshDict
+    (
+        IOdictionary
+        (
+            IOobject
+            (
+                "dynamicMeshDict",
+                mesh_.time().constant(),
+                mesh_,
+                IOobject::MUST_READ_IF_MODIFIED,
+                IOobject::NO_WRITE,
+                false
+            )
+        )
+    );
+
+    nBufferLayers_ = readLabel(dynamicMeshDict.subDict("dynamicRefineFvMeshNewCoeffs").lookup("nBufferLayers"));
+
+    if( dynamicMeshDict.isDict("multiCritRefinementControls") )
+    {
+        dictionary refineControlDict =
+            dynamicMeshDict.subDict("multiCritRefinementControls");
+
+        enableMultiCritRefinementControl_ =
+            Switch(refineControlDict.lookup("enableMultiCritRefinementControl"));
+
+        if( enableMultiCritRefinementControl_ )
+        {
+
+            dictionary multiCritRefinementControls =
+                dynamicMeshDict.subDict("multiCritRefinementControls");
+
+
+            // Overwrite field name entry in dynamicRefineFvMeshCoeffs?
+            // For now you just have to be smart and enter
+            // 'multiCritRefinementField' for the field name manually
+
+            // Read HashTable of field-refinement scalars
+            if( multiCritRefinementControls.found("fields") )
+            {
+                fields_ = HashTable< dictionary >
+                (
+                    multiCritRefinementControls.lookup("fields")
+                );
+            }
+
+            // Read HashTable of gradient-refinement scalars
+            if( multiCritRefinementControls.found("gradients") )
+            {
+                gradFields_ = HashTable< dictionary >
+                (
+                    multiCritRefinementControls.lookup("gradients")
+                );
+            }
+
+            // Read HashTable of curl-refinement vectors
+            if( multiCritRefinementControls.found("curls") )
+            {
+                curlFields_ = HashTable< dictionary >
+                (
+                    multiCritRefinementControls.lookup("curls")
+                );
+            }
+
+            // Read interface refinement data
+            if( multiCritRefinementControls.found("interface") )
+            {
+                interface_ = HashTable< dictionary >
+                (
+                    multiCritRefinementControls.lookup("interface")
+                );
+            }
+
+            // Read refinement regions
+            if( multiCritRefinementControls.found("regions") )
+            {
+                refinedRegions_ = PtrList<entry>
+                (
+                    multiCritRefinementControls.lookup("regions")
+                );
+            }
+
+            return true;
+        }else{
+            return false;
+        }
+    }
+    else
+    {
+        return false;
+    }
+}
+
+
+void Foam::multiCritRefinement::applyCritEntries(word critType, dictionary critDict, word critName)
+{
+
+    scalar minValue = readScalar(critDict.lookup("minValue"));
+    scalar maxValue = readScalar(critDict.lookup("maxValue"));
+    scalar refineLevel = readScalar(critDict.lookup("refineLevel"));
+
+    //- allow different criteria applied on one field, using different hash keys.
+    word fldName= "";
+    if (critDict.found("fieldName"))
+    {
+        fldName = word(critDict.lookup("fieldName"));
+    } else {
+        fldName = critName;
+    }
+
+    Field<scalar> refFld(mesh_.nCells(), 0.0);
+
+    if (critType == "field")
+    {
+        //- get a handle of the field
+        const volScalarField& fld = mesh_.lookupObject<volScalarField>(fldName);
+
+        refFld = fld;
+    }
+
+    if (critType == "grad")
+    {
+        //- get a handle of the field
+        const volVectorField& fld = mesh_.lookupObject<volVectorField>(fldName);
+
+        Field<scalar> cubeRtV = Foam::pow(mesh_.V(),1.0/3.0);
+
+        refFld = mag(fvc::grad(fld)) * cubeRtV;
+    }
+
+    if (critType == "curl")
+    {
+        //- get a handle of the field
+        const volVectorField& fld = mesh_.lookupObject<volVectorField>(fldName);
+
+        refFld = mag(fvc::curl(fld));
+    }
+
+    // Limit the value of refFld based on its max level
+    forAll(refFld, cellI)
+    {
+
+        if ((refFld[cellI] >= minValue) && (refFld[cellI] <= maxValue))
+        {
+            // increase targetLevel up to refineLevel
+            // BUT: do not decrease if cell already marked for higher refinement level by previous criterion
+            targetLevel_[cellI] = max(targetLevel_[cellI], refineLevel);
+        }
+    } 
+
+    //- AddLayer Keyword
+    scalar nAddLayers(0);
+    if (critDict.found("nAddLayers"))
+    {
+        nAddLayers = readScalar(critDict.lookup("nAddLayers"));
+    }
+
+    if (nAddLayers > 0)
+    {
+        //- create a volField of the labelList targetLevel
+            // Set the internal refinement field to zero to start with
+        volScalarField& tmp = *multiCritRefinementFieldPtr_;
+        tmp = dimensionedScalar("zero",dimless,0.0);
+        volScalarField tLevel(tmp * 0.0);
+        forAll(targetLevel_, cellI)
+        {
+            tLevel[cellI] = targetLevel_[cellI];
+        }
+
+        // #nAddLayers cells per additional level
+        for(label j=0; j < nAddLayers; j++)
+        {
+            //- select the area with targetLevel==refineLevel
+            volScalarField finest = pos(tLevel - refineLevel + SMALL);
+
+            //- add +1 to targetLevel on the enlarged stencil
+            tLevel += pos( fvc::average(fvc::interpolate(finest) - SMALL)) - finest;
+        }
+
+        //- copy the new results onto the target labelList
+        forAll(targetLevel_, cellI)
+        {
+            targetLevel_[cellI] = tLevel[cellI];
+        }
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::multiCritRefinement::multiCritRefinement(
+    const labelList& cellLevel, 
+    const fvMesh& mesh
+)
+:
+    cellLevel_(cellLevel),
+    mesh_(mesh),
+    multiCritRefinementFieldPtr_(NULL),
+    targetLevelPtr_(NULL),
+    targetLevel_(mesh.nCells(),0),
+    isLevelPtr_(NULL),
+    fields_(),
+    gradFields_(),
+    curlFields_(),
+    interface_(),
+    refinedRegions_(),
+    enableMultiCritRefinementControl_(false),
+    nBufferLayers_(0)
+{
+    // Read static part of dictionary
+    readMultiCritRefinementDict();
+
+    multiCritRefinementFieldPtr_ = new volScalarField
+        (
+            IOobject
+            (
+                "multiCritRefinementField",
+                mesh.time().timeName(),
+                mesh_,
+                IOobject::NO_READ,
+                IOobject::AUTO_WRITE
+            ),
+            mesh_,
+            dimensionedScalar("zero", dimless, 0.0)
+        );
+
+        targetLevelPtr_ = new volScalarField
+        (
+            IOobject
+            (
+                "targetLevel",
+                mesh_.time().timeName(),
+                mesh_,
+                IOobject::NO_READ,
+                IOobject::AUTO_WRITE
+            ),
+            mesh_,
+            dimensionedScalar("zero", dimless, 0.0)
+        );
+
+        isLevelPtr_ = new volScalarField
+        (
+            IOobject
+            (
+                "isLevel",
+                mesh_.time().timeName(),
+                mesh_,
+                IOobject::NO_READ,
+                IOobject::AUTO_WRITE
+            ),
+            mesh_,
+            dimensionedScalar("zero", dimless, 0.0)
+        );
+    
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::multiCritRefinement::~multiCritRefinement()
+{
+
+}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+void Foam::multiCritRefinement::updateRefinementField()
+{
+
+    if( !readMultiCritRefinementDict() ) 
+    {
+        return;
+    }
+
+    dictionary refineDict
+    (
+        IOdictionary
+        (
+            IOobject
+            (
+                "dynamicMeshDict",
+                mesh_.time().constant(),
+                mesh_,
+                IOobject::MUST_READ_IF_MODIFIED,
+                IOobject::NO_WRITE,
+                false
+            )
+        ).subDict("dynamicRefineFvMeshCoeffs")
+    );
+    scalar globalMaxRefLevel = readScalar(refineDict.lookup("maxRefinement"));
+
+    Info<< "Calculating multiCritRefinement field" << endl;
+
+    volScalarField& intRefFld = *multiCritRefinementFieldPtr_;
+    volScalarField& targetFld = *targetLevelPtr_;
+    volScalarField& currFld = *isLevelPtr_;
+
+    // Set the internal refinement field to zero to start with
+    intRefFld = dimensionedScalar("zero",dimless,0.0);
+
+    // init list for refine/unrefine field (-1=unrefine, 1=refine, 0=do nothing)
+    labelList markRefineCells (mesh_.nCells(), 0);
+
+    // init list for target refinement level per cell
+    targetLevel_ = markRefineCells;
+
+    Field<scalar> refFld(mesh_.nCells(),0.0);
+
+    // First fields
+    {
+        List<word> fieldNames = fields_.toc();
+
+
+        forAll(fieldNames, i)
+        {
+            
+            word fldEntry = fieldNames[i];
+
+            //- read criteria dict entries and calculate target level
+            applyCritEntries("field", fields_[fldEntry], fldEntry);            
+        }
+    }
+
+    // Then gradients
+    {
+        List<word> gradFieldNames = gradFields_.toc();
+        
+        forAll(gradFieldNames, i)
+        {
+             word fldEntry = gradFieldNames[i];
+
+            //- read criteria dict entries and calculate target level
+            applyCritEntries("grad", gradFields_[fldEntry], fldEntry);
+        }
+    }
+
+    // Then curls
+    {
+        List<word> curlFieldNames = curlFields_.toc();
+
+        forAll(curlFieldNames, i)
+        {
+            word fldEntry = curlFieldNames[i];
+
+            //- read criteria dict entries and calculate target level
+            applyCritEntries("curl", curlFields_[fldEntry], fldEntry);        
+        }
+    }
+
+    // Then at the interface (assumed to be always the maximum refinement level)
+    {
+        List<word> interfaceRefineField = interface_.toc();
+        forAll(interfaceRefineField, i)
+        {
+            word fldName = interfaceRefineField[i];
+            
+            // read region of maximum refinement levels inside and outside of interface indicator field
+            // (does not need to be alpha, can also be a concentration field)
+            scalar innerRefLayers = readScalar(interface_[fldName].lookup("innerRefLayers"));
+            scalar outerRefLayers = readScalar(interface_[fldName].lookup("outerRefLayers"));
+
+            scalar nAddLayers(0);
+            if (interface_[fldName].found("nAddLayers"))
+            {
+                nAddLayers = readScalar(interface_[fldName].lookup("nAddLayers"));
+            }
+            label refineLevel = globalMaxRefLevel;
+
+            if (interface_[fldName].found("maxRefineLevel"))
+            {
+                refineLevel = readScalar(interface_[fldName].lookup("maxRefineLevel"));
+
+                // to avoid user input mistakes, limit the value with the maximum allowed
+                refineLevel = min(globalMaxRefLevel, refineLevel);
+            }
+
+            const volScalarField& fld = mesh_.lookupObject<volScalarField>(fldName);
+
+            volScalarField isInterface(intRefFld * 0.0);
+            isInterface = dimensionedScalar("isInterface",dimless,0.0);
+
+            surfaceScalarField deltaAlpha = mag(fvc::snGrad(fld) / mesh_.deltaCoeffs());
+
+            const unallocLabelList& owner = mesh_.owner();
+            const unallocLabelList& neighbour = mesh_.neighbour();
+
+            forAll(deltaAlpha, faceI)
+            {
+            //TODO: add a min max value of the specified field to be marked for refinement
+            // NOW: hard-coded method snGradAlpha: checks mag(alpha_N - alpha_P) > 0.1 ? 1:0
+                if (deltaAlpha[faceI] > 0.1) // currently a fixed prescribed value; should be read from díctionary
+                {
+                    label own = owner[faceI];
+                    label nei = neighbour[faceI];
+
+                    // set isInterface field to one
+                    isInterface[own] = 1.0;
+                    isInterface[nei] = 1.0;
+                }
+            }
+
+            // assumed fld=0.5*(fldMax+fldMin) defines the interface
+            dimensionedScalar fldInterfaceValue(0.5*(gMax(fld)+gMin(fld)));
+
+            // Face-wise interplation for 2D meshes since point interpolation does not work
+            // on empty patches
+            if (mesh_.nGeometricD() == 2)
+            {
+
+                //-DD: implementation based on face interpolation
+                //     which results in slower transport in diagonal direction
+                // add inner refinement layers
+                for(label i=0; i < innerRefLayers; i++)
+                {
+                   isInterface += neg(- fvc::average(fvc::interpolate(isInterface)) * pos(fld - fldInterfaceValue));
+                   isInterface = neg(- isInterface);
+                }
+                
+                // add outer refinement layers
+                for(label i=0; i < outerRefLayers; i++)
+                {
+                   isInterface += neg(- fvc::average(fvc::interpolate(isInterface)) * pos(fldInterfaceValue - fld));
+                   isInterface = neg(- isInterface);
+                }
+                
+                forAll(isInterface, cellI)
+                {
+                   if (isInterface[cellI] > 0.5)
+                   {
+                       targetLevel_[cellI] = max(targetLevel_[cellI], refineLevel);
+                   }
+                }
+            } else {
+
+                //-DD: version using volPointInterpolation (direction independent buffer layer)
+                const volPointInterpolation& pInterp = volPointInterpolation::New(mesh_);
+                //const fvMesh& mesh = fld.mesh();
+
+                // add inner refinement layers
+                for(label i=0; i < innerRefLayers; i++)
+                {
+                    volScalarField markInner(isInterface*pos(fld - fldInterfaceValue));
+                    pointScalarField markLayerP(pInterp.interpolate(markInner));
+
+                    forAll(mesh_.C(), cellI)
+                    {
+                        scalar sum = 0.;
+                        label nPoints = 0;
+
+                        forAll(mesh_.cellPoints()[cellI], pointI)
+                        {
+                            sum += markLayerP[mesh_.cellPoints()[cellI][pointI]];
+                            nPoints++;
+                        }
+                        if (nPoints > 0)
+                        {
+                            sum /= nPoints;
+                        }
+                        isInterface[cellI] += sum;
+                    }
+                }
+                isInterface = pos(isInterface - SMALL);
+
+                // add outer refinement layers
+                for(label i=0; i < outerRefLayers; i++)
+                {
+                    volScalarField markOuter(isInterface*pos(fldInterfaceValue - fld));
+                    pointScalarField markLayerP(pInterp.interpolate(markOuter));
+
+                    forAll(mesh_.C(), cellI)
+                    {
+                        scalar sum = 0.;
+                        label nPoints = 0;
+
+                        forAll(mesh_.cellPoints()[cellI], pointI)
+                        {
+                            sum += markLayerP[mesh_.cellPoints()[cellI][pointI]];
+                            nPoints++;
+                        }
+                        if (nPoints > 0)
+                        {
+                            sum /= nPoints;
+                        }
+                        isInterface[cellI] += sum;
+                    }
+                }
+                isInterface = pos(isInterface - SMALL);
+
+                forAll(isInterface, cellI)
+                {
+                    if (isInterface[cellI] > 0.5)
+                    {
+                        targetLevel_[cellI] = max(targetLevel_[cellI], refineLevel);
+                    }
+                }
+            }
+
+            //-DD: old implementation based on face interpolation
+            //     which results in slower transport in diagonal direction
+            // expand additional layers if specified:
+            if (nAddLayers > 0)
+            {
+               // loop over additional layers
+               for(label i=1; i < refineLevel; i++)
+               {
+                   // #nAddLayers cells per additional level
+                   for(label j=0; j < nAddLayers; j++)
+                   {
+                       isInterface += neg(- fvc::average(fvc::interpolate(isInterface)));
+                       isInterface = neg(- isInterface);
+                   }
+
+                   forAll(isInterface, cellI)
+                   {
+                       if (isInterface[cellI] == 1.0)
+                       {
+                           targetLevel_[cellI] = max(targetLevel_[cellI], (refineLevel - i));
+                       }
+                   }
+               }
+            }
+
+        }
+    }
+
+    //- Finally geometric regions (force the mesh to stay refined near key features)
+    {
+        forAll(refinedRegions_, regionI)
+        {
+            const entry& region = refinedRegions_[regionI];
+
+            autoPtr<topoSetSource> source =
+                topoSetSource::New(region.keyword(), mesh_, region.dict());
+
+            cellSet selectedCellSet
+            (
+                mesh_,
+                "cellSet",
+                mesh_.nCells()/10+1 //estimate
+            );
+
+            source->applyToSet
+            (
+                topoSetSource::NEW,
+                selectedCellSet
+            );
+
+            const labelList cells = selectedCellSet.toc();
+
+            label minLevel = readLabel(region.dict().lookup("minLevel"));
+
+            forAll(cells, i)
+            {
+                const label& cellI = cells[i];
+
+                targetLevel_[cellI] = max(targetLevel_[cellI], minLevel);
+            }
+        }
+    }
+
+    //-DD: buffer layer based on targetLevel field to prevent 2-to-1 refinement
+    {
+        volScalarField blockedLevel = targetFld * 0.;
+
+        for (label currLayer=globalMaxRefLevel; currLayer>=1; currLayer--)
+        {
+            forAll (targetLevel_, cellI)
+            {
+                if (targetLevel_[cellI] >= currLayer)
+                {
+                    blockedLevel[cellI] = targetLevel_[cellI];
+                }
+            }
+
+            for (label i=0; i<nBufferLayers_; i++)
+            {
+                blockedLevel = max(blockedLevel, pos(fvc::average(fvc::interpolate(blockedLevel)) - SMALL)*(currLayer-1));
+            }
+
+            labelList blockLev(blockedLevel.internalField().size(), 0);
+            forAll (blockLev, cellI)
+            {
+                blockLev[cellI] = blockedLevel[cellI];
+            }
+            targetLevel_ = max(targetLevel_, blockLev);
+        }
+    }
+
+    // mark cells to be refined/unrefined based on above criteria:
+    // simply check, if targetLevel lower or higher cellLevel
+    forAll (intRefFld.internalField(), cellI)
+    {
+        intRefFld.primitiveFieldRef()[cellI] = targetLevel_[cellI] - cellLevel_[cellI];
+        targetFld.primitiveFieldRef()[cellI] = targetLevel_[cellI];
+        currFld.primitiveFieldRef()[cellI] =  cellLevel_[cellI];
+    }
+
+    intRefFld.correctBoundaryConditions();
+
+    Info<<"Min,max refinement field = " << Foam::min(intRefFld).value() << ", "
+        << Foam::max(intRefFld).value() << endl;
+}
+
+
+// ************************************************************************* //
diff --git a/AMR_tidy/dynamicRefineFvMeshNew/multiCritRefinement.H b/AMR_tidy/dynamicRefineFvMeshNew/multiCritRefinement.H
new file mode 100644
index 00000000..abf0f420
--- /dev/null
+++ b/AMR_tidy/dynamicRefineFvMeshNew/multiCritRefinement.H
@@ -0,0 +1,205 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::dynamicRefineFvMesh
+
+Description
+    Implementation of multi-criterion refinement options for dynamicRefineFvMesh
+
+    Multiples criteria can be selected:
+    fields      (e.g. alpha, speciesConcentration)
+    gradients   (e.g. grad(U))
+    curls       (e.g. )
+    interface   (e.g. alpha 0.5 iso-surface)
+
+    To be used with 
+        dynamicRefineFvMeshCoeffs.field multiCritRefinementField
+    and 
+        multiCritRefinementControls
+    Has no effect if the multiCritRefinementControls subdict doesnt exist.
+
+SourceFiles
+    multiCritRefinement.C
+
+Authors
+    Daniel Deising <deising@mma.tu-darmstadt.de>
+    Daniel Rettenmaier <rettenmaier@gsc.tu-darmstadt.de>
+    All rights reserved.
+
+Description
+    multi-criterion refinement as plugin for dynamicRefineFvMesh
+
+    You may refer to this software as :
+    //- full bibliographic data to be provided
+
+    This code has been developed by :
+        Daniel Rettenmaier (main developer).
+    
+    Method Development and Intellectual Property :
+        Daniel Deising <deising@mma.tu-darmstadt.de>
+        Daniel Rettenmaier <rettenmaier@gsc.tu-darmstadt.de>
+        Holger Marschall <marschall@csi.tu-darmstadt.de>
+        Dieter Bothe <bothe@csi.tu-darmstadt.de>
+        Cameron Tropea <ctropea@sla.tu-darmstadt.de>
+
+        School of Aeronautics and Astronautics
+        Purdue University
+        Mathematical Modeling and Analysis
+        Institute for Fluid Mechanics and Aerodynamics
+        Center of Smart Interfaces
+        Technische Universitaet Darmstadt
+       
+    If you use this software for your scientific work or your publications,
+    please don't forget to acknowledge explicitly the use of it.
+
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef multiCritRefinement_H
+#define multiCritRefinement_H
+
+//#include "dynamicFvMesh.H"
+//#include "PackedBoolList.H"
+#include "dynamicFvMesh.H"
+#include "surfaceInterpolate.H"
+#include "volFields.H"
+#include "syncTools.H"
+#include "pointFields.H"
+#include "fvCFD.H"
+#include "volPointInterpolation.H"
+#include "pointMesh.H"
+#include "Switch.H"
+#include "topoSetSource.H"
+#include "cellSet.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                     Class dynamicRefineFvMesh Declaration
+\*---------------------------------------------------------------------------*/
+
+class multiCritRefinement
+{
+
+private:
+
+        //- const reference to current refinement Level
+        const labelList& cellLevel_;
+
+        //- const reference to mesh
+        const fvMesh& mesh_;
+
+        //- difference of target and current refinement level > 0 refineme
+        //                                                    < 0 unrefine
+        volScalarField* multiCritRefinementFieldPtr_;
+
+        //- target refinement level combining all criteria
+        volScalarField* targetLevelPtr_;
+
+        labelList targetLevel_;
+
+        //- current refinement level
+        volScalarField* isLevelPtr_;
+
+        //- list of all fields and their refinement criteria:
+        //   minValue <= field <= maxValue
+        //   refinementLevel, nAddLayers                                                    
+        HashTable< dictionary > fields_;
+        
+        //- list of scalar fields of which the |gradient| serves as refinement criteria
+        //  minValue <= mag(grad(field)) <= maxValue
+        HashTable< dictionary > gradFields_;
+
+        //- list of fields of which its curl is used as refinement criteria
+        //  minValue <= mag(curl(field)) <= maxValue
+        HashTable< dictionary > curlFields_;
+
+        //- inner and outer regions of an interface ( 0.1 < grad(alpha) ) are set
+        //  to the global maxRefineLevel (in most cases you want exactly that)
+        HashTable< dictionary > interface_;
+
+        //- regions can be set to be quasi-static refined
+        PtrList<entry> refinedRegions_;
+
+        //- switch all criteria on or of
+        Switch enableMultiCritRefinementControl_;
+
+        //- the number of buffer layers between three different refinement levels
+        //  preferrably an even number
+        label nBufferLayers_;
+
+        //- reads and loads all "multiCritRefinementControl" - information
+        bool readMultiCritRefinementDict();
+
+        //- calculates target level for the criteria "field", "gradient" and "curl"
+        //  evaluates dict entries:
+        //      fieldName, minValue, maxValue, refineLevel, nAddLayers
+        void applyCritEntries(word critType, dictionary critDict, word critName);
+
+        //- Disallow default bitwise assignment
+        void operator=(const multiCritRefinement&);
+
+
+public:
+
+    // Constructors
+
+        //- Constructor
+            explicit multiCritRefinement(
+                    const labelList& cellLevel, 
+                    const fvMesh& mesh
+            );
+
+
+        //- Destructor
+        virtual ~multiCritRefinement();
+
+
+    // Protected Member Functions
+
+        //- Disallow default bitwise copy construct
+        multiCritRefinement(const multiCritRefinement&);
+
+        //- calculates the multiCritRefinementField 
+        void updateRefinementField();
+
+
+
+    // Writing
+
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/AMR_tidy/hexRef/hexRef.C b/AMR_tidy/hexRef/hexRef.C
new file mode 100644
index 00000000..51d7c022
--- /dev/null
+++ b/AMR_tidy/hexRef/hexRef.C
@@ -0,0 +1,3619 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2017 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "hexRef.H"
+
+#include "polyMesh.H"
+#include "polyTopoChange.H"
+#include "meshTools.H"
+#include "polyAddFace.H"
+#include "polyAddPoint.H"
+#include "polyAddCell.H"
+#include "polyModifyFace.H"
+#include "syncTools.H"
+#include "faceSet.H"
+#include "cellSet.H"
+#include "pointSet.H"
+#include "OFstream.H"
+#include "Time.H"
+#include "FaceCellWave.H"
+#include "mapDistributePolyMesh.H"
+#include "refinementData.H"
+#include "refinementDistanceData.H"
+#include "degenerateMatcher.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(hexRef, 0);
+    defineRunTimeSelectionTable(hexRef, mesh);
+    defineRunTimeSelectionTable(hexRef, levelsHist);
+    defineRunTimeSelectionTable(hexRef, levels);
+
+    //- Reduction class. If x and y are not equal assign value.
+    template<label value>
+    class ifEqEqOp
+    {
+        public:
+        void operator()(label& x, const label y) const
+        {
+            x = (x == y) ? x : value;
+        }
+    };
+}
+
+
+// * * * * * * * * * * * * * Protected Member Functions * * * * * * * * * * //
+
+void Foam::hexRef::reorder
+(
+    const labelList& map,
+    const label len,
+    const label null,
+    labelList& elems
+)
+{
+    labelList newElems(len, null);
+
+    forAll(elems, i)
+    {
+        label newI = map[i];
+
+        if (newI >= len)
+        {
+            FatalErrorInFunction << abort(FatalError);
+        }
+
+        if (newI >= 0)
+        {
+            newElems[newI] = elems[i];
+        }
+    }
+
+    elems.transfer(newElems);
+}
+
+
+void Foam::hexRef::getFaceInfo
+(
+    const label facei,
+    label& patchID,
+    label& zoneID,
+    label& zoneFlip
+) const
+{
+    patchID = -1;
+
+    if (!mesh_.isInternalFace(facei))
+    {
+        patchID = mesh_.boundaryMesh().whichPatch(facei);
+    }
+
+    zoneID = mesh_.faceZones().whichZone(facei);
+
+    zoneFlip = false;
+
+    if (zoneID >= 0)
+    {
+        const faceZone& fZone = mesh_.faceZones()[zoneID];
+
+        zoneFlip = fZone.flipMap()[fZone.whichFace(facei)];
+    }
+}
+
+
+// Adds a face on top of existing facei.
+Foam::label Foam::hexRef::addFace
+(
+    polyTopoChange& meshMod,
+    const label facei,
+    const face& newFace,
+    const label own,
+    const label nei
+) const
+{
+    label patchID, zoneID, zoneFlip;
+
+    getFaceInfo(facei, patchID, zoneID, zoneFlip);
+
+    label newFacei = -1;
+
+    if ((nei == -1) || (own < nei))
+    {
+        // Ordering ok.
+        newFacei = meshMod.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
+    {
+        // Reverse owner/neighbour
+        newFacei = meshMod.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;
+}
+
+
+// Adds an internal face from an edge. Assumes orientation correct.
+// Problem is that the face is between four new vertices. So what do we provide
+// as master? The only existing mesh item we have is the edge we have split.
+// Have to be careful in only using it if it has internal faces since otherwise
+// polyMeshMorph will complain (because it cannot generate a sensible mapping
+// for the face)
+Foam::label Foam::hexRef::addInternalFace
+(
+    polyTopoChange& meshMod,
+    const label meshFacei,
+    const label meshPointi,
+    const face& newFace,
+    const label own,
+    const label nei
+) const
+{
+/////////////////////////////////////////////////////////////////////////////////
+// D. Deising & D. Rettenmaier
+// Sets internalFaces falsly as masterFaces so internal face adressing gets mixed 
+// up. addInternalFace() is only called inside HexRef8, we expect no problems by 
+// commenting this case.
+
+// TODO: Check if commenting this case breaks any other functionality
+
+    // if (mesh_.isInternalFace(meshFacei))
+    // {
+    //    return meshMod.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
+/////////////////////////////////////////////////////////////////////////////////
+    {
+        // Two choices:
+        // - append (i.e. create out of nothing - will not be mapped)
+        //   problem: field does not get mapped.
+        // - inflate from point.
+        //   problem: does interpolative mapping which constructs full
+        //   volPointInterpolation!
+
+        // For now create out of nothing
+
+        return meshMod.setAction
+        (
+            polyAddFace
+            (
+                newFace,                    // face
+                own,                        // owner
+                nei,                        // neighbour
+                -1,                         // master point
+                -1,                         // master edge
+                -1,                         // master face for addition
+                false,                      // flux flip
+                -1,                         // patch for face
+                -1,                         // zone for face
+                false                       // face zone flip
+            )
+        );
+
+
+        ////- Inflate-from-point:
+        //// Check if point has any internal faces we can use.
+        //label masterPointi = -1;
+        //
+        //const labelList& pFaces = mesh_.pointFaces()[meshPointi];
+        //
+        //forAll(pFaces, i)
+        //{
+        //    if (mesh_.isInternalFace(pFaces[i]))
+        //    {
+        //        // meshPoint uses internal faces so ok to inflate from it
+        //        masterPointi = meshPointi;
+        //
+        //        break;
+        //    }
+        //}
+        //
+        //return meshMod.setAction
+        //(
+        //    polyAddFace
+        //    (
+        //        newFace,                    // face
+        //        own,                        // owner
+        //        nei,                        // neighbour
+        //        masterPointi,               // master point
+        //        -1,                         // master edge
+        //        -1,                         // master face for addition
+        //        false,                      // flux flip
+        //        -1,                         // patch for face
+        //        -1,                         // zone for face
+        //        false                       // face zone flip
+        //    )
+        //);
+    }
+}
+
+
+// Modifies existing facei for either new owner/neighbour or new face points.
+void Foam::hexRef::modFace
+(
+    polyTopoChange& meshMod,
+    const label facei,
+    const face& newFace,
+    const label own,
+    const label nei
+) const
+{
+    label patchID, zoneID, zoneFlip;
+
+    getFaceInfo(facei, patchID, zoneID, zoneFlip);
+
+    if
+    (
+        (own != mesh_.faceOwner()[facei])
+     || (
+            mesh_.isInternalFace(facei)
+         && (nei != mesh_.faceNeighbour()[facei])
+        )
+     || (newFace != mesh_.faces()[facei])
+    )
+    {
+        if ((nei == -1) || (own < nei))
+        {
+            meshMod.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
+        {
+            meshMod.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
+                )
+            );
+        }
+    }
+}
+
+
+// Bit complex way to determine the unrefined edge length.
+Foam::scalar Foam::hexRef::getLevel0EdgeLength() const
+{
+    if (cellLevel_.size() != mesh_.nCells())
+    {
+        FatalErrorInFunction
+            << "Number of cells in mesh:" << mesh_.nCells()
+            << " does not equal size of cellLevel:" << cellLevel_.size()
+            << endl
+            << "This might be because of a restart with inconsistent cellLevel."
+            << abort(FatalError);
+    }
+
+    // Determine minimum edge length per refinement level
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    const scalar GREAT2 = sqr(GREAT);
+
+    label nLevels = gMax(cellLevel_)+1;
+
+    scalarField typEdgeLenSqr(nLevels, GREAT2);
+
+
+    // 1. Look only at edges surrounded by cellLevel cells only.
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    {
+        // Per edge the cellLevel of connected cells. -1 if not set,
+        // labelMax if different levels, otherwise levels of connected cells.
+        labelList edgeLevel(mesh_.nEdges(), -1);
+
+        forAll(cellLevel_, celli)
+        {
+            const label cLevel = cellLevel_[celli];
+
+            const labelList& cEdges = mesh_.cellEdges(celli);
+
+            forAll(cEdges, i)
+            {
+                label edgeI = cEdges[i];
+
+                if (edgeLevel[edgeI] == -1)
+                {
+                    edgeLevel[edgeI] = cLevel;
+                }
+                else if (edgeLevel[edgeI] == labelMax)
+                {
+                    // Already marked as on different cellLevels
+                }
+                else if (edgeLevel[edgeI] != cLevel)
+                {
+                    edgeLevel[edgeI] = labelMax;
+                }
+            }
+        }
+
+        // Make sure that edges with different levels on different processors
+        // are also marked. Do the same test (edgeLevel != cLevel) on coupled
+        // edges.
+        syncTools::syncEdgeList
+        (
+            mesh_,
+            edgeLevel,
+            ifEqEqOp<labelMax>(),
+            labelMin
+        );
+
+        // Now use the edgeLevel with a valid value to determine the
+        // length per level.
+        forAll(edgeLevel, edgeI)
+        {
+            const label eLevel = edgeLevel[edgeI];
+
+            if (eLevel >= 0 && eLevel < labelMax)
+            {
+                const edge& e = mesh_.edges()[edgeI];
+
+                scalar edgeLenSqr = magSqr(e.vec(mesh_.points()));
+
+                typEdgeLenSqr[eLevel] = min(typEdgeLenSqr[eLevel], edgeLenSqr);
+            }
+        }
+    }
+
+    // Get the minimum per level over all processors. Note minimum so if
+    // cells are not cubic we use the smallest edge side.
+    Pstream::listCombineGather(typEdgeLenSqr, minEqOp<scalar>());
+    Pstream::listCombineScatter(typEdgeLenSqr);
+
+    if (debug)
+    {
+        Pout<< "hexRef::getLevel0EdgeLength() :"
+            << " After phase1: Edgelengths (squared) per refinementlevel:"
+            << typEdgeLenSqr << endl;
+    }
+
+
+    // 2. For any levels where we haven't determined a valid length yet
+    //    use any surrounding cell level. Here we use the max so we don't
+    //    pick up levels between celllevel and higher celllevel (will have
+    //    edges sized according to highest celllevel)
+    //    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    scalarField maxEdgeLenSqr(nLevels, -GREAT2);
+
+    forAll(cellLevel_, celli)
+    {
+        const label cLevel = cellLevel_[celli];
+
+        const labelList& cEdges = mesh_.cellEdges(celli);
+
+        forAll(cEdges, i)
+        {
+            const edge& e = mesh_.edges()[cEdges[i]];
+
+            scalar edgeLenSqr = magSqr(e.vec(mesh_.points()));
+
+            maxEdgeLenSqr[cLevel] = max(maxEdgeLenSqr[cLevel], edgeLenSqr);
+        }
+    }
+
+    Pstream::listCombineGather(maxEdgeLenSqr, maxEqOp<scalar>());
+    Pstream::listCombineScatter(maxEdgeLenSqr);
+
+    if (debug)
+    {
+        Pout<< "hexRef::getLevel0EdgeLength() :"
+            << " Crappy Edgelengths (squared) per refinementlevel:"
+            << maxEdgeLenSqr << endl;
+    }
+
+
+    // 3. Combine the two sets of lengths
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    forAll(typEdgeLenSqr, levelI)
+    {
+        if (typEdgeLenSqr[levelI] == GREAT2 && maxEdgeLenSqr[levelI] >= 0)
+        {
+            typEdgeLenSqr[levelI] = maxEdgeLenSqr[levelI];
+        }
+    }
+
+    if (debug)
+    {
+        Pout<< "hexRef::getLevel0EdgeLength() :"
+            << " Final Edgelengths (squared) per refinementlevel:"
+            << typEdgeLenSqr << endl;
+    }
+
+    // Find lowest level present
+    scalar level0Size = -1;
+
+    forAll(typEdgeLenSqr, levelI)
+    {
+        scalar lenSqr = typEdgeLenSqr[levelI];
+
+        if (lenSqr < GREAT2)
+        {
+            level0Size = Foam::sqrt(lenSqr)*(1<<levelI);
+
+            if (debug)
+            {
+                Pout<< "hexRef::getLevel0EdgeLength() :"
+                    << " For level:" << levelI
+                    << " have edgeLen:" << Foam::sqrt(lenSqr)
+                    << " with equivalent level0 len:" << level0Size
+                    << endl;
+            }
+            break;
+        }
+    }
+
+    if (level0Size == -1)
+    {
+        FatalErrorInFunction
+            << "Problem : typEdgeLenSqr:" << typEdgeLenSqr << abort(FatalError);
+    }
+
+    return level0Size;
+}
+
+
+// Check whether pointi is an anchor on celli.
+// If it is not check whether any other point on the face is an anchor cell.
+Foam::label Foam::hexRef::getAnchorCell
+(
+    const labelListList& cellAnchorPoints,
+    const labelListList& cellAddedCells,
+    const label celli,
+    const label facei,
+    const label pointi
+) const
+{
+    if (cellAnchorPoints[celli].size())
+    {
+        label index = findIndex(cellAnchorPoints[celli], pointi);
+
+        if (index != -1)
+        {
+            return cellAddedCells[celli][index];
+        }
+
+
+        // pointi is not an anchor cell.
+        // Maybe we are already a refined face so check all the face
+        // vertices.
+        const face& f = mesh_.faces()[facei];
+
+        forAll(f, fp)
+        {
+            label index = findIndex(cellAnchorPoints[celli], f[fp]);
+
+            if (index != -1)
+            {
+                return cellAddedCells[celli][index];
+            }
+        }
+
+        // Problem.
+        dumpCell(celli);
+        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;
+    }
+}
+
+
+// Get new owner and neighbour
+void Foam::hexRef::getFaceNeighbours
+(
+    const labelListList& cellAnchorPoints,
+    const labelListList& cellAddedCells,
+    const label facei,
+    const label pointi,
+
+    label& own,
+    label& nei
+) const
+{
+    // Is owner split?
+    own = getAnchorCell
+    (
+        cellAnchorPoints,
+        cellAddedCells,
+        mesh_.faceOwner()[facei],
+        facei,
+        pointi
+    );
+
+    if (mesh_.isInternalFace(facei))
+    {
+        nei = getAnchorCell
+        (
+            cellAnchorPoints,
+            cellAddedCells,
+            mesh_.faceNeighbour()[facei],
+            facei,
+            pointi
+        );
+    }
+    else
+    {
+        nei = -1;
+    }
+}
+
+
+// Get point with the lowest pointLevel
+Foam::label Foam::hexRef::findMinLevel(const labelList& f) const
+{
+    label minLevel = labelMax;
+    label minFp = -1;
+
+    forAll(f, fp)
+    {
+        label level = pointLevel_[f[fp]];
+
+        if (level < minLevel)
+        {
+            minLevel = level;
+            minFp = fp;
+        }
+    }
+
+    return minFp;
+}
+
+
+// Get point with the highest pointLevel
+Foam::label Foam::hexRef::findMaxLevel(const labelList& f) const
+{
+    label maxLevel = labelMin;
+    label maxFp = -1;
+
+    forAll(f, fp)
+    {
+        label level = pointLevel_[f[fp]];
+
+        if (level > maxLevel)
+        {
+            maxLevel = level;
+            maxFp = fp;
+        }
+    }
+
+    return maxFp;
+}
+
+
+Foam::label Foam::hexRef::countAnchors
+(
+    const labelList& f,
+    const label anchorLevel
+) const
+{
+    label nAnchors = 0;
+
+    forAll(f, fp)
+    {
+        if (pointLevel_[f[fp]] <= anchorLevel)
+        {
+            nAnchors++;
+        }
+    }
+    return nAnchors;
+}
+
+
+void Foam::hexRef::dumpCell(const label celli) const
+{
+    OFstream str(mesh_.time().path()/"cell_" + Foam::name(celli) + ".obj");
+    Pout<< "hexRef : Dumping cell as obj to " << str.name() << endl;
+
+    const cell& cFaces = mesh_.cells()[celli];
+
+    Map<label> pointToObjVert;
+    label objVertI = 0;
+
+    forAll(cFaces, i)
+    {
+        const face& f = mesh_.faces()[cFaces[i]];
+
+        forAll(f, fp)
+        {
+            if (pointToObjVert.insert(f[fp], objVertI))
+            {
+                meshTools::writeOBJ(str, mesh_.points()[f[fp]]);
+                objVertI++;
+            }
+        }
+    }
+
+    forAll(cFaces, i)
+    {
+        const face& f = mesh_.faces()[cFaces[i]];
+
+        forAll(f, fp)
+        {
+            label pointi = f[fp];
+            label nexPointi = f[f.fcIndex(fp)];
+
+            str << "l " << pointToObjVert[pointi]+1
+                << ' ' << pointToObjVert[nexPointi]+1 << nl;
+        }
+    }
+}
+
+
+// Find point with certain pointLevel. Skip any higher levels.
+Foam::label Foam::hexRef::findLevel
+(
+    const label facei,
+    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)
+        {
+            dumpCell(mesh_.faceOwner()[facei]);
+            if (mesh_.isInternalFace(facei))
+            {
+                dumpCell(mesh_.faceNeighbour()[facei]);
+            }
+
+            FatalErrorInFunction
+                << "face:" << f
+                << " level:" << UIndirectList<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);
+        }
+    }
+
+    dumpCell(mesh_.faceOwner()[facei]);
+    if (mesh_.isInternalFace(facei))
+    {
+        dumpCell(mesh_.faceNeighbour()[facei]);
+    }
+
+    FatalErrorInFunction
+        << "face:" << f
+        << " level:" << UIndirectList<label>(pointLevel_, f)()
+        << " startFp:" << startFp
+        << " wantedLevel:" << wantedLevel
+        << abort(FatalError);
+
+    return -1;
+}
+
+
+// Gets cell level such that the face has four points <= level.
+Foam::label Foam::hexRef::faceLevel(const label facei) const
+{
+    const face& f = mesh_.faces()[facei];
+
+    if (f.size() <= 4)
+    {
+        return pointLevel_[f[findMaxLevel(f)]];
+    }
+    else
+    {
+        label ownLevel = cellLevel_[mesh_.faceOwner()[facei]];
+
+        if (countAnchors(f, ownLevel) == 4)
+        {
+            return ownLevel;
+        }
+        else if (countAnchors(f, ownLevel+1) == 4)
+        {
+            return ownLevel+1;
+        }
+        else
+        {
+            return -1;
+        }
+    }
+}
+
+
+void Foam::hexRef::checkInternalOrientation
+(
+    polyTopoChange& meshMod,
+    const label celli,
+    const label facei,
+    const point& ownPt,
+    const point& neiPt,
+    const face& newFace
+)
+{
+    face compactFace(identity(newFace.size()));
+    pointField compactPoints(meshMod.points(), newFace);
+
+    vector n(compactFace.normal(compactPoints));
+
+    vector dir(neiPt - ownPt);
+
+    if ((dir & n) < 0)
+    {
+        FatalErrorInFunction
+            << "cell:" << celli << " old face:" << facei
+            << " newFace:" << newFace << endl
+            << " coords:" << compactPoints
+            << " ownPt:" << ownPt
+            << " neiPt:" << neiPt
+            << abort(FatalError);
+    }
+
+    vector fcToOwn(compactFace.centre(compactPoints) - ownPt);
+
+    scalar s = (fcToOwn&n) / (dir&n);
+
+    if (s < 0.1 || s > 0.9)
+    {
+        FatalErrorInFunction
+            << "cell:" << celli << " old face:" << facei
+            << " newFace:" << newFace << endl
+            << " coords:" << compactPoints
+            << " ownPt:" << ownPt
+            << " neiPt:" << neiPt
+            << " s:" << s
+            << abort(FatalError);
+    }
+}
+
+
+void Foam::hexRef::checkBoundaryOrientation
+(
+    polyTopoChange& meshMod,
+    const label celli,
+    const label facei,
+    const point& ownPt,
+    const point& boundaryPt,
+    const face& newFace
+)
+{
+    face compactFace(identity(newFace.size()));
+    pointField compactPoints(meshMod.points(), newFace);
+
+    vector n(compactFace.normal(compactPoints));
+
+    vector dir(boundaryPt - ownPt);
+
+    if ((dir & n) < 0)
+    {
+        FatalErrorInFunction
+            << "cell:" << celli << " old face:" << facei
+            << " newFace:" << newFace
+            << " coords:" << compactPoints
+            << " ownPt:" << ownPt
+            << " boundaryPt:" << boundaryPt
+            << abort(FatalError);
+    }
+
+    vector fcToOwn(compactFace.centre(compactPoints) - ownPt);
+
+    scalar s = (fcToOwn&dir) / magSqr(dir);
+
+    if (s < 0.7 || s > 1.3)
+    {
+        WarningInFunction
+            << "cell:" << celli << " old face:" << facei
+            << " newFace:" << newFace
+            << " coords:" << compactPoints
+            << " ownPt:" << ownPt
+            << " boundaryPt:" << boundaryPt
+            << " s:" << s
+            << endl;
+            //<< abort(FatalError);
+    }
+}
+
+
+// If p0 and p1 are existing vertices check if edge is split and insert
+// splitPoint.
+void Foam::hexRef::insertEdgeSplit
+(
+    const labelList& edgeMidPoint,
+    const label p0,
+    const label p1,
+    DynamicList<label>& verts
+) const
+{
+    if (p0 < mesh_.nPoints() && p1 < mesh_.nPoints())
+    {
+        label edgeI = meshTools::findEdge(mesh_, p0, p1);
+
+        if (edgeI != -1 && edgeMidPoint[edgeI] != -1)
+        {
+            verts.append(edgeMidPoint[edgeI]);
+        }
+    }
+}
+
+
+void Foam::hexRef::walkFaceToMid
+(
+    const labelList& edgeMidPoint,
+    const label cLevel,
+    const label facei,
+    const label startFp,
+    DynamicList<label>& faceVerts
+) const
+{
+    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]] >= 0)
+        {
+            faceVerts.append(edgeMidPoint[fEdges[fp]]);
+        }
+
+        fp = f.fcIndex(fp);
+
+        if (pointLevel_[f[fp]] <= cLevel)
+        {
+            // Next anchor. Have already append split point on edge in code
+            // above.
+            return;
+        }
+        else if (pointLevel_[f[fp]] == cLevel+1)
+        {
+            // Mid level
+            faceVerts.append(f[fp]);
+
+            return;
+        }
+        else if (pointLevel_[f[fp]] == cLevel+2)
+        {
+            // Store and continue to cLevel+1.
+            faceVerts.append(f[fp]);
+        }
+    }
+}
+
+
+// Same as walkFaceToMid but now walk back.
+void Foam::hexRef::walkFaceFromMid
+(
+    const labelList& edgeMidPoint,
+    const label cLevel,
+    const label facei,
+    const label startFp,
+    DynamicList<label>& faceVerts
+) const
+{
+    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.
+            break;
+        }
+        else if (pointLevel_[f[fp]] == cLevel+1)
+        {
+            // Mid level
+            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]] >= 0)
+        {
+            faceVerts.append(edgeMidPoint[fEdges[fp]]);
+        }
+
+        fp = f.fcIndex(fp);
+
+        if (fp == startFp)
+        {
+            break;
+        }
+        faceVerts.append(f[fp]);
+    }
+}
+
+
+// Updates refineCell (cells marked for refinement) so across all faces
+// there will be 2:1 consistency after refinement.
+Foam::label Foam::hexRef::faceConsistentRefinement
+(
+    const bool maxSet,
+    PackedBoolList& refineCell
+) const
+{
+    label nChanged = 0;
+
+    // Internal faces.
+    for (label facei = 0; facei < mesh_.nInternalFaces(); facei++)
+    {
+        label own = mesh_.faceOwner()[facei];
+        label ownLevel = cellLevel_[own] + refineCell.get(own);
+
+        label nei = mesh_.faceNeighbour()[facei];
+        label neiLevel = cellLevel_[nei] + refineCell.get(nei);
+
+        if (ownLevel > (neiLevel+1))
+        {
+            if (maxSet)
+            {
+                refineCell.set(nei);
+            }
+            else
+            {
+                refineCell.unset(own);
+            }
+            nChanged++;
+        }
+        else if (neiLevel > (ownLevel+1))
+        {
+            if (maxSet)
+            {
+                refineCell.set(own);
+            }
+            else
+            {
+                refineCell.unset(nei);
+            }
+            nChanged++;
+        }
+    }
+
+
+    // Coupled faces. Swap owner level to get neighbouring cell level.
+    // (only boundary faces of neiLevel used)
+    labelList neiLevel(mesh_.nFaces()-mesh_.nInternalFaces());
+
+    forAll(neiLevel, i)
+    {
+        label own = mesh_.faceOwner()[i+mesh_.nInternalFaces()];
+
+        neiLevel[i] = cellLevel_[own] + refineCell.get(own);
+    }
+
+    // Swap to neighbour
+    syncTools::swapBoundaryFaceList(mesh_, neiLevel);
+
+    // Now we have neighbour value see which cells need refinement
+    forAll(neiLevel, i)
+    {
+        label own = mesh_.faceOwner()[i+mesh_.nInternalFaces()];
+        label ownLevel = cellLevel_[own] + refineCell.get(own);
+
+        if (ownLevel > (neiLevel[i]+1))
+        {
+            if (!maxSet)
+            {
+                refineCell.unset(own);
+                nChanged++;
+            }
+        }
+        else if (neiLevel[i] > (ownLevel+1))
+        {
+            if (maxSet)
+            {
+                refineCell.set(own);
+                nChanged++;
+            }
+        }
+    }
+
+    return nChanged;
+}
+
+
+// Debug: check if wanted refinement is compatible with 2:1
+void Foam::hexRef::checkWantedRefinementLevels
+(
+    const labelList& cellsToRefine
+) const
+{
+    PackedBoolList refineCell(mesh_.nCells());
+    forAll(cellsToRefine, i)
+    {
+        refineCell.set(cellsToRefine[i]);
+    }
+
+    for (label facei = 0; facei < mesh_.nInternalFaces(); facei++)
+    {
+        label own = mesh_.faceOwner()[facei];
+        label ownLevel = cellLevel_[own] + refineCell.get(own);
+
+        label nei = mesh_.faceNeighbour()[facei];
+        label neiLevel = cellLevel_[nei] + refineCell.get(nei);
+
+        if (mag(ownLevel-neiLevel) > 1)
+        {
+            dumpCell(own);
+            dumpCell(nei);
+            FatalErrorInFunction
+                << "cell:" << own
+                << " current level:" << cellLevel_[own]
+                << " level after refinement:" << ownLevel
+                << nl
+                << "neighbour cell:" << nei
+                << " current level:" << cellLevel_[nei]
+                << " level after refinement:" << neiLevel
+                << nl
+                << "which does not satisfy 2:1 constraints anymore."
+                << abort(FatalError);
+        }
+    }
+
+    // Coupled faces. Swap owner level to get neighbouring cell level.
+    // (only boundary faces of neiLevel used)
+    labelList neiLevel(mesh_.nFaces()-mesh_.nInternalFaces());
+
+    forAll(neiLevel, i)
+    {
+        label own = mesh_.faceOwner()[i+mesh_.nInternalFaces()];
+
+        neiLevel[i] = cellLevel_[own] + refineCell.get(own);
+    }
+
+    // Swap to neighbour
+    syncTools::swapBoundaryFaceList(mesh_, neiLevel);
+
+    // Now we have neighbour value see which cells need refinement
+    forAll(neiLevel, i)
+    {
+        label facei = i + mesh_.nInternalFaces();
+
+        label own = mesh_.faceOwner()[facei];
+        label ownLevel = cellLevel_[own] + refineCell.get(own);
+
+        if (mag(ownLevel - neiLevel[i]) > 1)
+        {
+            label patchi = mesh_.boundaryMesh().whichPatch(facei);
+
+            dumpCell(own);
+            FatalErrorInFunction
+                << "Celllevel does not satisfy 2:1 constraint."
+                << " On coupled face "
+                << facei
+                << " on patch " << patchi << " "
+                << mesh_.boundaryMesh()[patchi].name()
+                << " owner cell " << own
+                << " current level:" << cellLevel_[own]
+                << " level after refinement:" << ownLevel
+                << nl
+                << " (coupled) neighbour cell will get refinement "
+                << neiLevel[i]
+                << abort(FatalError);
+        }
+    }
+}
+
+
+// Set instance for mesh files
+void Foam::hexRef::setInstance(const fileName& inst)
+{
+    if (debug)
+    {
+        Pout<< "hexRef::setInstance(const fileName& inst) : "
+            << "Resetting file instance to " << inst << endl;
+    }
+
+    cellLevel_.instance() = inst;
+    pointLevel_.instance() = inst;
+    level0Edge_.instance() = inst;
+    history_.instance() = inst;
+}
+
+
+void Foam::hexRef::collectLevelPoints
+(
+    const labelList& f,
+    const label level,
+    DynamicList<label>& points
+) const
+{
+    forAll(f, fp)
+    {
+        if (pointLevel_[f[fp]] <= level)
+        {
+            points.append(f[fp]);
+        }
+    }
+}
+
+
+void Foam::hexRef::collectLevelPoints
+(
+    const labelList& meshPoints,
+    const labelList& f,
+    const label level,
+    DynamicList<label>& points
+) const
+{
+    forAll(f, fp)
+    {
+        label pointi = meshPoints[f[fp]];
+        if (pointLevel_[pointi] <= level)
+        {
+            points.append(pointi);
+        }
+    }
+}
+
+
+// Return true if we've found 6 quads. faces guaranteed to be outwards pointing.
+bool Foam::hexRef::matchHexShape
+(
+    const label celli,
+    const label cellLevel,
+    DynamicList<face>& quads
+) const
+{
+    const cell& cFaces = mesh_.cells()[celli];
+
+    // Work arrays
+    DynamicList<label> verts(4);
+    quads.clear();
+
+
+    // 1. pick up any faces with four cellLevel points
+
+    forAll(cFaces, i)
+    {
+        label facei = cFaces[i];
+        const face& f = mesh_.faces()[facei];
+
+        verts.clear();
+        collectLevelPoints(f, cellLevel, verts);
+        if (verts.size() == 4)
+        {
+            if (mesh_.faceOwner()[facei] != celli)
+            {
+                reverse(verts);
+            }
+            quads.append(face(0));
+            labelList& quadVerts = quads.last();
+            quadVerts.transfer(verts);
+        }
+    }
+
+
+    if (quads.size() < 6)
+    {
+        Map<labelList> pointFaces(2*cFaces.size());
+
+        forAll(cFaces, i)
+        {
+            label facei = cFaces[i];
+            const face& f = mesh_.faces()[facei];
+
+            // Pick up any faces with only one level point.
+            // See if there are four of these where the commont point
+            // is a level+1 point. This common point is then the mid of
+            // a split face.
+
+            verts.clear();
+            collectLevelPoints(f, cellLevel, verts);
+            if (verts.size() == 1)
+            {
+                // Add to pointFaces for any level+1 point (this might be
+                // a midpoint of a split face)
+                forAll(f, fp)
+                {
+                    label pointi = f[fp];
+                    if (pointLevel_[pointi] == cellLevel+1)
+                    {
+                        Map<labelList>::iterator iter =
+                            pointFaces.find(pointi);
+                        if (iter != pointFaces.end())
+                        {
+                            labelList& pFaces = iter();
+                            if (findIndex(pFaces, facei) == -1)
+                            {
+                                pFaces.append(facei);
+                            }
+                        }
+                        else
+                        {
+                            pointFaces.insert
+                            (
+                                pointi,
+                                labelList(1, facei)
+                            );
+                        }
+                    }
+                }
+            }
+        }
+
+        // 2. Check if we've collected any midPoints.
+        forAllConstIter(Map<labelList>, pointFaces, iter)
+        {
+            const labelList& pFaces = iter();
+
+            if (pFaces.size() == 4)
+            {
+                // Collect and orient.
+                faceList fourFaces(pFaces.size());
+                forAll(pFaces, pFacei)
+                {
+                    label facei = pFaces[pFacei];
+                    const face& f = mesh_.faces()[facei];
+                    if (mesh_.faceOwner()[facei] == celli)
+                    {
+                        fourFaces[pFacei] = f;
+                    }
+                    else
+                    {
+                        fourFaces[pFacei] = f.reverseFace();
+                    }
+                }
+
+                primitivePatch bigFace
+                (
+                    SubList<face>(fourFaces, fourFaces.size()),
+                    mesh_.points()
+                );
+                const labelListList& edgeLoops = bigFace.edgeLoops();
+
+                if (edgeLoops.size() == 1)
+                {
+                    // Collect the 4 cellLevel points
+                    verts.clear();
+                    collectLevelPoints
+                    (
+                        bigFace.meshPoints(),
+                        bigFace.edgeLoops()[0],
+                        cellLevel,
+                        verts
+                    );
+
+                    if (verts.size() == 4)
+                    {
+                        quads.append(face(0));
+                        labelList& quadVerts = quads.last();
+                        quadVerts.transfer(verts);
+                    }
+                }
+            }
+        }
+    }
+
+    return (quads.size() == 6);
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+// Construct from mesh, read refinement data
+Foam::hexRef::hexRef(const polyMesh& mesh, const bool readHistory)
+:
+    mesh_(mesh),
+    cellLevel_
+    (
+        IOobject
+        (
+            "cellLevel",
+            mesh_.facesInstance(),
+            polyMesh::meshSubDir,
+            mesh_,
+            IOobject::READ_IF_PRESENT,
+            IOobject::NO_WRITE
+        ),
+        labelList(mesh_.nCells(), 0)
+    ),
+    pointLevel_
+    (
+        IOobject
+        (
+            "pointLevel",
+            mesh_.facesInstance(),
+            polyMesh::meshSubDir,
+            mesh_,
+            IOobject::READ_IF_PRESENT,
+            IOobject::NO_WRITE
+        ),
+        labelList(mesh_.nPoints(), 0)
+    ),
+    level0Edge_
+    (
+        IOobject
+        (
+            "level0Edge",
+            mesh_.facesInstance(),
+            polyMesh::meshSubDir,
+            mesh_,
+            IOobject::READ_IF_PRESENT,
+            IOobject::NO_WRITE
+        ),
+        dimensionedScalar("level0Edge", dimLength, getLevel0EdgeLength())
+    ),
+    history_
+    (
+        IOobject
+        (
+            "refinementHistory",
+            mesh_.facesInstance(),
+            polyMesh::meshSubDir,
+            mesh_,
+            IOobject::NO_READ,
+            IOobject::NO_WRITE
+        ),
+        // All cells visible if not read or readHistory = false
+        (readHistory ? mesh_.nCells() : 0)
+    ),
+    faceRemover_(mesh_, GREAT),     // merge boundary faces wherever possible
+    savedPointLevel_(0),
+    savedCellLevel_(0)
+{
+    if (readHistory)
+    {
+        // Make sure we don't use the master-only reading. Bit of a hack for
+        // now.
+        regIOobject::fileCheckTypes oldType =
+            regIOobject::fileModificationChecking;
+        regIOobject::fileModificationChecking = regIOobject::timeStamp;
+        history_.readOpt() = IOobject::READ_IF_PRESENT;
+        if (history_.headerOk())
+        {
+            history_.read();
+        }
+        regIOobject::fileModificationChecking = oldType;
+    }
+
+    if (history_.active() && history_.visibleCells().size() != mesh_.nCells())
+    {
+        FatalErrorInFunction
+            << "History enabled but number of visible cells "
+            << history_.visibleCells().size() << " in "
+            << history_.objectPath()
+            << " is not equal to the number of cells in the mesh "
+            << mesh_.nCells()
+            << abort(FatalError);
+    }
+
+    if
+    (
+        cellLevel_.size() != mesh_.nCells()
+     || pointLevel_.size() != mesh_.nPoints()
+    )
+    {
+        FatalErrorInFunction
+            << "Restarted from inconsistent cellLevel or pointLevel files."
+            << endl
+            << "cellLevel file " << cellLevel_.objectPath() << endl
+            << "pointLevel file " << pointLevel_.objectPath() << endl
+            << "Number of cells in mesh:" << mesh_.nCells()
+            << " does not equal size of cellLevel:" << cellLevel_.size() << endl
+            << "Number of points in mesh:" << mesh_.nPoints()
+            << " does not equal size of pointLevel:" << pointLevel_.size()
+            << abort(FatalError);
+    }
+
+
+    // Check refinement levels for consistency
+    checkRefinementLevels(-1, labelList(0));
+
+
+    // Check initial mesh for consistency
+
+    //if (debug)
+    {
+        checkMesh();
+    }
+}
+
+
+// Construct from components
+Foam::hexRef::hexRef
+(
+    const polyMesh& mesh,
+    const labelList& cellLevel,
+    const labelList& pointLevel,
+    const refinementHistory& history,
+    const scalar level0Edge
+)
+:
+    mesh_(mesh),
+    cellLevel_
+    (
+        IOobject
+        (
+            "cellLevel",
+            mesh_.facesInstance(),
+            polyMesh::meshSubDir,
+            mesh_,
+            IOobject::NO_READ,
+            IOobject::NO_WRITE
+        ),
+        cellLevel
+    ),
+    pointLevel_
+    (
+        IOobject
+        (
+            "pointLevel",
+            mesh_.facesInstance(),
+            polyMesh::meshSubDir,
+            mesh_,
+            IOobject::NO_READ,
+            IOobject::NO_WRITE
+        ),
+        pointLevel
+    ),
+    level0Edge_
+    (
+        IOobject
+        (
+            "level0Edge",
+            mesh_.facesInstance(),
+            polyMesh::meshSubDir,
+            mesh_,
+            IOobject::NO_READ,
+            IOobject::NO_WRITE
+        ),
+        dimensionedScalar
+        (
+            "level0Edge",
+            dimLength,
+            (level0Edge >= 0 ? level0Edge : getLevel0EdgeLength())
+        )
+    ),
+    history_
+    (
+        IOobject
+        (
+            "refinementHistory",
+            mesh_.facesInstance(),
+            polyMesh::meshSubDir,
+            mesh_,
+            IOobject::NO_READ,
+            IOobject::NO_WRITE
+        ),
+        history
+    ),
+    faceRemover_(mesh_, GREAT),     // merge boundary faces wherever possible
+    savedPointLevel_(0),
+    savedCellLevel_(0)
+{
+    if (history_.active() && history_.visibleCells().size() != mesh_.nCells())
+    {
+        FatalErrorInFunction
+            << "History enabled but number of visible cells in it "
+            << history_.visibleCells().size()
+            << " is not equal to the number of cells in the mesh "
+            << mesh_.nCells() << abort(FatalError);
+    }
+
+    if
+    (
+        cellLevel_.size() != mesh_.nCells()
+     || pointLevel_.size() != mesh_.nPoints()
+    )
+    {
+        FatalErrorInFunction
+            << "Incorrect cellLevel or pointLevel size." << endl
+            << "Number of cells in mesh:" << mesh_.nCells()
+            << " does not equal size of cellLevel:" << cellLevel_.size() << endl
+            << "Number of points in mesh:" << mesh_.nPoints()
+            << " does not equal size of pointLevel:" << pointLevel_.size()
+            << abort(FatalError);
+    }
+
+    // Check refinement levels for consistency
+    checkRefinementLevels(-1, labelList(0));
+
+
+    // Check initial mesh for consistency
+
+    //if (debug)
+    {
+        checkMesh();
+    }
+}
+
+
+// Construct from components
+Foam::hexRef::hexRef
+(
+    const polyMesh& mesh,
+    const labelList& cellLevel,
+    const labelList& pointLevel,
+    const scalar level0Edge
+)
+:
+    mesh_(mesh),
+    cellLevel_
+    (
+        IOobject
+        (
+            "cellLevel",
+            mesh_.facesInstance(),
+            polyMesh::meshSubDir,
+            mesh_,
+            IOobject::NO_READ,
+            IOobject::NO_WRITE
+        ),
+        cellLevel
+    ),
+    pointLevel_
+    (
+        IOobject
+        (
+            "pointLevel",
+            mesh_.facesInstance(),
+            polyMesh::meshSubDir,
+            mesh_,
+            IOobject::NO_READ,
+            IOobject::NO_WRITE
+        ),
+        pointLevel
+    ),
+    level0Edge_
+    (
+        IOobject
+        (
+            "level0Edge",
+            mesh_.facesInstance(),
+            polyMesh::meshSubDir,
+            mesh_,
+            IOobject::NO_READ,
+            IOobject::NO_WRITE
+        ),
+        dimensionedScalar
+        (
+            "level0Edge",
+            dimLength,
+            (level0Edge >= 0 ? level0Edge : getLevel0EdgeLength())
+        )
+    ),
+    history_
+    (
+        IOobject
+        (
+            "refinementHistory",
+            mesh_.facesInstance(),
+            polyMesh::meshSubDir,
+            mesh_,
+            IOobject::NO_READ,
+            IOobject::NO_WRITE
+        ),
+        List<refinementHistory::splitCell8>(0),
+        labelList(0),
+        false
+    ),
+    faceRemover_(mesh_, GREAT),     // merge boundary faces wherever possible
+    savedPointLevel_(0),
+    savedCellLevel_(0)
+{
+    if
+    (
+        cellLevel_.size() != mesh_.nCells()
+     || pointLevel_.size() != mesh_.nPoints()
+    )
+    {
+        FatalErrorInFunction
+            << "Incorrect cellLevel or pointLevel size." << endl
+            << "Number of cells in mesh:" << mesh_.nCells()
+            << " does not equal size of cellLevel:" << cellLevel_.size() << endl
+            << "Number of points in mesh:" << mesh_.nPoints()
+            << " does not equal size of pointLevel:" << pointLevel_.size()
+            << abort(FatalError);
+    }
+
+    // Check refinement levels for consistency
+    checkRefinementLevels(-1, labelList(0));
+
+    // Check initial mesh for consistency
+
+    //if (debug)
+    {
+        checkMesh();
+    }
+}
+
+// * * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * //
+
+Foam::hexRef::~hexRef()
+{}
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+Foam::labelList Foam::hexRef::consistentRefinement
+(
+    const labelList& cellsToRefine,
+    const bool maxSet
+) const
+{
+    // Loop, modifying cellsToRefine, until no more changes to due to 2:1
+    // conflicts.
+    // maxSet = false : unselect cells to refine
+    // maxSet = true  : select cells to refine
+
+    // Go to straight boolList.
+    PackedBoolList refineCell(mesh_.nCells());
+    forAll(cellsToRefine, i)
+    {
+        refineCell.set(cellsToRefine[i]);
+    }
+
+    while (true)
+    {
+        label nChanged = faceConsistentRefinement(maxSet, refineCell);
+
+        reduce(nChanged, sumOp<label>());
+
+        if (debug)
+        {
+            Pout<< "hexRef::consistentRefinement : Changed " << nChanged
+                << " refinement levels due to 2:1 conflicts."
+                << endl;
+        }
+
+        if (nChanged == 0)
+        {
+            break;
+        }
+    }
+
+
+    // Convert back to labelList.
+    label nRefined = 0;
+
+    forAll(refineCell, celli)
+    {
+        if (refineCell.get(celli))
+        {
+            nRefined++;
+        }
+    }
+
+    labelList newCellsToRefine(nRefined);
+    nRefined = 0;
+
+    forAll(refineCell, celli)
+    {
+        if (refineCell.get(celli))
+        {
+            newCellsToRefine[nRefined++] = celli;
+        }
+    }
+
+    if (debug)
+    {
+        checkWantedRefinementLevels(newCellsToRefine);
+    }
+
+    return newCellsToRefine;
+}
+
+
+// Given a list of cells to refine determine additional cells to refine
+// such that the overall refinement:
+// - satisfies maxFaceDiff (e.g. 2:1) across neighbouring faces
+// - satisfies maxPointDiff (e.g. 4:1) across selected point connected
+//   cells. This is used to ensure that e.g. cells on the surface are not
+//   point connected to cells which are 8 times smaller.
+Foam::labelList Foam::hexRef::consistentSlowRefinement
+(
+    const label maxFaceDiff,
+    const labelList& cellsToRefine,
+    const labelList& facesToCheck,
+    const label maxPointDiff,
+    const labelList& pointsToCheck
+) const
+{
+    const labelList& faceOwner = mesh_.faceOwner();
+    const labelList& faceNeighbour = mesh_.faceNeighbour();
+
+
+    if (maxFaceDiff <= 0)
+    {
+        FatalErrorInFunction
+            << "Illegal maxFaceDiff " << maxFaceDiff << nl
+            << "Value should be >= 1" << exit(FatalError);
+    }
+
+
+    // Bit tricky. Say we want a distance of three cells between two
+    // consecutive refinement levels. This is done by using FaceCellWave to
+    // transport out the new refinement level. It gets decremented by one
+    // every cell it crosses so if we initialize it to maxFaceDiff
+    // we will get a field everywhere that tells us whether an unselected cell
+    // needs refining as well.
+
+
+    // Initial information about (distance to) cellLevel on all cells
+    List<refinementData> allCellInfo(mesh_.nCells());
+
+    // Initial information about (distance to) cellLevel on all faces
+    List<refinementData> allFaceInfo(mesh_.nFaces());
+
+    forAll(allCellInfo, celli)
+    {
+        // maxFaceDiff since refinementData counts both
+        // faces and cells.
+        allCellInfo[celli] = refinementData
+        (
+            maxFaceDiff*(cellLevel_[celli]+1),// when cell is to be refined
+            maxFaceDiff*cellLevel_[celli]     // current level
+        );
+    }
+
+    // Cells to be refined will have cellLevel+1
+    forAll(cellsToRefine, i)
+    {
+        label celli = cellsToRefine[i];
+
+        allCellInfo[celli].count() = allCellInfo[celli].refinementCount();
+    }
+
+
+    // Labels of seed faces
+    DynamicList<label> seedFaces(mesh_.nFaces()/100);
+    // refinementLevel data on seed faces
+    DynamicList<refinementData> seedFacesInfo(mesh_.nFaces()/100);
+
+    // Dummy additional info for FaceCellWave
+    int dummyTrackData = 0;
+
+
+    // Additional buffer layer thickness by changing initial count. Usually
+    // this happens on boundary faces. Bit tricky. Use allFaceInfo to mark
+    // off thus marked faces so they're skipped in the next loop.
+    forAll(facesToCheck, i)
+    {
+        label facei = facesToCheck[i];
+
+        if (allFaceInfo[facei].valid(dummyTrackData))
+        {
+            // Can only occur if face has already gone through loop below.
+            FatalErrorInFunction
+                << "Argument facesToCheck seems to have duplicate entries!"
+                << endl
+                << "face:" << facei << " occurs at positions "
+                << findIndices(facesToCheck, facei)
+                << abort(FatalError);
+        }
+
+
+        const refinementData& ownData = allCellInfo[faceOwner[facei]];
+
+        if (mesh_.isInternalFace(facei))
+        {
+            // Seed face if neighbouring cell (after possible refinement)
+            // will be refined one more than the current owner or neighbour.
+
+            const refinementData& neiData = allCellInfo[faceNeighbour[facei]];
+
+            label faceCount;
+            label faceRefineCount;
+            if (neiData.count() > ownData.count())
+            {
+                faceCount = neiData.count() + maxFaceDiff;
+                faceRefineCount = faceCount + maxFaceDiff;
+            }
+            else
+            {
+                faceCount = ownData.count() + maxFaceDiff;
+                faceRefineCount = faceCount + maxFaceDiff;
+            }
+
+            seedFaces.append(facei);
+            seedFacesInfo.append
+            (
+                refinementData
+                (
+                    faceRefineCount,
+                    faceCount
+                )
+            );
+            allFaceInfo[facei] = seedFacesInfo.last();
+        }
+        else
+        {
+            label faceCount = ownData.count() + maxFaceDiff;
+            label faceRefineCount = faceCount + maxFaceDiff;
+
+            seedFaces.append(facei);
+            seedFacesInfo.append
+            (
+                refinementData
+                (
+                    faceRefineCount,
+                    faceCount
+                )
+            );
+            allFaceInfo[facei] = seedFacesInfo.last();
+        }
+    }
+
+
+    // Just seed with all faces inbetween different refinement levels for now
+    // (alternatively only seed faces on cellsToRefine but that gives problems
+    //  if no cells to refine)
+    forAll(faceNeighbour, facei)
+    {
+        // Check if face already handled in loop above
+        if (!allFaceInfo[facei].valid(dummyTrackData))
+        {
+            label own = faceOwner[facei];
+            label nei = faceNeighbour[facei];
+
+            // Seed face with transported data from highest cell.
+
+            if (allCellInfo[own].count() > allCellInfo[nei].count())
+            {
+                allFaceInfo[facei].updateFace
+                (
+                    mesh_,
+                    facei,
+                    own,
+                    allCellInfo[own],
+                    FaceCellWave<refinementData, int>::propagationTol(),
+                    dummyTrackData
+                );
+                seedFaces.append(facei);
+                seedFacesInfo.append(allFaceInfo[facei]);
+            }
+            else if (allCellInfo[own].count() < allCellInfo[nei].count())
+            {
+                allFaceInfo[facei].updateFace
+                (
+                    mesh_,
+                    facei,
+                    nei,
+                    allCellInfo[nei],
+                    FaceCellWave<refinementData, int>::propagationTol(),
+                    dummyTrackData
+                );
+                seedFaces.append(facei);
+                seedFacesInfo.append(allFaceInfo[facei]);
+            }
+        }
+    }
+
+    // Seed all boundary faces with owner value. This is to make sure that
+    // they are visited (probably only important for coupled faces since
+    // these need to be visited from both sides)
+    for (label facei = mesh_.nInternalFaces(); facei < mesh_.nFaces(); facei++)
+    {
+        // Check if face already handled in loop above
+        if (!allFaceInfo[facei].valid(dummyTrackData))
+        {
+            label own = faceOwner[facei];
+
+            // Seed face with transported data from owner.
+            refinementData faceData;
+            faceData.updateFace
+            (
+                mesh_,
+                facei,
+                own,
+                allCellInfo[own],
+                FaceCellWave<refinementData, int>::propagationTol(),
+                dummyTrackData
+            );
+            seedFaces.append(facei);
+            seedFacesInfo.append(faceData);
+        }
+    }
+
+
+    // face-cell-face transport engine
+    FaceCellWave<refinementData, int> levelCalc
+    (
+        mesh_,
+        allFaceInfo,
+        allCellInfo,
+        dummyTrackData
+    );
+
+    while (true)
+    {
+        if (debug)
+        {
+            Pout<< "hexRef::consistentSlowRefinement : Seeded "
+                << seedFaces.size() << " faces between cells with different"
+                << " refinement level." << endl;
+        }
+
+        // Set seed faces
+        levelCalc.setFaceInfo(seedFaces.shrink(), seedFacesInfo.shrink());
+        seedFaces.clear();
+        seedFacesInfo.clear();
+
+        // Iterate until no change. Now 2:1 face difference should be satisfied
+        levelCalc.iterate(mesh_.globalData().nTotalFaces()+1);
+
+
+        // Now check point-connected cells (face-connected cells already ok):
+        // - get per point max of connected cells
+        // - sync across coupled points
+        // - check cells against above point max
+
+        if (maxPointDiff == -1)
+        {
+            // No need to do any point checking.
+            break;
+        }
+
+        // Determine per point the max cell level. (done as count, not
+        // as cell level purely for ease)
+        labelList maxPointCount(mesh_.nPoints(), 0);
+
+        forAll(maxPointCount, pointi)
+        {
+            label& pLevel = maxPointCount[pointi];
+
+            const labelList& pCells = mesh_.pointCells(pointi);
+
+            forAll(pCells, i)
+            {
+                pLevel = max(pLevel, allCellInfo[pCells[i]].count());
+            }
+        }
+
+        // Sync maxPointCount to neighbour
+        syncTools::syncPointList
+        (
+            mesh_,
+            maxPointCount,
+            maxEqOp<label>(),
+            labelMin            // null value
+        );
+
+        // Update allFaceInfo from maxPointCount for all points to check
+        // (usually on boundary faces)
+
+        // Per face the new refinement data
+        Map<refinementData> changedFacesInfo(pointsToCheck.size());
+
+        forAll(pointsToCheck, i)
+        {
+            label pointi = pointsToCheck[i];
+
+            // Loop over all cells using the point and check whether their
+            // refinement level is much less than the maximum.
+
+            const labelList& pCells = mesh_.pointCells(pointi);
+
+            forAll(pCells, pCelli)
+            {
+                label celli = pCells[pCelli];
+
+                refinementData& cellInfo = allCellInfo[celli];
+
+                if
+                (
+                   !cellInfo.isRefined()
+                 && (
+                        maxPointCount[pointi]
+                      > cellInfo.count() + maxFaceDiff*maxPointDiff
+                    )
+                )
+                {
+                    // Mark cell for refinement
+                    cellInfo.count() = cellInfo.refinementCount();
+
+                    // Insert faces of cell as seed faces.
+                    const cell& cFaces = mesh_.cells()[celli];
+
+                    forAll(cFaces, cFacei)
+                    {
+                        label facei = cFaces[cFacei];
+
+                        refinementData faceData;
+                        faceData.updateFace
+                        (
+                            mesh_,
+                            facei,
+                            celli,
+                            cellInfo,
+                            FaceCellWave<refinementData, int>::propagationTol(),
+                            dummyTrackData
+                        );
+
+                        if (faceData.count() > allFaceInfo[facei].count())
+                        {
+                            changedFacesInfo.insert(facei, faceData);
+                        }
+                    }
+                }
+            }
+        }
+
+        label nChanged = changedFacesInfo.size();
+        reduce(nChanged, sumOp<label>());
+
+        if (nChanged == 0)
+        {
+            break;
+        }
+
+
+        // Transfer into seedFaces, seedFacesInfo
+        seedFaces.setCapacity(changedFacesInfo.size());
+        seedFacesInfo.setCapacity(changedFacesInfo.size());
+
+        forAllConstIter(Map<refinementData>, changedFacesInfo, iter)
+        {
+            seedFaces.append(iter.key());
+            seedFacesInfo.append(iter());
+        }
+    }
+
+
+    if (debug)
+    {
+        for (label facei = 0; facei < mesh_.nInternalFaces(); facei++)
+        {
+            label own = mesh_.faceOwner()[facei];
+            label ownLevel =
+                cellLevel_[own]
+              + (allCellInfo[own].isRefined() ? 1 : 0);
+
+            label nei = mesh_.faceNeighbour()[facei];
+            label neiLevel =
+                cellLevel_[nei]
+              + (allCellInfo[nei].isRefined() ? 1 : 0);
+
+            if (mag(ownLevel-neiLevel) > 1)
+            {
+                dumpCell(own);
+                dumpCell(nei);
+                FatalErrorInFunction
+                    << "cell:" << own
+                    << " current level:" << cellLevel_[own]
+                    << " current refData:" << allCellInfo[own]
+                    << " level after refinement:" << ownLevel
+                    << nl
+                    << "neighbour cell:" << nei
+                    << " current level:" << cellLevel_[nei]
+                    << " current refData:" << allCellInfo[nei]
+                    << " level after refinement:" << neiLevel
+                    << nl
+                    << "which does not satisfy 2:1 constraints anymore." << nl
+                    << "face:" << facei << " faceRefData:" << allFaceInfo[facei]
+                    << abort(FatalError);
+            }
+        }
+
+
+        // Coupled faces. Swap owner level to get neighbouring cell level.
+        // (only boundary faces of neiLevel used)
+
+        labelList neiLevel(mesh_.nFaces()-mesh_.nInternalFaces());
+        labelList neiCount(mesh_.nFaces()-mesh_.nInternalFaces());
+        labelList neiRefCount(mesh_.nFaces()-mesh_.nInternalFaces());
+
+        forAll(neiLevel, i)
+        {
+            label own = mesh_.faceOwner()[i+mesh_.nInternalFaces()];
+            neiLevel[i] = cellLevel_[own];
+            neiCount[i] = allCellInfo[own].count();
+            neiRefCount[i] = allCellInfo[own].refinementCount();
+        }
+
+        // Swap to neighbour
+        syncTools::swapBoundaryFaceList(mesh_, neiLevel);
+        syncTools::swapBoundaryFaceList(mesh_, neiCount);
+        syncTools::swapBoundaryFaceList(mesh_, neiRefCount);
+
+        // Now we have neighbour value see which cells need refinement
+        forAll(neiLevel, i)
+        {
+            label facei = i+mesh_.nInternalFaces();
+
+            label own = mesh_.faceOwner()[facei];
+            label ownLevel =
+                cellLevel_[own]
+              + (allCellInfo[own].isRefined() ? 1 : 0);
+
+            label nbrLevel =
+                neiLevel[i]
+              + ((neiCount[i] >= neiRefCount[i]) ? 1 : 0);
+
+            if (mag(ownLevel - nbrLevel) > 1)
+            {
+                dumpCell(own);
+                label patchi = mesh_.boundaryMesh().whichPatch(facei);
+
+                FatalErrorInFunction
+                    << "Celllevel does not satisfy 2:1 constraint."
+                    << " On coupled face "
+                    << facei
+                    << " refData:" << allFaceInfo[facei]
+                    << " on patch " << patchi << " "
+                    << mesh_.boundaryMesh()[patchi].name() << nl
+                    << "owner cell " << own
+                    << " current level:" << cellLevel_[own]
+                    << " current count:" << allCellInfo[own].count()
+                    << " current refCount:"
+                    << allCellInfo[own].refinementCount()
+                    << " level after refinement:" << ownLevel
+                    << nl
+                    << "(coupled) neighbour cell"
+                    << " has current level:" << neiLevel[i]
+                    << " current count:" << neiCount[i]
+                    << " current refCount:" << neiRefCount[i]
+                    << " level after refinement:" << nbrLevel
+                    << abort(FatalError);
+            }
+        }
+    }
+
+    // Convert back to labelList of cells to refine.
+
+    label nRefined = 0;
+
+    forAll(allCellInfo, celli)
+    {
+        if (allCellInfo[celli].isRefined())
+        {
+            nRefined++;
+        }
+    }
+
+    // Updated list of cells to refine
+    labelList newCellsToRefine(nRefined);
+    nRefined = 0;
+
+    forAll(allCellInfo, celli)
+    {
+        if (allCellInfo[celli].isRefined())
+        {
+            newCellsToRefine[nRefined++] = celli;
+        }
+    }
+
+    if (debug)
+    {
+        Pout<< "hexRef::consistentSlowRefinement : From "
+            << cellsToRefine.size() << " to " << newCellsToRefine.size()
+            << " cells to refine." << endl;
+    }
+
+    return newCellsToRefine;
+}
+
+
+Foam::labelList Foam::hexRef::consistentSlowRefinement2
+(
+    const label maxFaceDiff,
+    const labelList& cellsToRefine,
+    const labelList& facesToCheck
+) const
+{
+    const labelList& faceOwner = mesh_.faceOwner();
+    const labelList& faceNeighbour = mesh_.faceNeighbour();
+
+    if (maxFaceDiff <= 0)
+    {
+        FatalErrorInFunction
+            << "Illegal maxFaceDiff " << maxFaceDiff << nl
+            << "Value should be >= 1" << exit(FatalError);
+    }
+
+    const scalar level0Size = 2*maxFaceDiff*level0EdgeLength();
+
+
+    // Bit tricky. Say we want a distance of three cells between two
+    // consecutive refinement levels. This is done by using FaceCellWave to
+    // transport out the 'refinement shell'. Anything inside the refinement
+    // shell (given by a distance) gets marked for refinement.
+
+    // Initial information about (distance to) cellLevel on all cells
+    List<refinementDistanceData> allCellInfo(mesh_.nCells());
+
+    // Initial information about (distance to) cellLevel on all faces
+    List<refinementDistanceData> allFaceInfo(mesh_.nFaces());
+
+    // Dummy additional info for FaceCellWave
+    int dummyTrackData = 0;
+
+
+    // Mark cells with wanted refinement level
+    forAll(cellsToRefine, i)
+    {
+        label celli = cellsToRefine[i];
+
+        allCellInfo[celli] = refinementDistanceData
+        (
+            level0Size,
+            mesh_.cellCentres()[celli],
+            cellLevel_[celli]+1             // wanted refinement
+        );
+    }
+    // Mark all others with existing refinement level
+    forAll(allCellInfo, celli)
+    {
+        if (!allCellInfo[celli].valid(dummyTrackData))
+        {
+            allCellInfo[celli] = refinementDistanceData
+            (
+                level0Size,
+                mesh_.cellCentres()[celli],
+                cellLevel_[celli]           // wanted refinement
+            );
+        }
+    }
+
+
+    // Labels of seed faces
+    DynamicList<label> seedFaces(mesh_.nFaces()/100);
+    // refinementLevel data on seed faces
+    DynamicList<refinementDistanceData> seedFacesInfo(mesh_.nFaces()/100);
+
+    const pointField& cc = mesh_.cellCentres();
+
+    forAll(facesToCheck, i)
+    {
+        label facei = facesToCheck[i];
+
+        if (allFaceInfo[facei].valid(dummyTrackData))
+        {
+            // Can only occur if face has already gone through loop below.
+            FatalErrorInFunction
+                << "Argument facesToCheck seems to have duplicate entries!"
+                << endl
+                << "face:" << facei << " occurs at positions "
+                << findIndices(facesToCheck, facei)
+                << abort(FatalError);
+        }
+
+        label own = faceOwner[facei];
+
+        label ownLevel =
+        (
+            allCellInfo[own].valid(dummyTrackData)
+          ? allCellInfo[own].originLevel()
+          : cellLevel_[own]
+        );
+
+        if (!mesh_.isInternalFace(facei))
+        {
+            // Do as if boundary face would have neighbour with one higher
+            // refinement level.
+            const point& fc = mesh_.faceCentres()[facei];
+
+            refinementDistanceData neiData
+            (
+                level0Size,
+                2*fc - cc[own],    // est'd cell centre
+                ownLevel+1
+            );
+
+            allFaceInfo[facei].updateFace
+            (
+                mesh_,
+                facei,
+                own,        // not used (should be nei)
+                neiData,
+                FaceCellWave<refinementDistanceData, int>::propagationTol(),
+                dummyTrackData
+            );
+        }
+        else
+        {
+            label nei = faceNeighbour[facei];
+
+            label neiLevel =
+            (
+                allCellInfo[nei].valid(dummyTrackData)
+              ? allCellInfo[nei].originLevel()
+              : cellLevel_[nei]
+            );
+
+            if (ownLevel == neiLevel)
+            {
+                // Fake as if nei>own or own>nei (whichever one 'wins')
+                allFaceInfo[facei].updateFace
+                (
+                    mesh_,
+                    facei,
+                    nei,
+                    refinementDistanceData(level0Size, cc[nei], neiLevel+1),
+                    FaceCellWave<refinementDistanceData, int>::propagationTol(),
+                    dummyTrackData
+                );
+                allFaceInfo[facei].updateFace
+                (
+                    mesh_,
+                    facei,
+                    own,
+                    refinementDistanceData(level0Size, cc[own], ownLevel+1),
+                    FaceCellWave<refinementDistanceData, int>::propagationTol(),
+                    dummyTrackData
+                );
+            }
+            else
+            {
+                // Difference in level anyway.
+                allFaceInfo[facei].updateFace
+                (
+                    mesh_,
+                    facei,
+                    nei,
+                    refinementDistanceData(level0Size, cc[nei], neiLevel),
+                    FaceCellWave<refinementDistanceData, int>::propagationTol(),
+                    dummyTrackData
+                );
+                allFaceInfo[facei].updateFace
+                (
+                    mesh_,
+                    facei,
+                    own,
+                    refinementDistanceData(level0Size, cc[own], ownLevel),
+                    FaceCellWave<refinementDistanceData, int>::propagationTol(),
+                    dummyTrackData
+                );
+            }
+        }
+        seedFaces.append(facei);
+        seedFacesInfo.append(allFaceInfo[facei]);
+    }
+
+
+    // Create some initial seeds to start walking from. This is only if there
+    // are no facesToCheck.
+    // Just seed with all faces inbetween different refinement levels for now
+    forAll(faceNeighbour, facei)
+    {
+        // Check if face already handled in loop above
+        if (!allFaceInfo[facei].valid(dummyTrackData))
+        {
+            label own = faceOwner[facei];
+
+            label ownLevel =
+            (
+                allCellInfo[own].valid(dummyTrackData)
+              ? allCellInfo[own].originLevel()
+              : cellLevel_[own]
+            );
+
+            label nei = faceNeighbour[facei];
+
+            label neiLevel =
+            (
+                allCellInfo[nei].valid(dummyTrackData)
+              ? allCellInfo[nei].originLevel()
+              : cellLevel_[nei]
+            );
+
+            if (ownLevel > neiLevel)
+            {
+                // Set face to owner data. (since face not yet would be copy)
+                seedFaces.append(facei);
+                allFaceInfo[facei].updateFace
+                (
+                    mesh_,
+                    facei,
+                    own,
+                    refinementDistanceData(level0Size, cc[own], ownLevel),
+                    FaceCellWave<refinementDistanceData, int>::propagationTol(),
+                    dummyTrackData
+                );
+                seedFacesInfo.append(allFaceInfo[facei]);
+            }
+            else if (neiLevel > ownLevel)
+            {
+                seedFaces.append(facei);
+                allFaceInfo[facei].updateFace
+                (
+                    mesh_,
+                    facei,
+                    nei,
+                    refinementDistanceData(level0Size, cc[nei], neiLevel),
+                    FaceCellWave<refinementDistanceData, int>::propagationTol(),
+                    dummyTrackData
+                );
+                seedFacesInfo.append(allFaceInfo[facei]);
+            }
+        }
+    }
+
+    seedFaces.shrink();
+    seedFacesInfo.shrink();
+
+    // face-cell-face transport engine
+    FaceCellWave<refinementDistanceData, int> levelCalc
+    (
+        mesh_,
+        seedFaces,
+        seedFacesInfo,
+        allFaceInfo,
+        allCellInfo,
+        mesh_.globalData().nTotalCells()+1,
+        dummyTrackData
+    );
+
+
+    //if (debug)
+    //{
+    //    // Dump wanted level
+    //    volScalarField wantedLevel
+    //    (
+    //        IOobject
+    //        (
+    //            "wantedLevel",
+    //            fMesh.time().timeName(),
+    //            fMesh,
+    //            IOobject::NO_READ,
+    //            IOobject::NO_WRITE,
+    //            false
+    //        ),
+    //        fMesh,
+    //        dimensionedScalar("zero", dimless, 0)
+    //    );
+    //
+    //    forAll(wantedLevel, celli)
+    //    {
+    //        wantedLevel[celli] = allCellInfo[celli].wantedLevel(cc[celli]);
+    //    }
+    //
+    //    Pout<< "Writing " << wantedLevel.objectPath() << endl;
+    //    wantedLevel.write();
+    //}
+
+
+    // Convert back to labelList of cells to refine.
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    // 1. Force original refinement cells to be picked up by setting the
+    // originLevel of input cells to be a very large level (but within range
+    // of 1<< shift inside refinementDistanceData::wantedLevel)
+    forAll(cellsToRefine, i)
+    {
+        label celli = cellsToRefine[i];
+
+        allCellInfo[celli].originLevel() = sizeof(label)*8-2;
+        allCellInfo[celli].origin() = cc[celli];
+    }
+
+    // 2. Extend to 2:1. I don't understand yet why this is not done
+    // 2. Extend to 2:1. For non-cube cells the scalar distance does not work
+    // so make sure it at least provides 2:1.
+    PackedBoolList refineCell(mesh_.nCells());
+    forAll(allCellInfo, celli)
+    {
+        label wanted = allCellInfo[celli].wantedLevel(cc[celli]);
+
+        if (wanted > cellLevel_[celli]+1)
+        {
+            refineCell.set(celli);
+        }
+    }
+    faceConsistentRefinement(true, refineCell);
+
+    while (true)
+    {
+        label nChanged = faceConsistentRefinement(true, refineCell);
+
+        reduce(nChanged, sumOp<label>());
+
+        if (debug)
+        {
+            Pout<< "hexRef::consistentSlowRefinement2 : Changed " << nChanged
+                << " refinement levels due to 2:1 conflicts."
+                << endl;
+        }
+
+        if (nChanged == 0)
+        {
+            break;
+        }
+    }
+
+    // 3. Convert back to labelList.
+    label nRefined = 0;
+
+    forAll(refineCell, celli)
+    {
+//        if (refineCell.get(celli))
+        if (refineCell[celli])
+        {
+            nRefined++;
+        }
+    }
+
+    labelList newCellsToRefine(nRefined);
+    nRefined = 0;
+
+    forAll(refineCell, celli)
+    {
+//        if (refineCell.get(celli))
+        if (refineCell[celli])
+        {
+            newCellsToRefine[nRefined++] = celli;
+        }
+    }
+
+    if (debug)
+    {
+        Pout<< "hexRef::consistentSlowRefinement2 : From "
+            << cellsToRefine.size() << " to " << newCellsToRefine.size()
+            << " cells to refine." << endl;
+
+        // Check that newCellsToRefine obeys at least 2:1.
+
+        {
+            cellSet cellsIn(mesh_, "cellsToRefineIn", cellsToRefine);
+            Pout<< "hexRef::consistentSlowRefinement2 : writing "
+                << cellsIn.size() << " to cellSet "
+                << cellsIn.objectPath() << endl;
+            cellsIn.write();
+        }
+        {
+            cellSet cellsOut(mesh_, "cellsToRefineOut", newCellsToRefine);
+            Pout<< "hexRef::consistentSlowRefinement2 : writing "
+                << cellsOut.size() << " to cellSet "
+                << cellsOut.objectPath() << endl;
+            cellsOut.write();
+        }
+
+        // Extend to 2:1
+        PackedBoolList refineCell(mesh_.nCells());
+        forAll(newCellsToRefine, i)
+        {
+            refineCell.set(newCellsToRefine[i]);
+        }
+        const PackedBoolList savedRefineCell(refineCell);
+
+        label nChanged = faceConsistentRefinement(true, refineCell);
+
+        {
+            cellSet cellsOut2
+            (
+                mesh_, "cellsToRefineOut2", newCellsToRefine.size()
+            );
+            forAll(refineCell, celli)
+            {
+                if (refineCell.get(celli))
+                {
+                    cellsOut2.insert(celli);
+                }
+            }
+            Pout<< "hexRef::consistentSlowRefinement2 : writing "
+                << cellsOut2.size() << " to cellSet "
+                << cellsOut2.objectPath() << endl;
+            cellsOut2.write();
+        }
+
+        if (nChanged > 0)
+        {
+            forAll(refineCell, celli)
+            {
+                if (refineCell.get(celli) && !savedRefineCell.get(celli))
+                {
+                    dumpCell(celli);
+                    FatalErrorInFunction
+                        << "Cell:" << celli << " cc:"
+                        << mesh_.cellCentres()[celli]
+                        << " was not marked for refinement but does not obey"
+                        << " 2:1 constraints."
+                        << abort(FatalError);
+                }
+            }
+        }
+    }
+
+    return newCellsToRefine;
+}
+
+
+void Foam::hexRef::storeData
+(
+    const labelList& pointsToStore,
+    const labelList& facesToStore,
+    const labelList& cellsToStore
+)
+{
+    savedPointLevel_.resize(2*pointsToStore.size());
+    forAll(pointsToStore, i)
+    {
+        label pointi = pointsToStore[i];
+        savedPointLevel_.insert(pointi, pointLevel_[pointi]);
+    }
+
+    savedCellLevel_.resize(2*cellsToStore.size());
+    forAll(cellsToStore, i)
+    {
+        label celli = cellsToStore[i];
+        savedCellLevel_.insert(celli, cellLevel_[celli]);
+    }
+}
+
+
+// Gets called after the mesh change. setRefinement will already have made
+// sure the pointLevel_ and cellLevel_ are the size of the new mesh so we
+// only need to account for reordering.
+void Foam::hexRef::updateMesh(const mapPolyMesh& map)
+{
+    Map<label> dummyMap(0);
+
+    updateMesh(map, dummyMap, dummyMap, dummyMap);
+}
+
+
+// Gets called after the mesh change. setRefinement will already have made
+// sure the pointLevel_ and cellLevel_ are the size of the new mesh so we
+// only need to account for reordering.
+void Foam::hexRef::updateMesh
+(
+    const mapPolyMesh& map,
+    const Map<label>& pointsToRestore,
+    const Map<label>& facesToRestore,
+    const Map<label>& cellsToRestore
+)
+{
+    // Update celllevel
+    if (debug)
+    {
+        Pout<< "hexRef::updateMesh :"
+            << " Updating various lists"
+            << endl;
+    }
+
+    {
+        const labelList& reverseCellMap = map.reverseCellMap();
+
+        if (debug)
+        {
+            Pout<< "hexRef::updateMesh :"
+                << " reverseCellMap:" << map.reverseCellMap().size()
+                << " cellMap:" << map.cellMap().size()
+                << " nCells:" << mesh_.nCells()
+                << " nOldCells:" << map.nOldCells()
+                << " cellLevel_:" << cellLevel_.size()
+                << " reversePointMap:" << map.reversePointMap().size()
+                << " pointMap:" << map.pointMap().size()
+                << " nPoints:" << mesh_.nPoints()
+                << " nOldPoints:" << map.nOldPoints()
+                << " pointLevel_:" << pointLevel_.size()
+                << endl;
+        }
+
+        if (reverseCellMap.size() == cellLevel_.size())
+        {
+            // Assume it is after hexRef that this routine is called.
+            // Just account for reordering. We cannot use cellMap since
+            // then cells created from cells would get cellLevel_ of
+            // cell they were created from.
+            reorder(reverseCellMap, mesh_.nCells(), -1, cellLevel_);
+        }
+        else
+        {
+            // Map data
+            const labelList& cellMap = map.cellMap();
+
+            labelList newCellLevel(cellMap.size());
+            forAll(cellMap, newCelli)
+            {
+                label oldCelli = cellMap[newCelli];
+
+                if (oldCelli == -1)
+                {
+                    newCellLevel[newCelli] = -1;
+                }
+                else
+                {
+                    newCellLevel[newCelli] = cellLevel_[oldCelli];
+                }
+            }
+            cellLevel_.transfer(newCellLevel);
+        }
+
+        // See if any cells to restore. This will be for some new cells
+        // the corresponding old cell.
+        forAllConstIter(Map<label>, cellsToRestore, iter)
+        {
+            label newCelli = iter.key();
+            label storedCelli = iter();
+
+            Map<label>::iterator fnd = savedCellLevel_.find(storedCelli);
+
+            if (fnd == savedCellLevel_.end())
+            {
+                FatalErrorInFunction
+                    << "Problem : trying to restore old value for new cell "
+                    << newCelli << " but cannot find old cell " << storedCelli
+                    << " in map of stored values " << savedCellLevel_
+                    << abort(FatalError);
+            }
+            cellLevel_[newCelli] = fnd();
+        }
+
+        //if (findIndex(cellLevel_, -1) != -1)
+        //{
+        //    WarningInFunction
+        //        << "Problem : "
+        //        << "cellLevel_ contains illegal value -1 after mapping
+        //        << " at cell " << findIndex(cellLevel_, -1) << endl
+        //        << "This means that another program has inflated cells"
+        //        << " (created cells out-of-nothing) and hence we don't know"
+        //        << " their cell level. Continuing with illegal value."
+        //        << abort(FatalError);
+        //}
+    }
+
+
+    // Update pointlevel
+    {
+        const labelList& reversePointMap = map.reversePointMap();
+
+        if (reversePointMap.size() == pointLevel_.size())
+        {
+            // Assume it is after hexRef that this routine is called.
+            reorder(reversePointMap, mesh_.nPoints(), -1,  pointLevel_);
+        }
+        else
+        {
+            // Map data
+            const labelList& pointMap = map.pointMap();
+
+            labelList newPointLevel(pointMap.size());
+
+            forAll(pointMap, newPointi)
+            {
+                label oldPointi = pointMap[newPointi];
+
+                if (oldPointi == -1)
+                {
+                    //FatalErrorInFunction
+                    //    << "Problem : point " << newPointi
+                    //    << " at " << mesh_.points()[newPointi]
+                    //    << " does not originate from another point"
+                    //    << " (i.e. is inflated)." << nl
+                    //    << "Hence we cannot determine the new pointLevel"
+                    //    << " for it." << abort(FatalError);
+                    newPointLevel[newPointi] = -1;
+                }
+                else
+                {
+                    newPointLevel[newPointi] = pointLevel_[oldPointi];
+                }
+            }
+            pointLevel_.transfer(newPointLevel);
+        }
+
+        // See if any points to restore. This will be for some new points
+        // the corresponding old point (the one from the call to storeData)
+        forAllConstIter(Map<label>, pointsToRestore, iter)
+        {
+            label newPointi = iter.key();
+            label storedPointi = iter();
+
+            Map<label>::iterator fnd = savedPointLevel_.find(storedPointi);
+
+            if (fnd == savedPointLevel_.end())
+            {
+                FatalErrorInFunction
+                    << "Problem : trying to restore old value for new point "
+                    << newPointi << " but cannot find old point "
+                    << storedPointi
+                    << " in map of stored values " << savedPointLevel_
+                    << abort(FatalError);
+            }
+            pointLevel_[newPointi] = fnd();
+        }
+
+        //if (findIndex(pointLevel_, -1) != -1)
+        //{
+        //    WarningInFunction
+        //        << "Problem : "
+        //        << "pointLevel_ contains illegal value -1 after mapping"
+        //        << " at point" << findIndex(pointLevel_, -1) << endl
+        //        << "This means that another program has inflated points"
+        //        << " (created points out-of-nothing) and hence we don't know"
+        //        << " their point level. Continuing with illegal value."
+        //        //<< abort(FatalError);
+        //}
+    }
+
+    // Update refinement tree
+    if (history_.active())
+    {
+        history_.updateMesh(map);
+    }
+
+    // Mark files as changed
+    setInstance(mesh_.facesInstance());
+
+    // Update face removal engine
+    faceRemover_.updateMesh(map);
+
+    // Clear cell shapes
+    cellShapesPtr_.clear();
+}
+
+
+// Gets called after mesh subsetting. Maps are from new back to old.
+void Foam::hexRef::subset
+(
+    const labelList& pointMap,
+    const labelList& faceMap,
+    const labelList& cellMap
+)
+{
+    // Update celllevel
+    if (debug)
+    {
+        Pout<< "hexRef::subset :"
+            << " Updating various lists"
+            << endl;
+    }
+
+    if (history_.active())
+    {
+        WarningInFunction
+            << "Subsetting will not work in combination with unrefinement."
+            << nl
+            << "Proceed at your own risk." << endl;
+    }
+
+
+    // Update celllevel
+    {
+        labelList newCellLevel(cellMap.size());
+
+        forAll(cellMap, newCelli)
+        {
+            newCellLevel[newCelli] = cellLevel_[cellMap[newCelli]];
+        }
+
+        cellLevel_.transfer(newCellLevel);
+
+        if (findIndex(cellLevel_, -1) != -1)
+        {
+            FatalErrorInFunction
+                << "Problem : "
+                << "cellLevel_ contains illegal value -1 after mapping:"
+                << cellLevel_
+                << abort(FatalError);
+        }
+    }
+
+    // Update pointlevel
+    {
+        labelList newPointLevel(pointMap.size());
+
+        forAll(pointMap, newPointi)
+        {
+            newPointLevel[newPointi] = pointLevel_[pointMap[newPointi]];
+        }
+
+        pointLevel_.transfer(newPointLevel);
+
+        if (findIndex(pointLevel_, -1) != -1)
+        {
+            FatalErrorInFunction
+                << "Problem : "
+                << "pointLevel_ contains illegal value -1 after mapping:"
+                << pointLevel_
+                << abort(FatalError);
+        }
+    }
+
+    // Update refinement tree
+    if (history_.active())
+    {
+        history_.subset(pointMap, faceMap, cellMap);
+    }
+
+    // Mark files as changed
+    setInstance(mesh_.facesInstance());
+
+    // Nothing needs doing to faceRemover.
+    //faceRemover_.subset(pointMap, faceMap, cellMap);
+
+    // Clear cell shapes
+    cellShapesPtr_.clear();
+}
+
+
+// Gets called after the mesh distribution
+void Foam::hexRef::distribute(const mapDistributePolyMesh& map)
+{
+    if (debug)
+    {
+        Pout<< "hexRef::distribute :"
+            << " Updating various lists"
+            << endl;
+    }
+
+    // Update celllevel
+    map.distributeCellData(cellLevel_);
+    // Update pointlevel
+    map.distributePointData(pointLevel_);
+
+    // Update refinement tree
+    if (history_.active())
+    {
+        history_.distribute(map);
+    }
+
+    // Update face removal engine
+    faceRemover_.distribute(map);
+
+    // Clear cell shapes
+    cellShapesPtr_.clear();
+}
+
+
+void Foam::hexRef::checkMesh() const
+{
+    const scalar smallDim = 1e-6 * mesh_.bounds().mag();
+
+    if (debug)
+    {
+        Pout<< "hexRef::checkMesh : Using matching tolerance smallDim:"
+            << smallDim << endl;
+    }
+
+    // Check owner on coupled faces.
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    // There should be only one coupled face between two cells. Why? Since
+    // otherwise mesh redistribution might cause multiple faces between two
+    // cells
+    {
+        labelList nei(mesh_.nFaces()-mesh_.nInternalFaces());
+        forAll(nei, i)
+        {
+            nei[i] = mesh_.faceOwner()[i+mesh_.nInternalFaces()];
+        }
+
+        // Replace data on coupled patches with their neighbour ones.
+        syncTools::swapBoundaryFaceList(mesh_, nei);
+
+        const polyBoundaryMesh& patches = mesh_.boundaryMesh();
+
+        forAll(patches, patchi)
+        {
+            const polyPatch& pp = patches[patchi];
+
+            if (pp.coupled())
+            {
+                // Check how many faces between owner and neighbour. Should
+                // be only one.
+                HashTable<label, labelPair, labelPair::Hash<>>
+                    cellToFace(2*pp.size());
+
+                label facei = pp.start();
+
+                forAll(pp, i)
+                {
+                    label own = mesh_.faceOwner()[facei];
+                    label bFacei = facei-mesh_.nInternalFaces();
+
+                    if (!cellToFace.insert(labelPair(own, nei[bFacei]), facei))
+                    {
+                        dumpCell(own);
+                        FatalErrorInFunction
+                            << "Faces do not seem to be correct across coupled"
+                            << " boundaries" << endl
+                            << "Coupled face " << facei
+                            << " between owner " << own
+                            << " on patch " << pp.name()
+                            << " and coupled neighbour " << nei[bFacei]
+                            << " has two faces connected to it:"
+                            << facei << " and "
+                            << cellToFace[labelPair(own, nei[bFacei])]
+                            << abort(FatalError);
+                    }
+
+                    facei++;
+                }
+            }
+        }
+    }
+
+    // Check face areas.
+    // ~~~~~~~~~~~~~~~~~
+
+    {
+        scalarField neiFaceAreas(mesh_.nFaces()-mesh_.nInternalFaces());
+        forAll(neiFaceAreas, i)
+        {
+            neiFaceAreas[i] = mag(mesh_.faceAreas()[i+mesh_.nInternalFaces()]);
+        }
+
+        // Replace data on coupled patches with their neighbour ones.
+        syncTools::swapBoundaryFaceList(mesh_, neiFaceAreas);
+
+        forAll(neiFaceAreas, i)
+        {
+            label facei = i+mesh_.nInternalFaces();
+
+            const scalar magArea = mag(mesh_.faceAreas()[facei]);
+
+            if (mag(magArea - neiFaceAreas[i]) > smallDim)
+            {
+                const face& f = mesh_.faces()[facei];
+                label patchi = mesh_.boundaryMesh().whichPatch(facei);
+
+                dumpCell(mesh_.faceOwner()[facei]);
+
+                FatalErrorInFunction
+                    << "Faces do not seem to be correct across coupled"
+                    << " boundaries" << endl
+                    << "Coupled face " << facei
+                    << " on patch " << patchi
+                    << " " << mesh_.boundaryMesh()[patchi].name()
+                    << " coords:" << UIndirectList<point>(mesh_.points(), f)()
+                    << " has face area:" << magArea
+                    << " (coupled) neighbour face area differs:"
+                    << neiFaceAreas[i]
+                    << " to within tolerance " << smallDim
+                    << abort(FatalError);
+            }
+        }
+    }
+
+
+    // Check number of points on faces.
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    {
+        labelList nVerts(mesh_.nFaces()-mesh_.nInternalFaces());
+
+        forAll(nVerts, i)
+        {
+            nVerts[i] = mesh_.faces()[i+mesh_.nInternalFaces()].size();
+        }
+
+        // Replace data on coupled patches with their neighbour ones.
+        syncTools::swapBoundaryFaceList(mesh_, nVerts);
+
+        forAll(nVerts, i)
+        {
+            label facei = i+mesh_.nInternalFaces();
+
+            const face& f = mesh_.faces()[facei];
+
+            if (f.size() != nVerts[i])
+            {
+                dumpCell(mesh_.faceOwner()[facei]);
+
+                label patchi = mesh_.boundaryMesh().whichPatch(facei);
+
+                FatalErrorInFunction
+                    << "Faces do not seem to be correct across coupled"
+                    << " boundaries" << endl
+                    << "Coupled face " << facei
+                    << " on patch " << patchi
+                    << " " << mesh_.boundaryMesh()[patchi].name()
+                    << " coords:" << UIndirectList<point>(mesh_.points(), f)()
+                    << " has size:" << f.size()
+                    << " (coupled) neighbour face has size:"
+                    << nVerts[i]
+                    << abort(FatalError);
+            }
+        }
+    }
+
+
+    // Check points of face
+    // ~~~~~~~~~~~~~~~~~~~~
+    {
+        // Anchor points.
+        pointField anchorPoints(mesh_.nFaces()-mesh_.nInternalFaces());
+
+        forAll(anchorPoints, i)
+        {
+            label facei = i+mesh_.nInternalFaces();
+            const point& fc = mesh_.faceCentres()[facei];
+            const face& f = mesh_.faces()[facei];
+            const vector anchorVec(mesh_.points()[f[0]] - fc);
+
+            anchorPoints[i] = anchorVec;
+        }
+
+        // Replace data on coupled patches with their neighbour ones. Apply
+        // rotation transformation (but not separation since is relative vector
+        // to point on same face.
+        syncTools::swapBoundaryFaceList(mesh_, anchorPoints);
+
+        forAll(anchorPoints, i)
+        {
+            label facei = i+mesh_.nInternalFaces();
+            const point& fc = mesh_.faceCentres()[facei];
+            const face& f = mesh_.faces()[facei];
+            const vector anchorVec(mesh_.points()[f[0]] - fc);
+
+            if (mag(anchorVec - anchorPoints[i]) > smallDim)
+            {
+                dumpCell(mesh_.faceOwner()[facei]);
+
+                label patchi = mesh_.boundaryMesh().whichPatch(facei);
+
+                FatalErrorInFunction
+                    << "Faces do not seem to be correct across coupled"
+                    << " boundaries" << endl
+                    << "Coupled face " << facei
+                    << " on patch " << patchi
+                    << " " << mesh_.boundaryMesh()[patchi].name()
+                    << " coords:" << UIndirectList<point>(mesh_.points(), f)()
+                    << " has anchor vector:" << anchorVec
+                    << " (coupled) neighbour face anchor vector differs:"
+                    << anchorPoints[i]
+                    << " to within tolerance " << smallDim
+                    << abort(FatalError);
+            }
+        }
+    }
+
+    if (debug)
+    {
+        Pout<< "hexRef::checkMesh : Returning" << endl;
+    }
+}
+
+
+void Foam::hexRef::checkRefinementLevels
+(
+    const label maxPointDiff,
+    const labelList& pointsToCheck
+) const
+{
+    if (debug)
+    {
+        Pout<< "hexRef::checkRefinementLevels :"
+            << " Checking 2:1 refinement level" << endl;
+    }
+
+    if
+    (
+        cellLevel_.size() != mesh_.nCells()
+     || pointLevel_.size() != mesh_.nPoints()
+    )
+    {
+        FatalErrorInFunction
+            << "cellLevel size should be number of cells"
+            << " and pointLevel size should be number of points."<< nl
+            << "cellLevel:" << cellLevel_.size()
+            << " mesh.nCells():" << mesh_.nCells() << nl
+            << "pointLevel:" << pointLevel_.size()
+            << " mesh.nPoints():" << mesh_.nPoints()
+            << abort(FatalError);
+    }
+
+
+    // Check 2:1 consistency.
+    // ~~~~~~~~~~~~~~~~~~~~~~
+
+    {
+        // Internal faces.
+        for (label facei = 0; facei < mesh_.nInternalFaces(); facei++)
+        {
+            label own = mesh_.faceOwner()[facei];
+            label nei = mesh_.faceNeighbour()[facei];
+
+            if (mag(cellLevel_[own] - cellLevel_[nei]) > 1)
+            {
+                dumpCell(own);
+                dumpCell(nei);
+
+                FatalErrorInFunction
+                    << "Celllevel does not satisfy 2:1 constraint." << nl
+                    << "On face " << facei << " owner cell " << own
+                    << " has refinement " << cellLevel_[own]
+                    << " neighbour cell " << nei << " has refinement "
+                    << cellLevel_[nei]
+                    << abort(FatalError);
+            }
+        }
+
+        // Coupled faces. Get neighbouring value
+        labelList neiLevel(mesh_.nFaces()-mesh_.nInternalFaces());
+
+        forAll(neiLevel, i)
+        {
+            label own = mesh_.faceOwner()[i+mesh_.nInternalFaces()];
+
+            neiLevel[i] = cellLevel_[own];
+        }
+
+        // No separation
+        syncTools::swapBoundaryFaceList(mesh_, neiLevel);
+
+        forAll(neiLevel, i)
+        {
+            label facei = i+mesh_.nInternalFaces();
+
+            label own = mesh_.faceOwner()[facei];
+
+            if (mag(cellLevel_[own] - neiLevel[i]) > 1)
+            {
+                dumpCell(own);
+
+                label patchi = mesh_.boundaryMesh().whichPatch(facei);
+
+                FatalErrorInFunction
+                    << "Celllevel does not satisfy 2:1 constraint."
+                    << " On coupled face " << facei
+                    << " on patch " << patchi << " "
+                    << mesh_.boundaryMesh()[patchi].name()
+                    << " owner cell " << own << " has refinement "
+                    << cellLevel_[own]
+                    << " (coupled) neighbour cell has refinement "
+                    << neiLevel[i]
+                    << abort(FatalError);
+            }
+        }
+    }
+
+
+    // Check pointLevel is synchronized
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    {
+        labelList syncPointLevel(pointLevel_);
+
+        // Get min level
+        syncTools::syncPointList
+        (
+            mesh_,
+            syncPointLevel,
+            minEqOp<label>(),
+            labelMax
+        );
+
+
+        forAll(syncPointLevel, pointi)
+        {
+            if (pointLevel_[pointi] != syncPointLevel[pointi])
+            {
+                FatalErrorInFunction
+                    << "PointLevel is not consistent across coupled patches."
+                    << endl
+                    << "point:" << pointi << " coord:" << mesh_.points()[pointi]
+                    << " has level " << pointLevel_[pointi]
+                    << " whereas the coupled point has level "
+                    << syncPointLevel[pointi]
+                    << abort(FatalError);
+            }
+        }
+    }
+
+
+    // Check 2:1 across points (instead of faces)
+    if (maxPointDiff != -1)
+    {
+        // Determine per point the max cell level.
+        labelList maxPointLevel(mesh_.nPoints(), 0);
+
+        forAll(maxPointLevel, pointi)
+        {
+            const labelList& pCells = mesh_.pointCells(pointi);
+
+            label& pLevel = maxPointLevel[pointi];
+
+            forAll(pCells, i)
+            {
+                pLevel = max(pLevel, cellLevel_[pCells[i]]);
+            }
+        }
+
+        // Sync maxPointLevel to neighbour
+        syncTools::syncPointList
+        (
+            mesh_,
+            maxPointLevel,
+            maxEqOp<label>(),
+            labelMin            // null value
+        );
+
+        // Check 2:1 across boundary points
+        forAll(pointsToCheck, i)
+        {
+            label pointi = pointsToCheck[i];
+
+            const labelList& pCells = mesh_.pointCells(pointi);
+
+            forAll(pCells, i)
+            {
+                label celli = pCells[i];
+
+                if
+                (
+                    mag(cellLevel_[celli]-maxPointLevel[pointi])
+                  > maxPointDiff
+                )
+                {
+                    dumpCell(celli);
+
+                    FatalErrorInFunction
+                        << "Too big a difference between"
+                        << " point-connected cells." << nl
+                        << "cell:" << celli
+                        << " cellLevel:" << cellLevel_[celli]
+                        << " uses point:" << pointi
+                        << " coord:" << mesh_.points()[pointi]
+                        << " which is also used by a cell with level:"
+                        << maxPointLevel[pointi]
+                        << abort(FatalError);
+                }
+            }
+        }
+    }
+
+
+    //- Gives problems after first splitting off inside mesher.
+    //// Hanging points
+    //{
+    //    // Any patches with points having only two edges.
+    //
+    //    boolList isHangingPoint(mesh_.nPoints(), false);
+    //
+    //    const polyBoundaryMesh& patches = mesh_.boundaryMesh();
+    //
+    //    forAll(patches, patchi)
+    //    {
+    //        const polyPatch& pp = patches[patchi];
+    //
+    //        const labelList& meshPoints = pp.meshPoints();
+    //
+    //        forAll(meshPoints, i)
+    //        {
+    //            label pointi = meshPoints[i];
+    //
+    //            const labelList& pEdges = mesh_.pointEdges()[pointi];
+    //
+    //            if (pEdges.size() == 2)
+    //            {
+    //                isHangingPoint[pointi] = true;
+    //            }
+    //        }
+    //    }
+    //
+    //    syncTools::syncPointList
+    //    (
+    //        mesh_,
+    //        isHangingPoint,
+    //        andEqOp<bool>(),        // only if all decide it is hanging point
+    //        true,                   // null
+    //        false                   // no separation
+    //    );
+    //
+    //    //OFstream str(mesh_.time().path()/"hangingPoints.obj");
+    //
+    //    label nHanging = 0;
+    //
+    //    forAll(isHangingPoint, pointi)
+    //    {
+    //        if (isHangingPoint[pointi])
+    //        {
+    //            nHanging++;
+    //
+    //            Pout<< "Hanging boundary point " << pointi
+    //                << " at " << mesh_.points()[pointi]
+    //                << endl;
+    //            //meshTools::writeOBJ(str, mesh_.points()[pointi]);
+    //        }
+    //    }
+    //
+    //    if (returnReduce(nHanging, sumOp<label>()) > 0)
+    //    {
+    //        FatalErrorInFunction
+    //            << "Detected a point used by two edges only (hanging point)"
+    //            << nl << "This is not allowed"
+    //            << abort(FatalError);
+    //    }
+    //}
+}
+
+
+const Foam::cellShapeList& Foam::hexRef::cellShapes() const
+{
+    if (cellShapesPtr_.empty())
+    {
+        if (debug)
+        {
+            Pout<< "hexRef::cellShapes() : calculating splitHex cellShapes."
+                << " cellLevel:" << cellLevel_.size()
+                << " pointLevel:" << pointLevel_.size()
+                << endl;
+        }
+
+        const cellShapeList& meshShapes = mesh_.cellShapes();
+        cellShapesPtr_.reset(new cellShapeList(meshShapes));
+
+        label nSplitHex = 0;
+        label nUnrecognised = 0;
+
+        forAll(cellLevel_, celli)
+        {
+            if (meshShapes[celli].model().index() == 0)
+            {
+                label level = cellLevel_[celli];
+
+                // Return true if we've found 6 quads
+                DynamicList<face> quads;
+                bool haveQuads = matchHexShape
+                (
+                    celli,
+                    level,
+                    quads
+                );
+
+                if (haveQuads)
+                {
+                    // faceList faces(quads.xfer());
+                    faceList faces(quads);
+                    cellShapesPtr_()[celli] = degenerateMatcher::match(faces);
+                    nSplitHex++;
+                }
+                else
+                {
+                    nUnrecognised++;
+                }
+            }
+        }
+        if (debug)
+        {
+            Pout<< "hexRef::cellShapes() :"
+                << " nCells:" << mesh_.nCells() << " of which" << nl
+                << "    primitive:" << (mesh_.nCells()-nSplitHex-nUnrecognised)
+                << nl
+                << "    split-hex:" << nSplitHex << nl
+                << "    poly     :" << nUnrecognised << nl
+                << endl;
+        }
+    }
+    return cellShapesPtr_();
+}
+
+
+
+// Write refinement to polyMesh directory.
+bool Foam::hexRef::write() const
+{
+    bool writeOk =
+        cellLevel_.write()
+     && pointLevel_.write()
+     && level0Edge_.write();
+
+    if (history_.active())
+    {
+        writeOk = writeOk && history_.write();
+    }
+
+    return writeOk;
+}
+
+
+
+
+// ************************************************************************* //
diff --git a/AMR_tidy/hexRef/hexRef.H b/AMR_tidy/hexRef/hexRef.H
new file mode 100644
index 00000000..888ead7a
--- /dev/null
+++ b/AMR_tidy/hexRef/hexRef.H
@@ -0,0 +1,665 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::hexRef
+
+Description
+    Refinement of (split) hexes using polyTopoChange.
+    hexRef8.H has been abstracted to fit hexRef4 and hexRef4Axi 
+
+SourceFiles
+    hexRef.C
+
+Authors
+    Yun Ouedraogo 2018
+
+    Formerly hexRef8 adapted in 2018 by: 
+    Daniel Rettenmaier <rettenmaier@tu-darmstadt.de>
+    Daniel Deising <deising@mma.tu-darmstadt.de>
+    Changes: 
+        + Corrected adressing of refined internal faces
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef hexRef_H
+#define hexRef_H
+
+#include "labelIOList.H"
+#include "face.H"
+#include "HashSet.H"
+#include "DynamicList.H"
+#include "primitivePatch.H"
+#include "removeFaces.H"
+#include "refinementHistory.H"
+#include "PackedBoolList.H"
+#include "uniformDimensionedFields.H"
+#include "cellShapeList.H"
+#include "autoPtr.H"
+#include "runTimeSelectionTables.H"
+#include "volFields.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// Forward declaration of classes
+class polyMesh;
+class polyPatch;
+class polyTopoChange;
+class mapPolyMesh;
+class mapDistributePolyMesh;
+
+/*---------------------------------------------------------------------------*\
+                           Class hexRef Declaration
+\*---------------------------------------------------------------------------*/
+
+class hexRef
+{
+protected:
+    // Protected data
+
+        //- Reference to underlying mesh.
+        const polyMesh& mesh_;
+
+        //- Per cell the refinement level
+        labelIOList cellLevel_;
+
+        //- Per point the refinement level
+        labelIOList pointLevel_;
+
+        //- Typical edge length between unrefined points
+        uniformDimensionedScalarField level0Edge_;
+
+        //- Refinement history
+        refinementHistory history_;
+
+        //- Face remover engine
+        removeFaces faceRemover_;
+
+        //- Level of saved points
+        Map<label> savedPointLevel_;
+
+        //- Level of saved cells
+        Map<label> savedCellLevel_;
+
+        //- Cell shapes when seen as split hexes
+        mutable autoPtr<cellShapeList> cellShapesPtr_;
+
+
+    // Protected Member Functions
+
+        //- Reorder according to map.
+        static void reorder
+        (
+            const labelList& map,
+            const label len,
+            const label null,
+            labelList& elems
+        );
+
+        //- Get patch and zone info
+        void getFaceInfo
+        (
+            const label facei,
+            label& patchID,
+            label& zoneID,
+            label& zoneFlip
+        ) const;
+
+        //- Adds a face on top of existing facei. Reverses if necessary.
+        label addFace
+        (
+            polyTopoChange& meshMod,
+            const label facei,
+            const face& newFace,
+            const label own,
+            const label nei
+        ) const;
+
+        //- Adds internal face from point. No checks on reversal.
+        label addInternalFace
+        (
+            polyTopoChange& meshMod,
+            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 necessary.
+        void modFace
+        (
+            polyTopoChange& meshMod,
+            const label facei,
+            const face& newFace,
+            const label own,
+            const label nei
+        ) const;
+
+        scalar getLevel0EdgeLength() const;
+
+        //- Get cell added to point of celli (if any)
+        virtual label getAnchorCell
+        (
+            const labelListList& cellAnchorPoints,
+            const labelListList& cellAddedCells,
+            const label celli,
+            const label facei,
+            const label pointi
+        ) const = 0;
+
+        //- Get new owner and neighbour (in unspecified order) of pointi
+        //  on facei.
+        void getFaceNeighbours
+        (
+            const labelListList& cellAnchorPoints,
+            const labelListList& cellAddedCells,
+            const label facei,
+            const label pointi,
+
+            label& own,
+            label& nei
+        ) const;
+
+
+        //- Get index of minimum pointlevel.
+        label findMinLevel(const labelList& f) const;
+        //- Get maximum pointlevel.
+        label findMaxLevel(const labelList& f) const;
+        //- Count number of vertices <= anchorLevel
+        label countAnchors(const labelList&, const label) const;
+        //- Debugging: dump cell as .obj file
+        void dumpCell(const label celli) const;
+        //- Find index of point with wantedLevel, starting from fp.
+        label findLevel
+        (
+            const label facei,
+            const face& f,
+            const label startFp,
+            const bool searchForward,
+            const label wantedLevel
+        ) const;
+
+        ////- Print levels of list of points.
+        //void printLevels(Ostream&, const labelList&) const;
+
+        //- debug:check orientation of added internal face
+        static void checkInternalOrientation
+        (
+            polyTopoChange& meshMod,
+            const label celli,
+            const label facei,
+            const point& ownPt,
+            const point& neiPt,
+            const face& newFace
+        );
+
+        //- debug:check orientation of new boundary face
+        static void checkBoundaryOrientation
+        (
+            polyTopoChange& meshMod,
+            const label celli,
+            const label facei,
+            const point& ownPt,
+            const point& boundaryPt,
+            const face& newFace
+        );
+
+        //- If p0 and p1 are existing vertices check if edge is split and insert
+        // splitPoint.
+        void insertEdgeSplit
+        (
+            const labelList& edgeMidPoint,
+            const label p0,
+            const label p1,
+            DynamicList<label>& verts
+        ) const;
+
+        //- Store in maps correspondence from midpoint to anchors and faces.
+        virtual label storeMidPointInfo
+        (
+            const labelListList& cellAnchorPoints,
+            const labelListList& cellAddedCells,
+            const labelList& cellMidPoint,
+            const labelList& faceMidPoint,
+            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,
+            polyTopoChange& meshMod
+        ) const = 0;
+
+        //- Create all internal faces from an unsplit face.
+        void createInternalFromSplitFace
+        (
+            const labelListList& cellAnchorPoints,
+            const labelListList& cellAddedCells,
+            const labelList& cellMidPoint,
+            const labelList& faceMidPoint,
+            const labelList& edgeMidPoint,
+            const label celli,
+            const label facei,
+
+            Map<edge>& midPointToAnchors,
+            Map<edge>& midPointToFaceMids,
+            polyTopoChange& meshMod,
+            label& nFacesAdded
+        ) const;
+
+        //- Create all internal faces to split celli into 8.
+        virtual void createInternalFaces
+        (
+            const labelListList& cellAnchorPoints,
+            const labelListList& cellAddedCells,
+            const labelList& cellMidPoint,
+            const labelList& faceMidPoint,
+            const labelList& faceAnchorLevel,
+            const labelList& edgeMidPoint,
+            const label celli,
+            polyTopoChange& meshMod
+        ) const = 0;
+
+        //- Store vertices from startFp upto face split point.
+        //  Used when splitting face into 4.
+        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;
+
+        //- Updates refineCell so consistent 2:1 refinement. Returns local
+        //  number of cells changed.
+        label faceConsistentRefinement
+        (
+            const bool maxSet,
+            PackedBoolList& refineCell
+        ) const;
+
+        //- Check wanted refinement for 2:1 consistency
+        void checkWantedRefinementLevels(const labelList&) const;
+
+
+        // Cellshape recognition
+
+            //- Collect all points on face of certain level
+            void collectLevelPoints
+            (
+                const labelList& f,
+                const label level,
+                DynamicList<label>& points
+            ) const;
+
+            //- Collect all points on face (in local numbering) of certain level
+            void collectLevelPoints
+            (
+                const labelList& meshPoints,
+                const labelList& f,
+                const label level,
+                DynamicList<label>& points
+            ) const;
+
+            //- Collect all faces with four corner points and return true if
+            //  hex was matched (6 faces of each four corner points)
+            bool matchHexShape
+            (
+                const label celli,
+                const label cellLevel,
+                DynamicList<face>& quads
+            ) const;
+
+
+        //- Disallow default bitwise copy construct
+        hexRef(const hexRef&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const hexRef&);
+
+
+public:
+
+    //- Runtime type information
+    TypeName("hexRef");
+
+    // Declare run-time selection tables
+    declareRunTimeSelectionTable
+    (
+        autoPtr,
+        hexRef,
+        mesh,
+        (
+            const polyMesh& mesh,
+            const bool readHistory
+        ),
+        (mesh, readHistory)
+    );
+
+    declareRunTimeSelectionTable
+    (
+        autoPtr,
+        hexRef,
+        levelsHist,
+        (
+            const polyMesh& mesh,
+            const labelList& cellLevel,
+            const labelList& pointLevel,
+            const refinementHistory& history,
+            const scalar level0Edge
+        ),
+        (mesh, cellLevel, pointLevel, history, level0Edge)
+    );
+
+    declareRunTimeSelectionTable
+    (
+        autoPtr,
+        hexRef,
+        levels,
+        (
+            const polyMesh& mesh,
+            const labelList& cellLevel,
+            const labelList& pointLevel,
+            const scalar level0Edge
+        ),
+        (mesh, cellLevel, pointLevel, level0Edge)
+    );
+
+
+    // Constructors
+
+        //- Construct from mesh, read_if_present refinement data
+        //  (from write below). If readHistory is true does read_if_present
+        //  of refinement history. If false clears all history
+        hexRef(const polyMesh& mesh, const bool readHistory = true);
+
+        //- Construct from mesh and un/refinement data and optional size of
+        //  starting cells
+        hexRef
+        (
+            const polyMesh& mesh,
+            const labelList& cellLevel,
+            const labelList& pointLevel,
+            const refinementHistory& history,
+            const scalar level0Edge = -GREAT
+        );
+
+        //- Construct from mesh and refinement data and optional size of
+        //  starting cells
+        hexRef
+        (
+            const polyMesh& mesh,
+            const labelList& cellLevel,
+            const labelList& pointLevel,
+            const scalar level0Edge = -GREAT
+        );
+
+    // Selectors
+
+        static autoPtr<hexRef> New
+        (
+            const polyMesh& mesh, const bool readHistory = true
+        );
+
+        static autoPtr<hexRef> New
+        (
+            const polyMesh& mesh,
+            const labelList& cellLevel,
+            const labelList& pointLevel,
+            const refinementHistory& history,
+            const scalar level0Edge = -GREAT
+        );
+
+        static autoPtr<hexRef> New
+        (
+            const polyMesh& mesh,
+            const labelList& cellLevel,
+            const labelList& pointLevel,
+            const scalar level0Edge = -GREAT
+        );
+
+    // Destructor
+    virtual ~hexRef();
+
+    // Member Functions
+
+        // Access
+
+            const polyMesh& mesh() const
+            {
+                return mesh_;
+            }
+
+            const labelIOList& cellLevel() const
+            {
+                return cellLevel_;
+            }
+
+            const labelIOList& pointLevel() const
+            {
+                return pointLevel_;
+            }
+
+            const refinementHistory& history() const
+            {
+                return history_;
+            }
+
+            //- Typical edge length between unrefined points
+            scalar level0EdgeLength() const
+            {
+                return level0Edge_.value();
+            }
+
+        // Refinement
+
+            //- Gets level such that the face has four points <= level.
+            label faceLevel(const label facei) const;
+
+            //- Given valid mesh and current cell level and proposed
+            //  cells to refine calculate any clashes (due to 2:1) and return
+            //  ok list of cells to refine.
+            //  Either adds cells to refine to set (maxSet = true) or
+            //  removes cells to refine (maxSet = false)
+            labelList consistentRefinement
+            (
+                const labelList& cellsToRefine,
+                const bool maxSet
+            ) const;
+
+            //- Like consistentRefinement but slower:
+            //
+            //  - specify number of cells between consecutive refinement levels
+            //    (consistentRefinement equivalent to 1)
+            //  - specify max level difference between point-connected cells.
+            //    (-1 to disable) Note that with normal 2:1 limitation
+            //    (maxFaceDiff=1) there can be 8:1 size difference across point
+            //    connected cells so maxPointDiff allows you to make that less.
+            //  cellsToRefine : cells we're thinking about refining. It will
+            //                  extend this set. All refinement levels will be
+            //                  at least maxFaceDiff layers thick.
+            //  facesToCheck  : additional faces where to implement the
+            //                  maxFaceDiff thickness (usually only boundary
+            //                  faces)
+            labelList consistentSlowRefinement
+            (
+                const label maxFaceDiff,
+                const labelList& cellsToRefine,
+                const labelList& facesToCheck,
+                const label maxPointDiff,
+                const labelList& pointsToCheck
+            ) const;
+
+            //- Like consistentSlowRefinement but uses different meshWave
+            //  (proper distance instead of toplogical count). No point checks
+            //  yet.
+            labelList consistentSlowRefinement2
+            (
+                const label maxFaceDiff,
+                const labelList& cellsToRefine,
+                const labelList& facesToCheck
+            ) const;
+
+            //- Insert refinement. All selected cells will be split.
+            //  Returns per element in cells the cells they were split into.
+            virtual labelListList setRefinement
+            (
+                const labelList& cells,
+                polyTopoChange&
+            ) = 0;
+
+            //- Update local numbering for changed mesh.
+            void updateMesh(const mapPolyMesh&);
+
+
+            // Restoring : is where other processes delete and reinsert data.
+            //             These callbacks allow this to restore the cellLevel
+            //             and pointLevel for reintroduced points.
+            //             Is not related to undoing my refinement
+
+                //- Signal points/face/cells for which to store data
+                void storeData
+                (
+                    const labelList& pointsToStore,
+                    const labelList& facesToStore,
+                    const labelList& cellsToStore
+                );
+
+                //- Update local numbering + undo
+                //  Data to restore given as new pointlabel + stored pointlabel
+                //  (i.e. what was in pointsToStore)
+                void updateMesh
+                (
+                    const mapPolyMesh&,
+                    const Map<label>& pointsToRestore,
+                    const Map<label>& facesToRestore,
+                    const Map<label>& cellsToRestore
+                );
+
+
+            //- Update local numbering for subsetted mesh.
+            //  Gets new-to-old maps. Not compatible with unrefinement.
+            void subset
+            (
+                const labelList& pointMap,
+                const labelList& faceMap,
+                const labelList& cellMap
+            );
+
+            //- Update local numbering for mesh redistribution
+            void distribute(const mapDistributePolyMesh&);
+
+            //- Debug: Check coupled mesh for correctness
+            void checkMesh() const;
+
+            //- Debug: Check 2:1 consistency across faces.
+            //  maxPointDiff==-1 : only check 2:1 across faces
+            //  maxPointDiff!=-1 : check point-connected cells.
+            void checkRefinementLevels
+            (
+                const label maxPointDiff,
+                const labelList& pointsToCheck
+            ) const;
+
+            //- Utility: get hexes as cell shapes
+            const cellShapeList& cellShapes() const;
+
+
+        // Unrefinement (undoing refinement, not arbitrary coarsening)
+
+            //- Return the mid elems in top-level split cells
+            //  that can be unsplit.
+            virtual labelList getSplitElems() const = 0;
+
+            //- Given proposed
+            //  splitElems to unrefine according to calculate any clashes
+            //  (due to 2:1) and return ok list of mid elems to unrefine.
+            virtual labelList consistentUnrefinement
+            (
+                const labelList& elemsToUnrefine,
+                const bool maxSet
+            ) const = 0;
+
+            //- Remove some refinement. Needs to be supplied output of
+            //  consistentUnrefinement. Only call if undoable set.
+            //  All n edgeCells of a split edge will be combined into
+            //  the lowest numbered cell of those n.
+            virtual void setUnrefinement
+            (
+                const labelList& splitElemLabels,
+                polyTopoChange&
+            ) = 0;
+
+            virtual labelList selectUnrefineElems
+            (
+                const scalar unrefineLevel,
+                const PackedBoolList& markedCell,
+                const scalarField& vFld
+            ) const = 0;
+
+            virtual void calcFaceToSplitPoint
+            (
+                const labelList& splitElems,
+                Map<label>& faceToSplitPoint
+            ) = 0;
+
+        // Write
+
+            // Set instance for mesh files
+            void setInstance(const fileName& inst);
+
+            //- Force writing refinement+history to polyMesh directory.
+            bool write() const;
+
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/AMR_tidy/hexRef/hexRef2/hexRef2.C b/AMR_tidy/hexRef/hexRef2/hexRef2.C
new file mode 100644
index 00000000..fbcc9ea2
--- /dev/null
+++ b/AMR_tidy/hexRef/hexRef2/hexRef2.C
@@ -0,0 +1,2177 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "hexRef2.H"
+
+#include "emptyPolyPatch.H"
+
+#include "addToRunTimeSelectionTable.H"
+
+#include "polyMesh.H"
+#include "polyTopoChange.H"
+#include "meshTools.H"
+#include "polyAddFace.H"
+#include "polyAddPoint.H"
+#include "polyAddCell.H"
+#include "polyModifyFace.H"
+#include "syncTools.H"
+#include "faceSet.H"
+#include "cellSet.H"
+#include "pointSet.H"
+#include "OFstream.H"
+#include "Time.H"
+#include "FaceCellWave.H"
+#include "mapDistributePolyMesh.H"
+#include "refinementData.H"
+#include "refinementDistanceData.H"
+#include "degenerateMatcher.H"
+
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(hexRef2, 0);
+    addToRunTimeSelectionTable(hexRef, hexRef2, mesh);
+    addToRunTimeSelectionTable(hexRef, hexRef2, levelsHist);
+    addToRunTimeSelectionTable(hexRef, hexRef2, levels);
+}
+
+
+// * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
+
+// Check whether pointi is an anchor on celli.
+// If it is not check whether any other point on the face is an anchor cell.
+Foam::label Foam::hexRef2::getAnchorCell
+(
+    const labelListList& cellAnchorPoints,
+    const labelListList& cellAddedCells,
+    const label celli,
+    const label facei,
+    const label pointi
+) const
+{
+    return 1;
+}
+
+Foam::label Foam::hexRef2::myGetAnchorCell
+(
+    const labelListList& cellAnchorPoints,
+    const labelListList& cellAddedCells,
+    const labelList& edgeMidPoint,
+    const label celli,
+    const label facei,
+    const label pointi
+) const
+{
+    
+    if (cellAnchorPoints[celli].size())
+    {
+        
+        label index = 0;
+
+        const face& f = mesh_.faces()[facei];
+        label nextPointi = -1;
+
+        forAll(f,fp)
+        {
+            nextPointi = f[fp];
+            if( pointi == f[f.fcIndex(fp)] || pointi == f[f.rcIndex(fp)] )
+            {
+                label edgeJ = meshTools::findEdge (mesh_, pointi, nextPointi);
+                if(edgeMidPoint[edgeJ] >= 0)
+                {
+                    // const edge& ei = mesh_.edges()[edgeJ];
+                    // Pout<< "find anchor cell edge is :" << ei<< endl;
+                    break;
+                }
+            }
+        }
+        if(pointi < nextPointi)
+        {
+            index = 0;
+        }
+        else
+        {
+            index = 1;
+        }
+
+        //use for check
+        // Pout<< "go this way : 1" << endl;
+        // Pout<< "pointi is:" << pointi << endl;
+        // Pout<< "nextPointi is:" << nextPointi << endl;
+        // Pout<< "facei is: "<<f << endl;
+        // Pout<< "index is:" << index << endl;
+
+        return cellAddedCells[celli][index];
+
+        // Problem.
+        dumpCell(celli);
+        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
+    {
+        //use for check
+        // Pout<< "go this way : 3" << endl;
+        return celli;
+    }
+}
+
+// not be used in hexRef2
+Foam::label Foam::hexRef2::storeMidPointInfo
+(
+    const labelListList& cellAnchorPoints,
+    const labelListList& cellAddedCells,
+    const labelList& cellMidPoint,
+    const labelList& faceMidPoint,
+    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,
+    polyTopoChange& meshMod
+) const
+{
+    return -1;
+}
+
+
+//not be used in hexRef2
+void Foam::hexRef2::createInternalFaces
+(
+    const labelListList& cellAnchorPoints,
+    const labelListList& cellAddedCells,
+    const labelList& cellMidPoint,
+    const labelList& faceMidPoint,
+    const labelList& faceAnchorLevel,
+    const labelList& edgeMidPoint,
+    const label celli,
+
+    polyTopoChange& meshMod
+) const
+{
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+// Construct from mesh, read refinement data
+Foam::hexRef2::hexRef2(const polyMesh& mesh, const bool readHistory)
+:
+    hexRef(mesh, readHistory)
+{}
+
+
+// Construct from components
+Foam::hexRef2::hexRef2
+(
+    const polyMesh& mesh,
+    const labelList& cellLevel,
+    const labelList& pointLevel,
+    const refinementHistory& history,
+    const scalar level0Edge
+)
+:
+    hexRef(mesh, cellLevel, pointLevel, history, level0Edge)
+{}
+
+
+// Construct from components
+Foam::hexRef2::hexRef2
+(
+    const polyMesh& mesh,
+    const labelList& cellLevel,
+    const labelList& pointLevel,
+    const scalar level0Edge
+)
+:
+    hexRef(mesh, cellLevel, pointLevel, level0Edge)
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+// Top level driver to insert topo changes to do all refinement.
+Foam::labelListList Foam::hexRef2::setRefinement
+(
+    const labelList& cellLabels,
+    polyTopoChange& meshMod
+)
+{
+    if (debug)
+    {
+        Pout<< "hexRef2::setRefinement :"
+            << " Checking initial mesh just to make sure" << endl;
+
+        checkMesh();
+        // Cannot call checkRefinementlevels since hanging points might
+        // get triggered by the mesher after subsetting.
+        //checkRefinementLevels(-1, labelList(0));
+    }
+
+    // Clear any saved point/cell data.
+    savedPointLevel_.clear();
+    savedCellLevel_.clear();
+
+
+    // New point/cell level. Copy of pointLevel for existing points.
+    DynamicList<label> newCellLevel(cellLevel_.size());
+    forAll(cellLevel_, celli)
+    {
+        newCellLevel.append(cellLevel_[celli]);
+    }
+    DynamicList<label> newPointLevel(pointLevel_.size());
+    forAll(pointLevel_, pointi)
+    {
+        newPointLevel.append(pointLevel_[pointi]);
+    }
+
+
+    if (debug)
+    {
+        Pout<< "hexRef2::setRefinement :"
+            << " Allocating " << cellLabels.size() << " cell midpoints."
+            << endl;
+    }
+
+
+    // Mid point per refined cell.
+    // -1 : not refined
+    // >=0: label of mid point.
+    // just used to sign the cell that need to be split
+    labelList cellMidPoint(mesh_.nCells(), -1);
+
+    forAll(cellLabels, i)
+    {
+        label celli = cellLabels[i];
+        
+        cellMidPoint[celli] = 12345;
+    }
+
+    boolList isDivisibleFace(mesh_.nFaces(), false);
+    boolList isDivisibleEdge(mesh_.nEdges(), false);
+
+    // the last face and first face cannot cannot be divised
+    label firstBFace = -1;
+    label lastBFace = -1;
+    for (label facei = mesh_.nInternalFaces(); facei < mesh_.nFaces(); facei++)
+    {
+        const label & patchID = mesh_.boundaryMesh().whichPatch(facei);
+
+        if (mesh_.boundaryMesh()[patchID].type() == "empty")
+        {
+            isDivisibleFace[facei] = true;
+            const labelList& fEdges = mesh_.faceEdges(facei);
+
+            forAll(fEdges, i)
+            {
+                label edgeI = fEdges[i];
+                isDivisibleEdge[edgeI] = true;
+            }
+        }
+        else
+        {
+            if( firstBFace == -1 )
+            {
+                firstBFace = facei;
+            }
+            else
+            {
+                lastBFace = facei;
+            }
+        }
+    }
+
+    isDivisibleFace[firstBFace] = false;
+    const labelList& fbfEdges = mesh_.faceEdges(firstBFace);
+    forAll(fbfEdges, i)
+    {
+        label edgeI = fbfEdges[i];
+        isDivisibleEdge[edgeI] = false;
+    }
+    
+    isDivisibleFace[lastBFace] = false;
+    const labelList& lbfEdges = mesh_.faceEdges(lastBFace);
+    forAll(lbfEdges, i)
+    {
+        label edgeI = lbfEdges[i];
+        isDivisibleEdge[edgeI] = false;
+    }
+
+    // for (label facei = mesh_.nInternalFaces(); facei < mesh_.nFaces(); facei++)
+    // {
+    //     const label & patchID = mesh_.boundaryMesh().whichPatch(facei);
+
+    //     if (mesh_.boundaryMesh()[patchID].type() != "empty")
+    //     {
+    //         isDivisibleFace[facei] = false;
+    //         const labelList& fEdges = mesh_.faceEdges(facei);
+
+    //         forAll(fEdges, i)
+    //         {
+    //             label edgeI = fEdges[i];
+    //             isDivisibleEdge[edgeI] = false;
+    //         }
+    //     }
+    // }
+
+    for (label facei = 0; facei < mesh_.nInternalFaces(); facei++)
+    {
+        isDivisibleFace[facei] = false;
+        const labelList& fEdges = mesh_.faceEdges(facei);
+
+        forAll(fEdges, i)
+        {
+                label edgeI = fEdges[i];
+                isDivisibleEdge[edgeI] = false;
+        }
+    }
+
+    // use for check
+    // forAll(cellLabels, i)
+    // {
+    //     label celli = cellLabels[i];
+    //     if( cellMidPoint[celli] >= 0)
+    //     {
+    //         // label nface = 0;
+    //         label nedges = 0;
+    //         const labelList& cEdges = mesh_.cellEdges(celli);
+    //         forAll(cEdges, i)
+    //         {
+    //             label edgeI = cEdges[i];
+    //             if(isDivisibleEdge[edgeI])
+    //             {
+    //                 nedges++;
+    //             }
+    //         }
+    //         Pout<< "each cell edges need to split:"
+    //         << nedges << endl;
+            
+    //     }
+    // }
+
+    if (debug)
+    {
+        cellSet splitCells(mesh_, "splitCells", cellLabels.size());
+
+        forAll(cellMidPoint, celli)
+        {
+            if (cellMidPoint[celli] >= 0)
+            {
+                splitCells.insert(celli);
+            }
+        }
+
+        Pout<< "hexRef2::setRefinement : Dumping " << splitCells.size()
+            << " cells to split to cellSet " << splitCells.objectPath()
+            << endl;
+
+        splitCells.write();
+    }
+
+
+
+    // Split edges
+    // ~~~~~~~~~~~
+
+    if (debug)
+    {
+        Pout<< "hexRef2::setRefinement :"
+            << " Allocating edge midpoints."
+            << endl;
+    }
+
+    // Unrefined edges are ones between cellLevel or lower points.
+    // If any cell using this edge gets split then the edge needs to be split.
+
+    // -1  : no need to split edge
+    // >=0 : label of introduced mid point
+    labelList edgeMidPoint(mesh_.nEdges(), -1);
+
+    // Note: Loop over cells to be refined or edges?
+    forAll(cellMidPoint, celli)
+    {
+        // label n = 0;  //use to check
+        if (cellMidPoint[celli] >= 0)
+        {
+            const labelList& cEdges = mesh_.cellEdges(celli);
+
+            // use to check
+            // Pout<< "edges' number for a cell need to split : "<< cEdges.size()<<endl;
+            // Pout << "edges are :" << endl; 
+                        
+            // forAll(cEdges, i)
+            // {
+            //     label edgeI = cEdges[i];
+            //     const edge& e = mesh_.edges()[edgeI];
+            //     Pout << e << endl; 
+            // }
+            
+
+            forAll(cEdges, i)
+            {
+                label edgeI = cEdges[i];
+                const edge& e = mesh_.edges()[edgeI];
+                if
+                (
+                    isDivisibleEdge[edgeI]
+                 && pointLevel_[e[0]] <= cellLevel_[celli]
+                 && pointLevel_[e[1]] <= cellLevel_[celli]
+                )
+                {
+                    edgeMidPoint[edgeI] = 12345;    // mark need for splitting
+                    //n++;  //use to check
+                }
+            }
+        }
+
+        //use to check
+        // if(n > 0)
+        // {
+        //     Pout<< "edges need to split:"
+        //     << n << endl;
+        // }
+        
+    }
+
+    // Synchronize edgeMidPoint across coupled patches. Take max so that
+    // any split takes precedence.
+    syncTools::syncEdgeList
+    (
+        mesh_,
+        edgeMidPoint,
+        maxEqOp<label>(),
+        labelMin
+    );
+
+
+    // Introduce edge points
+    // ~~~~~~~~~~~~~~~~~~~~~
+
+    {
+        // Phase 1: calculate midpoints and sync.
+        // This needs doing for if people do not write binary and we slowly
+        // get differences.
+
+        pointField edgeMids(mesh_.nEdges(), point(-GREAT, -GREAT, -GREAT));
+
+        forAll(edgeMidPoint, edgeI)
+        {
+            if (edgeMidPoint[edgeI] >= 0)
+            {
+                // Edge marked to be split.
+                edgeMids[edgeI] = mesh_.edges()[edgeI].centre(mesh_.points());
+            }
+        }
+        syncTools::syncEdgePositions
+        (
+            mesh_,
+            edgeMids,
+            maxEqOp<vector>(),
+            point(-GREAT, -GREAT, -GREAT)
+        );
+
+
+        // Phase 2: introduce points at the synced locations.
+        forAll(edgeMidPoint, edgeI)
+        {
+            if (edgeMidPoint[edgeI] >= 0)
+            {
+                // Edge marked to be split. Replace edgeMidPoint with actual
+                // point label.
+
+                const edge& e = mesh_.edges()[edgeI];
+
+                edgeMidPoint[edgeI] = meshMod.setAction
+                (
+                    polyAddPoint
+                    (
+                        edgeMids[edgeI],            // point
+                        e[0],                       // master point
+                        -1,                         // zone for point
+                        true                        // supports a cell
+                    )
+                );
+
+                newPointLevel(edgeMidPoint[edgeI]) =
+                    max
+                    (
+                        pointLevel_[e[0]],
+                        pointLevel_[e[1]]
+                    )
+                  + 1;
+            }
+        }
+    }
+
+    if (debug)
+    {
+        OFstream str(mesh_.time().path()/"edgeMidPoint.obj");
+
+        forAll(edgeMidPoint, edgeI)
+        {
+            if (edgeMidPoint[edgeI] >= 0)
+            {
+                const edge& e = mesh_.edges()[edgeI];
+
+                meshTools::writeOBJ(str, e.centre(mesh_.points()));
+            }
+        }
+
+        Pout<< "hexRef2::setRefinement :"
+            << " Dumping edge centres to split to file " << str.name() << endl;
+    }
+
+
+    // Calculate face level
+    // ~~~~~~~~~~~~~~~~~~~~
+    // (after splitting)
+
+    if (debug)
+    {
+        Pout<< "hexRef2::setRefinement :"
+            << " Allocating face midpoints."
+            << endl;
+    }
+
+    // Face anchor level. There are guaranteed 4 points with level
+    // <= anchorLevel. These are the corner points.
+    labelList faceAnchorLevel(mesh_.nFaces());
+
+    for (label facei = 0; facei < mesh_.nFaces(); facei++)
+    {
+        faceAnchorLevel[facei] = faceLevel(facei);
+    }
+
+    // -1  : no need to split face
+    // >=0 : label of introduced mid point
+    labelList faceMidPoint(mesh_.nFaces(), -1);
+
+
+    // Internal faces: look at cells on both sides. Uniquely determined since
+    // face itself guaranteed to be same level as most refined neighbour.
+    // for (label facei = 0; facei < mesh_.nInternalFaces(); facei++)
+    // {
+    //     if (faceAnchorLevel[facei] >= 0)
+    //     {
+    //         label own = mesh_.faceOwner()[facei];
+    //         label ownLevel = cellLevel_[own];
+    //         label newOwnLevel = ownLevel + (cellMidPoint[own] >= 0 ? 1 : 0);
+
+    //         label nei = mesh_.faceNeighbour()[facei];
+    //         label neiLevel = cellLevel_[nei];
+    //         label newNeiLevel = neiLevel + (cellMidPoint[nei] >= 0 ? 1 : 0);
+
+    //         if(isDivisibleFace[facei])
+    //         {
+    //             // if
+    //             // (
+    //             //     newOwnLevel > faceAnchorLevel[facei]
+    //             // || newNeiLevel > faceAnchorLevel[facei]
+    //             // )
+    //             // {
+    //                 faceMidPoint[facei] = 12345;    // mark to be split
+    //             // }
+    //         }
+    //     }
+    // }
+
+    // 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)
+
+    {
+        labelList newNeiLevel(mesh_.nFaces()-mesh_.nInternalFaces());
+
+        forAll(newNeiLevel, i)
+        {
+            label own = mesh_.faceOwner()[i+mesh_.nInternalFaces()];
+            label ownLevel = cellLevel_[own];
+            label newOwnLevel = ownLevel + (cellMidPoint[own] >= 0 ? 1 : 0);
+
+            newNeiLevel[i] = newOwnLevel;
+        }
+
+        // Swap.
+        syncTools::swapBoundaryFaceList(mesh_, newNeiLevel);
+
+        // So now we have information on the neighbour.
+
+        forAll(newNeiLevel, i)
+        {
+            label facei = i+mesh_.nInternalFaces();
+
+            if (faceAnchorLevel[facei] >= 0)
+            {
+                //useless in hexRef2
+                // label own = mesh_.faceOwner()[facei];
+                // label ownLevel = cellLevel_[own];
+                // label newOwnLevel = ownLevel + (cellMidPoint[own] >= 0 ? 1 : 0);
+
+                if(isDivisibleFace[facei])
+                {
+                    faceMidPoint[facei] = 12345;    // mark to be split
+                }
+                
+            }
+        }
+    }
+
+    // Synchronize faceMidPoint across coupled patches. (logical or)
+    syncTools::syncFaceList
+    (
+        mesh_,
+        faceMidPoint,
+        maxEqOp<label>()
+    );
+
+    // Introduce face points
+    // ~~~~~~~~~~~~~~~~~~~~~
+    // no need to introduce face mid points
+
+    if (debug)
+    {
+        faceSet splitFaces(mesh_, "splitFaces", cellLabels.size());
+
+        forAll(faceMidPoint, facei)
+        {
+            if (faceMidPoint[facei] >= 0)
+            {
+                splitFaces.insert(facei);
+            }
+        }
+
+        Pout<< "hexRef2::setRefinement : Dumping " << splitFaces.size()
+            << " faces to split to faceSet " << splitFaces.objectPath() << endl;
+
+        splitFaces.write();
+    }
+
+
+    // Information complete
+    // ~~~~~~~~~~~~~~~~~~~~
+    // At this point we have all the information we need. We should no
+    // longer reference the cellLabels to refine. All the information is:
+    // - cellMidPoint >= 0 : cell needs to be split
+    // - faceMidPoint >= 0 : face needs to be split
+    // - edgeMidPoint >= 0 : edge needs to be split
+    // - isDivisibleFace true :face needs to be split in two
+
+
+
+    // Get the corner/anchor points
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    if (debug)
+    {
+        Pout<< "hexRef2::setRefinement :"
+            << " Finding cell anchorPoints (8 per cell)"
+            << endl;
+    }
+
+    // There will always be 8 points on the hex that have were introduced
+    // with the hex and will have the same or lower refinement level.
+
+    // Per cell the 8 corner points.
+    labelListList cellAnchorPoints(mesh_.nCells());
+
+    {
+        labelList nAnchorPoints(mesh_.nCells(), 0);
+
+        forAll(cellMidPoint, celli)
+        {
+            if (cellMidPoint[celli] >= 0)
+            {
+                cellAnchorPoints[celli].setSize(8);
+            }
+        }
+
+        forAll(pointLevel_, pointi)
+        {
+            const labelList& pCells = mesh_.pointCells(pointi);
+           
+            forAll(pCells, pCelli)
+            {
+                label celli = pCells[pCelli];
+
+                if
+                (
+                    cellMidPoint[celli] >= 0
+                 && pointLevel_[pointi] <= cellLevel_[celli]
+                )
+                {
+                    if (nAnchorPoints[celli] == 8)
+                    {
+                        dumpCell(celli);
+                        FatalErrorInFunction
+                            << "cell " << celli
+                            << " of level " << cellLevel_[celli]
+                            << " uses more than 8 points of equal or"
+                            << " lower level" << nl
+                            << "Points so far:" << cellAnchorPoints[celli]
+                            << abort(FatalError);
+                    }
+
+                    cellAnchorPoints[celli][nAnchorPoints[celli]++] = pointi;
+                }
+            }
+        }
+
+        forAll(cellMidPoint, celli)
+        {
+            if (cellMidPoint[celli] >= 0)
+            {
+                if (nAnchorPoints[celli] != 8)
+                {
+                    dumpCell(celli);
+
+                    const labelList& cPoints = mesh_.cellPoints(celli);
+
+                    FatalErrorInFunction
+                        << "cell " << celli
+                        << " of level " << cellLevel_[celli]
+                        << " does not seem to have 8 points of equal or"
+                        << " lower level" << endl
+                        << "cellPoints:" << cPoints << endl
+                        << "pointLevels:"
+                        << UIndirectList<label>(pointLevel_, cPoints)() << endl
+                        << abort(FatalError);
+                }
+            }
+        }
+    }
+
+
+    // Add the cells
+    // ~~~~~~~~~~~~~
+
+    if (debug)
+    {
+        Pout<< "hexRef2::setRefinement :"
+            << " Adding cells (1 per anchorPoint)"
+            << endl;
+    }
+
+    // Per cell the 1 added cells (+ original cell)
+    labelListList cellAddedCells(mesh_.nCells());
+
+    forAll(cellAnchorPoints, celli)
+    {
+        const labelList& cAnchors = cellAnchorPoints[celli];
+
+        if (cAnchors.size() == 8)
+        {
+            labelList& cAdded = cellAddedCells[celli];
+            cAdded.setSize(2);
+
+            // Original cell at 0
+            cAdded[0] = celli;
+
+            // Update cell level
+            newCellLevel[celli] = cellLevel_[celli]+1;
+
+
+            for (label i = 1; i < 2; i++)
+            {
+                cAdded[i] = meshMod.setAction
+                (
+                    polyAddCell
+                    (
+                        -1,                                 // master point
+                        -1,                                 // master edge
+                        -1,                                 // master face
+                        celli,                              // master cell
+                        mesh_.cellZones().whichZone(celli)  // zone for cell
+                    )
+                );
+
+                newCellLevel(cAdded[i]) = cellLevel_[celli]+1;
+            }
+        }
+    }
+
+
+    // Faces
+    // ~~~~~
+    // 1. existing faces that get split (into four always)
+    // 2. existing faces that do not get split but get new owner/neighbour
+    // 3. new internal faces inside split cells.
+
+    if (debug)
+    {
+        Pout<< "hexRef2::setRefinement :"
+            << " Marking faces to be handled"
+            << endl;
+    }
+
+    // Get all affected faces.
+    PackedBoolList affectedFace(mesh_.nFaces());
+
+    {
+        forAll(cellMidPoint, celli)
+        {
+            if (cellMidPoint[celli] >= 0)
+            {
+                const cell& cFaces = mesh_.cells()[celli];
+
+                forAll(cFaces, i)
+                {
+                    label facei = cFaces[i];
+                    if(!isDivisibleFace[facei])
+                    {
+                        affectedFace.set(cFaces[i]);
+                    } 
+                }
+            }
+        }
+    }
+
+
+    // 1. Faces that get split
+    // ~~~~~~~~~~~~~~~~~~~~~~~
+
+    if (debug)
+    {
+        Pout<< "hexRef2::setRefinement : Splitting faces" << endl;
+    }
+
+    forAll(faceMidPoint, facei)
+    {
+        if (faceMidPoint[facei] >= 0)
+        {
+            // Face needs to be split and hasn't yet been done in some way
+            // (affectedFace - is impossible since this is first change but
+            //  just for completeness)
+
+            const face& f = mesh_.faces()[facei];
+
+            // Has original facei been used (one face added, original gets
+            // modified)
+            bool modifiedFace = false;
+
+            //useless in hexRef2
+            // label anchorLevel = faceAnchorLevel[facei];
+
+            if(isDivisibleFace[facei])
+            {
+                face newFace(2);
+
+                // maybe need to adjust the point order
+                DynamicList<label> faceVerts(4);
+                
+
+                forAll(f, fp)
+                {
+                    label pointi = f[fp];
+
+                    label nextpointi = f[f.fcIndex(fp)];
+                    label edgeI = meshTools::findEdge (mesh_, pointi, nextpointi);
+
+                    if (edgeMidPoint[edgeI] >=0)
+                    {
+                        faceVerts.append(pointi);
+                        //change
+                        faceVerts.append(edgeMidPoint[edgeI]);
+
+                        //use to check
+                        // const edge& e = mesh_.edges()[edgeI];
+                        // Pout<< "add:" <<edgeMidPoint[edgeI]<< "is the mid of "<< e <<endl;
+
+                        DynamicList<label> storage;
+                        const labelList& fEdges = mesh_.faceEdges(facei,storage);
+                        forAll(fEdges,i)
+                        {
+                            label edgeJ = fEdges[i];
+                            if(edgeMidPoint[edgeJ] >= 0 && edgeJ!=edgeI )
+                            {
+                                faceVerts.append(edgeMidPoint[edgeJ]);
+
+                                //to check
+                                // const edge& e = mesh_.edges()[edgeJ];
+                                // Pout<< "add:" <<edgeMidPoint[edgeJ]<< "is the mid of "<< e <<endl;
+                                break;
+                            }
+                        }
+
+                        label pointJ = f[f.rcIndex(fp)];
+                        
+                        faceVerts.append(pointJ);
+
+                        newFace.transfer(faceVerts);
+
+                        //use to check
+                        // Pout<< "Split face:" << facei << " verts:" << f
+                        //     << " into quad:" << newFace << endl;
+
+                        // Get new owner/neighbour
+                        label nei = -1;
+                        label own = myGetAnchorCell
+                        (
+                            cellAnchorPoints,
+                            cellAddedCells,
+                            edgeMidPoint,
+                            mesh_.faceOwner()[facei],
+                            facei,
+                            pointi
+                        );
+
+                        if (mesh_.isInternalFace(facei))
+                        {
+                            nei = myGetAnchorCell
+                            (
+                                cellAnchorPoints,
+                                cellAddedCells,
+                                edgeMidPoint,
+                                mesh_.faceNeighbour()[facei],
+                                facei,
+                                pointi
+                            );
+                        }
+                        else
+                        {
+                            nei = -1;
+                        }
+
+                        // use to check
+                        // Pout<< "pointi is :" << pointi << endl;
+                        // Pout<< "owner cell:" << own << endl;
+                        // Pout<< "neighbour cell:" << nei << endl;
+
+                        if (debug)
+                        {
+                            if (mesh_.isInternalFace(facei))
+                            {
+                                label oldOwn = mesh_.faceOwner()[facei];
+                                label oldNei = mesh_.faceNeighbour()[facei];
+
+                                checkInternalOrientation
+                                (
+                                    meshMod,
+                                    oldOwn,
+                                    facei,
+                                    mesh_.cellCentres()[oldOwn],
+                                    mesh_.cellCentres()[oldNei],
+                                    newFace
+                                );
+                            }
+                            else
+                            {
+                                label oldOwn = mesh_.faceOwner()[facei];
+
+                                checkBoundaryOrientation
+                                (
+                                    meshMod,
+                                    oldOwn,
+                                    facei,
+                                    mesh_.cellCentres()[oldOwn],
+                                    mesh_.faceCentres()[facei],
+                                    newFace
+                                );
+                            }
+                        }
+
+
+                        if (!modifiedFace)
+                        {
+                            modifiedFace = true;
+
+                            modFace(meshMod, facei, newFace, own, nei);
+                        }
+                        else
+                        {
+                            addFace(meshMod, facei, newFace, own, nei);
+                        }
+                    }
+                }
+
+            }
+            // Mark face as having been handled
+            affectedFace.unset(facei);
+        }
+    }
+
+    // use to check
+    // Pout<< "done so far"<< endl;
+
+    // 2. faces that do not get split but whose owner/neighbour change
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    if (debug)
+    {
+        Pout<< "hexRef2::setRefinement :"
+            << " Changing owner/neighbour for otherwise unaffected faces"
+            << endl;
+    }
+
+    forAll(affectedFace, facei)
+    {
+        if (affectedFace.get(facei))
+        {
+            const face& f = mesh_.faces()[facei];
+            //use to check
+            // Pout<< "affectedFace face:" << facei << " verts:" << f
+            // << endl;
+
+            // The point with the lowest level should be an anchor
+            // point of the neighbouring cells.
+            label anchorFp = findMinLevel(f);
+            
+            label cello = mesh_.faceOwner()[facei];
+            const cell& ocFaces = mesh_.cells()[cello];
+            
+            label faceowner = -1;
+            bool findRightOwnerFace = false;
+            forAll(ocFaces, o)
+            {
+                label faceo = ocFaces[o];
+
+                if(faceMidPoint[faceo] >= 0)
+                {
+                    const face& of = mesh_.faces()[faceo];
+                    forAll(of,fpo)
+                    {
+                        if( of[fpo] == f[anchorFp] )
+                        {
+                            findRightOwnerFace = true;
+                            faceowner = faceo;
+                            break;
+                        }
+                    }
+                }
+                if(findRightOwnerFace)
+                {
+                    break;
+                }
+            }
+            
+            //use to check
+            // const face& fo = mesh_.faces()[faceowner];
+            // Pout<< "chosen faceOwner is :" << fo
+            // << endl;
+
+            label nei = -1;
+            label own = myGetAnchorCell
+            (
+                cellAnchorPoints,
+                cellAddedCells,
+                edgeMidPoint,
+                mesh_.faceOwner()[facei],
+                faceowner,
+                f[anchorFp]
+            );
+
+            if (mesh_.isInternalFace(facei))
+            {
+                label celln = mesh_.faceNeighbour()[facei];
+                const cell& ncFaces = mesh_.cells()[celln];
+                
+                label faceneighbour = -1;
+                bool findRightNeighbourFace = false;
+                forAll(ncFaces, n)
+                {
+                    label facen = ncFaces[n];
+
+                    if(faceMidPoint[facen] >= 0)
+                    {
+                        const face& nf = mesh_.faces()[facen];
+                        forAll(nf,fpn)
+                        {
+                            if( nf[fpn] == f[anchorFp] )
+                            {
+                                findRightNeighbourFace = true;
+                                faceneighbour = facen;
+                                break;
+                            }
+                        }
+                    }
+                    if(findRightNeighbourFace)
+                    {
+                        break;
+                    }
+                }
+                
+                //use to check
+                // const face& fk = mesh_.faces()[faceneighbour];
+                // Pout<< "chosen faceNeighbour is :" << fk
+                // << endl;
+
+                nei = myGetAnchorCell
+                (
+                    cellAnchorPoints,
+                    cellAddedCells,
+                    edgeMidPoint,
+                    mesh_.faceNeighbour()[facei],
+                    faceneighbour,
+                    f[anchorFp]
+                );
+            }
+            else
+            {
+                nei = -1;
+            }
+
+            modFace(meshMod, facei, f, own, nei);
+
+            // Mark face as having been handled
+            affectedFace.unset(facei);
+        }
+    }
+
+
+    // 3. new internal faces inside split cells.
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    if (debug)
+    {
+        Pout<< "hexRef2::setRefinement :"
+            << " Create new internal faces for split cells"
+            << endl;
+    }
+
+    forAll(cellMidPoint, celli)
+    {
+        if (cellMidPoint[celli] >= 0)
+        {
+            label addPoint = 0;
+            label anchorPointi = -1;
+            label nextAnchorPointi = -1;
+            label lastEdge = -1;
+            label lastFace = -1;
+            label faceI = -1;
+            pointField edgeMids(mesh_.nEdges(), point(-GREAT, -GREAT, -GREAT));
+            DynamicList<label> newFaceVerts(4);
+
+            bool FirstEdge = true;
+            label i = 0;
+            const cell& cFaces = mesh_.cells()[celli];
+            while(true)
+            {
+                label facei = cFaces[i];
+                //the first divisible edge : add first mid point and find anchor
+                if(faceMidPoint[facei] >= 0 && FirstEdge )
+                {
+                    const face& f = mesh_.faces()[facei];
+                    faceI = facei;
+                    lastFace = faceI;
+
+                    //decide two anchor point
+                    anchorPointi = f[0];
+                    nextAnchorPointi = f[f.fcIndex(0)];//start with forward
+                    label edgeI = meshTools::findEdge (mesh_, anchorPointi, nextAnchorPointi);
+
+                    if(edgeMidPoint[edgeI] >= 0)
+                    {
+                        edgeMids[edgeI] = mesh_.edges()[edgeI].centre(mesh_.points());
+                        newFaceVerts.append(edgeMidPoint[edgeI]);
+                        addPoint++;
+                        lastEdge = edgeI;
+                        FirstEdge = false;
+                    }
+                    else
+                    {
+                        nextAnchorPointi = f[f.rcIndex(0)]; //change to backward
+                        label edgeI = meshTools::findEdge (mesh_, anchorPointi, nextAnchorPointi);
+
+                        edgeMids[edgeI] = mesh_.edges()[edgeI].centre(mesh_.points());
+                        newFaceVerts.append(edgeMidPoint[edgeI]);
+
+                        //use to check:
+                        // const edge& e = mesh_.edges()[edgeI];
+                        // Pout<< "add internal face use edge :" <<e<< endl;
+                       
+                        if(edgeMidPoint[edgeI] <0 )
+                        {
+                            Pout<< "something wrong !" << endl;
+                        }
+                        addPoint++;
+                        lastEdge = edgeI;
+                        FirstEdge = false;
+                    } 
+                }
+                
+                //find the other points to make the new internal face
+                if(faceMidPoint[facei] >= 0 && !FirstEdge && facei!=lastFace)
+                {
+                    const edge& e = mesh_.edges()[lastEdge];
+                    const face& f = mesh_.faces()[facei];
+                    bool rightFace = false;
+
+                    forAll(f,fp0)
+                    {
+                        if( f[fp0] == e[0])
+                        {
+                            if( f[f.fcIndex(fp0)] == e[1] || f[f.rcIndex(fp0)] == e[1])
+                            {
+                                rightFace = true;
+                                break;
+                            }
+                        }
+                    }
+                    if(rightFace)
+                    {
+                        label point0 = -1;
+                        label point1 = -1;
+                        forAll(f,fp0)
+                        {
+                            if( f[fp0] != e[0] && f[fp0] != e[1] )
+                            {
+                                if(point0 == -1)
+                                {
+                                    point0 = f[fp0];
+                                }
+                                else
+                                {
+                                    point1 = f[fp0];
+                                    break;
+                                }
+                            }
+                        }
+                        label edgeII = meshTools::findEdge (mesh_, point0, point1);
+
+                        edgeMids[edgeII] = mesh_.edges()[edgeII].centre(mesh_.points());
+                        newFaceVerts.append(edgeMidPoint[edgeII]);
+
+                        //use to check:
+                        // const edge& e = mesh_.edges()[edgeII];
+                        // Pout<< "add internal face use edge :" <<e<< endl;
+                        
+                        if(edgeMidPoint[edgeII] <0 )
+                        {
+                            Pout<< "something wrong !" << endl;
+                        }
+                        addPoint++;
+                        lastEdge = edgeII;
+                        lastFace = facei;
+                        FirstEdge = false;
+                    }
+                }
+                i++;
+                if(i > 5)
+                {
+                    i = 0;
+                }
+                if( addPoint == 4)
+                {
+                    break;
+                }
+            }  
+            face newFace;
+            newFace.transfer(newFaceVerts);
+            //use to check
+            // Pout<< "done so far 2!,newInternalFace is "<< newFace <<endl;
+
+            label anchorCell0 = myGetAnchorCell
+            (
+                cellAnchorPoints,
+                cellAddedCells,
+                edgeMidPoint,
+                celli,
+                faceI,
+                anchorPointi
+            );
+            //use to check
+            // Pout<< "anchorCell0 =" << anchorCell0 << endl;
+            label anchorCell1 = myGetAnchorCell
+            (
+                cellAnchorPoints,
+                cellAddedCells,
+                edgeMidPoint,
+                celli,
+                faceI,
+                nextAnchorPointi
+            );
+
+            //use to check
+            // Pout<< "anchorCell1 =" << anchorCell1 << endl;
+            // Pout<< "done so far 2.2!" << endl;
+
+            label own, nei;
+            point ownPt, neiPt;
+
+            if (anchorCell0 < anchorCell1)
+            {
+                own = anchorCell0;
+                nei = anchorCell1;
+
+                ownPt = mesh_.points()[anchorPointi];
+                neiPt = mesh_.points()[nextAnchorPointi];
+
+            }
+            else
+            {
+                own = anchorCell1;
+                nei = anchorCell0;
+                newFace.flip();
+
+                ownPt = mesh_.points()[nextAnchorPointi];
+                neiPt = mesh_.points()[anchorPointi];
+            }
+
+            if (debug)
+            {
+                point ownPt, neiPt;
+
+                if (anchorCell0 < anchorCell1)
+                {
+                    ownPt = mesh_.points()[anchorPointi];
+                    neiPt = mesh_.points()[nextAnchorPointi];
+                }
+                else
+                {
+                    ownPt = mesh_.points()[nextAnchorPointi];
+                    neiPt = mesh_.points()[anchorPointi];
+                }
+
+                checkInternalOrientation
+                (
+                    meshMod,
+                    celli,
+                    faceI,
+                    ownPt,
+                    neiPt,
+                    newFace
+                );
+            }
+
+            //use to check
+            // Pout<< "done so far 3!"<< endl;
+
+            addInternalFace
+            (
+                meshMod,
+                faceI,
+                anchorPointi,
+                newFace,
+                own,
+                nei
+            );
+
+        }
+
+    }
+
+    // Extend pointLevels and cellLevels for the new cells. Could also be done
+    // in updateMesh but saves passing cellAddedCells out of this routine.
+
+    // Check
+    if (debug)
+    {
+        label minPointi = labelMax;
+        label maxPointi = labelMin;
+
+        forAll(cellMidPoint, celli)
+        {
+            if (cellMidPoint[celli] >= 0)
+            {
+                minPointi = min(minPointi, cellMidPoint[celli]);
+                maxPointi = max(maxPointi, cellMidPoint[celli]);
+            }
+        }
+        forAll(faceMidPoint, facei)
+        {
+            if (faceMidPoint[facei] >= 0)
+            {
+                minPointi = min(minPointi, faceMidPoint[facei]);
+                maxPointi = max(maxPointi, faceMidPoint[facei]);
+            }
+        }
+        forAll(edgeMidPoint, edgeI)
+        {
+            if (edgeMidPoint[edgeI] >= 0)
+            {
+                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);
+        }
+    }
+
+    pointLevel_.transfer(newPointLevel);
+    cellLevel_.transfer(newCellLevel);
+
+    // Mark files as changed
+    setInstance(mesh_.facesInstance());
+
+    //use to check
+    // Pout<< "done setInstance"<< endl;
+
+
+    // Update the live split cells tree.
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    // New unrefinement structure
+    if (history_.active())
+    {
+        if (debug)
+        {
+            Pout<< "hexRef2::setRefinement :"
+                << " Updating refinement history to " << cellLevel_.size()
+                << " cells" << endl;
+        }
+
+        // Extend refinement history for new cells
+        history_.resize(cellLevel_.size());
+
+        forAll(cellAddedCells, celli)
+        {
+            const labelList& addedCells = cellAddedCells[celli];
+
+            if (addedCells.size())
+            {
+                // Cell was split.
+                history_.storeSplit(celli, addedCells);
+            }
+        }
+    }
+
+    //use to check
+    // Pout<< "done New unrefinement structure"<< endl;
+
+    // Compact cellAddedCells.
+
+    labelListList refinedCells(cellLabels.size());
+
+    forAll(cellLabels, i)
+    {
+        label celli = cellLabels[i];
+        
+        refinedCells[i].transfer(cellAddedCells[celli]);
+    }
+
+    //use to check
+    // Pout<< "done Compact cellAddedCells"<< endl;
+    return refinedCells;
+}
+
+Foam::labelList Foam::hexRef2::selectUnrefineElems
+(
+    const scalar unrefineLevel,
+    const PackedBoolList& markedCell,
+    const scalarField& pFld
+) const
+{
+    // All points that can be unrefined
+    const labelList splitFaces(getSplitElems());
+
+    DynamicList<label> newSplitFaces(splitFaces.size());
+
+    forAll(splitFaces, i)
+    {
+        label facej = splitFaces[i];
+
+        const face& f = mesh_.faces()[facej];
+
+        forAll(f, i)
+        {
+            label pointi = f[i];
+
+            bool hasMarked = true;
+
+            if (pFld[pointi] < unrefineLevel)
+            {
+                // Check that all cells are not marked
+                const labelList& pCells = mesh_.pointCells()[pointi];
+
+                hasMarked = false;
+
+                forAll(pCells, pCelli)
+                {
+                    if (markedCell.get(pCells[pCelli]))
+                    {
+                        hasMarked = true;
+                        break;
+                    }
+                }
+            }
+
+            if (!hasMarked)
+            {
+                newSplitFaces.append(facej);
+                break;
+            }
+        }
+    }
+
+
+    newSplitFaces.shrink();
+
+    // Guarantee 2:1 refinement after unrefinement
+    labelList consistentSet
+    (
+        consistentUnrefinement
+        (
+            newSplitFaces,
+            false
+        )
+    );
+    Info<< "Selected " << returnReduce(consistentSet.size(), sumOp<label>())
+        << " split faces out of a possible "
+        << returnReduce(splitFaces.size(), sumOp<label>())
+        << "." << endl;
+
+    return consistentSet;
+}
+
+Foam::labelList Foam::hexRef2::consistentUnrefinement
+(
+    const labelList& elemsToUnrefine,
+    const bool maxSet
+) const
+{
+    if (debug)
+    {
+        Pout<< "hexRef2::consistentUnrefinement :"
+            << " Determining 2:1 consistent unrefinement" << endl;
+    }
+
+    if (maxSet)
+    {
+        FatalErrorInFunction
+            << "maxSet not implemented yet."
+            << abort(FatalError);
+    }
+
+    // For hexRef2, unrefinement is based on faces
+    const labelList& facesToUnrefine(elemsToUnrefine);
+
+    // Loop, modifying facesToUnrefine, until no more changes to due to 2:1
+    // conflicts.
+    // maxSet = false : unselect faces to refine
+    // maxSet = true: select faces to refine
+
+    // Maintain boolList for facesToUnrefine and cellsToUnrefine
+    PackedBoolList unrefineFace(mesh_.nFaces());
+
+    forAll(facesToUnrefine, i)
+    {
+        label facei = facesToUnrefine[i];
+
+        unrefineFace.set(facei);
+    }
+
+
+    while (true)
+    {
+        // Construct cells to unrefine
+        // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
+        // const labelListList& edgeCells = mesh_.edgeCells();
+
+        PackedBoolList unrefineCell(mesh_.nCells());
+
+        forAll(unrefineFace, facei)
+        {
+            if (unrefineFace.get(facei))
+            {
+                label pCells1 = mesh_.faceOwner()[facei];
+                label pCells2 = mesh_.faceNeighbour()[facei];
+                unrefineCell.set(pCells1);
+                unrefineCell.set(pCells2);
+            }
+        }
+
+
+        label nChanged = 0;
+
+
+        // Check 2:1 consistency taking refinement into account
+        // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+        // Internal faces.
+        for (label facei = 0; facei < mesh_.nInternalFaces(); facei++)
+        {
+            label own = mesh_.faceOwner()[facei];
+            label ownLevel = cellLevel_[own] - unrefineCell.get(own);
+
+            label nei = mesh_.faceNeighbour()[facei];
+            label neiLevel = cellLevel_[nei] - unrefineCell.get(nei);
+
+            if (ownLevel < (neiLevel-1))
+            {
+                // Since was 2:1 this can only occur if own is marked for
+                // unrefinement.
+
+                if (maxSet)
+                {
+                    unrefineCell.set(nei);
+                }
+                else
+                {
+                    // could also combine with unset:
+                    // if (!unrefineCell.unset(own))
+                    // {
+                    //     FatalErrorInFunction
+                    //         << "problem cell already unset"
+                    //         << abort(FatalError);
+                    // }
+                    if (unrefineCell.get(own) == 0)
+                    {
+                        FatalErrorInFunction
+                            << "problem" << abort(FatalError);
+                    }
+
+                    unrefineCell.unset(own);
+                }
+                nChanged++;
+            }
+            else if (neiLevel < (ownLevel-1))
+            {
+                if (maxSet)
+                {
+                    unrefineCell.set(own);
+                }
+                else
+                {
+                    if (unrefineCell.get(nei) == 0)
+                    {
+                        FatalErrorInFunction
+                            << "problem" << abort(FatalError);
+                    }
+
+                    unrefineCell.unset(nei);
+                }
+                nChanged++;
+            }
+        }
+
+
+        // Coupled faces. Swap owner level to get neighbouring cell level.
+        labelList neiLevel(mesh_.nFaces()-mesh_.nInternalFaces());
+
+        forAll(neiLevel, i)
+        {
+            label own = mesh_.faceOwner()[i+mesh_.nInternalFaces()];
+
+            neiLevel[i] = cellLevel_[own] - unrefineCell.get(own);
+        }
+
+        // Swap to neighbour
+        syncTools::swapBoundaryFaceList(mesh_, neiLevel);
+
+        forAll(neiLevel, i)
+        {
+            label facei = i+mesh_.nInternalFaces();
+            label own = mesh_.faceOwner()[facei];
+            label ownLevel = cellLevel_[own] - unrefineCell.get(own);
+
+            if (ownLevel < (neiLevel[i]-1))
+            {
+                if (!maxSet)
+                {
+                    if (unrefineCell.get(own) == 0)
+                    {
+                        FatalErrorInFunction
+                            << "problem" << abort(FatalError);
+                    }
+
+                    unrefineCell.unset(own);
+                    nChanged++;
+                }
+            }
+            else if (neiLevel[i] < (ownLevel-1))
+            {
+                if (maxSet)
+                {
+                    if (unrefineCell.get(own) == 1)
+                    {
+                        FatalErrorInFunction
+                            << "problem" << abort(FatalError);
+                    }
+
+                    unrefineCell.set(own);
+                    nChanged++;
+                }
+            }
+        }
+
+        reduce(nChanged, sumOp<label>());
+
+        if (debug)
+        {
+            Pout<< "hexRef2::consistentUnrefinement :"
+                << " Changed " << nChanged
+                << " refinement levels due to 2:1 conflicts."
+                << endl;
+        }
+
+        if (nChanged == 0)
+        {
+            break;
+        }
+
+
+        // Convert cellsToUnrefine back into points to unrefine
+        // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+        // Knock out any edge whose cell neighbour cannot be unrefined.
+        forAll(unrefineFace, facei)
+        {
+            if (unrefineFace.get(facei))
+            {
+                label pCells1 = mesh_.faceOwner()[facei];
+                label pCells2 = mesh_.faceNeighbour()[facei];
+
+                if (!unrefineCell.get(pCells1) || !unrefineCell.get(pCells2) )
+                {
+                    unrefineFace.unset(facei);
+                }
+            }
+        }
+    }
+
+
+    // Convert back to labelList.
+    label nSet = 0;
+
+    forAll(unrefineFace, facei)
+    {
+        if (unrefineFace.get(facei))
+        {
+            nSet++;
+        }
+    }
+
+    labelList newFacesToUnrefine(nSet);
+    nSet = 0;
+
+    forAll(unrefineFace, facei)
+    {
+        if (unrefineFace.get(facei))
+        {
+            newFacesToUnrefine[nSet++] = facei;
+        }
+    }
+
+    return newFacesToUnrefine;
+}
+
+void Foam::hexRef2::calcFaceToSplitPoint
+(
+    const labelList& splitElems,
+    Map<label>& faceToSplitPoint
+)
+{
+    // Save information on faces that will be combined
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    // For hexRef2, the split elems are faces
+    // const labelList& splitPoints(splitElems);
+    const labelList& splitFaces(splitElems);
+
+    faceToSplitPoint.resize(splitFaces.size());
+
+    {
+        forAll(splitFaces, i)
+        {
+            label facei = splitFaces[i];
+
+            const labelList& fEdges = mesh_.faceEdges(facei);
+
+            forAll(fEdges, j)
+            {
+                const edge& e = mesh_.edges()[fEdges[j]];
+
+                forAll(e, k)
+                {
+                    label pointi = e[k];
+
+                    const labelList& pFaces = mesh_.pointFaces()[pointi];
+
+                    forAll(pFaces, pFacei)
+                    {
+                        faceToSplitPoint.insert(pFaces[pFacei], pointi);
+                    }
+                }                
+            }
+        }
+    }
+}
+
+// For hexRef2, split elements is face
+Foam::labelList Foam::hexRef2::getSplitElems() const
+{
+    if (debug)
+    {
+        checkRefinementLevels(-1, labelList(0));
+    }
+
+    if (debug)
+    {
+        Pout<< "hexRef2::getSplitElems :"
+            << " Calculating unrefineable points" << endl;
+    }
+
+
+    if (!history_.active())
+    {
+        FatalErrorInFunction
+            << "Only call if constructed with history capability"
+            << abort(FatalError);
+    }
+
+    // Master cell
+    // -1 undetermined
+    // -2 certainly not split point
+    // >= label of master cell
+    labelList splitMaster(mesh_.nFaces(), -1);
+    labelList splitMasterLevel(mesh_.nFaces(), 0);
+
+    // Unmark all with not 2 cells
+    //const labelListList& pointCells = mesh_.pointCells();
+    // maybe useless in hexRef2
+    // const labelListList& edgeCells = mesh_.edgeCells();
+
+    // Unmark all with different master cells
+    const labelList& visibleCells = history_.visibleCells();
+
+    forAll(visibleCells, celli)
+    {
+        const cell& cFaces = mesh_.cells()[celli];
+
+        if (visibleCells[celli] != -1 && history_.parentIndex(celli) >= 0)
+        {
+            label parentIndex = history_.parentIndex(celli);
+
+            // Check same master.
+            forAll(cFaces, i)
+            {
+                label facei = cFaces[i];
+
+                label masterCelli = splitMaster[facei];
+
+                if (masterCelli == -1)
+                {
+                    // First time visit of point. Store parent cell and
+                    // level of the parent cell (with respect to celli). This
+                    // is additional guarantee that we're referring to the
+                    // same master at the same refinement level.
+
+                    splitMaster[facei] = parentIndex;
+                    splitMasterLevel[facei] = cellLevel_[celli] - 1;
+                }
+                else if (masterCelli == -2)
+                {
+                    // Already decided that edge is not splitEdge
+                }
+                else if
+                (
+                    (masterCelli != parentIndex)
+                 || (splitMasterLevel[facei] != cellLevel_[celli] - 1)
+                )
+                {
+                    // Different masters so edge is on two refinement
+                    // patterns
+                    splitMaster[facei] = -2;
+                }
+            }
+        }
+        else
+        {
+            // Either not visible or is unrefined cell
+            forAll(cFaces, i)
+            {
+                label facei = cFaces[i];
+
+                splitMaster[facei] = -2;
+            }
+        }
+    }
+
+    // Unmark boundary faces
+    for
+    (
+        label facei = mesh_.nInternalFaces();
+        facei < mesh_.nFaces();
+        facei++
+    )
+    {
+        splitMaster[facei] = -2;
+    }
+
+
+    // Collect into labelList
+
+    label nSplitFaces = 0;
+
+    forAll(splitMaster, facei)
+    {
+        if (splitMaster[facei] >= 0)
+        {
+            nSplitFaces++;
+        }
+    }
+
+    labelList splitFaces(nSplitFaces);
+    nSplitFaces = 0;
+
+    forAll(splitMaster, facei)
+    {
+        if (splitMaster[facei] >= 0)
+        {
+            splitFaces[nSplitFaces++] = facei;
+        }
+    }
+
+    return splitFaces;
+}
+
+
+void Foam::hexRef2::setUnrefinement
+(
+    const labelList& splitElemLabels,
+    polyTopoChange& meshMod
+)
+{
+    if (!history_.active())
+    {
+        FatalErrorInFunction
+            << "Only call if constructed with history capability"
+            << abort(FatalError);
+    }
+
+    // For hexRef2, unrefinement is based on faces
+    const labelList& splitFaceLabels(splitElemLabels);
+
+
+    //YO- This debug info would require writing edgeSets, which we do not have
+    //if (debug)
+    //{
+    //    Pout<< "hexRef::setUnrefinement :"
+    //        << " Checking initial mesh just to make sure" << endl;
+
+    //    checkMesh();
+
+    //    forAll(cellLevel_, celli)
+    //    {
+    //        if (cellLevel_[celli] < 0)
+    //        {
+    //            FatalErrorInFunction
+    //                << "Illegal cell level " << cellLevel_[celli]
+    //                << " for cell " << celli
+    //                << abort(FatalError);
+    //        }
+    //    }
+
+
+    //    // Write to sets.
+    //    pointSet pSet(mesh_, "splitPoints", splitPointLabels);
+    //    pSet.write();
+
+    //    cellSet cSet(mesh_, "splitPointCells", splitPointLabels.size());
+
+    //    forAll(splitPointLabels, i)
+    //    {
+    //        const labelList& pCells = mesh_.pointCells(splitPointLabels[i]);
+
+    //        forAll(pCells, j)
+    //        {
+    //            cSet.insert(pCells[j]);
+    //        }
+    //    }
+    //    cSet.write();
+
+    //    Pout<< "hexRef::setRefinement : Dumping " << pSet.size()
+    //        << " points and "
+    //        << cSet.size() << " cells for unrefinement to" << nl
+    //        << "    pointSet " << pSet.objectPath() << nl
+    //        << "    cellSet " << cSet.objectPath()
+    //        << endl;
+    //}
+
+
+    labelList cellRegion;
+    labelList cellRegionMaster;
+    labelList facesToRemove;
+
+    {
+        labelHashSet splitFaces(splitFaceLabels.size());
+
+        forAll(splitFaceLabels, i)
+        {
+            splitFaces.insert(splitFaceLabels[i]);
+        }
+
+        // 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,         // per cell -1 or region it is merged into
+            cellRegionMaster,   // per region the master cell
+            facesToRemove       // new faces to be removed.
+        );
+
+        if (facesToRemove.size() != splitFaces.size())
+        {
+            FatalErrorInFunction
+                << "Initial set of split points to unrefine does not"
+                << " seem to be consistent or not mid points of refined cells"
+                << abort(FatalError);
+        }
+    }
+
+    // Redo the region master so it is consistent with our master.
+    // This will guarantee that the new cell (for which faceRemover uses
+    // the region master) is already compatible with our refinement structure.
+
+    forAll(splitFaceLabels, i)
+    {
+        label facei = splitFaceLabels[i];
+
+        // Get original cell label
+
+        // const labelList& eCells = mesh_.edgeCells()[edgei];
+
+        // Check
+        if ( mesh_.faceNeighbour()[facei] == -1)
+        {
+            FatalErrorInFunction
+                << "splitFace " << facei
+                << " should have " << 2
+                << " cells using it. It has " << 1
+                << abort(FatalError);
+        }
+
+
+        // Check that the lowest numbered pCells is the master of the region
+        // (should be guaranteed by directRemoveFaces)
+        //if (debug)
+        {
+            // label masterCelli = min(eCells);
+            label masterCelli = mesh_.faceOwner()[facei];
+            label neighbourCelli = mesh_.faceNeighbour()[facei];
+
+            label regionOwner = cellRegion[masterCelli];
+            if (regionOwner == -1)
+            {
+                FatalErrorInFunction
+                    << "Ininitial set of split faces to unrefine does not"
+                    << " seem to be consistent or not mid faces"
+                    << " of refined cells" << nl
+                    << "cell:" << masterCelli << " on splitFace " << facei
+                    << " has no region to be merged into"
+                    << abort(FatalError);
+            }
+
+            if (masterCelli != cellRegionMaster[regionOwner])
+            {
+                FatalErrorInFunction
+                    << "cell:" << masterCelli << " on splitFace:" << facei
+                    << " in region " << regionOwner
+                    << " has master:" << cellRegionMaster[regionOwner]
+                    << " which is not the lowest numbered cell"
+                    << abort(FatalError);
+            }
+
+            label regionNeighbour = cellRegion[neighbourCelli];
+            if (regionNeighbour == -1)
+            {
+                FatalErrorInFunction
+                    << "Ininitial set of split faces to unrefine does not"
+                    << " seem to be consistent or not mid faces"
+                    << " of refined cells" << nl
+                    << "cell:" << neighbourCelli << " on splitFace " << facei
+                    << " has no region to be merged into"
+                    << abort(FatalError);
+            }
+
+            if (masterCelli != cellRegionMaster[regionNeighbour])
+            {
+                FatalErrorInFunction
+                    << "cell:" << neighbourCelli << " on splitFace:" << facei
+                    << " in region " << regionNeighbour
+                    << " has master:" << cellRegionMaster[regionNeighbour]
+                    << " which is not the lowest numbered cell"
+                    << abort(FatalError);
+            }
+        }
+    }
+
+    // Insert all commands to combine cells. Never fails so don't have to
+    // test for success.
+    faceRemover_.setRefinement
+    (
+        facesToRemove,
+        cellRegion,
+        cellRegionMaster,
+        meshMod
+    );
+
+    // Remove the n cells that originated from merging around the split point
+    // and adapt cell levels (not that pointLevels stay the same since points
+    // either get removed or stay at the same position.
+    forAll(splitFaceLabels, i)
+    {
+        label facei = splitFaceLabels[i];
+
+        labelList eCells(2);
+
+        label masterCelli = mesh_.faceOwner()[facei];
+        eCells[0] = masterCelli;
+        label neighbourCelli = mesh_.faceNeighbour()[facei];
+        eCells[1] = neighbourCelli;
+
+        cellLevel_[masterCelli]--;
+        cellLevel_[neighbourCelli]--;
+
+        history_.combineCells(masterCelli, eCells);
+    }
+
+    // Mark files as changed
+    setInstance(mesh_.facesInstance());
+
+    // history_.updateMesh will take care of truncating.
+}
+
+
+// ************************************************************************* //
diff --git a/AMR_tidy/hexRef/hexRef2/hexRef2.H b/AMR_tidy/hexRef/hexRef2/hexRef2.H
new file mode 100644
index 00000000..921183a0
--- /dev/null
+++ b/AMR_tidy/hexRef/hexRef2/hexRef2.H
@@ -0,0 +1,226 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::hexRef2
+
+Description
+    Refinement of (split) hexes using polyTopoChange.
+
+SourceFiles
+    hexRef2.C
+
+Authors
+    Original code:
+    Ahmad Baniabedalruhman 2015
+    Adapted by:
+    Yun Ouedraogo 2017
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef hexRef2_H
+#define hexRef2_H
+
+#include "hexRef.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                           Class hexRef2 Declaration
+\*---------------------------------------------------------------------------*/
+
+class hexRef2 : public hexRef
+{
+
+protected:
+
+        //- 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;
+
+        label myGetAnchorCell
+        (
+            const labelListList& cellAnchorPoints,
+            const labelListList& cellAddedCells,
+            const labelList& edgeMidPoint,
+            const label celli,
+            const label facei,
+            const label pointi
+        ) const;
+
+
+        //- Store in maps correspondence from midpoint to anchors and faces.
+        label storeMidPointInfo
+        (
+            const labelListList& cellAnchorPoints,
+            const labelListList& cellAddedCells,
+            const labelList& cellMidPoint,
+            const labelList& faceMidPoint,
+            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,
+            polyTopoChange& meshMod
+        ) const;
+
+        //- Create all internal faces to split celli into 2.
+        void createInternalFaces
+        (
+            const labelListList& cellAnchorPoints,
+            const labelListList& cellAddedCells,
+            const labelList& cellMidPoint,
+            const labelList& faceMidPoint,
+            const labelList& faceAnchorLevel,
+            const labelList& edgeMidPoint,
+            const label celli,
+            polyTopoChange& meshMod
+        ) const;
+
+        //- Disallow default bitwise copy construct
+        hexRef2(const hexRef2&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const hexRef2&);
+
+
+public:
+
+    //- Runtime type information
+    TypeName("hexRef2");
+
+
+    // Constructors
+
+        //- Construct from mesh, read_if_present refinement data
+        //  (from write below). If readHistory is true does read_if_present
+        //  of refinement history. If false clears all history
+        hexRef2(const polyMesh& mesh, const bool readHistory = true);
+
+        //- Construct from mesh and un/refinement data and optional size of
+        //  starting cells
+        hexRef2
+        (
+            const polyMesh& mesh,
+            const labelList& cellLevel,
+            const labelList& pointLevel,
+            const refinementHistory& history,
+            const scalar level0Edge = -GREAT
+        );
+
+        //- Construct from mesh and refinement data and optional size of
+        //  starting cells
+        hexRef2
+        (
+            const polyMesh& mesh,
+            const labelList& cellLevel,
+            const labelList& pointLevel,
+            const scalar level0Edge = -GREAT
+        );
+
+    // Member Functions
+
+        // Refinement
+
+            //- Insert refinement. All selected cells will be split into 8.
+            //  Returns per element in cells the 8 cells they were split into.
+            //  Guarantees that the 0th element is the original cell label.
+            //  Mapping:
+            //  -split cells: 3 new ones get added from original
+            //  -split faces: original gets modified; 3 new ones get added
+            //               from original
+            //  -added internal faces: added from original cell face(if
+            //   that was internal) or created out-of-nothing (so will not
+            //   get mapped!). Note: could make this inflate from point but
+            //   that will allocate interpolation.
+            //  -points added to split edge: added from edge start()
+            //  -midpoints added: added from cellPoints[0].
+            labelListList setRefinement
+            (
+                const labelList& cells,
+                polyTopoChange&
+            );
+
+        // Unrefinement
+            //- Return the mid elems in top-level split cells
+            //  that can be unsplit.
+            labelList getSplitElems() const;
+
+            //- Given proposed
+            //  splitElems to unrefine according to calculate any clashes
+            //  (due to 2:1) and return ok list of mid elems to unrefine.
+            labelList consistentUnrefinement
+            (
+                const labelList& elemsToUnrefine,
+                const bool maxSet
+            ) const;
+
+            //- Remove some refinement. Needs to be supplied output of
+            //  consistentUnrefinement. Only call if undoable set.
+            //  All n edgeCells of a split edge will be combined into
+            //  the lowest numbered cell of those n.
+            void setUnrefinement
+            (
+                const labelList& splitElemLabels,
+                polyTopoChange&
+            );
+
+            labelList selectUnrefineElems
+            (
+                const scalar unrefineLevel,
+                const PackedBoolList& markedCell,
+                const scalarField& vFld
+            ) const;
+
+            void calcFaceToSplitPoint
+            (
+                const labelList& splitElems,
+                Map<label>& faceToSplitPoint
+            );
+
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/AMR_tidy/hexRef/hexRef4/hexRef4.C b/AMR_tidy/hexRef/hexRef4/hexRef4.C
new file mode 100644
index 00000000..1b63b9b0
--- /dev/null
+++ b/AMR_tidy/hexRef/hexRef4/hexRef4.C
@@ -0,0 +1,2546 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "hexRef4.H"
+
+#include "emptyPolyPatch.H"
+
+#include "addToRunTimeSelectionTable.H"
+
+#include "polyMesh.H"
+#include "polyTopoChange.H"
+#include "meshTools.H"
+#include "polyAddFace.H"
+#include "polyAddPoint.H"
+#include "polyAddCell.H"
+#include "polyModifyFace.H"
+#include "syncTools.H"
+#include "faceSet.H"
+#include "cellSet.H"
+#include "pointSet.H"
+#include "OFstream.H"
+#include "Time.H"
+#include "FaceCellWave.H"
+#include "mapDistributePolyMesh.H"
+#include "refinementData.H"
+#include "refinementDistanceData.H"
+#include "degenerateMatcher.H"
+
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(hexRef4, 0);
+    addToRunTimeSelectionTable(hexRef, hexRef4, mesh);
+    addToRunTimeSelectionTable(hexRef, hexRef4, levelsHist);
+    addToRunTimeSelectionTable(hexRef, hexRef4, levels);
+}
+
+// * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
+
+// Check whether pointi is an anchor on celli.
+// If it is not check whether any other point on the face is an anchor cell.
+Foam::label Foam::hexRef4::getAnchorCell
+(
+    const labelListList& cellAnchorPoints,
+    const labelListList& cellAddedCells,
+    const label celli,
+    const label facei,
+    const label pointi
+) const
+{
+    if (cellAnchorPoints[celli].size())
+    {
+        label index = findIndex(cellAnchorPoints[celli], pointi);
+
+        if (index != -1)
+        {
+            if (index >= 4) //AB....
+            {
+                if (index == 4)
+                {
+                    index = 8;
+                }
+                index = 8 - index;
+            } //AB
+            return cellAddedCells[celli][index];
+        }
+
+
+        // pointi is not an anchor cell.
+        // Maybe we are already a refined face so check all the face
+        // vertices.
+        const face& f = mesh_.faces()[facei];
+
+        forAll(f, fp)
+        {
+            label index = findIndex(cellAnchorPoints[celli], f[fp]);
+
+            if (index != -1)
+            {
+                if (index >= 4) //AB....
+                {
+                if (index == 4)
+                    {
+                        index = 8;
+                    }
+                    index = 8 - index;
+                } //AB
+                return cellAddedCells[celli][index];
+            }
+        }
+
+        // Problem.
+        dumpCell(celli);
+        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;
+    }
+}
+
+
+// Internal faces are one per edge between anchor points. So one per midPoint
+// between the anchor points. Here we store the information on the midPoint
+// and if we have enough information:
+// - two anchors
+// - two face mid points
+// we add the face. Note that this routine 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.
+Foam::label Foam::hexRef4::storeMidPointInfo
+(
+    const labelListList& cellAnchorPoints,
+    const labelListList& cellAddedCells,
+    const labelList& cellMidPoint,
+    const labelList& faceMidPoint,
+    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,
+    polyTopoChange& meshMod
+) const
+{
+    // 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;
+        }
+    }
+
+
+    // Check if this call of storeMidPointinfo is the one that completed all
+    // the necessary information.
+
+    if (changed && haveTwoAnchors)
+    {
+        const cell& cFaces = mesh_.cells()[celli];
+        label face1 = -1;
+
+        forAll(cFaces, i)
+        {
+            label faceJ = cFaces[i];
+
+            if (faceMidPoint[faceJ] != faceMidPointi
+                && faceMidPoint[faceJ] >= 0
+                && faceMidPoint[faceJ] != 1234567890) // could be replace by faceJ == type "empty"
+            {
+                face1 = faceJ;  // needed to take the other face points
+            }
+        }
+
+        const edge& anchors = midPointToAnchors[edgeMidPointi];
+        label index = findIndex(cellAnchorPoints[celli], anchorPointi);
+
+        if (index == 0)
+        {
+            index = 4;
+        }
+        if (index == 4)
+        {
+            index = 8;
+        }
+
+        label point1 = cellAnchorPoints[celli][8 - index];
+        label edgeMidPointj = -1;
+
+        const face& f = mesh_.faces()[face1];       //other face
+        const labelList& fEdges = mesh_.faceEdges(face1);
+
+        DynamicList<label> newFaceVerts(4);
+
+        if (faceOrder == (mesh_.faceOwner()[facei] == celli))
+        {
+            label anch = findIndex(f, point1);
+
+            if (pointLevel_[f[f.rcIndex(anch)]] <= cellLevel_[celli])
+            {
+                label edgeJ = fEdges[f.rcIndex(anch)];
+                edgeMidPointj = edgeMidPoint[edgeJ];
+            }
+            else
+            {
+                label edgeMid = findLevel(face1, f, f.rcIndex(anch), false, cellLevel_[celli] +1);
+                edgeMidPointj = f[edgeMid];
+            }
+
+            newFaceVerts.append(faceMidPointi);
+
+            // Check & insert edge split if any
+            insertEdgeSplit
+            (
+                edgeMidPoint,
+                faceMidPointi,  // edge between faceMid and
+                edgeMidPointi,  // edgeMid
+                newFaceVerts
+            );
+
+            newFaceVerts.append(edgeMidPointi);
+
+            insertEdgeSplit
+            (
+                edgeMidPoint,
+                edgeMidPointi,
+                edgeMidPointj,
+                newFaceVerts
+            );
+
+            newFaceVerts.append(edgeMidPointj);
+            newFaceVerts.append(faceMidPoint[face1]);
+        }
+        else
+        {
+            label anch = findIndex(f, point1);
+
+            if (pointLevel_[f[f.fcIndex(anch)]] <= cellLevel_[celli])
+            {
+                label edgeJ = fEdges[anch];
+                edgeMidPointj = edgeMidPoint[edgeJ];
+            }
+            else
+            {
+                label edgeMid = findLevel
+                (
+                    face1,
+                    f,
+                    f.fcIndex(anch),
+                    false,
+                    cellLevel_[celli] +1
+                );
+                edgeMidPointj = f[edgeMid];
+            }
+
+            newFaceVerts.append(edgeMidPointj);
+
+            insertEdgeSplit
+            (
+                edgeMidPoint,
+                edgeMidPointj,
+                edgeMidPointi,
+                newFaceVerts
+            );
+
+            newFaceVerts.append(edgeMidPointi);
+
+            insertEdgeSplit
+            (
+                edgeMidPoint,
+                edgeMidPointi,
+                faceMidPointi,
+                newFaceVerts
+            );
+
+            newFaceVerts.append(faceMidPointi);
+            newFaceVerts.append(faceMidPoint[face1]);
+        }
+
+        face newFace;
+        newFace.transfer(newFaceVerts);
+
+        label anchorCell0 = getAnchorCell
+        (
+            cellAnchorPoints,
+            cellAddedCells,
+            celli,
+            facei,
+            anchorPointi
+        );
+        // Pout<< "anchorCell0 =" << anchorCell0 << endl;
+        label anchorCell1 = getAnchorCell
+        (
+            cellAnchorPoints,
+            cellAddedCells,
+            celli,
+            facei,
+            anchors.otherVertex(anchorPointi)
+        );
+        // Pout<< "anchorCell1 =" << anchorCell1 << endl;
+
+        label own, nei;
+        point ownPt, neiPt;
+
+        if (anchorCell0 < anchorCell1)
+        {
+            own = anchorCell0;
+            nei = anchorCell1;
+
+            ownPt = mesh_.points()[anchorPointi];
+            neiPt = mesh_.points()[anchors.otherVertex(anchorPointi)];
+
+        }
+        else
+        {
+            own = anchorCell1;
+            nei = anchorCell0;
+            newFace.flip();
+
+            ownPt = mesh_.points()[anchors.otherVertex(anchorPointi)];
+            neiPt = mesh_.points()[anchorPointi];
+        }
+
+        if (debug)
+        {
+            point ownPt, neiPt;
+
+            if (anchorCell0 < anchorCell1)
+            {
+                ownPt = mesh_.points()[anchorPointi];
+                neiPt = mesh_.points()[anchors.otherVertex(anchorPointi)];
+            }
+            else
+            {
+                ownPt = mesh_.points()[anchors.otherVertex(anchorPointi)];
+                neiPt = mesh_.points()[anchorPointi];
+            }
+
+            checkInternalOrientation
+            (
+                meshMod,
+                celli,
+                facei,
+                ownPt,
+                neiPt,
+                newFace
+            );
+        }
+
+        return addInternalFace
+        (
+            meshMod,
+            facei,
+            anchorPointi,
+            newFace,
+            own,
+            nei
+        );
+    }
+    else
+    {
+        return -1;
+    }
+}
+
+
+// Creates all the 4 internal faces for celli.
+void Foam::hexRef4::createInternalFaces
+(
+    const labelListList& cellAnchorPoints,
+    const labelListList& cellAddedCells,
+    const labelList& cellMidPoint,
+    const labelList& faceMidPoint,
+    const labelList& faceAnchorLevel,
+    const labelList& edgeMidPoint,
+    const label celli,
+
+    polyTopoChange& meshMod
+) const
+{
+    // Find in every face the cellLevel+1 points (from edge subdivision)
+    // and the anchor points.
+
+    const cell& cFaces = mesh_.cells()[celli];
+    const label cLevel = cellLevel_[celli];
+
+    // From edge mid to anchor points
+    Map<edge> midPointToAnchors(8);
+    // From edge mid to face mids
+    Map<edge> midPointToFaceMids(8);
+
+    // Storage for on-the-fly addressing
+    DynamicList<label> storage;
+
+
+    // Running count of number of internal faces added so far.
+    label nFacesAdded = 0;
+
+    forAll(cFaces, i)
+    {
+        label facei = cFaces[i];
+
+        const face& f = mesh_.faces()[facei];
+        const labelList& fEdges = mesh_.faceEdges(facei, storage);
+
+        // We are on the celli side of face f. The face will have 1 or 4
+        // cLevel points and lots of higher numbered ones.
+
+        label faceMidPointi = -1;
+
+        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.
+            // In 2D case this should never happen, as the shared faces with uncutted mesh
+            // can be only the ones splitted in two which have two anchors and two middle edge points.
+
+            Info << "Should never happen: nAnchors == 1" << endl;
+
+            // Find the one anchor.
+            label anchorFp = -1;
+
+            forAll(f, fp)
+            {
+                if (pointLevel_[f[fp]] <= cLevel)
+                {
+                    anchorFp = fp;
+                    break;
+                }
+            }
+
+            // Now the face mid point is the second cLevel+1 point:
+            // these two lines just repeat the same steps two times to reach the second cLevel+1
+            label edgeMid = findLevel
+            (
+                facei,
+                f,
+                f.fcIndex(anchorFp),
+                true,
+                cLevel+1
+            );
+
+            // to be checked!!!
+            label faceMid = findLevel
+            (
+                facei,
+                f,
+                f.fcIndex(edgeMid),
+                true,
+                cLevel+1
+            );
+
+            faceMidPointi = f[faceMid];
+        }
+        else if (nAnchors == 2)
+        {
+            // Only two anchor point. So the other side of the face has already
+            // been split using cLevel+1 and cLevel+2 points.
+
+            faceMidPointi = 1234567890;        // again not nice
+
+        }
+        else if (nAnchors == 4)
+        {
+            // There is no face middle yet but the face will be marked for
+            // splitting. For non-empty faces, faceMidPoint[facei] will be 1234567890,
+            // which is not a point ID. This is checked in storeMidPointinfo.
+
+            faceMidPointi = faceMidPoint[facei];
+        }
+        else
+        {
+            dumpCell(mesh_.faceOwner()[facei]);
+            if (mesh_.isInternalFace(facei))
+            {
+                dumpCell(mesh_.faceNeighbour()[facei]);
+            }
+
+            FatalErrorInFunction
+                << "nAnchors:" << nAnchors
+                << " facei:" << facei
+                << abort(FatalError);
+        }
+
+
+
+        // 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.
+        // Only empty faces are considered as they are split like the 3D case.
+
+        if(faceMidPoint[facei] != 1234567890 && faceMidPointi != 1234567890)
+        {
+            forAll(f, fp0)
+            {
+                label point0 = f[fp0];
+
+                if (pointLevel_[point0] <= cLevel)
+                {
+                    // Anchor.
+
+                    // Walk forward
+                    // ~~~~~~~~~~~~
+                    // to cLevel+1 or edgeMidPoint of this level.
+
+
+                    label edgeMidPointi = -1;
+
+                    label fp1 = f.fcIndex(fp0);
+
+                    if (pointLevel_[f[fp1]] <= cLevel)
+                    {
+                        // Anchor. Edge will be split.
+                        label edgeI = fEdges[fp0];
+
+                        edgeMidPointi = edgeMidPoint[edgeI];
+
+                        if (edgeMidPointi == -1)
+                        {
+                            dumpCell(celli);
+
+                            const labelList& cPoints = mesh_.cellPoints(celli);
+
+                            FatalErrorInFunction
+                                << "cell:" << celli << " cLevel:" << cLevel
+                                << " cell points:" << cPoints
+                                << " pointLevel:"
+                                << UIndirectList<label>(pointLevel_, cPoints)()
+                                << " face:" << facei
+                                << " f:" << f
+                                << " pointLevel:"
+                                << UIndirectList<label>(pointLevel_, f)()
+                                << " faceAnchorLevel:" << faceAnchorLevel[facei]
+                                << " faceMidPoint:" << faceMidPoint[facei]
+                                << " faceMidPointi:" << faceMidPointi
+                                << " fp:" << fp0
+                                << abort(FatalError);
+                        }
+                    }
+                    else
+                    {
+                        // Search forward in face to clevel+1
+                        // In 2D this should never be used as this case is verified with
+                        // shared faces between refined and not-refined cells which have
+                        // to be refined in this turn.
+
+                        label edgeMid = findLevel(facei, f, fp1, true, cLevel+1);
+
+                        edgeMidPointi = f[edgeMid];
+                    }
+
+                    label newFacei = storeMidPointInfo
+                    (
+                        cellAnchorPoints,
+                        cellAddedCells,
+                        cellMidPoint,
+                        faceMidPoint,
+                        edgeMidPoint,
+
+                        celli,
+                        facei,
+                        true,                   // mid point after anchor
+                        edgeMidPointi,          // edgemid
+                        point0,                 // anchor
+                        faceMidPointi,
+
+                        midPointToAnchors,
+                        midPointToFaceMids,
+                        meshMod
+                    );
+
+                    if (newFacei != -1)
+                    {
+                        nFacesAdded++;
+
+                        if (nFacesAdded == 4)
+                        {
+                            break;
+                        }
+                    }
+
+
+
+                    // Walk backward
+                    // ~~~~~~~~~~~~~
+
+                    label fpMin1 = f.rcIndex(fp0);
+
+                    if (pointLevel_[f[fpMin1]] <= cLevel)
+                    {
+                        // Anchor. Edge will be split.
+                        label edgeI = fEdges[fpMin1];
+
+                        edgeMidPointi = edgeMidPoint[edgeI];
+
+                        if (edgeMidPointi == -1)
+                        {
+                            dumpCell(celli);
+
+                            const labelList& cPoints = mesh_.cellPoints(celli);
+
+                            FatalErrorInFunction
+                                << "cell:" << celli << " cLevel:" << cLevel
+                                << " cell points:" << cPoints
+                                << " pointLevel:"
+                                << UIndirectList<label>(pointLevel_, cPoints)()
+                                << " face:" << facei
+                                << " f:" << f
+                                << " pointLevel:"
+                                << UIndirectList<label>(pointLevel_, f)()
+                                << " faceAnchorLevel:" << faceAnchorLevel[facei]
+                                << " faceMidPoint:" << faceMidPoint[facei]
+                                << " faceMidPointi:" << faceMidPointi
+                                << " fp:" << fp0
+                                << abort(FatalError);
+                        }
+                    }
+                    else
+                    {
+                        // Search back to clevel+1
+                        // In 2D this should never be used as this case is verified with
+                        // shared faces between refined and not-refined cells which have
+                        // to be refined in this turn.
+
+                        label edgeMid = findLevel
+                        (
+                            facei,
+                            f,
+                            fpMin1,
+                            false,
+                            cLevel+1
+                        );
+
+                        edgeMidPointi = f[edgeMid];
+                    }
+
+                    newFacei = storeMidPointInfo
+                    (
+                        cellAnchorPoints,
+                        cellAddedCells,
+                        cellMidPoint,
+                        faceMidPoint,
+                        edgeMidPoint,
+
+                        celli,
+                        facei,
+                        false,                  // mid point before anchor
+                        edgeMidPointi,          // edgemid
+                        point0,                 // anchor
+                        faceMidPointi,
+
+                        midPointToAnchors,
+                        midPointToFaceMids,
+                        meshMod
+                    );
+
+                    if (newFacei != -1)
+                    {
+                        nFacesAdded++;
+
+                        if (nFacesAdded == 4)
+                        {
+                            break;
+                        }
+                    }
+                }   // done anchor
+            } // done face
+        }   // done check empty condition
+
+        if (nFacesAdded == 4)
+        {
+            break;
+        }
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+// Construct from mesh, read refinement data
+Foam::hexRef4::hexRef4(const polyMesh& mesh, const bool readHistory)
+:
+    hexRef(mesh, readHistory)
+{}
+
+
+// Construct from components
+Foam::hexRef4::hexRef4
+(
+    const polyMesh& mesh,
+    const labelList& cellLevel,
+    const labelList& pointLevel,
+    const refinementHistory& history,
+    const scalar level0Edge
+)
+:
+    hexRef(mesh, cellLevel, pointLevel, history, level0Edge)
+{}
+
+
+// Construct from components
+Foam::hexRef4::hexRef4
+(
+    const polyMesh& mesh,
+    const labelList& cellLevel,
+    const labelList& pointLevel,
+    const scalar level0Edge
+)
+:
+    hexRef(mesh, cellLevel, pointLevel, level0Edge)
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+// Top level driver to insert topo changes to do all refinement.
+Foam::labelListList Foam::hexRef4::setRefinement
+(
+    const labelList& cellLabels,
+    polyTopoChange& meshMod
+)
+{
+    if (debug)
+    {
+        Pout<< "hexRef4::setRefinement :"
+            << " Checking initial mesh just to make sure" << endl;
+
+        checkMesh();
+        // Cannot call checkRefinementlevels since hanging points might
+        // get triggered by the mesher after subsetting.
+        //checkRefinementLevels(-1, labelList(0));
+    }
+
+    // Clear any saved point/cell data.
+    savedPointLevel_.clear();
+    savedCellLevel_.clear();
+
+
+    // New point/cell level. Copy of pointLevel for existing points.
+    DynamicList<label> newCellLevel(cellLevel_.size());
+    forAll(cellLevel_, celli)
+    {
+        newCellLevel.append(cellLevel_[celli]);
+    }
+    DynamicList<label> newPointLevel(pointLevel_.size());
+    forAll(pointLevel_, pointi)
+    {
+        newPointLevel.append(pointLevel_[pointi]);
+    }
+
+
+    if (debug)
+    {
+        Pout<< "hexRef4::setRefinement :"
+            << " Allocating " << cellLabels.size() << " cell midpoints."
+            << endl;
+    }
+
+
+    // Mid point per refined cell.
+    // -1 : not refined
+    // >=0: label of mid point.
+    labelList cellMidPoint(mesh_.nCells(), -1);
+    forAll(cellLabels, i)
+    {
+        label celli = cellLabels[i];
+        cellMidPoint[celli] = 1234567890;    // mark need for splitting
+    }
+
+
+    boolList isDivisibleFace(mesh_.nFaces(), false);
+    boolList isDivisibleEdge(mesh_.nEdges(), false);
+
+    for (label facei = mesh_.nInternalFaces(); facei < mesh_.nFaces(); facei++)
+    {
+        const label & patchID = mesh_.boundaryMesh().whichPatch(facei);
+
+//        if (isA<emptyPolyPatch>(mesh_.boundaryMesh()[patchID])
+        if (mesh_.boundaryMesh()[patchID].type() == "empty")
+        {
+            isDivisibleFace[facei] = true;
+            const labelList& fEdges = mesh_.faceEdges(facei);
+
+            forAll(fEdges, i)
+            {
+                label edgeJ = fEdges[i];
+                isDivisibleEdge[edgeJ] = true;
+            }
+        }
+    }
+
+
+    if (debug)
+    {
+        cellSet splitCells(mesh_, "splitCells", cellLabels.size());
+
+        forAll(cellMidPoint, celli)
+        {
+            if (cellMidPoint[celli] >= 0)
+            {
+                splitCells.insert(celli);
+            }
+        }
+
+        Pout<< "hexRef4::setRefinement : Dumping " << splitCells.size()
+            << " cells to split to cellSet " << splitCells.objectPath()
+            << endl;
+
+        splitCells.write();
+    }
+
+
+
+    // Split edges
+    // ~~~~~~~~~~~
+
+    if (debug)
+    {
+        Pout<< "hexRef4::setRefinement :"
+            << " Allocating edge midpoints."
+            << endl;
+    }
+
+    // Unrefined edges are ones between cellLevel or lower points.
+    // If any cell using this edge gets split then the edge needs to be split.
+
+    // -1  : no need to split edge
+    // >=0 : label of introduced mid point
+    labelList edgeMidPoint(mesh_.nEdges(), -1);
+
+    // Note: Loop over cells to be refined or edges?
+    forAll(cellMidPoint, celli)
+    {
+        if (cellMidPoint[celli] >= 0)
+        {
+            const labelList& cEdges = mesh_.cellEdges(celli);
+            forAll(cEdges, i)
+            {
+                label edgeI = cEdges[i];
+                const edge& e = mesh_.edges()[edgeI];
+                if
+                (
+                 isDivisibleEdge[edgeI]
+                 && pointLevel_[e[0]] <= cellLevel_[celli]
+                 && pointLevel_[e[1]] <= cellLevel_[celli]
+                )
+                {
+                    edgeMidPoint[edgeI] = 12345;    // mark need for splitting
+                }
+            }
+        }
+    }
+
+    // Synchronize edgeMidPoint across coupled patches. Take max so that
+    // any split takes precedence.
+    syncTools::syncEdgeList
+    (
+        mesh_,
+        edgeMidPoint,
+        maxEqOp<label>(),
+        labelMin
+    );
+
+
+    // Introduce edge points
+    // ~~~~~~~~~~~~~~~~~~~~~
+
+    {
+        // Phase 1: calculate midpoints and sync.
+        // This needs doing for if people do not write binary and we slowly
+        // get differences.
+
+        pointField edgeMids(mesh_.nEdges(), point(-GREAT, -GREAT, -GREAT));
+
+        forAll(edgeMidPoint, edgeI)
+        {
+            if (edgeMidPoint[edgeI] >= 0)
+            {
+                // Edge marked to be split.
+                edgeMids[edgeI] = mesh_.edges()[edgeI].centre(mesh_.points());
+            }
+        }
+        syncTools::syncEdgePositions
+        (
+            mesh_,
+            edgeMids,
+            maxEqOp<vector>(),
+            point(-GREAT, -GREAT, -GREAT)
+        );
+
+
+        // Phase 2: introduce points at the synced locations.
+        forAll(edgeMidPoint, edgeI)
+        {
+            if (edgeMidPoint[edgeI] >= 0)
+            {
+                // Edge marked to be split. Replace edgeMidPoint with actual
+                // point label.
+
+                const edge& e = mesh_.edges()[edgeI];
+
+                edgeMidPoint[edgeI] = meshMod.setAction
+                (
+                    polyAddPoint
+                    (
+                        edgeMids[edgeI],            // point
+                        e[0],                       // master point
+                        -1,                         // zone for point
+                        true                        // supports a cell
+                    )
+                );
+
+                newPointLevel(edgeMidPoint[edgeI]) =
+                    max
+                    (
+                        pointLevel_[e[0]],
+                        pointLevel_[e[1]]
+                    )
+                  + 1;
+            }
+        }
+    }
+
+    if (debug)
+    {
+        OFstream str(mesh_.time().path()/"edgeMidPoint.obj");
+
+        forAll(edgeMidPoint, edgeI)
+        {
+            if (edgeMidPoint[edgeI] >= 0)
+            {
+                const edge& e = mesh_.edges()[edgeI];
+
+                meshTools::writeOBJ(str, e.centre(mesh_.points()));
+            }
+        }
+
+        Pout<< "hexRef4::setRefinement :"
+            << " Dumping edge centres to split to file " << str.name() << endl;
+    }
+
+
+    // Calculate face level
+    // ~~~~~~~~~~~~~~~~~~~~
+    // (after splitting)
+
+    if (debug)
+    {
+        Pout<< "hexRef4::setRefinement :"
+            << " Allocating face midpoints."
+            << endl;
+    }
+
+    // Face anchor level. There are guaranteed 4 points with level
+    // <= anchorLevel. These are the corner points.
+    labelList faceAnchorLevel(mesh_.nFaces());
+
+    for (label facei = 0; facei < mesh_.nFaces(); facei++)
+    {
+        faceAnchorLevel[facei] = faceLevel(facei);
+    }
+
+    // -1  : no need to split face
+    // >=0 : label of introduced mid point
+    labelList faceMidPoint(mesh_.nFaces(), -1);
+
+
+    // Internal faces: look at cells on both sides. Uniquely determined since
+    // face itself guaranteed to be same level as most refined neighbour.
+    for (label facei = 0; facei < mesh_.nInternalFaces(); facei++)
+    {
+        if (faceAnchorLevel[facei] >= 0)
+        {
+            label own = mesh_.faceOwner()[facei];
+            label ownLevel = cellLevel_[own];
+            label newOwnLevel = ownLevel + (cellMidPoint[own] >= 0 ? 1 : 0);
+
+            label nei = mesh_.faceNeighbour()[facei];
+            label neiLevel = cellLevel_[nei];
+            label newNeiLevel = neiLevel + (cellMidPoint[nei] >= 0 ? 1 : 0);
+
+            if
+            (
+                newOwnLevel > faceAnchorLevel[facei]
+             || newNeiLevel > faceAnchorLevel[facei]
+            )
+            {
+                faceMidPoint[facei] = 1234567890;    // mark to be split (not a real nice way)
+            }
+        }
+    }
+
+    // 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)
+
+    {
+        labelList newNeiLevel(mesh_.nFaces()-mesh_.nInternalFaces());
+
+        forAll(newNeiLevel, i)
+        {
+            label own = mesh_.faceOwner()[i+mesh_.nInternalFaces()];
+            label ownLevel = cellLevel_[own];
+            label newOwnLevel = ownLevel + (cellMidPoint[own] >= 0 ? 1 : 0);
+
+            newNeiLevel[i] = newOwnLevel;
+        }
+
+        // Swap.
+        syncTools::swapBoundaryFaceList(mesh_, newNeiLevel);
+
+        // So now we have information on the neighbour.
+
+        forAll(newNeiLevel, i)
+        {
+            label facei = i+mesh_.nInternalFaces();
+
+            if (faceAnchorLevel[facei] >= 0)
+            {
+                label own = mesh_.faceOwner()[facei];
+                label ownLevel = cellLevel_[own];
+                label newOwnLevel = ownLevel + (cellMidPoint[own] >= 0 ? 1 : 0);
+
+                if
+                (
+                    newOwnLevel > faceAnchorLevel[facei]
+                 || newNeiLevel[i] > faceAnchorLevel[facei]
+                )
+                {
+                    faceMidPoint[facei] = 1234567890;    // mark to be split (not really nice way)
+                }
+            }
+        }
+    }
+
+
+    // Synchronize faceMidPoint across coupled patches. (logical or)
+    syncTools::syncFaceList
+    (
+        mesh_,
+        faceMidPoint,
+        maxEqOp<label>()
+    );
+
+
+
+    // Introduce face points
+    // ~~~~~~~~~~~~~~~~~~~~~
+
+    {
+        // Phase 1: determine mid points and sync. See comment for edgeMids
+        // above
+        pointField bFaceMids
+        (
+            mesh_.nFaces()-mesh_.nInternalFaces(),
+            point(-GREAT, -GREAT, -GREAT)
+        );
+
+        forAll(bFaceMids, i)
+        {
+            label facei = i+mesh_.nInternalFaces();
+
+            if (faceMidPoint[facei] >= 0)
+            {
+                bFaceMids[i] = mesh_.faceCentres()[facei];
+            }
+        }
+        syncTools::syncBoundaryFacePositions
+        (
+            mesh_,
+            bFaceMids,
+            maxEqOp<vector>()
+        );
+
+        forAll(faceMidPoint, facei)
+        {
+            if (faceMidPoint[facei] >= 0 && isDivisibleFace[facei])
+            {
+                // Face marked to be split. Replace faceMidPoint with actual
+                // point label.
+
+                const face& f = mesh_.faces()[facei];
+                faceMidPoint[facei] = meshMod.setAction
+                (
+                    polyAddPoint
+                    (
+                        (
+                            facei < mesh_.nInternalFaces()
+                          ? mesh_.faceCentres()[facei]
+                          : bFaceMids[facei-mesh_.nInternalFaces()]
+                        ),                          // point
+                        f[0],                       // master point
+                        -1,                         // zone for point
+                        true                        // supports a cell
+                    )
+                );
+
+                // Determine the level of the corner points and midpoint will
+                // be one higher.
+                newPointLevel(faceMidPoint[facei]) = faceAnchorLevel[facei]+1;
+            }
+        }
+    }
+
+    if (debug)
+    {
+        faceSet splitFaces(mesh_, "splitFaces", cellLabels.size());
+
+        forAll(faceMidPoint, facei)
+        {
+            if (faceMidPoint[facei] >= 0)
+            {
+                splitFaces.insert(facei);
+            }
+        }
+
+        Pout<< "hexRef4::setRefinement : Dumping " << splitFaces.size()
+            << " faces to split to faceSet " << splitFaces.objectPath() << endl;
+
+        splitFaces.write();
+    }
+
+
+    // Information complete
+    // ~~~~~~~~~~~~~~~~~~~~
+    // At this point we have all the information we need. We should no
+    // longer reference the cellLabels to refine. All the information is:
+    // - cellMidPoint >= 0 : cell needs to be split.
+    // - faceMidPoint >= 0 : face needs to be split.
+    // - edgeMidPoint >= 0 : edge needs to be split.
+    // - isDivisibleFace true : face needs to be split in 4 else in 2.
+    //   for the 2 split case, faceMidPoint is >= 0 but not initalized with a point.
+
+
+    // Get the corner/anchor points
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    if (debug)
+    {
+        Pout<< "hexRef4::setRefinement :"
+            << " Finding cell anchorPoints (8 per cell)"
+            << endl;
+    }
+
+    // There will always be 8 points on the hex that have were introduced
+    // with the hex and will have the same or lower refinement level.
+
+    // Per cell the 8 corner points.
+    labelListList cellAnchorPoints(mesh_.nCells());
+    {
+        labelList nAnchorPoints(mesh_.nCells(), 0);
+        forAll(cellMidPoint, celli)
+        {
+            if (cellMidPoint[celli] >= 0)
+            {
+                cellAnchorPoints[celli].setSize(8);
+            }
+        }
+
+       forAll(cellMidPoint, celli)
+       {
+            const cell& cFaces = mesh_.cells()[celli];
+            forAll(cFaces, i)
+            {
+                label facei = cFaces[i];
+                const face& f = mesh_.faces()[facei];
+                forAll(f, fp)
+                {
+                    label pointi = f[fp];
+                    if
+                    (
+                        cellMidPoint[celli] >= 0
+                        && isDivisibleFace[facei]
+                        && pointLevel_[pointi] <= cellLevel_[celli]
+                    )
+                    {
+                        if (nAnchorPoints[celli] == 8)
+                        {
+                            dumpCell(celli);
+                            FatalErrorInFunction
+                                << "cell " << celli
+                                << " of level " << cellLevel_[celli]
+                                << " uses more than 8 points of equal or"
+                                << " lower level" << nl
+                                << "Points so far:" << cellAnchorPoints[celli]
+                                << abort(FatalError);
+                        }
+                        cellAnchorPoints[celli][nAnchorPoints[celli]++]
+                            = pointi;
+                    }
+                }
+            }
+        }
+
+
+        forAll(cellMidPoint, celli)
+        {
+            if (cellMidPoint[celli] >= 0)
+            {
+                if (nAnchorPoints[celli] != 8)
+                {
+                    const labelList cPoints(mesh_.cellPoints(celli));
+
+                    FatalErrorInFunction
+                        << "cell " << celli
+                        << " of level " << cellLevel_[celli]
+                        << " does not seem to have 8 points of equal or"
+                        << " lower level" << endl
+                        << "cellPoints:" << cPoints << endl
+                        << "pointLevels:"
+                        << IndirectList<label>(pointLevel_, cPoints)() << endl
+                        << abort(FatalError);
+                }
+            }
+        }
+    }
+
+
+    // Add the cells
+    // ~~~~~~~~~~~~~
+
+    if (debug)
+    {
+        Pout<< "hexRef4::setRefinement :"
+            << " Adding cells (1 per anchorPoint)"
+            << endl;
+    }
+
+    // Per cell the 3 added cells (+ original cell)
+    labelListList cellAddedCells(mesh_.nCells());
+
+    forAll(cellAnchorPoints, celli)
+    {
+        const labelList& cAnchors = cellAnchorPoints[celli];
+
+        if (cAnchors.size() == 8)
+        {
+            labelList& cAdded = cellAddedCells[celli];
+            cAdded.setSize(4);
+
+            // Original cell at 0
+            cAdded[0] = celli;
+
+            // Update cell level
+            newCellLevel[celli] = cellLevel_[celli]+1;
+
+
+            for (label i = 1; i < 4; i++)
+            {
+                cAdded[i] = meshMod.setAction
+                (
+                    polyAddCell
+                    (
+                        -1,                                 // master point
+                        -1,                                 // master edge
+                        -1,                                 // master face
+                        celli,                              // master cell
+                        mesh_.cellZones().whichZone(celli)  // zone for cell
+                    )
+                );
+
+                newCellLevel(cAdded[i]) = cellLevel_[celli]+1;
+            }
+        }
+    }
+
+
+    // Faces
+    // ~~~~~
+    // 1. existing faces that get split (into four always)
+    // 2. existing faces that do not get split but only edges get split
+    // 3. existing faces that do not get split but get new owner/neighbour
+    // 4. new internal faces inside split cells.
+
+    if (debug)
+    {
+        Pout<< "hexRef4::setRefinement :"
+            << " Marking faces to be handled"
+            << endl;
+    }
+
+    // Get all affected faces.
+    PackedBoolList affectedFace(mesh_.nFaces());
+
+    {
+        forAll(cellMidPoint, celli)
+        {
+            if (cellMidPoint[celli] >= 0)
+            {
+                const cell& cFaces = mesh_.cells()[celli];
+
+                forAll(cFaces, i)
+                {
+                    affectedFace.set(cFaces[i]);
+                }
+            }
+        }
+
+        forAll(faceMidPoint, facei)
+        {
+            if (faceMidPoint[facei] >= 0)
+            {
+                affectedFace.set(facei);
+            }
+        }
+
+        forAll(edgeMidPoint, edgeI)
+        {
+            if (edgeMidPoint[edgeI] >= 0)
+            {
+                const labelList& eFaces = mesh_.edgeFaces(edgeI);
+
+                forAll(eFaces, i)
+                {
+                    affectedFace.set(eFaces[i]);
+                }
+            }
+        }
+    }
+
+
+    // 1. Faces that get split
+    // ~~~~~~~~~~~~~~~~~~~~~~~
+
+    if (debug)
+    {
+        Pout<< "hexRef4::setRefinement : Splitting faces" << endl;
+    }
+
+    forAll(faceMidPoint, facei)
+    {
+        if (faceMidPoint[facei] >= 0 && affectedFace.get(facei))
+        {
+            // Face needs to be split and hasn't yet been done in some way
+            // (affectedFace - is impossible since this is first change but
+            //  just for completeness)
+
+            const face& f = mesh_.faces()[facei];
+
+            // Has original facei been used (three faces added, original gets
+            // modified)
+            bool modifiedFace = false;
+            label anchorLevel = faceAnchorLevel[facei];
+
+            if(isDivisibleFace[facei])
+            {
+                face newFace(4);
+                forAll(f, fp)
+                {
+                    label pointi = f[fp];
+                    if (pointLevel_[pointi] <= anchorLevel)
+                    {
+                        // point is anchor. Start collecting face.
+                        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
+
+                        walkFaceToMid
+                        (
+                            edgeMidPoint,
+                            anchorLevel,
+                            facei,
+                            fp,
+                            faceVerts
+                        );
+
+                        faceVerts.append(faceMidPoint[facei]);
+                        walkFaceFromMid
+                        (
+                            edgeMidPoint,
+                            anchorLevel,
+                            facei,
+                            fp,
+                            faceVerts
+                        );
+
+                        // Convert dynamiclist to face.
+                        newFace.transfer(faceVerts);
+
+                        // Get new owner/neighbour
+                        label own, nei;
+                        getFaceNeighbours
+                        (
+                            cellAnchorPoints,
+                            cellAddedCells,
+                            facei,
+                            pointi,          // Anchor point
+                            own,
+                            nei
+                        );
+
+                        if (debug)
+                        {
+                            if (mesh_.isInternalFace(facei))
+                            {
+                                label oldOwn = mesh_.faceOwner()[facei];
+                                label oldNei = mesh_.faceNeighbour()[facei];
+                                checkInternalOrientation
+                                (
+                                    meshMod,
+                                    oldOwn,
+                                    facei,
+                                    mesh_.cellCentres()[oldOwn],
+                                    mesh_.cellCentres()[oldNei],
+                                    newFace
+                                );
+                            }
+                            else
+                            {
+                                label oldOwn = mesh_.faceOwner()[facei];
+                                checkBoundaryOrientation
+                                (
+                                    meshMod,
+                                    oldOwn,
+                                    facei,
+                                    mesh_.cellCentres()[oldOwn],
+                                    mesh_.faceCentres()[facei],
+                                    newFace
+                                );
+                            }
+                        }
+                        if (!modifiedFace)
+                        {
+                            modifiedFace = true;
+                            modFace(meshMod, facei, newFace, own, nei);
+                        }
+                        else
+                        {
+                            addFace(meshMod, facei, newFace, own, nei);
+                        }
+                    }
+                }
+            }
+            else
+            {
+                face newFace(2);
+                forAll(f,fp)
+                {
+                    label pointi = f[fp];
+                    label nextpointi = f[f.fcIndex(fp)];
+                    label edgeI = meshTools::findEdge (mesh_, pointi, nextpointi);
+                    if (edgeMidPoint[edgeI] >=0)
+                    {
+                        DynamicList<label> faceVerts(4);
+                        label pointJ = f[f.rcIndex(fp)];
+                        faceVerts.append(pointi);
+                        walkFaceToMid
+                        (
+                            edgeMidPoint,
+                            anchorLevel,
+                            facei,
+                            fp,
+                            faceVerts
+                        );
+
+                        walkFaceFromMid
+                        (
+                            edgeMidPoint,
+                            anchorLevel,
+                            facei,
+                            f.rcIndex(fp),
+                            faceVerts
+                        );
+
+                        faceVerts.append(pointJ);
+                        newFace.transfer(faceVerts);
+
+                        // Pout<< "Split face:" << facei << " verts:" << f
+                        //     << " into quad:" << newFace << endl;
+
+                        label own, nei;
+                        getFaceNeighbours
+                        (
+                            cellAnchorPoints,
+                            cellAddedCells,
+                            facei,
+                            pointi,
+                            own,
+                            nei
+                        );
+
+                        // Pout<< "owner cell:" << own << endl;
+                        // Pout<< "neighbour cell:" << nei << endl;
+
+
+                        if (debug)
+                        {
+                            if (mesh_.isInternalFace(facei))
+                            {
+                                label oldOwn = mesh_.faceOwner()[facei];
+                                label oldNei = mesh_.faceNeighbour()[facei];
+                                checkInternalOrientation
+                                (
+                                    meshMod,
+                                    oldOwn,
+                                    facei,
+                                    mesh_.cellCentres()[oldOwn],
+                                    mesh_.cellCentres()[oldNei],
+                                    newFace
+                                );
+                            }
+                            else
+                            {
+                                label oldOwn = mesh_.faceOwner()[facei];
+                                checkBoundaryOrientation
+                                (
+                                    meshMod,
+                                    oldOwn,
+                                    facei,
+                                    mesh_.cellCentres()[oldOwn],
+                                    mesh_.faceCentres()[facei],
+                                    newFace
+                                );
+                            }
+                        }
+                        if (!modifiedFace)
+                        {
+                            modifiedFace = true;
+                            modFace(meshMod, facei, newFace, own, nei);
+                        }
+                        else
+                        {
+                            addFace(meshMod, facei, newFace, own, nei);
+                        }
+                    }
+                }
+            }
+
+            // Mark face as having been handled
+            affectedFace.unset(facei);
+        }
+    }
+
+    // Pout<< "done so far"<< endl;
+
+    // 2. faces that do not get split but use edges that get split
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    if (debug)
+    {
+        Pout<< "hexRef4::setRefinement :"
+            << " Adding edge splits to unsplit faces"
+            << endl;
+    }
+
+    DynamicList<label> eFacesStorage;
+    DynamicList<label> fEdgesStorage;
+
+    forAll(edgeMidPoint, edgeI)
+    {
+        if (edgeMidPoint[edgeI] >= 0)
+        {
+            // Split edge. Check that face not already handled above.
+
+            const labelList& eFaces = mesh_.edgeFaces(edgeI, eFacesStorage);
+
+            forAll(eFaces, i)
+            {
+                label facei = eFaces[i];
+
+                if (faceMidPoint[facei] < 0 && affectedFace.get(facei))
+                {
+                    // Unsplit face. Add edge splits to face.
+
+                    const face& f = mesh_.faces()[facei];
+                    const labelList& fEdges = mesh_.faceEdges
+                    (
+                        facei,
+                        fEdgesStorage
+                    );
+
+                    DynamicList<label> newFaceVerts(f.size());
+
+                    forAll(f, fp)
+                    {
+                        newFaceVerts.append(f[fp]);
+
+                        label edgeI = fEdges[fp];
+
+                        if (edgeMidPoint[edgeI] >= 0)
+                        {
+                            newFaceVerts.append(edgeMidPoint[edgeI]);
+                        }
+                    }
+
+                    face newFace;
+                    newFace.transfer(newFaceVerts);
+
+                    // The point with the lowest level should be an anchor
+                    // point of the neighbouring cells.
+                    label anchorFp = findMinLevel(f);
+
+                    label own, nei;
+                    getFaceNeighbours
+                    (
+                        cellAnchorPoints,
+                        cellAddedCells,
+                        facei,
+                        f[anchorFp],          // Anchor point
+
+                        own,
+                        nei
+                    );
+
+
+                    if (debug)
+                    {
+                        if (mesh_.isInternalFace(facei))
+                        {
+                            label oldOwn = mesh_.faceOwner()[facei];
+                            label oldNei = mesh_.faceNeighbour()[facei];
+
+                            checkInternalOrientation
+                            (
+                                meshMod,
+                                oldOwn,
+                                facei,
+                                mesh_.cellCentres()[oldOwn],
+                                mesh_.cellCentres()[oldNei],
+                                newFace
+                            );
+                        }
+                        else
+                        {
+                            label oldOwn = mesh_.faceOwner()[facei];
+
+                            checkBoundaryOrientation
+                            (
+                                meshMod,
+                                oldOwn,
+                                facei,
+                                mesh_.cellCentres()[oldOwn],
+                                mesh_.faceCentres()[facei],
+                                newFace
+                            );
+                        }
+                    }
+
+                    modFace(meshMod, facei, newFace, own, nei);
+
+                    // Mark face as having been handled
+                    affectedFace.unset(facei);
+                }
+            }
+        }
+    }
+
+
+    // 3. faces that do not get split but whose owner/neighbour change
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    if (debug)
+    {
+        Pout<< "hexRef4::setRefinement :"
+            << " Changing owner/neighbour for otherwise unaffected faces"
+            << endl;
+    }
+
+    forAll(affectedFace, facei)
+    {
+        if (affectedFace.get(facei))
+        {
+            const face& f = mesh_.faces()[facei];
+
+            // The point with the lowest level should be an anchor
+            // point of the neighbouring cells.
+            label anchorFp = findMinLevel(f);
+
+            label own, nei;
+            getFaceNeighbours
+            (
+                cellAnchorPoints,
+                cellAddedCells,
+                facei,
+                f[anchorFp],          // Anchor point
+
+                own,
+                nei
+            );
+
+            modFace(meshMod, facei, f, own, nei);
+
+            // Mark face as having been handled
+            affectedFace.unset(facei);
+        }
+    }
+
+
+    // 4. new internal faces inside split cells.
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+
+    // This is the hard one. 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<< "hexRef4::setRefinement :"
+            << " Create new internal faces for split cells"
+            << endl;
+    }
+
+    forAll(cellMidPoint, celli)
+    {
+        if (cellMidPoint[celli] >= 0)
+        {
+            createInternalFaces
+            (
+                cellAnchorPoints,
+                cellAddedCells,
+                cellMidPoint,
+                faceMidPoint,
+                faceAnchorLevel,
+                edgeMidPoint,
+                celli,
+                meshMod
+            );
+        }
+    }
+
+    // Extend pointLevels and cellLevels for the new cells. Could also be done
+    // in updateMesh but saves passing cellAddedCells out of this routine.
+
+    // Check
+    if (debug)
+    {
+        label minPointi = labelMax;
+        label maxPointi = labelMin;
+
+        forAll(cellMidPoint, celli)
+        {
+            if (cellMidPoint[celli] >= 0)
+            {
+                minPointi = min(minPointi, cellMidPoint[celli]);
+                maxPointi = max(maxPointi, cellMidPoint[celli]);
+            }
+        }
+        forAll(faceMidPoint, facei)
+        {
+            if (faceMidPoint[facei] >= 0)
+            {
+                minPointi = min(minPointi, faceMidPoint[facei]);
+                maxPointi = max(maxPointi, faceMidPoint[facei]);
+            }
+        }
+        forAll(edgeMidPoint, edgeI)
+        {
+            if (edgeMidPoint[edgeI] >= 0)
+            {
+                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);
+        }
+    }
+
+    pointLevel_.transfer(newPointLevel);
+    cellLevel_.transfer(newCellLevel);
+
+    // Mark files as changed
+    setInstance(mesh_.facesInstance());
+
+
+    // Update the live split cells tree.
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    // New unrefinement structure
+    if (history_.active())
+    {
+        if (debug)
+        {
+            Pout<< "hexRef4::setRefinement :"
+                << " Updating refinement history to " << cellLevel_.size()
+                << " cells" << endl;
+        }
+
+        // Extend refinement history for new cells
+        history_.resize(cellLevel_.size());
+
+        forAll(cellAddedCells, celli)
+        {
+            const labelList& addedCells = cellAddedCells[celli];
+
+            if (addedCells.size())
+            {
+                // Cell was split.
+                history_.storeSplit(celli, addedCells);
+            }
+        }
+    }
+
+    // Compact cellAddedCells.
+
+    labelListList refinedCells(cellLabels.size());
+
+    forAll(cellLabels, i)
+    {
+        label celli = cellLabels[i];
+
+        refinedCells[i].transfer(cellAddedCells[celli]);
+    }
+
+    return refinedCells;
+}
+
+Foam::labelList Foam::hexRef4::selectUnrefineElems
+(
+    const scalar unrefineLevel,
+    const PackedBoolList& markedCell,
+    const scalarField& pFld
+) const
+{
+    // All points that can be unrefined
+    const labelList splitEdges(getSplitElems());
+
+    DynamicList<label> newSplitEdges(splitEdges.size());
+
+    forAll(splitEdges, i)
+    {
+        label edgej = splitEdges[i];
+
+        const edge& e = mesh_.edges()[edgej];
+
+        forAll(e, i)
+        {
+            label pointi = e[i];
+
+            bool hasMarked = true;
+
+            if (pFld[pointi] < unrefineLevel)
+            {
+                // Check that all cells are not marked
+                const labelList& pCells = mesh_.pointCells()[pointi];
+
+                hasMarked = false;
+
+                forAll(pCells, pCelli)
+                {
+                    if (markedCell.get(pCells[pCelli]))
+                    {
+                        hasMarked = true;
+                        break;
+                    }
+                }
+            }
+
+            if (!hasMarked)
+            {
+                newSplitEdges.append(edgej);
+                break;
+            }
+        }
+    }
+
+
+    newSplitEdges.shrink();
+
+    // Guarantee 2:1 refinement after unrefinement
+    labelList consistentSet
+    (
+        consistentUnrefinement
+        (
+            newSplitEdges,
+            false
+        )
+    );
+    Info<< "Selected " << returnReduce(consistentSet.size(), sumOp<label>())
+        << " split edges out of a possible "
+        << returnReduce(splitEdges.size(), sumOp<label>())
+        << "." << endl;
+
+    return consistentSet;
+}
+
+Foam::labelList Foam::hexRef4::consistentUnrefinement
+(
+    const labelList& elemsToUnrefine,
+    const bool maxSet
+) const
+{
+    if (debug)
+    {
+        Pout<< "hexRef4::consistentUnrefinement :"
+            << " Determining 2:1 consistent unrefinement" << endl;
+    }
+
+    if (maxSet)
+    {
+        FatalErrorInFunction
+            << "maxSet not implemented yet."
+            << abort(FatalError);
+    }
+
+    // For hexRef4, unrefinement is based on edges
+    const labelList& edgesToUnrefine(elemsToUnrefine);
+
+    // Loop, modifying edgesToUnrefine, until no more changes to due to 2:1
+    // conflicts.
+    // maxSet = false : unselect edges to refine
+    // maxSet = true: select edges to refine
+
+    // Maintain boolList for edgesToUnrefine and cellsToUnrefine
+    PackedBoolList unrefineEdge(mesh_.nEdges());
+
+    forAll(edgesToUnrefine, i)
+    {
+        label edgei = edgesToUnrefine[i];
+
+        unrefineEdge.set(edgei);
+    }
+
+
+    while (true)
+    {
+        // Construct cells to unrefine
+        // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
+        const labelListList& edgeCells = mesh_.edgeCells();
+
+        PackedBoolList unrefineCell(mesh_.nCells());
+
+        forAll(unrefineEdge, edgei)
+        {
+            if (unrefineEdge.get(edgei))
+            {
+                const labelList& pCells = edgeCells[edgei];
+
+                forAll(pCells, j)
+                {
+                    unrefineCell.set(pCells[j]);
+                }
+            }
+        }
+
+
+        label nChanged = 0;
+
+
+        // Check 2:1 consistency taking refinement into account
+        // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+        // Internal faces.
+        for (label facei = 0; facei < mesh_.nInternalFaces(); facei++)
+        {
+            label own = mesh_.faceOwner()[facei];
+            label ownLevel = cellLevel_[own] - unrefineCell.get(own);
+
+            label nei = mesh_.faceNeighbour()[facei];
+            label neiLevel = cellLevel_[nei] - unrefineCell.get(nei);
+
+            if (ownLevel < (neiLevel-1))
+            {
+                // Since was 2:1 this can only occur if own is marked for
+                // unrefinement.
+
+                if (maxSet)
+                {
+                    unrefineCell.set(nei);
+                }
+                else
+                {
+                    // could also combine with unset:
+                    // if (!unrefineCell.unset(own))
+                    // {
+                    //     FatalErrorInFunction
+                    //         << "problem cell already unset"
+                    //         << abort(FatalError);
+                    // }
+                    if (unrefineCell.get(own) == 0)
+                    {
+                        FatalErrorInFunction
+                            << "problem" << abort(FatalError);
+                    }
+
+                    unrefineCell.unset(own);
+                }
+                nChanged++;
+            }
+            else if (neiLevel < (ownLevel-1))
+            {
+                if (maxSet)
+                {
+                    unrefineCell.set(own);
+                }
+                else
+                {
+                    if (unrefineCell.get(nei) == 0)
+                    {
+                        FatalErrorInFunction
+                            << "problem" << abort(FatalError);
+                    }
+
+                    unrefineCell.unset(nei);
+                }
+                nChanged++;
+            }
+        }
+
+
+        // Coupled faces. Swap owner level to get neighbouring cell level.
+        labelList neiLevel(mesh_.nFaces()-mesh_.nInternalFaces());
+
+        forAll(neiLevel, i)
+        {
+            label own = mesh_.faceOwner()[i+mesh_.nInternalFaces()];
+
+            neiLevel[i] = cellLevel_[own] - unrefineCell.get(own);
+        }
+
+        // Swap to neighbour
+        syncTools::swapBoundaryFaceList(mesh_, neiLevel);
+
+        forAll(neiLevel, i)
+        {
+            label facei = i+mesh_.nInternalFaces();
+            label own = mesh_.faceOwner()[facei];
+            label ownLevel = cellLevel_[own] - unrefineCell.get(own);
+
+            if (ownLevel < (neiLevel[i]-1))
+            {
+                if (!maxSet)
+                {
+                    if (unrefineCell.get(own) == 0)
+                    {
+                        FatalErrorInFunction
+                            << "problem" << abort(FatalError);
+                    }
+
+                    unrefineCell.unset(own);
+                    nChanged++;
+                }
+            }
+            else if (neiLevel[i] < (ownLevel-1))
+            {
+                if (maxSet)
+                {
+                    if (unrefineCell.get(own) == 1)
+                    {
+                        FatalErrorInFunction
+                            << "problem" << abort(FatalError);
+                    }
+
+                    unrefineCell.set(own);
+                    nChanged++;
+                }
+            }
+        }
+
+        reduce(nChanged, sumOp<label>());
+
+        if (debug)
+        {
+            Pout<< "hexRef4::consistentUnrefinement :"
+                << " Changed " << nChanged
+                << " refinement levels due to 2:1 conflicts."
+                << endl;
+        }
+
+        if (nChanged == 0)
+        {
+            break;
+        }
+
+
+        // Convert cellsToUnrefine back into points to unrefine
+        // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+        // Knock out any edge whose cell neighbour cannot be unrefined.
+        forAll(unrefineEdge, edgei)
+        {
+            if (unrefineEdge.get(edgei))
+            {
+                const labelList& pCells = edgeCells[edgei];
+
+                forAll(pCells, j)
+                {
+                    if (!unrefineCell.get(pCells[j]))
+                    {
+                        unrefineEdge.unset(edgei);
+                        break;
+                    }
+                }
+            }
+        }
+    }
+
+
+    // Convert back to labelList.
+    label nSet = 0;
+
+    forAll(unrefineEdge, edgei)
+    {
+        if (unrefineEdge.get(edgei))
+        {
+            nSet++;
+        }
+    }
+
+    labelList newEdgesToUnrefine(nSet);
+    nSet = 0;
+
+    forAll(unrefineEdge, edgei)
+    {
+        if (unrefineEdge.get(edgei))
+        {
+            newEdgesToUnrefine[nSet++] = edgei;
+        }
+    }
+
+    return newEdgesToUnrefine;
+}
+
+void Foam::hexRef4::calcFaceToSplitPoint
+(
+    const labelList& splitElems,
+    Map<label>& faceToSplitPoint
+)
+{
+    // Save information on faces that will be combined
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    // For hexRef4, the split elems are edges
+    const labelList& splitEdges(splitElems);
+
+    faceToSplitPoint.resize(2*splitEdges.size());
+
+    {
+        forAll(splitEdges, i)
+        {
+            label edgei = splitEdges[i];
+
+            const edge& e = mesh_.edges()[edgei];
+
+            forAll(e, j)
+            {
+                label pointi = e[j];
+
+                const labelList& pFaces = mesh_.pointFaces()[pointi];
+
+                forAll(pFaces, pFacei)
+                {
+                    faceToSplitPoint.insert(pFaces[pFacei], pointi);
+                }
+            }
+        }
+    }
+}
+
+Foam::labelList Foam::hexRef4::getSplitElems() const
+{
+    if (debug)
+    {
+        checkRefinementLevels(-1, labelList(0));
+    }
+
+    if (debug)
+    {
+        Pout<< "hexRef4::getSplitElems :"
+            << " Calculating unrefineable mid elements" << endl;
+    }
+
+
+    if (!history_.active())
+    {
+        FatalErrorInFunction
+            << "Only call if constructed with history capability"
+            << abort(FatalError);
+    }
+
+    // Master cell
+    // -1 undetermined
+    // -2 certainly not split edge
+    // >= label of master cell
+    labelList splitMaster(mesh_.nEdges(), -1);
+    labelList splitMasterLevel(mesh_.nEdges(), 0);
+
+    // Unmark all with not 4 cells (so internal edges)
+    const labelListList& edgeCells = mesh_.edgeCells();
+
+    forAll(edgeCells, edgei)
+    {
+        const labelList& eCells = edgeCells[edgei];
+
+        if (eCells.size() != 4)
+        {
+            splitMaster[edgei] = -2;
+        }
+    }
+
+    // Unmark all with different master cells
+    const labelList& visibleCells = history_.visibleCells();
+
+    forAll(visibleCells, celli)
+    {
+        const labelList& cEdges = mesh_.cellEdges(celli);
+
+        if (visibleCells[celli] != -1 && history_.parentIndex(celli) >= 0)
+        {
+            label parentIndex = history_.parentIndex(celli);
+
+            // Check same master.
+            forAll(cEdges, i)
+            {
+                label edgei = cEdges[i];
+
+                label masterCelli = splitMaster[edgei];
+
+                if (masterCelli == -1)
+                {
+                    // First time visit of point. Store parent cell and
+                    // level of the parent cell (with respect to celli). This
+                    // is additional guarantee that we're referring to the
+                    // same master at the same refinement level.
+
+                    splitMaster[edgei] = parentIndex;
+                    splitMasterLevel[edgei] = cellLevel_[celli] - 1;
+                }
+                else if (masterCelli == -2)
+                {
+                    // Already decided that edge is not splitEdge
+                }
+                else if
+                (
+                    (masterCelli != parentIndex)
+                 || (splitMasterLevel[edgei] != cellLevel_[celli] - 1)
+                )
+                {
+                    // Different masters so edge is on two refinement
+                    // patterns
+                    splitMaster[edgei] = -2;
+                }
+            }
+        }
+        else
+        {
+            // Either not visible or is unrefined cell
+            forAll(cEdges, i)
+            {
+                label edgei = cEdges[i];
+
+                splitMaster[edgei] = -2;
+            }
+        }
+    }
+
+    // Unmark boundary faces
+    for
+    (
+        label facei = mesh_.nInternalFaces();
+        facei < mesh_.nFaces();
+        facei++
+    )
+    {
+        const labelList& fEdges = mesh_.faceEdges()[facei];
+
+        forAll(fEdges, i)
+        {
+            label edgei = fEdges[i];
+
+            splitMaster[edgei] = -2;
+        }
+    }
+
+
+    // Collect into labelList
+
+    label nSplitEdges = 0;
+
+    forAll(splitMaster, edgei)
+    {
+        if (splitMaster[edgei] >= 0)
+        {
+            nSplitEdges++;
+        }
+    }
+
+    labelList splitEdges(nSplitEdges);
+    nSplitEdges = 0;
+
+    forAll(splitMaster, edgei)
+    {
+        if (splitMaster[edgei] >= 0)
+        {
+            splitEdges[nSplitEdges++] = edgei;
+        }
+    }
+
+    return splitEdges;
+}
+
+void Foam::hexRef4::setUnrefinement
+(
+    const labelList& splitElemLabels,
+    polyTopoChange& meshMod
+)
+{
+    if (!history_.active())
+    {
+        FatalErrorInFunction
+            << "Only call if constructed with history capability"
+            << abort(FatalError);
+    }
+
+    // For hexRef4, unrefinement is based on edges
+    const labelList& splitEdgeLabels(splitElemLabels);
+
+
+    //YO- This debug info would require writing edgeSets, which we do not have
+    //if (debug)
+    //{
+    //    Pout<< "hexRef::setUnrefinement :"
+    //        << " Checking initial mesh just to make sure" << endl;
+
+    //    checkMesh();
+
+    //    forAll(cellLevel_, celli)
+    //    {
+    //        if (cellLevel_[celli] < 0)
+    //        {
+    //            FatalErrorInFunction
+    //                << "Illegal cell level " << cellLevel_[celli]
+    //                << " for cell " << celli
+    //                << abort(FatalError);
+    //        }
+    //    }
+
+
+    //    // Write to sets.
+    //    pointSet pSet(mesh_, "splitPoints", splitPointLabels);
+    //    pSet.write();
+
+    //    cellSet cSet(mesh_, "splitPointCells", splitPointLabels.size());
+
+    //    forAll(splitPointLabels, i)
+    //    {
+    //        const labelList& pCells = mesh_.pointCells(splitPointLabels[i]);
+
+    //        forAll(pCells, j)
+    //        {
+    //            cSet.insert(pCells[j]);
+    //        }
+    //    }
+    //    cSet.write();
+
+    //    Pout<< "hexRef::setRefinement : Dumping " << pSet.size()
+    //        << " points and "
+    //        << cSet.size() << " cells for unrefinement to" << nl
+    //        << "    pointSet " << pSet.objectPath() << nl
+    //        << "    cellSet " << cSet.objectPath()
+    //        << endl;
+    //}
+
+
+    labelList cellRegion;
+    labelList cellRegionMaster;
+    labelList facesToRemove;
+
+    {
+        labelHashSet splitFaces(4*splitEdgeLabels.size());
+
+        forAll(splitEdgeLabels, i)
+        {
+            const labelList& eFaces = mesh_.edgeFaces()[splitEdgeLabels[i]];
+
+            forAll(eFaces, j)
+            {
+                splitFaces.insert(eFaces[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,         // per cell -1 or region it is merged into
+            cellRegionMaster,   // per region the master cell
+            facesToRemove       // new faces to be removed.
+        );
+
+        if (facesToRemove.size() != splitFaces.size())
+        {
+            FatalErrorInFunction
+                << "Initial set of split points to unrefine does not"
+                << " seem to be consistent or not mid points of refined cells"
+                << abort(FatalError);
+        }
+    }
+
+    // Redo the region master so it is consistent with our master.
+    // This will guarantee that the new cell (for which faceRemover uses
+    // the region master) is already compatible with our refinement structure.
+
+    forAll(splitEdgeLabels, i)
+    {
+        label edgei = splitEdgeLabels[i];
+
+        // Get original cell label
+
+        const labelList& eCells = mesh_.edgeCells()[edgei];
+
+        // Check
+        if (eCells.size() != 4)
+        {
+            FatalErrorInFunction
+                << "splitEdge " << edgei
+                << " should have " << 4
+                << " cells using it. It has " << eCells
+                << abort(FatalError);
+        }
+
+
+        // Check that the lowest numbered pCells is the master of the region
+        // (should be guaranteed by directRemoveFaces)
+        //if (debug)
+        {
+            label masterCelli = min(eCells);
+
+            forAll(eCells, j)
+            {
+                label celli = eCells[j];
+
+                label region = cellRegion[celli];
+
+                if (region == -1)
+                {
+                    FatalErrorInFunction
+                        << "Ininitial set of split edges to unrefine does not"
+                        << " seem to be consistent or not mid edges"
+                        << " of refined cells" << nl
+                        << "cell:" << celli << " on splitEdge " << edgei
+                        << " has no region to be merged into"
+                        << abort(FatalError);
+                }
+
+                if (masterCelli != cellRegionMaster[region])
+                {
+                    FatalErrorInFunction
+                        << "cell:" << celli << " on splitEdge:" << edgei
+                        << " in region " << region
+                        << " has master:" << cellRegionMaster[region]
+                        << " which is not the lowest numbered cell"
+                        << " among the edgeCells:" << eCells
+                        << abort(FatalError);
+                }
+            }
+        }
+    }
+
+    // Insert all commands to combine cells. Never fails so don't have to
+    // test for success.
+    faceRemover_.setRefinement
+    (
+        facesToRemove,
+        cellRegion,
+        cellRegionMaster,
+        meshMod
+    );
+
+    // Remove the n cells that originated from merging around the split point
+    // and adapt cell levels (not that pointLevels stay the same since points
+    // either get removed or stay at the same position.
+    forAll(splitEdgeLabels, i)
+    {
+        label edgei = splitEdgeLabels[i];
+
+        const labelList& eCells = mesh_.edgeCells()[edgei];
+
+        label masterCelli = min(eCells);
+
+        forAll(eCells, j)
+        {
+            cellLevel_[eCells[j]]--;
+        }
+
+        history_.combineCells(masterCelli, eCells);
+    }
+
+    // Mark files as changed
+    setInstance(mesh_.facesInstance());
+
+    // history_.updateMesh will take care of truncating.
+}
+
+
+// ************************************************************************* //
diff --git a/AMR_tidy/hexRef/hexRef4/hexRef4.H b/AMR_tidy/hexRef/hexRef4/hexRef4.H
new file mode 100644
index 00000000..4f5f3561
--- /dev/null
+++ b/AMR_tidy/hexRef/hexRef4/hexRef4.H
@@ -0,0 +1,215 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::hexRef4
+
+Description
+    Refinement of (split) hexes using polyTopoChange.
+
+SourceFiles
+    hexRef4.C
+
+Authors
+    Original code:
+    Ahmad Baniabedalruhman 2015
+    Adapted by:
+    Yun Ouedraogo 2017
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef hexRef4_H
+#define hexRef4_H
+
+#include "hexRef.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                           Class hexRef4 Declaration
+\*---------------------------------------------------------------------------*/
+
+class hexRef4 : public hexRef
+{
+
+protected:
+
+        //- 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;
+
+        //- Store in maps correspondence from midpoint to anchors and faces.
+        label storeMidPointInfo
+        (
+            const labelListList& cellAnchorPoints,
+            const labelListList& cellAddedCells,
+            const labelList& cellMidPoint,
+            const labelList& faceMidPoint,
+            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,
+            polyTopoChange& meshMod
+        ) const;
+
+        //- Create all internal faces to split celli into 4.
+        void createInternalFaces
+        (
+            const labelListList& cellAnchorPoints,
+            const labelListList& cellAddedCells,
+            const labelList& cellMidPoint,
+            const labelList& faceMidPoint,
+            const labelList& faceAnchorLevel,
+            const labelList& edgeMidPoint,
+            const label celli,
+            polyTopoChange& meshMod
+        ) const;
+
+        //- Disallow default bitwise copy construct
+        hexRef4(const hexRef4&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const hexRef4&);
+
+
+public:
+
+    //- Runtime type information
+    TypeName("hexRef4");
+
+
+    // Constructors
+
+        //- Construct from mesh, read_if_present refinement data
+        //  (from write below). If readHistory is true does read_if_present
+        //  of refinement history. If false clears all history
+        hexRef4(const polyMesh& mesh, const bool readHistory = true);
+
+        //- Construct from mesh and un/refinement data and optional size of
+        //  starting cells
+        hexRef4
+        (
+            const polyMesh& mesh,
+            const labelList& cellLevel,
+            const labelList& pointLevel,
+            const refinementHistory& history,
+            const scalar level0Edge = -GREAT
+        );
+
+        //- Construct from mesh and refinement data and optional size of
+        //  starting cells
+        hexRef4
+        (
+            const polyMesh& mesh,
+            const labelList& cellLevel,
+            const labelList& pointLevel,
+            const scalar level0Edge = -GREAT
+        );
+
+    // Member Functions
+
+        // Refinement
+
+            //- Insert refinement. All selected cells will be split into 8.
+            //  Returns per element in cells the 8 cells they were split into.
+            //  Guarantees that the 0th element is the original cell label.
+            //  Mapping:
+            //  -split cells: 3 new ones get added from original
+            //  -split faces: original gets modified; 3 new ones get added
+            //               from original
+            //  -added internal faces: added from original cell face(if
+            //   that was internal) or created out-of-nothing (so will not
+            //   get mapped!). Note: could make this inflate from point but
+            //   that will allocate interpolation.
+            //  -points added to split edge: added from edge start()
+            //  -midpoints added: added from cellPoints[0].
+            labelListList setRefinement
+            (
+                const labelList& cells,
+                polyTopoChange&
+            );
+
+        // Unrefinement
+            //- Return the mid elems in top-level split cells
+            //  that can be unsplit.
+            labelList getSplitElems() const;
+
+            //- Given proposed
+            //  splitElems to unrefine according to calculate any clashes
+            //  (due to 2:1) and return ok list of mid elems to unrefine.
+            labelList consistentUnrefinement
+            (
+                const labelList& elemsToUnrefine,
+                const bool maxSet
+            ) const;
+
+            //- Remove some refinement. Needs to be supplied output of
+            //  consistentUnrefinement. Only call if undoable set.
+            //  All n edgeCells of a split edge will be combined into
+            //  the lowest numbered cell of those n.
+            void setUnrefinement
+            (
+                const labelList& splitElemLabels,
+                polyTopoChange&
+            );
+
+            labelList selectUnrefineElems
+            (
+                const scalar unrefineLevel,
+                const PackedBoolList& markedCell,
+                const scalarField& vFld
+            ) const;
+
+            void calcFaceToSplitPoint
+            (
+                const labelList& splitElems,
+                Map<label>& faceToSplitPoint
+            );
+
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/AMR_tidy/hexRef/hexRef4Axi/hexRef4Axi.C b/AMR_tidy/hexRef/hexRef4Axi/hexRef4Axi.C
new file mode 100644
index 00000000..d84a7814
--- /dev/null
+++ b/AMR_tidy/hexRef/hexRef4Axi/hexRef4Axi.C
@@ -0,0 +1,2572 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "hexRef4Axi.H"
+
+#include "wedgePolyPatch.H"
+
+#include "addToRunTimeSelectionTable.H"
+
+#include "polyMesh.H"
+#include "polyTopoChange.H"
+#include "meshTools.H"
+#include "polyAddFace.H"
+#include "polyAddPoint.H"
+#include "polyAddCell.H"
+#include "polyModifyFace.H"
+#include "syncTools.H"
+#include "faceSet.H"
+#include "cellSet.H"
+#include "pointSet.H"
+#include "OFstream.H"
+#include "Time.H"
+#include "FaceCellWave.H"
+#include "mapDistributePolyMesh.H"
+#include "refinementData.H"
+#include "refinementDistanceData.H"
+#include "degenerateMatcher.H"
+
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(hexRef4Axi, 0);
+    addToRunTimeSelectionTable(hexRef, hexRef4Axi, mesh);
+    addToRunTimeSelectionTable(hexRef, hexRef4Axi, levelsHist);
+    addToRunTimeSelectionTable(hexRef, hexRef4Axi, levels);
+}
+
+
+// * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
+
+// Check whether pointi is an anchor on celli.
+// If it is not check whether any other point on the face is an anchor cell.
+Foam::label Foam::hexRef4Axi::getAnchorCell
+(
+    const labelListList& cellAnchorPoints,
+    const labelListList& cellAddedCells,
+    const label celli,
+    const label facei,
+    const label pointi
+) const
+{
+    if (cellAnchorPoints[celli].size())
+    {
+        label index = findIndex(cellAnchorPoints[celli], pointi);
+
+        if (index != -1)
+        {
+            if (index >= 4) //AB....
+            {
+                if (index == 4)
+                {
+                    index = 8;
+                }
+                index = 8 - index;
+            } //AB
+            return cellAddedCells[celli][index];
+        }
+
+
+        // pointi is not an anchor cell.
+        // Maybe we are already a refined face so check all the face
+        // vertices.
+        const face& f = mesh_.faces()[facei];
+
+        forAll(f, fp)
+        {
+            label index = findIndex(cellAnchorPoints[celli], f[fp]);
+
+            if (index != -1)
+            {
+                if (index >= 4) //AB....
+                {
+                if (index == 4)
+                    {
+                        index = 8;
+                    }
+                    index = 8 - index;
+                } //AB
+                return cellAddedCells[celli][index];
+            }
+        }
+
+        // Problem.
+        dumpCell(celli);
+        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;
+    }
+}
+
+// Internal faces are one per edge between anchor points. So one per midPoint
+// between the anchor points. Here we store the information on the midPoint
+// and if we have enough information:
+// - two anchors
+// - two face mid points
+// we add the face. Note that this routine 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.
+Foam::label Foam::hexRef4Axi::storeMidPointInfo
+(
+    const labelListList& cellAnchorPoints,
+    const labelListList& cellAddedCells,
+    const labelList& cellMidPoint,
+    const labelList& faceMidPoint,
+    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,
+    polyTopoChange& meshMod
+) const
+{
+    // 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;
+        }
+    }
+
+
+    // Check if this call of storeMidPointInfo is the one that completed all
+    // the necessary information.
+
+    if (changed && haveTwoAnchors)
+    {
+        const cell& cFaces = mesh_.cells()[celli];
+        label face1 = -1;
+
+        forAll(cFaces, i)
+        {
+            label faceJ = cFaces[i];
+
+            if (faceMidPoint[faceJ] != faceMidPointi
+                && faceMidPoint[faceJ] >= 0
+                && faceMidPoint[faceJ] != 1234567890) // could be replace by faceJ == type "empty"
+            {
+                face1 = faceJ;  // needed to take the other face points
+            }
+        }
+
+        const edge& anchors = midPointToAnchors[edgeMidPointi];
+        label index = findIndex(cellAnchorPoints[celli], anchorPointi);
+
+        if (index == 0)
+        {
+            index = 4;
+        }
+        if (index == 4)
+        {
+            index = 8;
+        }
+
+        label point1 = cellAnchorPoints[celli][8 - index];
+        label edgeMidPointj = -1;
+
+        const face& f = mesh_.faces()[face1];       //other face
+        const labelList& fEdges = mesh_.faceEdges(face1);
+
+        DynamicList<label> newFaceVerts(4);
+
+        if (faceOrder == (mesh_.faceOwner()[facei] == celli))
+        {
+            label anch = findIndex(f, point1);
+
+            if (pointLevel_[f[f.rcIndex(anch)]] <= cellLevel_[celli])
+            {
+                label edgeJ = fEdges[f.rcIndex(anch)];
+                edgeMidPointj = edgeMidPoint[edgeJ];
+            }
+            else
+            {
+                label edgeMid = findLevel(face1, f, f.rcIndex(anch), false, cellLevel_[celli] +1);
+                edgeMidPointj = f[edgeMid];
+            }
+
+            newFaceVerts.append(faceMidPointi);
+
+            // Check & insert edge split if any
+            insertEdgeSplit
+            (
+                edgeMidPoint,
+                faceMidPointi,  // edge between faceMid and
+                edgeMidPointi,  // edgeMid
+                newFaceVerts
+            );
+
+            newFaceVerts.append(edgeMidPointi);
+
+            if (edgeMidPointi != edgeMidPointj)
+            {
+                insertEdgeSplit
+                (
+                    edgeMidPoint,
+                    edgeMidPointi,
+                    edgeMidPointj,
+                    newFaceVerts
+                );
+                newFaceVerts.append(edgeMidPointj);
+            }
+
+            newFaceVerts.append(faceMidPoint[face1]);
+        }
+        else
+        {
+            label anch = findIndex(f, point1);
+
+            if (pointLevel_[f[f.fcIndex(anch)]] <= cellLevel_[celli])
+            {
+                label edgeJ = fEdges[anch];
+                edgeMidPointj = edgeMidPoint[edgeJ];
+            }
+            else
+            {
+                label edgeMid = findLevel
+                (
+                    face1,
+                    f,
+                    f.fcIndex(anch),
+                    false,
+                    cellLevel_[celli] +1
+                );
+                edgeMidPointj = f[edgeMid];
+            }
+
+            if (edgeMidPointi != edgeMidPointj)
+            {
+                newFaceVerts.append(edgeMidPointj);
+
+                insertEdgeSplit
+                (
+                    edgeMidPoint,
+                    edgeMidPointj,
+                    edgeMidPointi,
+                    newFaceVerts
+                );
+            }
+
+            newFaceVerts.append(edgeMidPointi);
+
+            insertEdgeSplit
+            (
+                edgeMidPoint,
+                edgeMidPointi,
+                faceMidPointi,
+                newFaceVerts
+            );
+
+            newFaceVerts.append(faceMidPointi);
+            newFaceVerts.append(faceMidPoint[face1]);
+        }
+
+        face newFace;
+        newFace.transfer(newFaceVerts);
+
+        label anchorCell0 = getAnchorCell
+        (
+            cellAnchorPoints,
+            cellAddedCells,
+            celli,
+            facei,
+            anchorPointi
+        );
+        label anchorCell1 = getAnchorCell
+        (
+            cellAnchorPoints,
+            cellAddedCells,
+            celli,
+            facei,
+            anchors.otherVertex(anchorPointi)
+        );
+
+
+        label own, nei;
+        point ownPt, neiPt;
+
+        if (anchorCell0 < anchorCell1)
+        {
+            own = anchorCell0;
+            nei = anchorCell1;
+
+            ownPt = mesh_.points()[anchorPointi];
+            neiPt = mesh_.points()[anchors.otherVertex(anchorPointi)];
+
+        }
+        else
+        {
+            own = anchorCell1;
+            nei = anchorCell0;
+            newFace.flip();
+
+            ownPt = mesh_.points()[anchors.otherVertex(anchorPointi)];
+            neiPt = mesh_.points()[anchorPointi];
+        }
+
+        if (debug)
+        {
+            point ownPt, neiPt;
+
+            if (anchorCell0 < anchorCell1)
+            {
+                ownPt = mesh_.points()[anchorPointi];
+                neiPt = mesh_.points()[anchors.otherVertex(anchorPointi)];
+            }
+            else
+            {
+                ownPt = mesh_.points()[anchors.otherVertex(anchorPointi)];
+                neiPt = mesh_.points()[anchorPointi];
+            }
+
+            checkInternalOrientation
+            (
+                meshMod,
+                celli,
+                facei,
+                ownPt,
+                neiPt,
+                newFace
+            );
+        }
+
+        return addInternalFace
+        (
+            meshMod,
+            facei,
+            anchorPointi,
+            newFace,
+            own,
+            nei
+        );
+    }
+    else
+    {
+        return -1;
+    }
+}
+
+
+// Creates all the 4 internal faces for celli.
+void Foam::hexRef4Axi::createInternalFaces
+(
+    const labelListList& cellAnchorPoints,
+    const labelListList& cellAddedCells,
+    const labelList& cellMidPoint,
+    const labelList& faceMidPoint,
+    const labelList& faceAnchorLevel,
+    const labelList& edgeMidPoint,
+    const label celli,
+
+    polyTopoChange& meshMod
+) const
+{
+    // Find in every face the cellLevel+1 points (from edge subdivision)
+    // and the anchor points.
+
+    const cell& cFaces = mesh_.cells()[celli];
+    const label cLevel = cellLevel_[celli];
+
+    // From edge mid to anchor points
+    Map<edge> midPointToAnchors(8);
+    // From edge mid to face mids
+    Map<edge> midPointToFaceMids(8);
+
+    // Storage for on-the-fly addressing
+    DynamicList<label> storage;
+
+
+    // Running count of number of internal faces added so far.
+    label nFacesAdded = 0;
+
+    forAll(cFaces, i)
+    {
+        label facei = cFaces[i];
+
+        const face& f = mesh_.faces()[facei];
+        const labelList& fEdges = mesh_.faceEdges(facei, storage);
+
+        // We are on the celli side of face f. The face will have 1 or 4
+        // cLevel points and lots of higher numbered ones.
+
+        label faceMidPointi = -1;
+
+        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.
+            // In 2D case this should never happen, as the shared faces with uncutted mesh
+            // can be only the ones splitted in two which have two anchors and two middle edge points.
+
+            //Info << "Should never happen: nAnchors == 1" << endl;
+
+            // Find the one anchor.
+            label anchorFp = -1;
+
+            forAll(f, fp)
+            {
+                if (pointLevel_[f[fp]] <= cLevel)
+                {
+                    anchorFp = fp;
+                    break;
+                }
+            }
+
+            // Now the face mid point is the second cLevel+1 point:
+            // these two lines just repeat the same steps two times to reach the second cLevel+1
+            label edgeMid = findLevel
+            (
+                facei,
+                f,
+                f.fcIndex(anchorFp),
+                true,
+                cLevel+1
+            );
+
+            // to be checked!!!
+            label faceMid = findLevel
+            (
+                facei,
+                f,
+                f.fcIndex(edgeMid),
+                true,
+                cLevel+1
+            );
+
+            faceMidPointi = f[faceMid];
+        }
+        else if (nAnchors == 2)
+        {
+            // Only two anchor point. So the other side of the face has already
+            // been split using cLevel+1 and cLevel+2 points.
+
+            faceMidPointi = 1234567890;        // again not nice
+
+        }
+        else if (nAnchors == 4 || nAnchors == 3)
+        {
+            // There is no face middle yet but the face will be marked for
+            // splitting. For non-wedge faces, faceMidPoint[facei] will be 1234567890,
+            // which is not a point ID. This is checked in storeMidPointInfo.
+
+            faceMidPointi = faceMidPoint[facei];
+        }
+        else
+        {
+            dumpCell(mesh_.faceOwner()[facei]);
+            if (mesh_.isInternalFace(facei))
+            {
+                dumpCell(mesh_.faceNeighbour()[facei]);
+            }
+
+            FatalErrorInFunction
+                << "nAnchors:" << nAnchors
+                << " facei:" << facei
+                << abort(FatalError);
+        }
+
+
+
+        // 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.
+        // Only wedge faces are considered as they are split like the 3D case.
+
+        if(faceMidPoint[facei] != 1234567890 && faceMidPointi != 1234567890)
+        {
+            forAll(f, fp0)
+            {
+                label point0 = f[fp0];
+
+                if (pointLevel_[point0] <= cLevel)
+                {
+                    // Anchor.
+
+                    // Walk forward
+                    // ~~~~~~~~~~~~
+                    // to cLevel+1 or edgeMidPoint of this level.
+
+
+                    label edgeMidPointi = -1;
+
+                    label fp1 = f.fcIndex(fp0);
+
+                    if (pointLevel_[f[fp1]] <= cLevel)
+                    {
+                        // Anchor. Edge will be split.
+                        label edgei = fEdges[fp0];
+
+                        edgeMidPointi = edgeMidPoint[edgei];
+
+                        if (edgeMidPointi == -1)
+                        {
+                            dumpCell(celli);
+
+                            const labelList& cPoints = mesh_.cellPoints(celli);
+
+                            FatalErrorInFunction
+                                << "cell:" << celli << " cLevel:" << cLevel
+                                << " cell points:" << cPoints
+                                << " pointLevel:"
+                                << UIndirectList<label>(pointLevel_, cPoints)()
+                                << " face:" << facei
+                                << " f:" << f
+                                << " pointLevel:"
+                                << UIndirectList<label>(pointLevel_, f)()
+                                << " faceAnchorLevel:" << faceAnchorLevel[facei]
+                                << " faceMidPoint:" << faceMidPoint[facei]
+                                << " faceMidPointi:" << faceMidPointi
+                                << " fp:" << fp0
+                                << abort(FatalError);
+                        }
+                    }
+                    else
+                    {
+                        // Search forward in face to clevel+1
+                        // In 2D this should never be used as this case is verified with
+                        // shared faces between refined and not-refined cells which have
+                        // to be refined in this turn.
+
+                        label edgeMid = findLevel(facei, f, fp1, true, cLevel+1);
+
+                        edgeMidPointi = f[edgeMid];
+                    }
+
+                    label newFacei = storeMidPointInfo
+                    (
+                        cellAnchorPoints,
+                        cellAddedCells,
+                        cellMidPoint,
+                        faceMidPoint,
+                        edgeMidPoint,
+
+                        celli,
+                        facei,
+                        true,                   // mid point after anchor
+                        edgeMidPointi,          // edgemid
+                        point0,                 // anchor
+                        faceMidPointi,
+
+                        midPointToAnchors,
+                        midPointToFaceMids,
+                        meshMod
+                    );
+
+                    if (newFacei != -1)
+                    {
+                        nFacesAdded++;
+
+                        if (nFacesAdded == 4)
+                        {
+                            break;
+                        }
+                    }
+
+
+
+                    // Walk backward
+                    // ~~~~~~~~~~~~~
+
+                    label fpMin1 = f.rcIndex(fp0);
+
+                    if (pointLevel_[f[fpMin1]] <= cLevel)
+                    {
+                        // Anchor. Edge will be split.
+                        label edgei = fEdges[fpMin1];
+
+                        edgeMidPointi = edgeMidPoint[edgei];
+
+                        if (edgeMidPointi == -1)
+                        {
+                            dumpCell(celli);
+
+                            const labelList& cPoints = mesh_.cellPoints(celli);
+
+                            FatalErrorInFunction
+                                << "cell:" << celli << " cLevel:" << cLevel
+                                << " cell points:" << cPoints
+                                << " pointLevel:"
+                                << UIndirectList<label>(pointLevel_, cPoints)()
+                                << " face:" << facei
+                                << " f:" << f
+                                << " pointLevel:"
+                                << UIndirectList<label>(pointLevel_, f)()
+                                << " faceAnchorLevel:" << faceAnchorLevel[facei]
+                                << " faceMidPoint:" << faceMidPoint[facei]
+                                << " faceMidPointi:" << faceMidPointi
+                                << " fp:" << fp0
+                                << abort(FatalError);
+                        }
+                    }
+                    else
+                    {
+                        // Search back to clevel+1
+                        // In 2D this should never be used as this case is verified with
+                        // shared faces between refined and not-refined cells which have
+                        // to be refined in this turn.
+
+                        label edgeMid = findLevel
+                        (
+                            facei,
+                            f,
+                            fpMin1,
+                            false,
+                            cLevel+1
+                        );
+
+                        edgeMidPointi = f[edgeMid];
+                    }
+
+                    newFacei = storeMidPointInfo
+                    (
+                        cellAnchorPoints,
+                        cellAddedCells,
+                        cellMidPoint,
+                        faceMidPoint,
+                        edgeMidPoint,
+
+                        celli,
+                        facei,
+                        false,                  // mid point before anchor
+                        edgeMidPointi,          // edgemid
+                        point0,                 // anchor
+                        faceMidPointi,
+
+                        midPointToAnchors,
+                        midPointToFaceMids,
+                        meshMod
+                    );
+
+                    if (newFacei != -1)
+                    {
+                        nFacesAdded++;
+
+                        if (nFacesAdded == 4)
+                        {
+                            break;
+                        }
+                    }
+                }   // done anchor
+            } // done face
+        }   // done check wedge condition
+
+        if (nFacesAdded == 4)
+        {
+            break;
+        }
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+// Construct from mesh, read refinement data
+Foam::hexRef4Axi::hexRef4Axi(const polyMesh& mesh, const bool readHistory)
+:
+    hexRef(mesh, readHistory)
+{}
+
+
+// Construct from components
+Foam::hexRef4Axi::hexRef4Axi
+(
+    const polyMesh& mesh,
+    const labelList& cellLevel,
+    const labelList& pointLevel,
+    const refinementHistory& history,
+    const scalar level0Edge
+)
+:
+    hexRef(mesh, cellLevel, pointLevel, history, level0Edge)
+{}
+
+
+// Construct from components
+Foam::hexRef4Axi::hexRef4Axi
+(
+    const polyMesh& mesh,
+    const labelList& cellLevel,
+    const labelList& pointLevel,
+    const scalar level0Edge
+)
+:
+    hexRef(mesh, cellLevel, pointLevel, level0Edge)
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+// Top level driver to insert topo changes to do all refinement.
+Foam::labelListList Foam::hexRef4Axi::setRefinement
+(
+    const labelList& cellLabels,
+    polyTopoChange& meshMod
+)
+{
+    if (debug)
+    {
+        Pout<< "hexRef4Axi::setRefinement :"
+            << " Checking initial mesh just to make sure" << endl;
+
+        checkMesh();
+        // Cannot call checkRefinementlevels since hanging points might
+        // get triggered by the mesher after subsetting.
+        //checkRefinementLevels(-1, labelList(0));
+    }
+
+    // Clear any saved point/cell data.
+    savedPointLevel_.clear();
+    savedCellLevel_.clear();
+
+
+    // New point/cell level. Copy of pointLevel for existing points.
+    DynamicList<label> newCellLevel(cellLevel_.size());
+    forAll(cellLevel_, celli)
+    {
+        newCellLevel.append(cellLevel_[celli]);
+    }
+    DynamicList<label> newPointLevel(pointLevel_.size());
+    forAll(pointLevel_, pointi)
+    {
+        newPointLevel.append(pointLevel_[pointi]);
+    }
+
+
+    if (debug)
+    {
+        Pout<< "hexRef4Axi::setRefinement :"
+            << " Allocating " << cellLabels.size() << " cell midpoints."
+            << endl;
+    }
+
+
+    // Mid point per refined cell.
+    // -1 : not refined
+    // >=0: label of mid point.
+    labelList cellMidPoint(mesh_.nCells(), -1);
+    forAll(cellLabels, i)
+    {
+        label celli = cellLabels[i];
+        cellMidPoint[celli] = 1234567890;    // mark need for splitting
+    }
+
+
+    boolList isDivisibleFace(mesh_.nFaces(), false);
+    boolList isDivisibleEdge(mesh_.nEdges(), false);
+
+    for (label facei = mesh_.nInternalFaces(); facei < mesh_.nFaces(); facei++)
+    {
+        const label & patchID = mesh_.boundaryMesh().whichPatch(facei);
+
+//        if (isA<wedgePolyPatch>(mesh_.boundaryMesh()[patchID])
+        if (mesh_.boundaryMesh()[patchID].type() == "wedge")
+        {
+            isDivisibleFace[facei] = true;
+            const labelList& fEdges = mesh_.faceEdges(facei);
+
+            forAll(fEdges, i)
+            {
+                label edgeJ = fEdges[i];
+                isDivisibleEdge[edgeJ] = true;
+            }
+        }
+    }
+
+
+    if (debug)
+    {
+        cellSet splitCells(mesh_, "splitCells", cellLabels.size());
+
+        forAll(cellMidPoint, celli)
+        {
+            if (cellMidPoint[celli] >= 0)
+            {
+                splitCells.insert(celli);
+            }
+        }
+
+        Pout<< "hexRef4Axi::setRefinement : Dumping " << splitCells.size()
+            << " cells to split to cellSet " << splitCells.objectPath()
+            << endl;
+
+        splitCells.write();
+    }
+
+
+
+    // Split edges
+    // ~~~~~~~~~~~
+
+    if (debug)
+    {
+        Pout<< "hexRef4Axi::setRefinement :"
+            << " Allocating edge midpoints."
+            << endl;
+    }
+
+    // Unrefined edges are ones between cellLevel or lower points.
+    // If any cell using this edge gets split then the edge needs to be split.
+
+    // -1  : no need to split edge
+    // >=0 : label of introduced mid point
+    labelList edgeMidPoint(mesh_.nEdges(), -1);
+
+    // Note: Loop over cells to be refined or edges?
+    forAll(cellMidPoint, celli)
+    {
+        if (cellMidPoint[celli] >= 0)
+        {
+            const labelList& cEdges = mesh_.cellEdges(celli);
+            forAll(cEdges, i)
+            {
+                label edgei = cEdges[i];
+                const edge& e = mesh_.edges()[edgei];
+                if
+                (
+                 isDivisibleEdge[edgei]
+                 && pointLevel_[e[0]] <= cellLevel_[celli]
+                 && pointLevel_[e[1]] <= cellLevel_[celli]
+                )
+                {
+                    edgeMidPoint[edgei] = 12345;    // mark need for splitting
+                }
+            }
+        }
+    }
+
+    // Synchronize edgeMidPoint across coupled patches. Take max so that
+    // any split takes precedence.
+    syncTools::syncEdgeList
+    (
+        mesh_,
+        edgeMidPoint,
+        maxEqOp<label>(),
+        labelMin
+    );
+
+
+    // Introduce edge points
+    // ~~~~~~~~~~~~~~~~~~~~~
+
+    {
+        // Phase 1: calculate midpoints and sync.
+        // This needs doing for if people do not write binary and we slowly
+        // get differences.
+
+        pointField edgeMids(mesh_.nEdges(), point(-GREAT, -GREAT, -GREAT));
+
+        forAll(edgeMidPoint, edgei)
+        {
+            if (edgeMidPoint[edgei] >= 0)
+            {
+                // Edge marked to be split.
+                edgeMids[edgei] = mesh_.edges()[edgei].centre(mesh_.points());
+            }
+        }
+        syncTools::syncEdgePositions
+        (
+            mesh_,
+            edgeMids,
+            maxEqOp<vector>(),
+            point(-GREAT, -GREAT, -GREAT)
+        );
+
+
+        // Phase 2: introduce points at the synced locations.
+        forAll(edgeMidPoint, edgei)
+        {
+            if (edgeMidPoint[edgei] >= 0)
+            {
+                // Edge marked to be split. Replace edgeMidPoint with actual
+                // point label.
+
+                const edge& e = mesh_.edges()[edgei];
+
+                edgeMidPoint[edgei] = meshMod.setAction
+                (
+                    polyAddPoint
+                    (
+                        edgeMids[edgei],            // point
+                        e[0],                       // master point
+                        -1,                         // zone for point
+                        true                        // supports a cell
+                    )
+                );
+
+                newPointLevel(edgeMidPoint[edgei]) =
+                    max
+                    (
+                        pointLevel_[e[0]],
+                        pointLevel_[e[1]]
+                    )
+                  + 1;
+            }
+        }
+    }
+
+    if (debug)
+    {
+        OFstream str(mesh_.time().path()/"edgeMidPoint.obj");
+
+        forAll(edgeMidPoint, edgei)
+        {
+            if (edgeMidPoint[edgei] >= 0)
+            {
+                const edge& e = mesh_.edges()[edgei];
+
+                meshTools::writeOBJ(str, e.centre(mesh_.points()));
+            }
+        }
+
+        Pout<< "hexRef4Axi::setRefinement :"
+            << " Dumping edge centres to split to file " << str.name() << endl;
+    }
+
+
+    // Calculate face level
+    // ~~~~~~~~~~~~~~~~~~~~
+    // (after splitting)
+
+    if (debug)
+    {
+        Pout<< "hexRef4Axi::setRefinement :"
+            << " Allocating face midpoints."
+            << endl;
+    }
+
+    // Face anchor level. There are guaranteed 4 points with level
+    // <= anchorLevel. These are the corner points.
+    labelList faceAnchorLevel(mesh_.nFaces());
+
+    for (label facei = 0; facei < mesh_.nFaces(); facei++)
+    {
+        faceAnchorLevel[facei] = faceLevel(facei);
+    }
+
+    // -1  : no need to split face
+    // >=0 : label of introduced mid point
+    labelList faceMidPoint(mesh_.nFaces(), -1);
+
+
+    // Internal faces: look at cells on both sides. Uniquely determined since
+    // face itself guaranteed to be same level as most refined neighbour.
+    for (label facei = 0; facei < mesh_.nInternalFaces(); facei++)
+    {
+        if (faceAnchorLevel[facei] >= 0)
+        {
+            label own = mesh_.faceOwner()[facei];
+            label ownLevel = cellLevel_[own];
+            label newOwnLevel = ownLevel + (cellMidPoint[own] >= 0 ? 1 : 0);
+
+            label nei = mesh_.faceNeighbour()[facei];
+            label neiLevel = cellLevel_[nei];
+            label newNeiLevel = neiLevel + (cellMidPoint[nei] >= 0 ? 1 : 0);
+
+            if
+            (
+                newOwnLevel > faceAnchorLevel[facei]
+             || newNeiLevel > faceAnchorLevel[facei]
+            )
+            {
+                faceMidPoint[facei] = 1234567890;    // mark to be split (not a real nice way)
+            }
+        }
+    }
+
+    // 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)
+
+    {
+        labelList newNeiLevel(mesh_.nFaces()-mesh_.nInternalFaces());
+
+        forAll(newNeiLevel, i)
+        {
+            label own = mesh_.faceOwner()[i+mesh_.nInternalFaces()];
+            label ownLevel = cellLevel_[own];
+            label newOwnLevel = ownLevel + (cellMidPoint[own] >= 0 ? 1 : 0);
+
+            newNeiLevel[i] = newOwnLevel;
+        }
+
+        // Swap.
+        syncTools::swapBoundaryFaceList(mesh_, newNeiLevel);
+
+        // So now we have information on the neighbour.
+
+        forAll(newNeiLevel, i)
+        {
+            label facei = i+mesh_.nInternalFaces();
+
+            if (faceAnchorLevel[facei] >= 0)
+            {
+                label own = mesh_.faceOwner()[facei];
+                label ownLevel = cellLevel_[own];
+                label newOwnLevel = ownLevel + (cellMidPoint[own] >= 0 ? 1 : 0);
+
+                if
+                (
+                    newOwnLevel > faceAnchorLevel[facei]
+                 || newNeiLevel[i] > faceAnchorLevel[facei]
+                )
+                {
+                    faceMidPoint[facei] = 1234567890;    // mark to be split (not really nice way)
+                }
+            }
+        }
+    }
+
+
+    // Synchronize faceMidPoint across coupled patches. (logical or)
+    syncTools::syncFaceList
+    (
+        mesh_,
+        faceMidPoint,
+        maxEqOp<label>()
+    );
+
+
+
+    // Introduce face points
+    // ~~~~~~~~~~~~~~~~~~~~~
+
+    {
+        // Phase 1: determine mid points and sync. See comment for edgeMids
+        // above
+        pointField bFaceMids
+        (
+            mesh_.nFaces()-mesh_.nInternalFaces(),
+            point(-GREAT, -GREAT, -GREAT)
+        );
+
+        forAll(bFaceMids, i)
+        {
+            label facei = i+mesh_.nInternalFaces();
+
+            if (faceMidPoint[facei] >= 0)
+            {
+                bFaceMids[i] = mesh_.faceCentres()[facei];
+            }
+        }
+        syncTools::syncBoundaryFacePositions
+        (
+            mesh_,
+            bFaceMids,
+            maxEqOp<vector>()
+        );
+
+        forAll(faceMidPoint, facei)
+        {
+            if (faceMidPoint[facei] >= 0 && isDivisibleFace[facei])
+            {
+                // Face marked to be split. Replace faceMidPoint with actual
+                // point label.
+
+                const face& f = mesh_.faces()[facei];
+                faceMidPoint[facei] = meshMod.setAction
+                (
+                    polyAddPoint
+                    (
+                        (
+                            facei < mesh_.nInternalFaces()
+                          ? mesh_.faceCentres()[facei]
+                          : bFaceMids[facei-mesh_.nInternalFaces()]
+                        ),                          // point
+                        f[0],                       // master point
+                        -1,                         // zone for point
+                        true                        // supports a cell
+                    )
+                );
+
+                // Determine the level of the corner points and midpoint will
+                // be one higher.
+                newPointLevel(faceMidPoint[facei]) = faceAnchorLevel[facei]+1;
+            }
+        }
+    }
+
+    if (debug)
+    {
+        faceSet splitFaces(mesh_, "splitFaces", cellLabels.size());
+
+        forAll(faceMidPoint, facei)
+        {
+            if (faceMidPoint[facei] >= 0)
+            {
+                splitFaces.insert(facei);
+            }
+        }
+
+        Pout<< "hexRef4Axi::setRefinement : Dumping " << splitFaces.size()
+            << " faces to split to faceSet " << splitFaces.objectPath() << endl;
+
+        splitFaces.write();
+    }
+
+
+    // Information complete
+    // ~~~~~~~~~~~~~~~~~~~~
+    // At this point we have all the information we need. We should no
+    // longer reference the cellLabels to refine. All the information is:
+    // - cellMidPoint >= 0 : cell needs to be split.
+    // - faceMidPoint >= 0 : face needs to be split.
+    // - edgeMidPoint >= 0 : edge needs to be split.
+    // - isDivisibleFace true : face needs to be split in 4 else in 2.
+    //   for the 2 split case, faceMidPoint is >= 0 but not initalized with a point.
+
+
+    // Get the corner/anchor points
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    if (debug)
+    {
+        Pout<< "hexRef4Axi::setRefinement :"
+            << " Finding cell anchorPoints (8 per cell)"
+            << endl;
+    }
+
+    // There will always be 8 points on the hex that have were introduced
+    // with the hex and will have the same or lower refinement level.
+
+    // Per cell the 8 corner points.
+    labelListList cellAnchorPoints(mesh_.nCells());
+    {
+        labelList nAnchorPoints(mesh_.nCells(), 0);
+        forAll(cellMidPoint, celli)
+        {
+            if (cellMidPoint[celli] >= 0)
+            {
+                cellAnchorPoints[celli].setSize(8);
+            }
+        }
+
+       forAll(cellMidPoint, celli)
+       {
+            const cell& cFaces = mesh_.cells()[celli];
+            forAll(cFaces, i)
+            {
+                label facei = cFaces[i];
+                const face& f = mesh_.faces()[facei];
+                forAll(f, fp)
+                {
+                    label pointi = f[fp];
+                    if
+                    (
+                        cellMidPoint[celli] >= 0
+                        && isDivisibleFace[facei]
+                        && pointLevel_[pointi] <= cellLevel_[celli]
+                    )
+                    {
+                        if (nAnchorPoints[celli] == 8)
+                        {
+                            dumpCell(celli);
+                            FatalErrorInFunction
+                                << "cell " << celli
+                                << " of level " << cellLevel_[celli]
+                                << " uses more than 8 points of equal or"
+                                << " lower level" << nl
+                                << "Points so far:" << cellAnchorPoints[celli]
+                                << abort(FatalError);
+                        }
+                        cellAnchorPoints[celli][nAnchorPoints[celli]++]
+                            = pointi;
+                    }
+                }
+            }
+        }
+
+
+        forAll(cellMidPoint, celli)
+        {
+            if (cellMidPoint[celli] >= 0)
+            {
+                if (nAnchorPoints[celli] != 8)
+                {
+                    const labelList cPoints(mesh_.cellPoints(celli));
+
+                    FatalErrorInFunction
+                        << "cell " << celli
+                        << " of level " << cellLevel_[celli]
+                        << " does not seem to have 8 points of equal or"
+                        << " lower level" << endl
+                        << "cellPoints:" << cPoints << endl
+                        << "pointLevels:"
+                        << IndirectList<label>(pointLevel_, cPoints)() << endl
+                        << abort(FatalError);
+                }
+            }
+        }
+    }
+
+
+    // Add the cells
+    // ~~~~~~~~~~~~~
+
+    if (debug)
+    {
+        Pout<< "hexRef4Axi::setRefinement :"
+            << " Adding cells (1 per anchorPoint)"
+            << endl;
+    }
+
+    // Per cell the 3 added cells (+ original cell)
+    labelListList cellAddedCells(mesh_.nCells());
+
+    forAll(cellAnchorPoints, celli)
+    {
+        const labelList& cAnchors = cellAnchorPoints[celli];
+
+        if (cAnchors.size() == 8)
+        {
+            labelList& cAdded = cellAddedCells[celli];
+            cAdded.setSize(4);
+
+            // Original cell at 0
+            cAdded[0] = celli;
+
+            // Update cell level
+            newCellLevel[celli] = cellLevel_[celli]+1;
+
+
+            for (label i = 1; i < 4; i++)
+            {
+                cAdded[i] = meshMod.setAction
+                (
+                    polyAddCell
+                    (
+                        -1,                                 // master point
+                        -1,                                 // master edge
+                        -1,                                 // master face
+                        celli,                              // master cell
+                        mesh_.cellZones().whichZone(celli)  // zone for cell
+                    )
+                );
+
+                newCellLevel(cAdded[i]) = cellLevel_[celli]+1;
+            }
+        }
+    }
+
+
+    // Faces
+    // ~~~~~
+    // 1. existing faces that get split (into four always)
+    // 2. existing faces that do not get split but only edges get split
+    // 3. existing faces that do not get split but get new owner/neighbour
+    // 4. new internal faces inside split cells.
+
+    if (debug)
+    {
+        Pout<< "hexRef4Axi::setRefinement :"
+            << " Marking faces to be handled"
+            << endl;
+    }
+
+    // Get all affected faces.
+    PackedBoolList affectedFace(mesh_.nFaces());
+
+    {
+        forAll(cellMidPoint, celli)
+        {
+            if (cellMidPoint[celli] >= 0)
+            {
+                const cell& cFaces = mesh_.cells()[celli];
+
+                forAll(cFaces, i)
+                {
+                    affectedFace.set(cFaces[i]);
+                }
+            }
+        }
+
+        forAll(faceMidPoint, facei)
+        {
+            if (faceMidPoint[facei] >= 0)
+            {
+                affectedFace.set(facei);
+            }
+        }
+
+        forAll(edgeMidPoint, edgei)
+        {
+            if (edgeMidPoint[edgei] >= 0)
+            {
+                const labelList& eFaces = mesh_.edgeFaces(edgei);
+
+                forAll(eFaces, i)
+                {
+                    affectedFace.set(eFaces[i]);
+                }
+            }
+        }
+    }
+
+
+    // 1. Faces that get split
+    // ~~~~~~~~~~~~~~~~~~~~~~~
+
+    if (debug)
+    {
+        Pout<< "hexRef4Axi::setRefinement : Splitting faces" << endl;
+    }
+
+    forAll(faceMidPoint, facei)
+    {
+        if (faceMidPoint[facei] >= 0 && affectedFace.get(facei))
+        {
+            // Face needs to be split and hasn't yet been done in some way
+            // (affectedFace - is impossible since this is first change but
+            //  just for completeness)
+
+            const face& f = mesh_.faces()[facei];
+
+            // Has original facei been used (three faces added, original gets
+            // modified)
+            bool modifiedFace = false;
+            label anchorLevel = faceAnchorLevel[facei];
+
+            if(isDivisibleFace[facei])
+            {
+                face newFace(4);
+                forAll(f, fp)
+                {
+                    label pointi = f[fp];
+                    if (pointLevel_[pointi] <= anchorLevel)
+                    {
+                        // point is anchor. Start collecting face.
+                        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
+
+                        walkFaceToMid
+                        (
+                            edgeMidPoint,
+                            anchorLevel,
+                            facei,
+                            fp,
+                            faceVerts
+                        );
+
+                        faceVerts.append(faceMidPoint[facei]);
+                        walkFaceFromMid
+                        (
+                            edgeMidPoint,
+                            anchorLevel,
+                            facei,
+                            fp,
+                            faceVerts
+                        );
+
+                        // Convert dynamiclist to face.
+                        newFace.transfer(faceVerts);
+                        // Get new owner/neighbour
+                        label own, nei;
+                        getFaceNeighbours
+                        (
+                            cellAnchorPoints,
+                            cellAddedCells,
+                            facei,
+                            pointi,          // Anchor point
+                            own,
+                            nei
+                        );
+
+
+                        if (debug)
+                        {
+                            if (mesh_.isInternalFace(facei))
+                            {
+                                label oldOwn = mesh_.faceOwner()[facei];
+                                label oldNei = mesh_.faceNeighbour()[facei];
+                                checkInternalOrientation
+                                (
+                                    meshMod,
+                                    oldOwn,
+                                    facei,
+                                    mesh_.cellCentres()[oldOwn],
+                                    mesh_.cellCentres()[oldNei],
+                                    newFace
+                                );
+                            }
+                            else
+                            {
+                                label oldOwn = mesh_.faceOwner()[facei];
+                                checkBoundaryOrientation
+                                (
+                                    meshMod,
+                                    oldOwn,
+                                    facei,
+                                    mesh_.cellCentres()[oldOwn],
+                                    mesh_.faceCentres()[facei],
+                                    newFace
+                                );
+                            }
+                        }
+                        if (!modifiedFace)
+                        {
+                            modifiedFace = true;
+                            modFace(meshMod, facei, newFace, own, nei);
+                        }
+                        else
+                        {
+                            addFace(meshMod, facei, newFace, own, nei);
+                        }
+                    }
+                }
+            }
+            else
+            {
+                face newFace(4);
+                forAll(f,fp)
+                {
+                    label pointi = f[fp];
+                    label nextpointi = f[f.fcIndex(fp)];
+                    label edgei = meshTools::findEdge (mesh_, pointi, nextpointi);
+                    if (edgeMidPoint[edgei] >=0)
+                    {
+                        label pointj = f[f.rcIndex(fp)];
+                        label prevPointj = f[f.rcIndex(f.rcIndex(fp))];
+                        label edgep = meshTools::findEdge(mesh_, prevPointj, pointj);
+                        if (edgeMidPoint[edgep] >= 0)
+                        {
+                            DynamicList<label> faceVerts(4);
+                            faceVerts.append(pointi);
+                            walkFaceToMid
+                            (
+                                edgeMidPoint,
+                                anchorLevel,
+                                facei,
+                                fp,
+                                faceVerts
+                            );
+
+                            walkFaceFromMid
+                            (
+                                edgeMidPoint,
+                                anchorLevel,
+                                facei,
+                                f.rcIndex(fp),
+                                faceVerts
+                            );
+
+                            faceVerts.append(pointj);
+                            newFace.transfer(faceVerts);
+                        }
+                        else
+                        {
+                            DynamicList<label> faceVerts(3);
+                            faceVerts.append(pointi);
+                            walkFaceToMid
+                            (
+                                edgeMidPoint,
+                                anchorLevel,
+                                facei,
+                                fp,
+                                faceVerts
+                            );
+
+                            walkFaceFromMid
+                            (
+                                edgeMidPoint,
+                                anchorLevel,
+                                facei,
+                                fp,
+                                faceVerts
+                            );
+
+                            newFace.transfer(faceVerts);
+                        }
+
+                        label own, nei;
+                        getFaceNeighbours
+
+                        (
+                            cellAnchorPoints,
+                            cellAddedCells,
+                            facei,
+                            pointi,
+                            own,
+                            nei
+                        );
+
+                        if (debug)
+                        {
+                            if (mesh_.isInternalFace(facei))
+                            {
+                                label oldOwn = mesh_.faceOwner()[facei];
+                                label oldNei = mesh_.faceNeighbour()[facei];
+                                checkInternalOrientation
+                                (
+                                    meshMod,
+                                    oldOwn,
+                                    facei,
+                                    mesh_.cellCentres()[oldOwn],
+                                    mesh_.cellCentres()[oldNei],
+                                    newFace
+                                );
+                            }
+                            else
+                            {
+                                label oldOwn = mesh_.faceOwner()[facei];
+                                checkBoundaryOrientation
+                                (
+                                    meshMod,
+                                    oldOwn,
+                                    facei,
+                                    mesh_.cellCentres()[oldOwn],
+                                    mesh_.faceCentres()[facei],
+                                    newFace
+                                );
+                            }
+                        }
+                        if (!modifiedFace)
+                        {
+                            modifiedFace = true;
+                            modFace(meshMod, facei, newFace, own, nei);
+                        }
+                        else
+                        {
+                            addFace(meshMod, facei, newFace, own, nei);
+                        }
+                    }
+                }
+            }
+
+            // Mark face as having been handled
+            affectedFace.unset(facei);
+        }
+    }
+
+
+    // 2. faces that do not get split but use edges that get split
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    if (debug)
+    {
+        Pout<< "hexRef4Axi::setRefinement :"
+            << " Adding edge splits to unsplit faces"
+            << endl;
+    }
+
+    DynamicList<label> eFacesStorage;
+    DynamicList<label> fEdgesStorage;
+
+    forAll(edgeMidPoint, edgei)
+    {
+        if (edgeMidPoint[edgei] >= 0)
+        {
+            // Split edge. Check that face not already handled above.
+
+            const labelList& eFaces = mesh_.edgeFaces(edgei, eFacesStorage);
+
+            forAll(eFaces, i)
+            {
+                label facei = eFaces[i];
+
+                if (faceMidPoint[facei] < 0 && affectedFace.get(facei))
+                {
+                    // Unsplit face. Add edge splits to face.
+
+                    const face& f = mesh_.faces()[facei];
+                    const labelList& fEdges = mesh_.faceEdges
+                    (
+                        facei,
+                        fEdgesStorage
+                    );
+
+                    DynamicList<label> newFaceVerts(f.size());
+
+                    forAll(f, fp)
+                    {
+                        newFaceVerts.append(f[fp]);
+
+                        label edgei = fEdges[fp];
+
+                        if (edgeMidPoint[edgei] >= 0)
+                        {
+                            newFaceVerts.append(edgeMidPoint[edgei]);
+                        }
+                    }
+
+                    face newFace;
+                    newFace.transfer(newFaceVerts);
+
+                    // The point with the lowest level should be an anchor
+                    // point of the neighbouring cells.
+                    label anchorFp = findMinLevel(f);
+
+                    label own, nei;
+                    getFaceNeighbours
+                    (
+                        cellAnchorPoints,
+                        cellAddedCells,
+                        facei,
+                        f[anchorFp],          // Anchor point
+
+                        own,
+                        nei
+                    );
+
+
+                    if (debug)
+                    {
+                        if (mesh_.isInternalFace(facei))
+                        {
+                            label oldOwn = mesh_.faceOwner()[facei];
+                            label oldNei = mesh_.faceNeighbour()[facei];
+
+                            checkInternalOrientation
+                            (
+                                meshMod,
+                                oldOwn,
+                                facei,
+                                mesh_.cellCentres()[oldOwn],
+                                mesh_.cellCentres()[oldNei],
+                                newFace
+                            );
+                        }
+                        else
+                        {
+                            label oldOwn = mesh_.faceOwner()[facei];
+
+                            checkBoundaryOrientation
+                            (
+                                meshMod,
+                                oldOwn,
+                                facei,
+                                mesh_.cellCentres()[oldOwn],
+                                mesh_.faceCentres()[facei],
+                                newFace
+                            );
+                        }
+                    }
+
+                    modFace(meshMod, facei, newFace, own, nei);
+
+                    // Mark face as having been handled
+                    affectedFace.unset(facei);
+                }
+            }
+        }
+    }
+
+
+    // 3. faces that do not get split but whose owner/neighbour change
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    if (debug)
+    {
+        Pout<< "hexRef4Axi::setRefinement :"
+            << " Changing owner/neighbour for otherwise unaffected faces"
+            << endl;
+    }
+
+    forAll(affectedFace, facei)
+    {
+        if (affectedFace.get(facei))
+        {
+            const face& f = mesh_.faces()[facei];
+
+            // The point with the lowest level should be an anchor
+            // point of the neighbouring cells.
+            label anchorFp = findMinLevel(f);
+
+            label own, nei;
+            getFaceNeighbours
+            (
+                cellAnchorPoints,
+                cellAddedCells,
+                facei,
+                f[anchorFp],          // Anchor point
+
+                own,
+                nei
+            );
+
+            modFace(meshMod, facei, f, own, nei);
+
+            // Mark face as having been handled
+            affectedFace.unset(facei);
+        }
+    }
+
+
+    // 4. new internal faces inside split cells.
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+
+    // This is the hard one. 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<< "hexRef4Axi::setRefinement :"
+            << " Create new internal faces for split cells"
+            << endl;
+    }
+
+    forAll(cellMidPoint, celli)
+    {
+        if (cellMidPoint[celli] >= 0)
+        {
+            createInternalFaces
+            (
+                cellAnchorPoints,
+                cellAddedCells,
+                cellMidPoint,
+                faceMidPoint,
+                faceAnchorLevel,
+                edgeMidPoint,
+                celli,
+                meshMod
+            );
+        }
+    }
+
+    // Extend pointLevels and cellLevels for the new cells. Could also be done
+    // in updateMesh but saves passing cellAddedCells out of this routine.
+
+    // Check
+    if (debug)
+    {
+        label minPointi = labelMax;
+        label maxPointi = labelMin;
+
+        forAll(cellMidPoint, celli)
+        {
+            if (cellMidPoint[celli] >= 0)
+            {
+                minPointi = min(minPointi, cellMidPoint[celli]);
+                maxPointi = max(maxPointi, cellMidPoint[celli]);
+            }
+        }
+        forAll(faceMidPoint, facei)
+        {
+            if (faceMidPoint[facei] >= 0)
+            {
+                minPointi = min(minPointi, faceMidPoint[facei]);
+                maxPointi = max(maxPointi, faceMidPoint[facei]);
+            }
+        }
+        forAll(edgeMidPoint, edgei)
+        {
+            if (edgeMidPoint[edgei] >= 0)
+            {
+                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);
+        }
+    }
+
+    pointLevel_.transfer(newPointLevel);
+    cellLevel_.transfer(newCellLevel);
+
+    // Mark files as changed
+    setInstance(mesh_.facesInstance());
+
+
+    // Update the live split cells tree.
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    // New unrefinement structure
+    if (history_.active())
+    {
+        if (debug)
+        {
+            Pout<< "hexRef4Axi::setRefinement :"
+                << " Updating refinement history to " << cellLevel_.size()
+                << " cells" << endl;
+        }
+
+        // Extend refinement history for new cells
+        history_.resize(cellLevel_.size());
+
+        forAll(cellAddedCells, celli)
+        {
+            const labelList& addedCells = cellAddedCells[celli];
+
+            if (addedCells.size())
+            {
+                // Cell was split.
+                history_.storeSplit(celli, addedCells);
+            }
+        }
+    }
+
+    // Compact cellAddedCells.
+
+    labelListList refinedCells(cellLabels.size());
+
+    forAll(cellLabels, i)
+    {
+        label celli = cellLabels[i];
+
+        refinedCells[i].transfer(cellAddedCells[celli]);
+    }
+
+    return refinedCells;
+}
+
+
+Foam::labelList Foam::hexRef4Axi::selectUnrefineElems
+(
+    const scalar unrefineLevel,
+    const PackedBoolList& markedCell,
+    const scalarField& pFld
+) const
+{
+    // All points that can be unrefined
+    const labelList splitEdges(getSplitElems());
+
+    DynamicList<label> newSplitEdges(splitEdges.size());
+
+    forAll(splitEdges, i)
+    {
+        label edgej = splitEdges[i];
+
+        const edge& e = mesh_.edges()[edgej];
+
+        forAll(e, i)
+        {
+            label pointi = e[i];
+
+            bool hasMarked = true;
+
+            if (pFld[pointi] < unrefineLevel)
+            {
+                // Check that all cells are not marked
+                const labelList& pCells = mesh_.pointCells()[pointi];
+
+                hasMarked = false;
+
+                forAll(pCells, pCelli)
+                {
+                    if (markedCell.get(pCells[pCelli]))
+                    {
+                        hasMarked = true;
+                        break;
+                    }
+                }
+            }
+
+            if (!hasMarked)
+            {
+                newSplitEdges.append(edgej);
+                break;
+            }
+        }
+    }
+
+
+    newSplitEdges.shrink();
+
+    // Guarantee 2:1 refinement after unrefinement
+    labelList consistentSet
+    (
+        consistentUnrefinement
+        (
+            newSplitEdges,
+            false
+        )
+    );
+    Info<< "Selected " << returnReduce(consistentSet.size(), sumOp<label>())
+        << " split edges out of a possible "
+        << returnReduce(splitEdges.size(), sumOp<label>())
+        << "." << endl;
+
+    return consistentSet;
+}
+
+Foam::labelList Foam::hexRef4Axi::consistentUnrefinement
+(
+    const labelList& elemsToUnrefine,
+    const bool maxSet
+) const
+{
+    if (debug)
+    {
+        Pout<< "hexRef4Axi::consistentUnrefinement :"
+            << " Determining 2:1 consistent unrefinement" << endl;
+    }
+
+    if (maxSet)
+    {
+        FatalErrorInFunction
+            << "maxSet not implemented yet."
+            << abort(FatalError);
+    }
+
+    // For hexRef4Axi, unrefinement is based on edges
+    const labelList& edgesToUnrefine(elemsToUnrefine);
+
+    // Loop, modifying edgesToUnrefine, until no more changes to due to 2:1
+    // conflicts.
+    // maxSet = false : unselect edges to refine
+    // maxSet = true: select edges to refine
+
+    // Maintain boolList for edgesToUnrefine and cellsToUnrefine
+    PackedBoolList unrefineEdge(mesh_.nEdges());
+
+    forAll(edgesToUnrefine, i)
+    {
+        label edgei = edgesToUnrefine[i];
+
+        unrefineEdge.set(edgei);
+    }
+
+
+    while (true)
+    {
+        // Construct cells to unrefine
+        // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
+        const labelListList& edgeCells = mesh_.edgeCells();
+
+        PackedBoolList unrefineCell(mesh_.nCells());
+
+        forAll(unrefineEdge, edgei)
+        {
+            if (unrefineEdge.get(edgei))
+            {
+                const labelList& pCells = edgeCells[edgei];
+
+                forAll(pCells, j)
+                {
+                    unrefineCell.set(pCells[j]);
+                }
+            }
+        }
+
+
+        label nChanged = 0;
+
+
+        // Check 2:1 consistency taking refinement into account
+        // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+        // Internal faces.
+        for (label facei = 0; facei < mesh_.nInternalFaces(); facei++)
+        {
+            label own = mesh_.faceOwner()[facei];
+            label ownLevel = cellLevel_[own] - unrefineCell.get(own);
+
+            label nei = mesh_.faceNeighbour()[facei];
+            label neiLevel = cellLevel_[nei] - unrefineCell.get(nei);
+
+            if (ownLevel < (neiLevel-1))
+            {
+                // Since was 2:1 this can only occur if own is marked for
+                // unrefinement.
+
+                if (maxSet)
+                {
+                    unrefineCell.set(nei);
+                }
+                else
+                {
+                    // could also combine with unset:
+                    // if (!unrefineCell.unset(own))
+                    // {
+                    //     FatalErrorInFunction
+                    //         << "problem cell already unset"
+                    //         << abort(FatalError);
+                    // }
+                    if (unrefineCell.get(own) == 0)
+                    {
+                        FatalErrorInFunction
+                            << "problem" << abort(FatalError);
+                    }
+
+                    unrefineCell.unset(own);
+                }
+                nChanged++;
+            }
+            else if (neiLevel < (ownLevel-1))
+            {
+                if (maxSet)
+                {
+                    unrefineCell.set(own);
+                }
+                else
+                {
+                    if (unrefineCell.get(nei) == 0)
+                    {
+                        FatalErrorInFunction
+                            << "problem" << abort(FatalError);
+                    }
+
+                    unrefineCell.unset(nei);
+                }
+                nChanged++;
+            }
+        }
+
+
+        // Coupled faces. Swap owner level to get neighbouring cell level.
+        labelList neiLevel(mesh_.nFaces()-mesh_.nInternalFaces());
+
+        forAll(neiLevel, i)
+        {
+            label own = mesh_.faceOwner()[i+mesh_.nInternalFaces()];
+
+            neiLevel[i] = cellLevel_[own] - unrefineCell.get(own);
+        }
+
+        // Swap to neighbour
+        syncTools::swapBoundaryFaceList(mesh_, neiLevel);
+
+        forAll(neiLevel, i)
+        {
+            label facei = i+mesh_.nInternalFaces();
+            label own = mesh_.faceOwner()[facei];
+            label ownLevel = cellLevel_[own] - unrefineCell.get(own);
+
+            if (ownLevel < (neiLevel[i]-1))
+            {
+                if (!maxSet)
+                {
+                    if (unrefineCell.get(own) == 0)
+                    {
+                        FatalErrorInFunction
+                            << "problem" << abort(FatalError);
+                    }
+
+                    unrefineCell.unset(own);
+                    nChanged++;
+                }
+            }
+            else if (neiLevel[i] < (ownLevel-1))
+            {
+                if (maxSet)
+                {
+                    if (unrefineCell.get(own) == 1)
+                    {
+                        FatalErrorInFunction
+                            << "problem" << abort(FatalError);
+                    }
+
+                    unrefineCell.set(own);
+                    nChanged++;
+                }
+            }
+        }
+
+        reduce(nChanged, sumOp<label>());
+
+        if (debug)
+        {
+            Pout<< "hexRef4Axi::consistentUnrefinement :"
+                << " Changed " << nChanged
+                << " refinement levels due to 2:1 conflicts."
+                << endl;
+        }
+
+        if (nChanged == 0)
+        {
+            break;
+        }
+
+
+        // Convert cellsToUnrefine back into points to unrefine
+        // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+        // Knock out any edge whose cell neighbour cannot be unrefined.
+        forAll(unrefineEdge, edgei)
+        {
+            if (unrefineEdge.get(edgei))
+            {
+                const labelList& pCells = edgeCells[edgei];
+
+                forAll(pCells, j)
+                {
+                    if (!unrefineCell.get(pCells[j]))
+                    {
+                        unrefineEdge.unset(edgei);
+                        break;
+                    }
+                }
+            }
+        }
+    }
+
+
+    // Convert back to labelList.
+    label nSet = 0;
+
+    forAll(unrefineEdge, edgei)
+    {
+        if (unrefineEdge.get(edgei))
+        {
+            nSet++;
+        }
+    }
+
+    labelList newEdgesToUnrefine(nSet);
+    nSet = 0;
+
+    forAll(unrefineEdge, edgei)
+    {
+        if (unrefineEdge.get(edgei))
+        {
+            newEdgesToUnrefine[nSet++] = edgei;
+        }
+    }
+
+    return newEdgesToUnrefine;
+}
+
+void Foam::hexRef4Axi::calcFaceToSplitPoint
+(
+    const labelList& splitElems,
+    Map<label>& faceToSplitPoint
+)
+{
+    // Save information on faces that will be combined
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    // For hexRef4Axi, the split elems are edges
+    faceToSplitPoint.resize(2*splitElems.size());
+
+    {
+        forAll(splitElems, i)
+        {
+            label edgei = splitElems[i];
+
+            const edge& e = mesh_.edges()[edgei];
+
+            forAll(e, j)
+            {
+                label pointi = e[j];
+
+                const labelList& pFaces = mesh_.pointFaces()[pointi];
+
+                forAll(pFaces, pFacei)
+                {
+                    faceToSplitPoint.insert(pFaces[pFacei], pointi);
+                }
+            }
+        }
+    }
+}
+
+Foam::labelList Foam::hexRef4Axi::getSplitElems() const
+{
+    if (debug)
+    {
+        checkRefinementLevels(-1, labelList(0));
+    }
+
+    if (debug)
+    {
+        Pout<< "hexRef4Axi::getSplitElems :"
+            << " Calculating unrefineable mid elements" << endl;
+    }
+
+
+    if (!history_.active())
+    {
+        FatalErrorInFunction
+            << "Only call if constructed with history capability"
+            << abort(FatalError);
+    }
+
+    // Master cell
+    // -1 undetermined
+    // -2 certainly not split edge
+    // >= label of master cell
+    labelList splitMaster(mesh_.nEdges(), -1);
+    labelList splitMasterLevel(mesh_.nEdges(), 0);
+
+    // Unmark all with not 4 cells (so internal edges)
+    const labelListList& edgeCells = mesh_.edgeCells();
+
+    forAll(edgeCells, edgei)
+    {
+        const labelList& eCells = edgeCells[edgei];
+
+        if (eCells.size() != 4)
+        {
+            splitMaster[edgei] = -2;
+        }
+    }
+
+    // Unmark all with different master cells
+    const labelList& visibleCells = history_.visibleCells();
+
+    forAll(visibleCells, celli)
+    {
+        const labelList& cEdges = mesh_.cellEdges(celli);
+
+        if (visibleCells[celli] != -1 && history_.parentIndex(celli) >= 0)
+        {
+            label parentIndex = history_.parentIndex(celli);
+
+            // Check same master.
+            forAll(cEdges, i)
+            {
+                label edgei = cEdges[i];
+
+                label masterCelli = splitMaster[edgei];
+
+                if (masterCelli == -1)
+                {
+                    // First time visit of point. Store parent cell and
+                    // level of the parent cell (with respect to celli). This
+                    // is additional guarantee that we're referring to the
+                    // same master at the same refinement level.
+
+                    splitMaster[edgei] = parentIndex;
+                    splitMasterLevel[edgei] = cellLevel_[celli] - 1;
+                }
+                else if (masterCelli == -2)
+                {
+                    // Already decided that edge is not splitEdge
+                }
+                else if
+                (
+                    (masterCelli != parentIndex)
+                 || (splitMasterLevel[edgei] != cellLevel_[celli] - 1)
+                )
+                {
+                    // Different masters so edge is on two refinement
+                    // patterns
+                    splitMaster[edgei] = -2;
+                }
+            }
+        }
+        else
+        {
+            // Either not visible or is unrefined cell
+            forAll(cEdges, i)
+            {
+                label edgei = cEdges[i];
+
+                splitMaster[edgei] = -2;
+            }
+        }
+    }
+
+    // Unmark boundary faces
+    for
+    (
+        label facei = mesh_.nInternalFaces();
+        facei < mesh_.nFaces();
+        facei++
+    )
+    {
+        const labelList& fEdges = mesh_.faceEdges()[facei];
+
+        forAll(fEdges, i)
+        {
+            label edgei = fEdges[i];
+
+            splitMaster[edgei] = -2;
+        }
+    }
+
+
+    // Collect into labelList
+
+    label nSplitEdges = 0;
+
+    forAll(splitMaster, edgei)
+    {
+        if (splitMaster[edgei] >= 0)
+        {
+            nSplitEdges++;
+        }
+    }
+
+    labelList splitEdges(nSplitEdges);
+    nSplitEdges = 0;
+
+    forAll(splitMaster, edgei)
+    {
+        if (splitMaster[edgei] >= 0)
+        {
+            splitEdges[nSplitEdges++] = edgei;
+        }
+    }
+
+    return splitEdges;
+}
+
+void Foam::hexRef4Axi::setUnrefinement
+(
+    const labelList& splitElemLabels,
+    polyTopoChange& meshMod
+)
+{
+    if (!history_.active())
+    {
+        FatalErrorInFunction
+            << "Only call if constructed with history capability"
+            << abort(FatalError);
+    }
+
+    // For hexRef4Axi, unrefinement is based on edges
+    const labelList& splitEdgeLabels(splitElemLabels);
+
+
+    //YO- This debug info would require writing edgeSets, which we do not have
+    //if (debug)
+    //{
+    //    Pout<< "hexRef::setUnrefinement :"
+    //        << " Checking initial mesh just to make sure" << endl;
+
+    //    checkMesh();
+
+    //    forAll(cellLevel_, celli)
+    //    {
+    //        if (cellLevel_[celli] < 0)
+    //        {
+    //            FatalErrorInFunction
+    //                << "Illegal cell level " << cellLevel_[celli]
+    //                << " for cell " << celli
+    //                << abort(FatalError);
+    //        }
+    //    }
+
+
+    //    // Write to sets.
+    //    pointSet pSet(mesh_, "splitPoints", splitPointLabels);
+    //    pSet.write();
+
+    //    cellSet cSet(mesh_, "splitPointCells", splitPointLabels.size());
+
+    //    forAll(splitPointLabels, i)
+    //    {
+    //        const labelList& pCells = mesh_.pointCells(splitPointLabels[i]);
+
+    //        forAll(pCells, j)
+    //        {
+    //            cSet.insert(pCells[j]);
+    //        }
+    //    }
+    //    cSet.write();
+
+    //    Pout<< "hexRef::setRefinement : Dumping " << pSet.size()
+    //        << " points and "
+    //        << cSet.size() << " cells for unrefinement to" << nl
+    //        << "    pointSet " << pSet.objectPath() << nl
+    //        << "    cellSet " << cSet.objectPath()
+    //        << endl;
+    //}
+
+
+    labelList cellRegion;
+    labelList cellRegionMaster;
+    labelList facesToRemove;
+
+    {
+        labelHashSet splitFaces(4*splitEdgeLabels.size());
+
+        forAll(splitEdgeLabels, i)
+        {
+            const labelList& eFaces = mesh_.edgeFaces()[splitEdgeLabels[i]];
+
+            forAll(eFaces, j)
+            {
+                splitFaces.insert(eFaces[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,         // per cell -1 or region it is merged into
+            cellRegionMaster,   // per region the master cell
+            facesToRemove       // new faces to be removed.
+        );
+
+        if (facesToRemove.size() != splitFaces.size())
+        {
+            FatalErrorInFunction
+                << "Initial set of split points to unrefine does not"
+                << " seem to be consistent or not mid points of refined cells"
+                << abort(FatalError);
+        }
+    }
+
+    // Redo the region master so it is consistent with our master.
+    // This will guarantee that the new cell (for which faceRemover uses
+    // the region master) is already compatible with our refinement structure.
+
+    forAll(splitEdgeLabels, i)
+    {
+        label edgei = splitEdgeLabels[i];
+
+        // Get original cell label
+
+        const labelList& eCells = mesh_.edgeCells()[edgei];
+
+        // Check
+        if (eCells.size() != 4)
+        {
+            FatalErrorInFunction
+                << "splitEdge " << edgei
+                << " should have " << 4
+                << " cells using it. It has " << eCells
+                << abort(FatalError);
+        }
+
+
+        // Check that the lowest numbered pCells is the master of the region
+        // (should be guaranteed by directRemoveFaces)
+        //if (debug)
+        {
+            label masterCelli = min(eCells);
+
+            forAll(eCells, j)
+            {
+                label celli = eCells[j];
+
+                label region = cellRegion[celli];
+
+                if (region == -1)
+                {
+                    FatalErrorInFunction
+                        << "Ininitial set of split edges to unrefine does not"
+                        << " seem to be consistent or not mid edges"
+                        << " of refined cells" << nl
+                        << "cell:" << celli << " on splitEdge " << edgei
+                        << " has no region to be merged into"
+                        << abort(FatalError);
+                }
+
+                if (masterCelli != cellRegionMaster[region])
+                {
+                    FatalErrorInFunction
+                        << "cell:" << celli << " on splitEdge:" << edgei
+                        << " in region " << region
+                        << " has master:" << cellRegionMaster[region]
+                        << " which is not the lowest numbered cell"
+                        << " among the edgeCells:" << eCells
+                        << abort(FatalError);
+                }
+            }
+        }
+    }
+
+    // Insert all commands to combine cells. Never fails so don't have to
+    // test for success.
+    faceRemover_.setRefinement
+    (
+        facesToRemove,
+        cellRegion,
+        cellRegionMaster,
+        meshMod
+    );
+
+    // Remove the n cells that originated from merging around the split point
+    // and adapt cell levels (not that pointLevels stay the same since points
+    // either get removed or stay at the same position.
+    forAll(splitEdgeLabels, i)
+    {
+        label edgei = splitEdgeLabels[i];
+
+        const labelList& eCells = mesh_.edgeCells()[edgei];
+
+        label masterCelli = min(eCells);
+
+        forAll(eCells, j)
+        {
+            cellLevel_[eCells[j]]--;
+        }
+
+        history_.combineCells(masterCelli, eCells);
+    }
+
+    // Mark files as changed
+    setInstance(mesh_.facesInstance());
+
+    // history_.updateMesh will take care of truncating.
+}
+
+
+// ************************************************************************* //
diff --git a/AMR_tidy/hexRef/hexRef4Axi/hexRef4Axi.H b/AMR_tidy/hexRef/hexRef4Axi/hexRef4Axi.H
new file mode 100644
index 00000000..2399b469
--- /dev/null
+++ b/AMR_tidy/hexRef/hexRef4Axi/hexRef4Axi.H
@@ -0,0 +1,215 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::hexRef4Axi
+
+Description
+    Refinement of (split) hexes using polyTopoChange.
+
+SourceFiles
+    hexRef4Axi.C
+
+Authors
+    Original code:
+    Ahmad Baniabedalruhman 2015
+    Adapted by:
+    Yun Ouedraogo 2017
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef hexRef4Axi_H
+#define hexRef4Axi_H
+
+#include "hexRef.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+/*---------------------------------------------------------------------------*\
+                           Class hexRef4Axi Declaration
+\*---------------------------------------------------------------------------*/
+
+class hexRef4Axi : public hexRef
+{
+
+protected:
+
+        //- 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;
+
+        //- Store in maps correspondence from midpoint to anchors and faces.
+        label storeMidPointInfo
+        (
+            const labelListList& cellAnchorPoints,
+            const labelListList& cellAddedCells,
+            const labelList& cellMidPoint,
+            const labelList& faceMidPoint,
+            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,
+            polyTopoChange& meshMod
+        ) const;
+
+        //- Create all internal faces to split celli into 4.
+        void createInternalFaces
+        (
+            const labelListList& cellAnchorPoints,
+            const labelListList& cellAddedCells,
+            const labelList& cellMidPoint,
+            const labelList& faceMidPoint,
+            const labelList& faceAnchorLevel,
+            const labelList& edgeMidPoint,
+            const label celli,
+            polyTopoChange& meshMod
+        ) const;
+
+        //- Disallow default bitwise copy construct
+        hexRef4Axi(const hexRef4Axi&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const hexRef4Axi&);
+
+
+public:
+
+    //- Runtime type information
+    TypeName("hexRef4Axi");
+
+
+    // Constructors
+
+        //- Construct from mesh, read_if_present refinement data
+        //  (from write below). If readHistory is true does read_if_present
+        //  of refinement history. If false clears all history
+        hexRef4Axi(const polyMesh& mesh, const bool readHistory = true);
+
+        //- Construct from mesh and un/refinement data and optional size of
+        //  starting cells
+        hexRef4Axi
+        (
+            const polyMesh& mesh,
+            const labelList& cellLevel,
+            const labelList& pointLevel,
+            const refinementHistory& history,
+            const scalar level0Edge = -GREAT
+        );
+
+        //- Construct from mesh and refinement data and optional size of
+        //  starting cells
+        hexRef4Axi
+        (
+            const polyMesh& mesh,
+            const labelList& cellLevel,
+            const labelList& pointLevel,
+            const scalar level0Edge = -GREAT
+        );
+
+
+    // Member Functions
+
+        // Refinement
+
+            //- Insert refinement. All selected cells will be split into 8.
+            //  Returns per element in cells the 8 cells they were split into.
+            //  Guarantees that the 0th element is the original cell label.
+            //  Mapping:
+            //  -split cells: 3 new ones get added from original
+            //  -split faces: original gets modified; 3 new ones get added
+            //               from original
+            //  -added internal faces: added from original cell face(if
+            //   that was internal) or created out-of-nothing (so will not
+            //   get mapped!). Note: could make this inflate from point but
+            //   that will allocate interpolation.
+            //  -points added to split edge: added from edge start()
+            //  -midpoints added: added from cellPoints[0].
+            labelListList setRefinement
+            (
+                const labelList& cells,
+                polyTopoChange&
+            );
+
+        // Unrefinement
+            //- Return the mid elems in top-level split cells
+            //  that can be unsplit.
+            labelList getSplitElems() const;
+
+            //- Given proposed
+            //  splitElems to unrefine according to calculate any clashes
+            //  (due to 2:1) and return ok list of mid elems to unrefine.
+            labelList consistentUnrefinement
+            (
+                const labelList& elemsToUnrefine,
+                const bool maxSet
+            ) const;
+
+            //- Remove some refinement. Needs to be supplied output of
+            //  consistentUnrefinement. Only call if undoable set.
+            //  All n edgeCells of a split edge will be combined into
+            //  the lowest numbered cell of those n.
+            void setUnrefinement
+            (
+                const labelList& splitElemLabels,
+                polyTopoChange&
+            );
+
+            labelList selectUnrefineElems
+            (
+                const scalar unrefineLevel,
+                const PackedBoolList& markedCell,
+                const scalarField& vFld
+            ) const;
+
+            void calcFaceToSplitPoint
+            (
+                const labelList& splitElems,
+                Map<label>& faceToSplitPoint
+            );
+
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/AMR_tidy/hexRef/hexRef8/hexRef8.C b/AMR_tidy/hexRef/hexRef8/hexRef8.C
new file mode 100644
index 00000000..ecd0851d
--- /dev/null
+++ b/AMR_tidy/hexRef/hexRef8/hexRef8.C
@@ -0,0 +1,2366 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "hexRef8.H"
+
+#include "addToRunTimeSelectionTable.H"
+
+#include "polyMesh.H"
+#include "polyTopoChange.H"
+#include "meshTools.H"
+#include "polyAddFace.H"
+#include "polyAddPoint.H"
+#include "polyAddCell.H"
+#include "polyModifyFace.H"
+#include "syncTools.H"
+#include "faceSet.H"
+#include "cellSet.H"
+#include "pointSet.H"
+#include "OFstream.H"
+#include "Time.H"
+#include "FaceCellWave.H"
+#include "mapDistributePolyMesh.H"
+#include "refinementData.H"
+#include "refinementDistanceData.H"
+#include "degenerateMatcher.H"
+
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(hexRef8, 0);
+    addToRunTimeSelectionTable(hexRef, hexRef8, mesh);
+    addToRunTimeSelectionTable(hexRef, hexRef8, levelsHist);
+    addToRunTimeSelectionTable(hexRef, hexRef8, levels);
+}
+
+
+// * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
+
+// Check whether pointi is an anchor on celli.
+// If it is not check whether any other point on the face is an anchor cell.
+Foam::label Foam::hexRef8::getAnchorCell
+(
+    const labelListList& cellAnchorPoints,
+    const labelListList& cellAddedCells,
+    const label celli,
+    const label facei,
+    const label pointi
+) const
+{
+    if (cellAnchorPoints[celli].size())
+    {
+        label index = findIndex(cellAnchorPoints[celli], pointi);
+
+        if (index != -1)
+        {
+            return cellAddedCells[celli][index];
+        }
+
+
+        // pointi is not an anchor cell.
+        // Maybe we are already a refined face so check all the face
+        // vertices.
+        const face& f = mesh_.faces()[facei];
+
+        forAll(f, fp)
+        {
+            label index = findIndex(cellAnchorPoints[celli], f[fp]);
+
+            if (index != -1)
+            {
+                return cellAddedCells[celli][index];
+            }
+        }
+
+        // Problem.
+        dumpCell(celli);
+        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;
+    }
+}
+
+// Internal faces are one per edge between anchor points. So one per midPoint
+// between the anchor points. Here we store the information on the midPoint
+// and if we have enough information:
+// - two anchors
+// - two face mid points
+// we add the face. Note that this routine 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.
+Foam::label Foam::hexRef8::storeMidPointInfo
+(
+    const labelListList& cellAnchorPoints,
+    const labelListList& cellAddedCells,
+    const labelList& cellMidPoint,
+    const labelList& faceMidPoint,
+    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,
+    polyTopoChange& meshMod
+) const
+{
+    // 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 necessary 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 cellMid and face mids.
+
+        DynamicList<label> newFaceVerts(4);
+        if (faceOrder == (mesh_.faceOwner()[facei] == celli))
+        {
+            newFaceVerts.append(faceMidPointi);
+
+            // Check & 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);
+
+        label anchorCell0 = getAnchorCell
+        (
+            cellAnchorPoints,
+            cellAddedCells,
+            celli,
+            facei,
+            anchorPointi
+        );
+        label anchorCell1 = getAnchorCell
+        (
+            cellAnchorPoints,
+            cellAddedCells,
+            celli,
+            facei,
+            anchors.otherVertex(anchorPointi)
+        );
+
+
+        label own, nei;
+        point ownPt, neiPt;
+
+        if (anchorCell0 < anchorCell1)
+        {
+            own = anchorCell0;
+            nei = anchorCell1;
+
+            ownPt = mesh_.points()[anchorPointi];
+            neiPt = mesh_.points()[anchors.otherVertex(anchorPointi)];
+
+        }
+        else
+        {
+            own = anchorCell1;
+            nei = anchorCell0;
+            newFace.flip();
+
+            ownPt = mesh_.points()[anchors.otherVertex(anchorPointi)];
+            neiPt = mesh_.points()[anchorPointi];
+        }
+
+        if (debug)
+        {
+            point ownPt, neiPt;
+
+            if (anchorCell0 < anchorCell1)
+            {
+                ownPt = mesh_.points()[anchorPointi];
+                neiPt = mesh_.points()[anchors.otherVertex(anchorPointi)];
+            }
+            else
+            {
+                ownPt = mesh_.points()[anchors.otherVertex(anchorPointi)];
+                neiPt = mesh_.points()[anchorPointi];
+            }
+
+            checkInternalOrientation
+            (
+                meshMod,
+                celli,
+                facei,
+                ownPt,
+                neiPt,
+                newFace
+            );
+        }
+
+        return addInternalFace
+        (
+            meshMod,
+            facei,
+            anchorPointi,
+            newFace,
+            own,
+            nei
+        );
+    }
+    else
+    {
+        return -1;
+    }
+}
+
+
+// Creates all the 12 internal faces for celli.
+void Foam::hexRef8::createInternalFaces
+(
+    const labelListList& cellAnchorPoints,
+    const labelListList& cellAddedCells,
+    const labelList& cellMidPoint,
+    const labelList& faceMidPoint,
+    const labelList& faceAnchorLevel,
+    const labelList& edgeMidPoint,
+    const label celli,
+
+    polyTopoChange& meshMod
+) const
+{
+    // Find in every face the cellLevel+1 points (from edge subdivision)
+    // and the anchor points.
+
+    const cell& cFaces = mesh_.cells()[celli];
+    const label cLevel = cellLevel_[celli];
+
+    // From edge mid to anchor points
+    Map<edge> midPointToAnchors(24);
+    // From edge mid to face mids
+    Map<edge> midPointToFaceMids(24);
+
+    // Storage for on-the-fly addressing
+    DynamicList<label> storage;
+
+
+    // Running count of number of internal faces added so far.
+    label nFacesAdded = 0;
+
+    forAll(cFaces, i)
+    {
+        label facei = cFaces[i];
+
+        const face& f = mesh_.faces()[facei];
+        const labelList& fEdges = mesh_.faceEdges(facei, storage);
+
+        // We are on the celli side of face f. The face will have 1 or 4
+        // cLevel points and lots of higher numbered ones.
+
+        label faceMidPointi = -1;
+
+        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;
+
+            forAll(f, fp)
+            {
+                if (pointLevel_[f[fp]] <= cLevel)
+                {
+                    anchorFp = fp;
+                    break;
+                }
+            }
+
+            // Now the face mid point is the second cLevel+1 point
+            label edgeMid = findLevel
+            (
+                facei,
+                f,
+                f.fcIndex(anchorFp),
+                true,
+                cLevel+1
+            );
+            label faceMid = findLevel
+            (
+                facei,
+                f,
+                f.fcIndex(edgeMid),
+                true,
+                cLevel+1
+            );
+
+            faceMidPointi = f[faceMid];
+        }
+        else if (nAnchors == 4)
+        {
+            // There is no face middle yet but the face will be marked for
+            // splitting.
+
+            faceMidPointi = faceMidPoint[facei];
+        }
+        else
+        {
+            dumpCell(mesh_.faceOwner()[facei]);
+            if (mesh_.isInternalFace(facei))
+            {
+                dumpCell(mesh_.faceNeighbour()[facei]);
+            }
+
+            FatalErrorInFunction
+                << "nAnchors:" << nAnchors
+                << " facei:" << facei
+                << abort(FatalError);
+        }
+
+
+
+        // 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)
+        {
+            label point0 = f[fp0];
+
+            if (pointLevel_[point0] <= cLevel)
+            {
+                // Anchor.
+
+                // Walk forward
+                // ~~~~~~~~~~~~
+                // to cLevel+1 or edgeMidPoint of this level.
+
+
+                label edgeMidPointi = -1;
+
+                label fp1 = f.fcIndex(fp0);
+
+                if (pointLevel_[f[fp1]] <= cLevel)
+                {
+                    // Anchor. Edge will be split.
+                    label edgeI = fEdges[fp0];
+
+                    edgeMidPointi = edgeMidPoint[edgeI];
+
+                    if (edgeMidPointi == -1)
+                    {
+                        dumpCell(celli);
+
+                        const labelList& cPoints = mesh_.cellPoints(celli);
+
+                        FatalErrorInFunction
+                            << "cell:" << celli << " cLevel:" << cLevel
+                            << " cell points:" << cPoints
+                            << " pointLevel:"
+                            << UIndirectList<label>(pointLevel_, cPoints)()
+                            << " face:" << facei
+                            << " f:" << f
+                            << " pointLevel:"
+                            << UIndirectList<label>(pointLevel_, f)()
+                            << " faceAnchorLevel:" << faceAnchorLevel[facei]
+                            << " faceMidPoint:" << faceMidPoint[facei]
+                            << " faceMidPointi:" << faceMidPointi
+                            << " fp:" << fp0
+                            << abort(FatalError);
+                    }
+                }
+                else
+                {
+                    // Search forward in face to clevel+1
+                    label edgeMid = findLevel(facei, f, fp1, true, cLevel+1);
+
+                    edgeMidPointi = f[edgeMid];
+                }
+
+                label newFacei = storeMidPointInfo
+                (
+                    cellAnchorPoints,
+                    cellAddedCells,
+                    cellMidPoint,
+                    faceMidPoint,
+                    edgeMidPoint,
+
+                    celli,
+                    facei,
+                    true,                   // mid point after anchor
+                    edgeMidPointi,          // edgemid
+                    point0,                 // anchor
+                    faceMidPointi,
+
+                    midPointToAnchors,
+                    midPointToFaceMids,
+                    meshMod
+                );
+
+                if (newFacei != -1)
+                {
+                    nFacesAdded++;
+
+                    if (nFacesAdded == 12)
+                    {
+                        break;
+                    }
+                }
+
+
+
+                // Walk backward
+                // ~~~~~~~~~~~~~
+
+                label fpMin1 = f.rcIndex(fp0);
+
+                if (pointLevel_[f[fpMin1]] <= cLevel)
+                {
+                    // Anchor. Edge will be split.
+                    label edgeI = fEdges[fpMin1];
+
+                    edgeMidPointi = edgeMidPoint[edgeI];
+
+                    if (edgeMidPointi == -1)
+                    {
+                        dumpCell(celli);
+
+                        const labelList& cPoints = mesh_.cellPoints(celli);
+
+                        FatalErrorInFunction
+                            << "cell:" << celli << " cLevel:" << cLevel
+                            << " cell points:" << cPoints
+                            << " pointLevel:"
+                            << UIndirectList<label>(pointLevel_, cPoints)()
+                            << " face:" << facei
+                            << " f:" << f
+                            << " pointLevel:"
+                            << UIndirectList<label>(pointLevel_, f)()
+                            << " faceAnchorLevel:" << faceAnchorLevel[facei]
+                            << " faceMidPoint:" << faceMidPoint[facei]
+                            << " faceMidPointi:" << faceMidPointi
+                            << " fp:" << fp0
+                            << abort(FatalError);
+                    }
+                }
+                else
+                {
+                    // Search back to clevel+1
+                    label edgeMid = findLevel
+                    (
+                        facei,
+                        f,
+                        fpMin1,
+                        false,
+                        cLevel+1
+                    );
+
+                    edgeMidPointi = f[edgeMid];
+                }
+
+                newFacei = storeMidPointInfo
+                (
+                    cellAnchorPoints,
+                    cellAddedCells,
+                    cellMidPoint,
+                    faceMidPoint,
+                    edgeMidPoint,
+
+                    celli,
+                    facei,
+                    false,                  // mid point before anchor
+                    edgeMidPointi,          // edgemid
+                    point0,                 // anchor
+                    faceMidPointi,
+
+                    midPointToAnchors,
+                    midPointToFaceMids,
+                    meshMod
+                );
+
+                if (newFacei != -1)
+                {
+                    nFacesAdded++;
+
+                    if (nFacesAdded == 12)
+                    {
+                        break;
+                    }
+                }
+            }   // done anchor
+        }   // done face
+
+        if (nFacesAdded == 12)
+        {
+            break;
+        }
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+// Construct from mesh, read refinement data
+Foam::hexRef8::hexRef8(const polyMesh& mesh, const bool readHistory)
+:
+    hexRef(mesh, readHistory)
+{}
+
+
+// Construct from components
+Foam::hexRef8::hexRef8
+(
+    const polyMesh& mesh,
+    const labelList& cellLevel,
+    const labelList& pointLevel,
+    const refinementHistory& history,
+    const scalar level0Edge
+)
+:
+    hexRef(mesh, cellLevel, pointLevel, history, level0Edge)
+{}
+
+
+// Construct from components
+Foam::hexRef8::hexRef8
+(
+    const polyMesh& mesh,
+    const labelList& cellLevel,
+    const labelList& pointLevel,
+    const scalar level0Edge
+)
+:
+    hexRef(mesh, cellLevel, pointLevel, level0Edge)
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+// Top level driver to insert topo changes to do all refinement.
+Foam::labelListList Foam::hexRef8::setRefinement
+(
+    const labelList& cellLabels,
+    polyTopoChange& meshMod
+)
+{
+    if (debug)
+    {
+        Pout<< "hexRef8::setRefinement :"
+            << " Checking initial mesh just to make sure" << endl;
+
+        checkMesh();
+        // Cannot call checkRefinementlevels since hanging points might
+        // get triggered by the mesher after subsetting.
+        //checkRefinementLevels(-1, labelList(0));
+    }
+
+    // Clear any saved point/cell data.
+    savedPointLevel_.clear();
+    savedCellLevel_.clear();
+
+
+    // New point/cell level. Copy of pointLevel for existing points.
+    DynamicList<label> newCellLevel(cellLevel_.size());
+    forAll(cellLevel_, celli)
+    {
+        newCellLevel.append(cellLevel_[celli]);
+    }
+    DynamicList<label> newPointLevel(pointLevel_.size());
+    forAll(pointLevel_, pointi)
+    {
+        newPointLevel.append(pointLevel_[pointi]);
+    }
+
+
+    if (debug)
+    {
+        Pout<< "hexRef8::setRefinement :"
+            << " Allocating " << cellLabels.size() << " cell midpoints."
+            << endl;
+    }
+
+
+    // Mid point per refined cell.
+    // -1 : not refined
+    // >=0: label of mid point.
+    labelList cellMidPoint(mesh_.nCells(), -1);
+
+    forAll(cellLabels, i)
+    {
+        label celli = cellLabels[i];
+
+        label anchorPointi = mesh_.faces()[mesh_.cells()[celli][0]][0];
+
+        cellMidPoint[celli] = meshMod.setAction
+        (
+            polyAddPoint
+            (
+                mesh_.cellCentres()[celli],     // point
+                anchorPointi,                   // master point
+                -1,                             // zone for point
+                true                            // supports a cell
+            )
+        );
+
+        newPointLevel(cellMidPoint[celli]) = cellLevel_[celli]+1;
+    }
+
+
+    if (debug)
+    {
+        cellSet splitCells(mesh_, "splitCells", cellLabels.size());
+
+        forAll(cellMidPoint, celli)
+        {
+            if (cellMidPoint[celli] >= 0)
+            {
+                splitCells.insert(celli);
+            }
+        }
+
+        Pout<< "hexRef8::setRefinement : Dumping " << splitCells.size()
+            << " cells to split to cellSet " << splitCells.objectPath()
+            << endl;
+
+        splitCells.write();
+    }
+
+
+
+    // Split edges
+    // ~~~~~~~~~~~
+
+    if (debug)
+    {
+        Pout<< "hexRef8::setRefinement :"
+            << " Allocating edge midpoints."
+            << endl;
+    }
+
+    // Unrefined edges are ones between cellLevel or lower points.
+    // If any cell using this edge gets split then the edge needs to be split.
+
+    // -1  : no need to split edge
+    // >=0 : label of introduced mid point
+    labelList edgeMidPoint(mesh_.nEdges(), -1);
+
+    // Note: Loop over cells to be refined or edges?
+    forAll(cellMidPoint, celli)
+    {
+        if (cellMidPoint[celli] >= 0)
+        {
+            const labelList& cEdges = mesh_.cellEdges(celli);
+
+            forAll(cEdges, i)
+            {
+                label edgeI = cEdges[i];
+
+                const edge& e = mesh_.edges()[edgeI];
+
+                if
+                (
+                    pointLevel_[e[0]] <= cellLevel_[celli]
+                 && pointLevel_[e[1]] <= cellLevel_[celli]
+                )
+                {
+                    edgeMidPoint[edgeI] = 12345;    // mark need for splitting
+                }
+            }
+        }
+    }
+
+    // Synchronize edgeMidPoint across coupled patches. Take max so that
+    // any split takes precedence.
+    syncTools::syncEdgeList
+    (
+        mesh_,
+        edgeMidPoint,
+        maxEqOp<label>(),
+        labelMin
+    );
+
+
+    // Introduce edge points
+    // ~~~~~~~~~~~~~~~~~~~~~
+
+    {
+        // Phase 1: calculate midpoints and sync.
+        // This needs doing for if people do not write binary and we slowly
+        // get differences.
+
+        pointField edgeMids(mesh_.nEdges(), point(-GREAT, -GREAT, -GREAT));
+
+        forAll(edgeMidPoint, edgeI)
+        {
+            if (edgeMidPoint[edgeI] >= 0)
+            {
+                // Edge marked to be split.
+                edgeMids[edgeI] = mesh_.edges()[edgeI].centre(mesh_.points());
+            }
+        }
+        syncTools::syncEdgePositions
+        (
+            mesh_,
+            edgeMids,
+            maxEqOp<vector>(),
+            point(-GREAT, -GREAT, -GREAT)
+        );
+
+
+        // Phase 2: introduce points at the synced locations.
+        forAll(edgeMidPoint, edgeI)
+        {
+            if (edgeMidPoint[edgeI] >= 0)
+            {
+                // Edge marked to be split. Replace edgeMidPoint with actual
+                // point label.
+
+                const edge& e = mesh_.edges()[edgeI];
+
+                edgeMidPoint[edgeI] = meshMod.setAction
+                (
+                    polyAddPoint
+                    (
+                        edgeMids[edgeI],            // point
+                        e[0],                       // master point
+                        -1,                         // zone for point
+                        true                        // supports a cell
+                    )
+                );
+
+                newPointLevel(edgeMidPoint[edgeI]) =
+                    max
+                    (
+                        pointLevel_[e[0]],
+                        pointLevel_[e[1]]
+                    )
+                  + 1;
+            }
+        }
+    }
+
+    if (debug)
+    {
+        OFstream str(mesh_.time().path()/"edgeMidPoint.obj");
+
+        forAll(edgeMidPoint, edgeI)
+        {
+            if (edgeMidPoint[edgeI] >= 0)
+            {
+                const edge& e = mesh_.edges()[edgeI];
+
+                meshTools::writeOBJ(str, e.centre(mesh_.points()));
+            }
+        }
+
+        Pout<< "hexRef8::setRefinement :"
+            << " Dumping edge centres to split to file " << str.name() << endl;
+    }
+
+
+    // Calculate face level
+    // ~~~~~~~~~~~~~~~~~~~~
+    // (after splitting)
+
+    if (debug)
+    {
+        Pout<< "hexRef8::setRefinement :"
+            << " Allocating face midpoints."
+            << endl;
+    }
+
+    // Face anchor level. There are guaranteed 4 points with level
+    // <= anchorLevel. These are the corner points.
+    labelList faceAnchorLevel(mesh_.nFaces());
+
+    for (label facei = 0; facei < mesh_.nFaces(); facei++)
+    {
+        faceAnchorLevel[facei] = faceLevel(facei);
+    }
+
+    // -1  : no need to split face
+    // >=0 : label of introduced mid point
+    labelList faceMidPoint(mesh_.nFaces(), -1);
+
+
+    // Internal faces: look at cells on both sides. Uniquely determined since
+    // face itself guaranteed to be same level as most refined neighbour.
+    for (label facei = 0; facei < mesh_.nInternalFaces(); facei++)
+    {
+        if (faceAnchorLevel[facei] >= 0)
+        {
+            label own = mesh_.faceOwner()[facei];
+            label ownLevel = cellLevel_[own];
+            label newOwnLevel = ownLevel + (cellMidPoint[own] >= 0 ? 1 : 0);
+
+            label nei = mesh_.faceNeighbour()[facei];
+            label neiLevel = cellLevel_[nei];
+            label newNeiLevel = neiLevel + (cellMidPoint[nei] >= 0 ? 1 : 0);
+
+            if
+            (
+                newOwnLevel > faceAnchorLevel[facei]
+             || newNeiLevel > faceAnchorLevel[facei]
+            )
+            {
+                faceMidPoint[facei] = 12345;    // mark to be split
+            }
+        }
+    }
+
+    // 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)
+
+    {
+        labelList newNeiLevel(mesh_.nFaces()-mesh_.nInternalFaces());
+
+        forAll(newNeiLevel, i)
+        {
+            label own = mesh_.faceOwner()[i+mesh_.nInternalFaces()];
+            label ownLevel = cellLevel_[own];
+            label newOwnLevel = ownLevel + (cellMidPoint[own] >= 0 ? 1 : 0);
+
+            newNeiLevel[i] = newOwnLevel;
+        }
+
+        // Swap.
+        syncTools::swapBoundaryFaceList(mesh_, newNeiLevel);
+
+        // So now we have information on the neighbour.
+
+        forAll(newNeiLevel, i)
+        {
+            label facei = i+mesh_.nInternalFaces();
+
+            if (faceAnchorLevel[facei] >= 0)
+            {
+                label own = mesh_.faceOwner()[facei];
+                label ownLevel = cellLevel_[own];
+                label newOwnLevel = ownLevel + (cellMidPoint[own] >= 0 ? 1 : 0);
+
+                if
+                (
+                    newOwnLevel > faceAnchorLevel[facei]
+                 || newNeiLevel[i] > faceAnchorLevel[facei]
+                )
+                {
+                    faceMidPoint[facei] = 12345;    // mark to be split
+                }
+            }
+        }
+    }
+
+
+    // Synchronize faceMidPoint across coupled patches. (logical or)
+    syncTools::syncFaceList
+    (
+        mesh_,
+        faceMidPoint,
+        maxEqOp<label>()
+    );
+
+
+
+    // Introduce face points
+    // ~~~~~~~~~~~~~~~~~~~~~
+
+    {
+        // Phase 1: determine mid points and sync. See comment for edgeMids
+        // above
+        pointField bFaceMids
+        (
+            mesh_.nFaces()-mesh_.nInternalFaces(),
+            point(-GREAT, -GREAT, -GREAT)
+        );
+
+        forAll(bFaceMids, i)
+        {
+            label facei = i+mesh_.nInternalFaces();
+
+            if (faceMidPoint[facei] >= 0)
+            {
+                bFaceMids[i] = mesh_.faceCentres()[facei];
+            }
+        }
+        syncTools::syncBoundaryFacePositions
+        (
+            mesh_,
+            bFaceMids,
+            maxEqOp<vector>()
+        );
+
+        forAll(faceMidPoint, facei)
+        {
+            if (faceMidPoint[facei] >= 0)
+            {
+                // Face marked to be split. Replace faceMidPoint with actual
+                // point label.
+
+                const face& f = mesh_.faces()[facei];
+
+                faceMidPoint[facei] = meshMod.setAction
+                (
+                    polyAddPoint
+                    (
+                        (
+                            facei < mesh_.nInternalFaces()
+                          ? mesh_.faceCentres()[facei]
+                          : bFaceMids[facei-mesh_.nInternalFaces()]
+                        ),                          // point
+                        f[0],                       // master point
+                        -1,                         // zone for point
+                        true                        // supports a cell
+                    )
+                );
+
+                // Determine the level of the corner points and midpoint will
+                // be one higher.
+                newPointLevel(faceMidPoint[facei]) = faceAnchorLevel[facei]+1;
+            }
+        }
+    }
+
+    if (debug)
+    {
+        faceSet splitFaces(mesh_, "splitFaces", cellLabels.size());
+
+        forAll(faceMidPoint, facei)
+        {
+            if (faceMidPoint[facei] >= 0)
+            {
+                splitFaces.insert(facei);
+            }
+        }
+
+        Pout<< "hexRef8::setRefinement : Dumping " << splitFaces.size()
+            << " faces to split to faceSet " << splitFaces.objectPath() << endl;
+
+        splitFaces.write();
+    }
+
+
+    // Information complete
+    // ~~~~~~~~~~~~~~~~~~~~
+    // At this point we have all the information we need. We should no
+    // longer reference the cellLabels to refine. All the information is:
+    // - cellMidPoint >= 0 : cell needs to be split
+    // - faceMidPoint >= 0 : face needs to be split
+    // - edgeMidPoint >= 0 : edge needs to be split
+
+
+
+    // Get the corner/anchor points
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    if (debug)
+    {
+        Pout<< "hexRef8::setRefinement :"
+            << " Finding cell anchorPoints (8 per cell)"
+            << endl;
+    }
+
+    // There will always be 8 points on the hex that have were introduced
+    // with the hex and will have the same or lower refinement level.
+
+    // Per cell the 8 corner points.
+    labelListList cellAnchorPoints(mesh_.nCells());
+
+    {
+        labelList nAnchorPoints(mesh_.nCells(), 0);
+
+        forAll(cellMidPoint, celli)
+        {
+            if (cellMidPoint[celli] >= 0)
+            {
+                cellAnchorPoints[celli].setSize(8);
+            }
+        }
+
+        forAll(pointLevel_, pointi)
+        {
+            const labelList& pCells = mesh_.pointCells(pointi);
+
+            forAll(pCells, pCelli)
+            {
+                label celli = pCells[pCelli];
+
+                if
+                (
+                    cellMidPoint[celli] >= 0
+                 && pointLevel_[pointi] <= cellLevel_[celli]
+                )
+                {
+                    if (nAnchorPoints[celli] == 8)
+                    {
+                        dumpCell(celli);
+                        FatalErrorInFunction
+                            << "cell " << celli
+                            << " of level " << cellLevel_[celli]
+                            << " uses more than 8 points of equal or"
+                            << " lower level" << nl
+                            << "Points so far:" << cellAnchorPoints[celli]
+                            << abort(FatalError);
+                    }
+
+                    cellAnchorPoints[celli][nAnchorPoints[celli]++] = pointi;
+                }
+            }
+        }
+
+        forAll(cellMidPoint, celli)
+        {
+            if (cellMidPoint[celli] >= 0)
+            {
+                if (nAnchorPoints[celli] != 8)
+                {
+                    dumpCell(celli);
+
+                    const labelList& cPoints = mesh_.cellPoints(celli);
+
+                    FatalErrorInFunction
+                        << "cell " << celli
+                        << " of level " << cellLevel_[celli]
+                        << " does not seem to have 8 points of equal or"
+                        << " lower level" << endl
+                        << "cellPoints:" << cPoints << endl
+                        << "pointLevels:"
+                        << UIndirectList<label>(pointLevel_, cPoints)() << endl
+                        << abort(FatalError);
+                }
+            }
+        }
+    }
+
+
+    // Add the cells
+    // ~~~~~~~~~~~~~
+
+    if (debug)
+    {
+        Pout<< "hexRef8::setRefinement :"
+            << " Adding cells (1 per anchorPoint)"
+            << endl;
+    }
+
+    // Per cell the 7 added cells (+ original cell)
+    labelListList cellAddedCells(mesh_.nCells());
+
+    forAll(cellAnchorPoints, celli)
+    {
+        const labelList& cAnchors = cellAnchorPoints[celli];
+
+        if (cAnchors.size() == 8)
+        {
+            labelList& cAdded = cellAddedCells[celli];
+            cAdded.setSize(8);
+
+            // Original cell at 0
+            cAdded[0] = celli;
+
+            // Update cell level
+            newCellLevel[celli] = cellLevel_[celli]+1;
+
+
+            for (label i = 1; i < 8; i++)
+            {
+                cAdded[i] = meshMod.setAction
+                (
+                    polyAddCell
+                    (
+                        -1,                                 // master point
+                        -1,                                 // master edge
+                        -1,                                 // master face
+                        celli,                              // master cell
+                        mesh_.cellZones().whichZone(celli)  // zone for cell
+                    )
+                );
+
+                newCellLevel(cAdded[i]) = cellLevel_[celli]+1;
+            }
+        }
+    }
+
+
+    // Faces
+    // ~~~~~
+    // 1. existing faces that get split (into four always)
+    // 2. existing faces that do not get split but only edges get split
+    // 3. existing faces that do not get split but get new owner/neighbour
+    // 4. new internal faces inside split cells.
+
+    if (debug)
+    {
+        Pout<< "hexRef8::setRefinement :"
+            << " Marking faces to be handled"
+            << endl;
+    }
+
+    // Get all affected faces.
+    PackedBoolList affectedFace(mesh_.nFaces());
+
+    {
+        forAll(cellMidPoint, celli)
+        {
+            if (cellMidPoint[celli] >= 0)
+            {
+                const cell& cFaces = mesh_.cells()[celli];
+
+                forAll(cFaces, i)
+                {
+                    affectedFace.set(cFaces[i]);
+                }
+            }
+        }
+
+        forAll(faceMidPoint, facei)
+        {
+            if (faceMidPoint[facei] >= 0)
+            {
+                affectedFace.set(facei);
+            }
+        }
+
+        forAll(edgeMidPoint, edgeI)
+        {
+            if (edgeMidPoint[edgeI] >= 0)
+            {
+                const labelList& eFaces = mesh_.edgeFaces(edgeI);
+
+                forAll(eFaces, i)
+                {
+                    affectedFace.set(eFaces[i]);
+                }
+            }
+        }
+    }
+
+
+    // 1. Faces that get split
+    // ~~~~~~~~~~~~~~~~~~~~~~~
+
+    if (debug)
+    {
+        Pout<< "hexRef8::setRefinement : Splitting faces" << endl;
+    }
+
+    forAll(faceMidPoint, facei)
+    {
+        if (faceMidPoint[facei] >= 0 && affectedFace.get(facei))
+        {
+            // Face needs to be split and hasn't yet been done in some way
+            // (affectedFace - is impossible since this is first change but
+            //  just for completeness)
+
+            const face& f = mesh_.faces()[facei];
+
+            // Has original facei been used (three faces added, original gets
+            // modified)
+            bool modifiedFace = false;
+
+            label anchorLevel = faceAnchorLevel[facei];
+
+            face newFace(4);
+
+            forAll(f, fp)
+            {
+                label pointi = f[fp];
+
+                if (pointLevel_[pointi] <= anchorLevel)
+                {
+                    // point is anchor. Start collecting face.
+
+                    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
+
+                    walkFaceToMid
+                    (
+                        edgeMidPoint,
+                        anchorLevel,
+                        facei,
+                        fp,
+                        faceVerts
+                    );
+
+                    faceVerts.append(faceMidPoint[facei]);
+
+                    walkFaceFromMid
+                    (
+                        edgeMidPoint,
+                        anchorLevel,
+                        facei,
+                        fp,
+                        faceVerts
+                    );
+
+                    // Convert dynamiclist to face.
+                    newFace.transfer(faceVerts);
+
+                    //Pout<< "Split face:" << facei << " verts:" << f
+                    //    << " into quad:" << newFace << endl;
+
+                    // Get new owner/neighbour
+                    label own, nei;
+                    getFaceNeighbours
+                    (
+                        cellAnchorPoints,
+                        cellAddedCells,
+                        facei,
+                        pointi,          // Anchor point
+
+                        own,
+                        nei
+                    );
+
+
+                    if (debug)
+                    {
+                        if (mesh_.isInternalFace(facei))
+                        {
+                            label oldOwn = mesh_.faceOwner()[facei];
+                            label oldNei = mesh_.faceNeighbour()[facei];
+
+                            checkInternalOrientation
+                            (
+                                meshMod,
+                                oldOwn,
+                                facei,
+                                mesh_.cellCentres()[oldOwn],
+                                mesh_.cellCentres()[oldNei],
+                                newFace
+                            );
+                        }
+                        else
+                        {
+                            label oldOwn = mesh_.faceOwner()[facei];
+
+                            checkBoundaryOrientation
+                            (
+                                meshMod,
+                                oldOwn,
+                                facei,
+                                mesh_.cellCentres()[oldOwn],
+                                mesh_.faceCentres()[facei],
+                                newFace
+                            );
+                        }
+                    }
+
+
+                    if (!modifiedFace)
+                    {
+                        modifiedFace = true;
+
+                        modFace(meshMod, facei, newFace, own, nei);
+                    }
+                    else
+                    {
+                        addFace(meshMod, facei, newFace, own, nei);
+                    }
+                }
+            }
+
+            // Mark face as having been handled
+            affectedFace.unset(facei);
+        }
+    }
+
+
+    // 2. faces that do not get split but use edges that get split
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    if (debug)
+    {
+        Pout<< "hexRef8::setRefinement :"
+            << " Adding edge splits to unsplit faces"
+            << endl;
+    }
+
+    DynamicList<label> eFacesStorage;
+    DynamicList<label> fEdgesStorage;
+
+    forAll(edgeMidPoint, edgeI)
+    {
+        if (edgeMidPoint[edgeI] >= 0)
+        {
+            // Split edge. Check that face not already handled above.
+
+            const labelList& eFaces = mesh_.edgeFaces(edgeI, eFacesStorage);
+
+            forAll(eFaces, i)
+            {
+                label facei = eFaces[i];
+
+                if (faceMidPoint[facei] < 0 && affectedFace.get(facei))
+                {
+                    // Unsplit face. Add edge splits to face.
+
+                    const face& f = mesh_.faces()[facei];
+                    const labelList& fEdges = mesh_.faceEdges
+                    (
+                        facei,
+                        fEdgesStorage
+                    );
+
+                    DynamicList<label> newFaceVerts(f.size());
+
+                    forAll(f, fp)
+                    {
+                        newFaceVerts.append(f[fp]);
+
+                        label edgeI = fEdges[fp];
+
+                        if (edgeMidPoint[edgeI] >= 0)
+                        {
+                            newFaceVerts.append(edgeMidPoint[edgeI]);
+                        }
+                    }
+
+                    face newFace;
+                    newFace.transfer(newFaceVerts);
+
+                    // The point with the lowest level should be an anchor
+                    // point of the neighbouring cells.
+                    label anchorFp = findMinLevel(f);
+
+                    label own, nei;
+                    getFaceNeighbours
+                    (
+                        cellAnchorPoints,
+                        cellAddedCells,
+                        facei,
+                        f[anchorFp],          // Anchor point
+
+                        own,
+                        nei
+                    );
+
+
+                    if (debug)
+                    {
+                        if (mesh_.isInternalFace(facei))
+                        {
+                            label oldOwn = mesh_.faceOwner()[facei];
+                            label oldNei = mesh_.faceNeighbour()[facei];
+
+                            checkInternalOrientation
+                            (
+                                meshMod,
+                                oldOwn,
+                                facei,
+                                mesh_.cellCentres()[oldOwn],
+                                mesh_.cellCentres()[oldNei],
+                                newFace
+                            );
+                        }
+                        else
+                        {
+                            label oldOwn = mesh_.faceOwner()[facei];
+
+                            checkBoundaryOrientation
+                            (
+                                meshMod,
+                                oldOwn,
+                                facei,
+                                mesh_.cellCentres()[oldOwn],
+                                mesh_.faceCentres()[facei],
+                                newFace
+                            );
+                        }
+                    }
+
+                    modFace(meshMod, facei, newFace, own, nei);
+
+                    // Mark face as having been handled
+                    affectedFace.unset(facei);
+                }
+            }
+        }
+    }
+
+
+    // 3. faces that do not get split but whose owner/neighbour change
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    if (debug)
+    {
+        Pout<< "hexRef8::setRefinement :"
+            << " Changing owner/neighbour for otherwise unaffected faces"
+            << endl;
+    }
+
+    forAll(affectedFace, facei)
+    {
+        if (affectedFace.get(facei))
+        {
+            const face& f = mesh_.faces()[facei];
+
+            // The point with the lowest level should be an anchor
+            // point of the neighbouring cells.
+            label anchorFp = findMinLevel(f);
+
+            label own, nei;
+            getFaceNeighbours
+            (
+                cellAnchorPoints,
+                cellAddedCells,
+                facei,
+                f[anchorFp],          // Anchor point
+
+                own,
+                nei
+            );
+
+            modFace(meshMod, facei, f, own, nei);
+
+            // Mark face as having been handled
+            affectedFace.unset(facei);
+        }
+    }
+
+
+    // 4. new internal faces inside split cells.
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+
+    // This is the hard one. 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<< "hexRef8::setRefinement :"
+            << " Create new internal faces for split cells"
+            << endl;
+    }
+
+    forAll(cellMidPoint, celli)
+    {
+        if (cellMidPoint[celli] >= 0)
+        {
+            createInternalFaces
+            (
+                cellAnchorPoints,
+                cellAddedCells,
+                cellMidPoint,
+                faceMidPoint,
+                faceAnchorLevel,
+                edgeMidPoint,
+                celli,
+                meshMod
+            );
+        }
+    }
+
+    // Extend pointLevels and cellLevels for the new cells. Could also be done
+    // in updateMesh but saves passing cellAddedCells out of this routine.
+
+    // Check
+    if (debug)
+    {
+        label minPointi = labelMax;
+        label maxPointi = labelMin;
+
+        forAll(cellMidPoint, celli)
+        {
+            if (cellMidPoint[celli] >= 0)
+            {
+                minPointi = min(minPointi, cellMidPoint[celli]);
+                maxPointi = max(maxPointi, cellMidPoint[celli]);
+            }
+        }
+        forAll(faceMidPoint, facei)
+        {
+            if (faceMidPoint[facei] >= 0)
+            {
+                minPointi = min(minPointi, faceMidPoint[facei]);
+                maxPointi = max(maxPointi, faceMidPoint[facei]);
+            }
+        }
+        forAll(edgeMidPoint, edgeI)
+        {
+            if (edgeMidPoint[edgeI] >= 0)
+            {
+                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);
+        }
+    }
+
+    pointLevel_.transfer(newPointLevel);
+    cellLevel_.transfer(newCellLevel);
+
+    // Mark files as changed
+    setInstance(mesh_.facesInstance());
+
+
+    // Update the live split cells tree.
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    // New unrefinement structure
+    if (history_.active())
+    {
+        if (debug)
+        {
+            Pout<< "hexRef8::setRefinement :"
+                << " Updating refinement history to " << cellLevel_.size()
+                << " cells" << endl;
+        }
+
+        // Extend refinement history for new cells
+        history_.resize(cellLevel_.size());
+
+        forAll(cellAddedCells, celli)
+        {
+            const labelList& addedCells = cellAddedCells[celli];
+
+            if (addedCells.size())
+            {
+                // Cell was split.
+                history_.storeSplit(celli, addedCells);
+            }
+        }
+    }
+
+    // Compact cellAddedCells.
+
+    labelListList refinedCells(cellLabels.size());
+
+    forAll(cellLabels, i)
+    {
+        label celli = cellLabels[i];
+
+        refinedCells[i].transfer(cellAddedCells[celli]);
+    }
+
+    return refinedCells;
+}
+
+
+Foam::labelList Foam::hexRef8::consistentUnrefinement
+(
+    const labelList& elemsToUnrefine,
+    const bool maxSet
+) const
+{
+    if (debug)
+    {
+        Pout<< "hexRef8::consistentUnrefinement :"
+            << " Determining 2:1 consistent unrefinement" << endl;
+    }
+
+    if (maxSet)
+    {
+        FatalErrorInFunction
+            << "maxSet not implemented yet."
+            << abort(FatalError);
+    }
+
+    // For hexRef8, unrefinement is based on points
+    const labelList& pointsToUnrefine(elemsToUnrefine);
+
+    // Loop, modifying pointsToUnrefine, until no more changes to due to 2:1
+    // conflicts.
+    // maxSet = false : unselect points to refine
+    // maxSet = true: select points to refine
+
+    // Maintain boolList for pointsToUnrefine and cellsToUnrefine
+    PackedBoolList unrefinePoint(mesh_.nPoints());
+
+    forAll(pointsToUnrefine, i)
+    {
+        label pointi = pointsToUnrefine[i];
+
+        unrefinePoint.set(pointi);
+    }
+
+
+    while (true)
+    {
+        // Construct cells to unrefine
+        // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+        PackedBoolList unrefineCell(mesh_.nCells());
+
+        forAll(unrefinePoint, pointi)
+        {
+            if (unrefinePoint.get(pointi))
+            {
+                const labelList& pCells = mesh_.pointCells(pointi);
+
+                forAll(pCells, j)
+                {
+                    unrefineCell.set(pCells[j]);
+                }
+            }
+        }
+
+
+        label nChanged = 0;
+
+
+        // Check 2:1 consistency taking refinement into account
+        // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+        // Internal faces.
+        for (label facei = 0; facei < mesh_.nInternalFaces(); facei++)
+        {
+            label own = mesh_.faceOwner()[facei];
+            label ownLevel = cellLevel_[own] - unrefineCell.get(own);
+
+            label nei = mesh_.faceNeighbour()[facei];
+            label neiLevel = cellLevel_[nei] - unrefineCell.get(nei);
+
+            if (ownLevel < (neiLevel-1))
+            {
+                // Since was 2:1 this can only occur if own is marked for
+                // unrefinement.
+
+                if (maxSet)
+                {
+                    unrefineCell.set(nei);
+                }
+                else
+                {
+                    // could also combine with unset:
+                    // if (!unrefineCell.unset(own))
+                    // {
+                    //     FatalErrorInFunction
+                    //         << "problem cell already unset"
+                    //         << abort(FatalError);
+                    // }
+                    if (unrefineCell.get(own) == 0)
+                    {
+                        FatalErrorInFunction
+                            << "problem" << abort(FatalError);
+                    }
+
+                    unrefineCell.unset(own);
+                }
+                nChanged++;
+            }
+            else if (neiLevel < (ownLevel-1))
+            {
+                if (maxSet)
+                {
+                    unrefineCell.set(own);
+                }
+                else
+                {
+                    if (unrefineCell.get(nei) == 0)
+                    {
+                        FatalErrorInFunction
+                            << "problem" << abort(FatalError);
+                    }
+
+                    unrefineCell.unset(nei);
+                }
+                nChanged++;
+            }
+        }
+
+
+        // Coupled faces. Swap owner level to get neighbouring cell level.
+        labelList neiLevel(mesh_.nFaces()-mesh_.nInternalFaces());
+
+        forAll(neiLevel, i)
+        {
+            label own = mesh_.faceOwner()[i+mesh_.nInternalFaces()];
+
+            neiLevel[i] = cellLevel_[own] - unrefineCell.get(own);
+        }
+
+        // Swap to neighbour
+        syncTools::swapBoundaryFaceList(mesh_, neiLevel);
+
+        forAll(neiLevel, i)
+        {
+            label facei = i+mesh_.nInternalFaces();
+            label own = mesh_.faceOwner()[facei];
+            label ownLevel = cellLevel_[own] - unrefineCell.get(own);
+
+            if (ownLevel < (neiLevel[i]-1))
+            {
+                if (!maxSet)
+                {
+                    if (unrefineCell.get(own) == 0)
+                    {
+                        FatalErrorInFunction
+                            << "problem" << abort(FatalError);
+                    }
+
+                    unrefineCell.unset(own);
+                    nChanged++;
+                }
+            }
+            else if (neiLevel[i] < (ownLevel-1))
+            {
+                if (maxSet)
+                {
+                    if (unrefineCell.get(own) == 1)
+                    {
+                        FatalErrorInFunction
+                            << "problem" << abort(FatalError);
+                    }
+
+                    unrefineCell.set(own);
+                    nChanged++;
+                }
+            }
+        }
+
+        reduce(nChanged, sumOp<label>());
+
+        if (debug)
+        {
+            Pout<< "hexRef8::consistentUnrefinement :"
+                << " Changed " << nChanged
+                << " refinement levels due to 2:1 conflicts."
+                << endl;
+        }
+
+        if (nChanged == 0)
+        {
+            break;
+        }
+
+
+        // Convert cellsToUnrefine back into points to unrefine
+        // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+        // Knock out any point whose cell neighbour cannot be unrefined.
+        forAll(unrefinePoint, pointi)
+        {
+            if (unrefinePoint.get(pointi))
+            {
+                const labelList& pCells = mesh_.pointCells(pointi);
+
+                forAll(pCells, j)
+                {
+                    if (!unrefineCell.get(pCells[j]))
+                    {
+                        unrefinePoint.unset(pointi);
+                        break;
+                    }
+                }
+            }
+        }
+    }
+
+
+    // Convert back to labelList.
+    label nSet = 0;
+
+    forAll(unrefinePoint, pointi)
+    {
+        if (unrefinePoint.get(pointi))
+        {
+            nSet++;
+        }
+    }
+
+    labelList newPointsToUnrefine(nSet);
+    nSet = 0;
+
+    forAll(unrefinePoint, pointi)
+    {
+        if (unrefinePoint.get(pointi))
+        {
+            newPointsToUnrefine[nSet++] = pointi;
+        }
+    }
+
+    return newPointsToUnrefine;
+}
+
+void Foam::hexRef8::setUnrefinement
+(
+    const labelList& splitElemLabels,
+    polyTopoChange& meshMod
+)
+{
+    if (!history_.active())
+    {
+        FatalErrorInFunction
+            << "Only call if constructed with history capability"
+            << abort(FatalError);
+    }
+
+    // For hexRef8, unrefinement is based on points
+    const labelList& splitPointLabels(splitElemLabels);
+
+    if (debug)
+    {
+        Pout<< "hexRef8::setUnrefinement :"
+            << " Checking initial mesh just to make sure" << endl;
+
+        checkMesh();
+
+        forAll(cellLevel_, celli)
+        {
+            if (cellLevel_[celli] < 0)
+            {
+                FatalErrorInFunction
+                    << "Illegal cell level " << cellLevel_[celli]
+                    << " for cell " << celli
+                    << abort(FatalError);
+            }
+        }
+
+
+        // Write to sets.
+        pointSet pSet(mesh_, "splitPoints", splitPointLabels);
+        pSet.write();
+
+        cellSet cSet(mesh_, "splitPointCells", splitPointLabels.size());
+
+        forAll(splitPointLabels, i)
+        {
+            const labelList& pCells = mesh_.pointCells(splitPointLabels[i]);
+
+            forAll(pCells, j)
+            {
+                cSet.insert(pCells[j]);
+            }
+        }
+        cSet.write();
+
+        Pout<< "hexRef8::setRefinement : Dumping " << pSet.size()
+            << " points and "
+            << cSet.size() << " cells for unrefinement to" << nl
+            << "    pointSet " << pSet.objectPath() << nl
+            << "    cellSet " << cSet.objectPath()
+            << endl;
+    }
+
+
+    labelList cellRegion;
+    labelList cellRegionMaster;
+    labelList facesToRemove;
+
+    {
+        labelHashSet splitFaces(12*splitPointLabels.size());
+
+        forAll(splitPointLabels, i)
+        {
+            const labelList& pFaces = mesh_.pointFaces()[splitPointLabels[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,         // per cell -1 or region it is merged into
+            cellRegionMaster,   // per region the master cell
+            facesToRemove       // new faces to be removed.
+        );
+
+        if (facesToRemove.size() != splitFaces.size())
+        {
+            FatalErrorInFunction
+                << "Ininitial set of split points to unrefine does not"
+                << " seem to be consistent or not mid points of refined cells"
+                << abort(FatalError);
+        }
+    }
+
+    // Redo the region master so it is consistent with our master.
+    // This will guarantee that the new cell (for which faceRemover uses
+    // the region master) is already compatible with our refinement structure.
+
+    forAll(splitPointLabels, i)
+    {
+        label pointi = splitPointLabels[i];
+
+        // Get original cell label
+
+        const labelList& pCells = mesh_.pointCells(pointi);
+
+        // Check
+        if (pCells.size() != 8)
+        {
+            FatalErrorInFunction
+                << "splitPoint " << pointi
+                << " should have 8 cells using it. It has " << pCells
+                << abort(FatalError);
+        }
+
+
+        // Check that the lowest numbered pCells is the master of the region
+        // (should be guaranteed by directRemoveFaces)
+        //if (debug)
+        {
+            label masterCelli = min(pCells);
+
+            forAll(pCells, j)
+            {
+                label celli = pCells[j];
+
+                label region = cellRegion[celli];
+
+                if (region == -1)
+                {
+                    FatalErrorInFunction
+                        << "Ininitial set of split points to unrefine does not"
+                        << " seem to be consistent or not mid points"
+                        << " of refined cells" << nl
+                        << "cell:" << celli << " on splitPoint " << pointi
+                        << " has no region to be merged into"
+                        << abort(FatalError);
+                }
+
+                if (masterCelli != cellRegionMaster[region])
+                {
+                    FatalErrorInFunction
+                        << "cell:" << celli << " on splitPoint:" << pointi
+                        << " in region " << region
+                        << " has master:" << cellRegionMaster[region]
+                        << " which is not the lowest numbered cell"
+                        << " among the pointCells:" << pCells
+                        << abort(FatalError);
+                }
+            }
+        }
+    }
+
+    // Insert all commands to combine cells. Never fails so don't have to
+    // test for success.
+    faceRemover_.setRefinement
+    (
+        facesToRemove,
+        cellRegion,
+        cellRegionMaster,
+        meshMod
+    );
+
+    // Remove the 8 cells that originated from merging around the split point
+    // and adapt cell levels (not that pointLevels stay the same since points
+    // either get removed or stay at the same position.
+    forAll(splitPointLabels, i)
+    {
+        label pointi = splitPointLabels[i];
+
+        const labelList& pCells = mesh_.pointCells(pointi);
+
+        label masterCelli = min(pCells);
+
+        forAll(pCells, j)
+        {
+            cellLevel_[pCells[j]]--;
+        }
+
+        history_.combineCells(masterCelli, pCells);
+    }
+
+    // Mark files as changed
+    setInstance(mesh_.facesInstance());
+
+    // history_.updateMesh will take care of truncating.
+}
+
+void Foam::hexRef8::calcFaceToSplitPoint
+(
+    const labelList& splitElems,
+    Map<label>& faceToSplitPoint
+)
+{
+    // Save information on faces that will be combined
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    // For hexRef8, the split elems are points
+    const labelList& splitPoints(splitElems);
+
+    faceToSplitPoint.resize(3*splitElems.size());
+
+    {
+        forAll(splitPoints, i)
+        {
+            label pointi = splitPoints[i];
+
+            const labelList& pEdges = mesh_.pointEdges()[pointi];
+
+            forAll(pEdges, j)
+            {
+                label otherPointi = mesh_.edges()[pEdges[j]].otherVertex(pointi);
+
+                const labelList& pFaces = mesh_.pointFaces()[otherPointi];
+
+                forAll(pFaces, pFacei)
+                {
+                    faceToSplitPoint.insert(pFaces[pFacei], otherPointi);
+                }
+            }
+        }
+    }
+}
+
+
+Foam::labelList Foam::hexRef8::getSplitElems() const
+{
+    if (debug)
+    {
+        checkRefinementLevels(-1, labelList(0));
+    }
+
+    if (debug)
+    {
+        Pout<< "hexRef8::getSplitPoints :"
+            << " Calculating unrefineable points" << endl;
+    }
+
+
+    if (!history_.active())
+    {
+        FatalErrorInFunction
+            << "Only call if constructed with history capability"
+            << abort(FatalError);
+    }
+
+    // Master cell
+    // -1 undetermined
+    // -2 certainly not split point
+    // >= label of master cell
+    labelList splitMaster(mesh_.nPoints(), -1);
+    labelList splitMasterLevel(mesh_.nPoints(), 0);
+
+    // Unmark all with not 8 cells
+    //const labelListList& pointCells = mesh_.pointCells();
+
+    for (label pointi = 0; pointi < mesh_.nPoints(); pointi++)
+    {
+        const labelList& pCells = mesh_.pointCells(pointi);
+
+        if (pCells.size() != 8)
+        {
+            splitMaster[pointi] = -2;
+        }
+    }
+
+    // Unmark all with different master cells
+    const labelList& visibleCells = history_.visibleCells();
+
+    forAll(visibleCells, celli)
+    {
+        const labelList& cPoints = mesh_.cellPoints(celli);
+
+        if (visibleCells[celli] != -1 && history_.parentIndex(celli) >= 0)
+        {
+            label parentIndex = history_.parentIndex(celli);
+
+            // Check same master.
+            forAll(cPoints, i)
+            {
+                label pointi = cPoints[i];
+
+                label masterCelli = splitMaster[pointi];
+
+                if (masterCelli == -1)
+                {
+                    // First time visit of point. Store parent cell and
+                    // level of the parent cell (with respect to celli). This
+                    // is additional guarantee that we're referring to the
+                    // same master at the same refinement level.
+
+                    splitMaster[pointi] = parentIndex;
+                    splitMasterLevel[pointi] = cellLevel_[celli] - 1;
+                }
+                else if (masterCelli == -2)
+                {
+                    // Already decided that point is not splitPoint
+                }
+                else if
+                (
+                    (masterCelli != parentIndex)
+                 || (splitMasterLevel[pointi] != cellLevel_[celli] - 1)
+                )
+                {
+                    // Different masters so point is on two refinement
+                    // patterns
+                    splitMaster[pointi] = -2;
+                }
+            }
+        }
+        else
+        {
+            // Either not visible or is unrefined cell
+            forAll(cPoints, i)
+            {
+                label pointi = cPoints[i];
+
+                splitMaster[pointi] = -2;
+            }
+        }
+    }
+
+    // Unmark boundary faces
+    for
+    (
+        label facei = mesh_.nInternalFaces();
+        facei < mesh_.nFaces();
+        facei++
+    )
+    {
+        const face& f = mesh_.faces()[facei];
+
+        forAll(f, fp)
+        {
+            splitMaster[f[fp]] = -2;
+        }
+    }
+
+
+    // Collect into labelList
+
+    label nSplitPoints = 0;
+
+    forAll(splitMaster, pointi)
+    {
+        if (splitMaster[pointi] >= 0)
+        {
+            nSplitPoints++;
+        }
+    }
+
+    labelList splitPoints(nSplitPoints);
+    nSplitPoints = 0;
+
+    forAll(splitMaster, pointi)
+    {
+        if (splitMaster[pointi] >= 0)
+        {
+            splitPoints[nSplitPoints++] = pointi;
+        }
+    }
+
+    return splitPoints;
+}
+
+
+Foam::labelList Foam::hexRef8::selectUnrefineElems
+(
+    const scalar unrefineLevel,
+    const PackedBoolList& markedCell,
+    const scalarField& pFld
+) const
+{
+    // All points that can be unrefined
+    const labelList splitPoints(getSplitElems());
+
+    DynamicList<label> newSplitPoints(splitPoints.size());
+
+    forAll(splitPoints, i)
+    {
+        label pointi = splitPoints[i];
+
+        if (pFld[pointi] < unrefineLevel)
+        {
+            // Check that all cells are not marked
+            const labelList& pCells = mesh_.pointCells()[pointi];
+
+            bool hasMarked = false;
+
+            forAll(pCells, pCelli)
+            {
+                if (markedCell.get(pCells[pCelli]))
+                {
+                    hasMarked = true;
+                    break;
+                }
+            }
+
+            if (!hasMarked)
+            {
+                newSplitPoints.append(pointi);
+            }
+        }
+    }
+
+
+    newSplitPoints.shrink();
+
+    // Guarantee 2:1 refinement after unrefinement
+    labelList consistentSet
+    (
+        consistentUnrefinement
+        (
+            newSplitPoints,
+            false
+        )
+    );
+    Info<< "Selected " << returnReduce(consistentSet.size(), sumOp<label>())
+        << " split points out of a possible "
+        << returnReduce(splitPoints.size(), sumOp<label>())
+        << "." << endl;
+
+    return consistentSet;
+}
+
+// ************************************************************************* //
diff --git a/AMR_tidy/hexRef/hexRef8/hexRef8.H b/AMR_tidy/hexRef/hexRef8/hexRef8.H
new file mode 100644
index 00000000..c953b2bf
--- /dev/null
+++ b/AMR_tidy/hexRef/hexRef8/hexRef8.H
@@ -0,0 +1,234 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::hexRef8
+
+Description
+    Refinement of (split) hexes using polyTopoChange.
+
+SourceFiles
+    hexRef8.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef hexRef8_H
+#define hexRef8_H
+
+#include "hexRef.H"
+
+#include "addToRunTimeSelectionTable.H"
+
+#include "polyMesh.H"
+#include "polyTopoChange.H"
+#include "meshTools.H"
+#include "polyAddFace.H"
+#include "polyAddPoint.H"
+#include "polyAddCell.H"
+#include "polyModifyFace.H"
+#include "syncTools.H"
+#include "faceSet.H"
+#include "cellSet.H"
+#include "pointSet.H"
+#include "OFstream.H"
+#include "Time.H"
+#include "FaceCellWave.H"
+#include "mapDistributePolyMesh.H"
+#include "refinementData.H"
+#include "refinementDistanceData.H"
+#include "degenerateMatcher.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                           Class hexRef8 Declaration
+\*---------------------------------------------------------------------------*/
+
+class hexRef8 : public hexRef
+{
+
+protected:
+
+        //- 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;
+
+        //- Store in maps correspondence from midpoint to anchors and faces.
+        label storeMidPointInfo
+        (
+            const labelListList& cellAnchorPoints,
+            const labelListList& cellAddedCells,
+            const labelList& cellMidPoint,
+            const labelList& faceMidPoint,
+            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,
+            polyTopoChange& meshMod
+        ) const;
+
+        //- Create all internal faces to split celli into 8.
+        void createInternalFaces
+        (
+            const labelListList& cellAnchorPoints,
+            const labelListList& cellAddedCells,
+            const labelList& cellMidPoint,
+            const labelList& faceMidPoint,
+            const labelList& faceAnchorLevel,
+            const labelList& edgeMidPoint,
+            const label celli,
+            polyTopoChange& meshMod
+        ) const;
+
+        //- Disallow default bitwise copy construct
+        hexRef8(const hexRef8&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const hexRef8&);
+
+
+public:
+
+    //- Runtime type information
+    TypeName("hexRef8");
+
+
+    // Constructors
+
+        //- Construct from mesh, read_if_present refinement data
+        //  (from write below). If readHistory is true does read_if_present
+        //  of refinement history. If false clears all history
+        hexRef8(const polyMesh& mesh, const bool readHistory = true);
+
+        //- Construct from mesh and un/refinement data and optional size of
+        //  starting cells
+        hexRef8
+        (
+            const polyMesh& mesh,
+            const labelList& cellLevel,
+            const labelList& pointLevel,
+            const refinementHistory& history,
+            const scalar level0Edge = -GREAT
+        );
+
+        //- Construct from mesh and refinement data and optional size of
+        //  starting cells
+        hexRef8
+        (
+            const polyMesh& mesh,
+            const labelList& cellLevel,
+            const labelList& pointLevel,
+            const scalar level0Edge = -GREAT
+        );
+
+
+    // Member Functions
+
+
+        // Refinement
+
+            //- Insert refinement. All selected cells will be split into 8.
+            //  Returns per element in cells the 8 cells they were split into.
+            //  Guarantees that the 0th element is the original cell label.
+            //  Mapping:
+            //  -split cells: 7 new ones get added from original
+            //  -split faces: original gets modified; 3 new ones get added
+            //               from original
+            //  -added internal faces: added from original cell face(if
+            //   that was internal) or created out-of-nothing (so will not
+            //   get mapped!). Note: could make this inflate from point but
+            //   that will allocate interpolation.
+            //  -points added to split edge: added from edge start()
+            //  -midpoints added: added from cellPoints[0].
+            labelListList setRefinement
+            (
+                const labelList& cells,
+                polyTopoChange&
+            );
+
+
+        // Unrefinement
+            //- Return the mid elems in top-level split cells
+            //  that can be unsplit.
+            labelList getSplitElems() const;
+
+            //- Given proposed
+            //  splitElems to unrefine according to calculate any clashes
+            //  (due to 2:1) and return ok list of mid elems to unrefine.
+            labelList consistentUnrefinement
+            (
+                const labelList& elemsToUnrefine,
+                const bool maxSet
+            ) const;
+
+            //- Remove some refinement. Needs to be supplied output of
+            //  consistentUnrefinement. Only call if undoable set.
+            //  All n edgeCells of a split edge will be combined into
+            //  the lowest numbered cell of those n.
+            void setUnrefinement
+            (
+                const labelList& splitElemLabels,
+                polyTopoChange&
+            );
+
+            labelList selectUnrefineElems
+            (
+                const scalar unrefineLevel,
+                const PackedBoolList& markedCell,
+                const scalarField& vFld
+            ) const;
+
+            void calcFaceToSplitPoint
+            (
+                const labelList& splitElems,
+                Map<label>& faceToSplitPoint
+            );
+
+
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/AMR_tidy/hexRef/hexRefData.C b/AMR_tidy/hexRef/hexRefData.C
new file mode 100644
index 00000000..1b1045e9
--- /dev/null
+++ b/AMR_tidy/hexRef/hexRefData.C
@@ -0,0 +1,343 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2015-2016 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "IOobject.H"
+#include "UList.H"
+
+#include "hexRefData.H"
+#include "mapPolyMesh.H"
+#include "mapDistributePolyMesh.H"
+#include "polyMesh.H"
+#include "syncTools.H"
+#include "refinementHistory.H"
+#include "fvMesh.H"
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::hexRef8Data::hexRef8Data(const IOobject& io)
+{
+    {
+        IOobject rio(io);
+        rio.rename("cellLevel");
+        // bool haveFile = returnReduce(rio.headerOk(), orOp<bool>());
+        bool haveFile = returnReduce(rio.typeHeaderOk<labelIOList>(), orOp<bool>());
+        if (haveFile)
+        {
+            Info<< "Reading hexRef data : " << rio.name() << endl;
+            cellLevelPtr_.reset(new labelIOList(rio));
+        }
+    }
+    {
+        IOobject rio(io);
+        rio.rename("pointLevel");
+        // bool haveFile = returnReduce(rio.headerOk(), orOp<bool>());
+        bool haveFile = returnReduce(rio.typeHeaderOk<labelIOList>(), orOp<bool>());
+        if (haveFile)
+        {
+            Info<< "Reading hexRef data : " << rio.name() << endl;
+            pointLevelPtr_.reset(new labelIOList(rio));
+        }
+    }
+    {
+        IOobject rio(io);
+        rio.rename("level0Edge");
+        // bool haveFile = returnReduce(rio.headerOk(), orOp<bool>());
+        bool haveFile = returnReduce(rio.typeHeaderOk<labelIOList>(), orOp<bool>());
+        if (haveFile)
+        {
+            Info<< "Reading hexRef data : " << rio.name() << endl;
+            level0EdgePtr_.reset(new uniformDimensionedScalarField(rio));
+        }
+    }
+    {
+        IOobject rio(io);
+        rio.rename("refinementHistory");
+        // bool haveFile = returnReduce(rio.headerOk(), orOp<bool>());
+        bool haveFile = returnReduce(rio.typeHeaderOk<labelIOList>(), orOp<bool>());
+        if (haveFile)
+        {
+            Info<< "Reading hexRef data : " << rio.name() << endl;
+            refHistoryPtr_.reset(new refinementHistory(rio));
+        }
+    }
+}
+
+
+Foam::hexRef8Data::hexRef8Data
+(
+    const IOobject& io,
+    const hexRef8Data& data,
+    const labelList& cellMap,
+    const labelList& pointMap
+)
+{
+    if (data.cellLevelPtr_.valid())
+    {
+        IOobject rio(io);
+        rio.rename(data.cellLevelPtr_().name());
+
+        cellLevelPtr_.reset
+        (
+            new labelIOList
+            (
+                rio,
+                UIndirectList<label>(data.cellLevelPtr_(), cellMap)()
+            )
+        );
+    }
+    if (data.pointLevelPtr_.valid())
+    {
+        IOobject rio(io);
+        rio.rename(data.pointLevelPtr_().name());
+
+        pointLevelPtr_.reset
+        (
+            new labelIOList
+            (
+                rio,
+                UIndirectList<label>(data.pointLevelPtr_(), pointMap)()
+            )
+        );
+    }
+    if (data.level0EdgePtr_.valid())
+    {
+        IOobject rio(io);
+        rio.rename(data.level0EdgePtr_().name());
+
+        level0EdgePtr_.reset
+        (
+            new uniformDimensionedScalarField(rio, data.level0EdgePtr_())
+        );
+    }
+    if (data.refHistoryPtr_.valid())
+    {
+        IOobject rio(io);
+        rio.rename(data.refHistoryPtr_().name());
+
+        refHistoryPtr_ = data.refHistoryPtr_().clone(rio, cellMap);
+    }
+}
+
+
+Foam::hexRef8Data::hexRef8Data
+(
+    const IOobject& io,
+    const UPtrList<const labelList>& cellMaps,
+    const UPtrList<const labelList>& pointMaps,
+    const UPtrList<const hexRef8Data>& procDatas
+)
+{
+    const polyMesh& mesh = dynamic_cast<const polyMesh&>(io.db());
+
+    // cellLevel
+
+    if (procDatas[0].cellLevelPtr_.valid())
+    {
+        IOobject rio(io);
+        rio.rename(procDatas[0].cellLevelPtr_().name());
+
+        cellLevelPtr_.reset(new labelIOList(rio, mesh.nCells()));
+        labelList& cellLevel = cellLevelPtr_();
+
+        forAll(procDatas, procI)
+        {
+            const labelList& procCellLevel = procDatas[procI].cellLevelPtr_();
+            UIndirectList<label>(cellLevel, cellMaps[procI]) = procCellLevel;
+        }
+    }
+
+
+    // pointLevel
+
+    if (procDatas[0].pointLevelPtr_.valid())
+    {
+        IOobject rio(io);
+        rio.rename(procDatas[0].pointLevelPtr_().name());
+
+        pointLevelPtr_.reset(new labelIOList(rio, mesh.nPoints()));
+        labelList& pointLevel = pointLevelPtr_();
+
+        forAll(procDatas, procI)
+        {
+            const labelList& procPointLevel = procDatas[procI].pointLevelPtr_();
+            UIndirectList<label>(pointLevel, pointMaps[procI]) = procPointLevel;
+        }
+    }
+
+
+    // level0Edge
+
+    if (procDatas[0].level0EdgePtr_.valid())
+    {
+        IOobject rio(io);
+        rio.rename(procDatas[0].level0EdgePtr_().name());
+
+        level0EdgePtr_.reset
+        (
+            new uniformDimensionedScalarField
+            (
+                rio,
+                procDatas[0].level0EdgePtr_()
+            )
+        );
+    }
+
+
+    // refinementHistory
+
+    if (procDatas[0].refHistoryPtr_.valid())
+    {
+        IOobject rio(io);
+        rio.rename(procDatas[0].refHistoryPtr_().name());
+
+        UPtrList<const refinementHistory> procRefs(procDatas.size());
+        forAll(procDatas, i)
+        {
+            procRefs.set(i, &procDatas[i].refHistoryPtr_());
+        }
+
+        refHistoryPtr_.reset
+        (
+            new refinementHistory
+            (
+                rio,
+                cellMaps,
+                procRefs
+            )
+        );
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::hexRef8Data::~hexRef8Data()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+void Foam::hexRef8Data::sync(const IOobject& io)
+{
+    const polyMesh& mesh = dynamic_cast<const polyMesh&>(io.db());
+
+    bool hasCellLevel = returnReduce(cellLevelPtr_.valid(), orOp<bool>());
+    if (hasCellLevel && !cellLevelPtr_.valid())
+    {
+        IOobject rio(io);
+        rio.rename("cellLevel");
+        rio.readOpt() = IOobject::NO_READ;
+        cellLevelPtr_.reset(new labelIOList(rio, labelList(mesh.nCells(), 0)));
+    }
+
+    bool hasPointLevel = returnReduce(pointLevelPtr_.valid(), orOp<bool>());
+    if (hasPointLevel && !pointLevelPtr_.valid())
+    {
+        IOobject rio(io);
+        rio.rename("pointLevel");
+        rio.readOpt() = IOobject::NO_READ;
+        pointLevelPtr_.reset
+        (
+            new labelIOList(rio, labelList(mesh.nPoints(), 0))
+        );
+    }
+
+    bool hasLevel0Edge = returnReduce(level0EdgePtr_.valid(), orOp<bool>());
+    if (hasLevel0Edge)
+    {
+        // Get master length
+        scalar masterLen = level0EdgePtr_().value();
+        Pstream::scatter(masterLen);
+        if (!level0EdgePtr_.valid())
+        {
+            IOobject rio(io);
+            rio.rename("level0Edge");
+            rio.readOpt() = IOobject::NO_READ;
+            level0EdgePtr_.reset
+            (
+                new uniformDimensionedScalarField
+                (
+                    rio,
+                    dimensionedScalar("zero", dimLength, masterLen)
+                )
+            );
+        }
+    }
+
+    bool hasHistory = returnReduce(refHistoryPtr_.valid(), orOp<bool>());
+    if (hasHistory && !refHistoryPtr_.valid())
+    {
+        IOobject rio(io);
+        rio.rename("refinementHistory");
+        rio.readOpt() = IOobject::NO_READ;
+        refHistoryPtr_.reset(new refinementHistory(rio, mesh.nCells(), true));
+    }
+}
+
+
+void Foam::hexRef8Data::distribute(const mapDistributePolyMesh& map)
+{
+    if (cellLevelPtr_.valid())
+    {
+        map.cellMap().distribute(cellLevelPtr_());
+    }
+    if (pointLevelPtr_.valid())
+    {
+        map.pointMap().distribute(pointLevelPtr_());
+    }
+
+    // No need to distribute the level0Edge
+
+    if (refHistoryPtr_.valid() && refHistoryPtr_().active())
+    {
+        refHistoryPtr_().distribute(map);
+    }
+}
+
+
+bool Foam::hexRef8Data::write() const
+{
+    bool ok = true;
+    if (cellLevelPtr_.valid())
+    {
+        ok = ok && cellLevelPtr_().write();
+    }
+    if (pointLevelPtr_.valid())
+    {
+        ok = ok && pointLevelPtr_().write();
+    }
+    if (level0EdgePtr_.valid())
+    {
+        ok = ok && level0EdgePtr_().write();
+    }
+    if (refHistoryPtr_.valid())
+    {
+        ok = ok && refHistoryPtr_().write();
+    }
+    return ok;
+}
+
+
+// ************************************************************************* //
diff --git a/AMR_tidy/hexRef/hexRefData.H b/AMR_tidy/hexRef/hexRefData.H
new file mode 100644
index 00000000..b8f1272d
--- /dev/null
+++ b/AMR_tidy/hexRef/hexRefData.H
@@ -0,0 +1,137 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2015-2016 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::hexRef8Data
+
+Description
+    Various for reading/decomposing/reconstructing/distributing refinement
+    data.
+
+SourceFiles
+    hexRef8Data.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef hexRef8Data_H
+#define hexRef8Data_H
+
+#include "labelIOList.H"
+#include "uniformDimensionedFields.H"
+#include "UPtrList.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// Forward declaration of classes
+class mapPolyMesh;
+class mapDistributePolyMesh;
+class refinementHistory;
+class fvMesh;
+
+/*---------------------------------------------------------------------------*\
+                           Class hexRef8Data Declaration
+\*---------------------------------------------------------------------------*/
+
+class hexRef8Data
+{
+
+private:
+
+    // Private data
+
+        autoPtr<labelIOList> cellLevelPtr_;
+
+        autoPtr<labelIOList> pointLevelPtr_;
+
+        autoPtr<uniformDimensionedScalarField> level0EdgePtr_;
+
+        autoPtr<refinementHistory> refHistoryPtr_;
+
+
+    // Private Member Functions
+
+        //- Disallow default bitwise copy construct
+        hexRef8Data(const hexRef8Data&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const hexRef8Data&);
+
+
+public:
+
+    // Constructors
+
+        //- Construct read. Has special provision for only some processors
+        //  having the files so can be used in redistribution.
+        hexRef8Data(const IOobject& io);
+
+        //- Construct as subset
+        hexRef8Data
+        (
+            const IOobject& io,
+            const hexRef8Data&,
+            const labelList& cellMap,
+            const labelList& pointMap
+        );
+
+        //- Construct from multiple hexRef8Data
+        hexRef8Data
+        (
+            const IOobject& io,
+            const UPtrList<const labelList>& cellMaps,
+            const UPtrList<const labelList>& pointMaps,
+            const UPtrList<const hexRef8Data>&
+        );
+
+
+    //- Destructor
+    ~hexRef8Data();
+
+
+    // Member Functions
+
+        //- Parallel synchronise. This enforces valid objects on all processors
+        //  (even if they don't have a mesh). Used by redistributePar.
+        void sync(const IOobject& io);
+
+        //- In-place distribute
+        void distribute(const mapDistributePolyMesh&);
+
+        //- Write
+        bool write() const;
+};
+
+typedef hexRef8Data hexRefData;
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/AMR_tidy/hexRef/hexRefNew.C b/AMR_tidy/hexRef/hexRefNew.C
new file mode 100644
index 00000000..369442d5
--- /dev/null
+++ b/AMR_tidy/hexRef/hexRefNew.C
@@ -0,0 +1,198 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2015 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "hexRef.H"
+
+#include "polyMesh.H"
+#include "autoPtr.H"
+#include "runTimeSelectionTables.H"
+
+// * * * * * * * * * * * * * * * * Selectors * * * * * * * * * * * * * * * * //
+
+Foam::autoPtr<Foam::hexRef> Foam::hexRef::New
+(
+    const polyMesh& mesh,
+    const bool readHistory
+)
+{
+    word hexRefTypeName;
+
+    // Infer the type of hexRef we need to use from the number of dimensions in
+    // the polymesh
+    // nSolutionD == 3 && nGeometricD == 3: 3D mesh => hexRef8
+    // nSolutionD == 3 && nGeometricD == 2: axisymmetric mesh => hexRef4Axi
+    // nSolutionD == 2 && nGeometricD == 2: 2D mesh => hexRef4
+    // nSolutionD == 1 && nGeometricD == 1: 1D mesh => hexRef2
+
+    label nSoluD(mesh.nSolutionD());
+    label nGeomD(mesh.nGeometricD());
+
+    if (nSoluD == 3 && nGeomD == 3)
+    {
+        hexRefTypeName = "hexRef8";
+    }
+    else if (nSoluD == 3 && nGeomD == 2)
+    {
+        hexRefTypeName = "hexRef4Axi";
+    }
+    else if (nSoluD == 2 && nGeomD == 2)
+    {
+        hexRefTypeName = "hexRef4";
+    }
+    else if (nSoluD == 1 && nGeomD == 1)
+    {
+        hexRefTypeName = "hexRef2";
+    }
+
+    meshConstructorTable::iterator hexRefIter =
+        meshConstructorTablePtr_->find(hexRefTypeName);
+
+    if (hexRefIter == meshConstructorTablePtr_->end())
+    {
+        FatalErrorInFunction
+            << "Unsupported mesh number of dimensions for hex refinement" << nl
+            << "nSolutionD: " << nSoluD << ", nGeometricD: " << nGeomD << nl
+            << "Only 3D, 2D, 1D and 2D axisymmetric mesh refinements are supported"
+            << exit(FatalError);
+    }
+
+    return autoPtr<hexRef>
+    (
+        hexRefIter()(mesh, readHistory)
+    );
+}
+
+Foam::autoPtr<Foam::hexRef> Foam::hexRef::New
+(
+    const polyMesh& mesh,
+    const labelList& cellLevel,
+    const labelList& pointLevel,
+    const refinementHistory& history,
+    const scalar level0Edge
+)
+{
+    word hexRefTypeName;
+
+    // Infer the type of hexRef we need to use from the number of dimensions in
+    // the polymesh
+    // nSolutionD == 3 && nGeometricD == 3: 3D mesh => hexRef8
+    // nSolutionD == 3 && nGeometricD == 2: axisymmetric mesh => hexRef4Axi
+    // nSolutionD == 2 && nGeometricD == 2: 2D mesh => hexRef4
+    // nSolutionD == 1 && nGeometricD == 1: 1D mesh => hexRef2
+
+    label nSoluD(mesh.nSolutionD());
+    label nGeomD(mesh.nGeometricD());
+
+    if (nSoluD == 3 && nGeomD == 3)
+    {
+        hexRefTypeName = "hexRef8";
+    }
+    else if (nSoluD == 3 && nGeomD == 2)
+    {
+        hexRefTypeName = "hexRef4Axi";
+    }
+    else if (nSoluD == 2 && nGeomD == 2)
+    {
+        hexRefTypeName = "hexRef4";
+    }
+    else if (nSoluD == 1 && nGeomD == 1)
+    {
+        hexRefTypeName = "hexRef2";
+    }
+
+    levelsHistConstructorTable::iterator hexRefIter =
+        levelsHistConstructorTablePtr_->find(hexRefTypeName);
+
+    if (hexRefIter == levelsHistConstructorTablePtr_->end())
+    {
+        FatalErrorInFunction
+            << "Unsupported mesh number of dimensions for hex refinement" << nl
+            << "nSolutionD: " << nSoluD << ", nGeometricD: " << nGeomD << nl
+            << "Only 3D, 2D, 1D and 2D axisymmetric mesh refinements are supported"
+            << exit(FatalError);
+    }
+
+    return autoPtr<hexRef>
+    (
+        hexRefIter()(mesh, cellLevel, pointLevel, history, level0Edge)
+    );
+}
+
+Foam::autoPtr<Foam::hexRef> Foam::hexRef::New
+(
+    const polyMesh& mesh,
+    const labelList& cellLevel,
+    const labelList& pointLevel,
+    const scalar level0Edge
+)
+{
+    word hexRefTypeName;
+
+    // Infer the type of hexRef we need to use from the number of dimensions in
+    // the polymesh
+    // nSolutionD == 3 && nGeometricD == 3: 3D mesh => hexRef8
+    // nSolutionD == 3 && nGeometricD == 2: axisymmetric mesh => hexRef4Axi
+    // nSolutionD == 2 && nGeometricD == 2: 2D mesh => hexRef4
+    // nSolutionD == 1 && nGeometricD == 1: 1D mesh => hexRef2
+
+    label nSoluD(mesh.nSolutionD());
+    label nGeomD(mesh.nGeometricD());
+
+    if (nSoluD == 3 && nGeomD == 3)
+    {
+        hexRefTypeName = "hexRef8";
+    }
+    else if (nSoluD == 3 && nGeomD == 2)
+    {
+        hexRefTypeName = "hexRef4Axi";
+    }
+    else if (nSoluD == 2 && nGeomD == 2)
+    {
+        hexRefTypeName = "hexRef4";
+    }
+    else if (nSoluD == 1 && nGeomD == 1)
+    {
+        hexRefTypeName = "hexRef2";
+    }
+
+    levelsConstructorTable::iterator hexRefIter =
+        levelsConstructorTablePtr_->find(hexRefTypeName);
+
+    if (hexRefIter == levelsConstructorTablePtr_->end())
+    {
+        FatalErrorInFunction
+            << "Unsupported mesh number of dimensions for hex refinement" << nl
+            << "nSolutionD: " << nSoluD << ", nGeometricD: " << nGeomD << nl
+            << "Only 3D, 2D, 1D and 2D axisymmetric mesh refinements are supported"
+            << exit(FatalError);
+    }
+
+    return autoPtr<hexRef>
+    (
+        hexRefIter()(mesh, cellLevel, pointLevel, level0Edge)
+    );
+}
+
+// ************************************************************************* //
diff --git a/AMR_tidy/hexRef/refinementHistory.C b/AMR_tidy/hexRef/refinementHistory.C
new file mode 100644
index 00000000..a72a64a7
--- /dev/null
+++ b/AMR_tidy/hexRef/refinementHistory.C
@@ -0,0 +1,1793 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2017 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "refinementHistory.H"
+#include "mapPolyMesh.H"
+#include "mapDistributePolyMesh.H"
+#include "polyMesh.H"
+#include "syncTools.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(refinementHistory, 0);
+}
+
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+void Foam::refinementHistory::writeEntry
+(
+    const List<splitCell8>& splitCells,
+    const splitCell8& split
+)
+{
+    // Write me:
+    if (split.addedCellsPtr_.valid())
+    {
+        Pout<< "parent:" << split.parent_
+            << " subCells:" << split.addedCellsPtr_()
+            << endl;
+    }
+    else
+    {
+        Pout<< "parent:" << split.parent_
+            << " no subcells"
+            << endl;
+    }
+
+    if (split.parent_ >= 0)
+    {
+        Pout<< "parent data:" << endl;
+        // Write my parent
+        string oldPrefix = Pout.prefix();
+        Pout.prefix() = "  " + oldPrefix;
+        writeEntry(splitCells, splitCells[split.parent_]);
+        Pout.prefix() = oldPrefix;
+    }
+}
+
+
+void Foam::refinementHistory::writeDebug
+(
+    const labelList& visibleCells,
+    const List<splitCell8>& splitCells
+)
+{
+    string oldPrefix = Pout.prefix();
+    Pout.prefix() = "";
+
+    forAll(visibleCells, celli)
+    {
+        label index = visibleCells[celli];
+
+        if (index >= 0)
+        {
+            Pout<< "Cell from refinement:" << celli << " index:" << index
+                << endl;
+
+            string oldPrefix = Pout.prefix();
+            Pout.prefix() = "  " + oldPrefix;
+            writeEntry(splitCells, splitCells[index]);
+            Pout.prefix() = oldPrefix;
+        }
+        else
+        {
+            Pout<< "Unrefined cell:" << celli << " index:" << index << endl;
+        }
+    }
+    Pout.prefix() = oldPrefix;
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::refinementHistory::splitCell8::splitCell8()
+:
+    parent_(-1),
+    addedCellsPtr_(nullptr)
+{}
+
+
+Foam::refinementHistory::splitCell8::splitCell8(const label parent)
+:
+    parent_(parent),
+    addedCellsPtr_(nullptr)
+{}
+
+
+Foam::refinementHistory::splitCell8::splitCell8(Istream& is)
+{
+    is >> *this;
+}
+
+
+Foam::refinementHistory::splitCell8::splitCell8(const splitCell8& sc)
+:
+    parent_(sc.parent_),
+    addedCellsPtr_
+    (
+        sc.addedCellsPtr_.valid()
+      ? new FixedList<label, 8>(sc.addedCellsPtr_())
+      : nullptr
+    )
+{}
+
+
+// * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * * //
+
+void Foam::refinementHistory::splitCell8::operator=(const splitCell8& s)
+{
+    //- Assignment operator since autoPtr otherwise 'steals' storage.
+
+    // Check for assignment to self
+    if (this == &s)
+    {
+        FatalErrorIn("splitCell8::operator=(const Foam::splitCell8&)")
+            << "Attempted assignment to self"
+            << abort(FatalError);
+    }
+
+    parent_ = s.parent_;
+
+    addedCellsPtr_.reset
+    (
+        s.addedCellsPtr_.valid()
+      ? new FixedList<label, 8>(s.addedCellsPtr_())
+      : nullptr
+    );
+}
+
+
+bool Foam::refinementHistory::splitCell8::operator==(const splitCell8& s) const
+{
+    if (addedCellsPtr_.valid() != s.addedCellsPtr_.valid())
+    {
+        return false;
+    }
+    else if (parent_ != s.parent_)
+    {
+        return false;
+    }
+    else if (addedCellsPtr_.valid())
+    {
+        return addedCellsPtr_() == s.addedCellsPtr_();
+    }
+    else
+    {
+        return true;
+    }
+}
+
+
+bool Foam::refinementHistory::splitCell8::operator!=(const splitCell8& s) const
+{
+    return !operator==(s);
+}
+
+
+// * * * * * * * * * * * * * * Friend Operators  * * * * * * * * * * * * * * //
+
+Foam::Istream& Foam::operator>>(Istream& is, refinementHistory::splitCell8& sc)
+{
+    labelList addedCells;
+
+    is >> sc.parent_ >> addedCells;
+
+    if (addedCells.size())
+    {
+        sc.addedCellsPtr_.reset(new FixedList<label, 8>(addedCells));
+    }
+    else
+    {
+        sc.addedCellsPtr_.reset(nullptr);
+    }
+
+    return is;
+}
+
+
+Foam::Ostream& Foam::operator<<
+(
+    Ostream& os,
+    const refinementHistory::splitCell8& sc
+)
+{
+    // Output as labelList so we can have 0 sized lists. Alternative is to
+    // output as fixedlist with e.g. -1 elements and check for this upon
+    // reading. However would cause much more data to be transferred.
+
+    if (sc.addedCellsPtr_.valid())
+    {
+        return os
+            << sc.parent_
+            << token::SPACE
+            << labelList(sc.addedCellsPtr_());
+    }
+    else
+    {
+        return os << sc.parent_ << token::SPACE << labelList(0);
+    }
+}
+
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+void Foam::refinementHistory::checkIndices() const
+{
+    // Check indices.
+    forAll(visibleCells_, i)
+    {
+        if (visibleCells_[i] < 0 && visibleCells_[i] >= splitCells_.size())
+        {
+            FatalErrorInFunction
+                << "Illegal entry " << visibleCells_[i]
+                << " in visibleCells at location" << i << nl
+                << "It points outside the range of splitCells : 0.."
+                << splitCells_.size()-1
+                << abort(FatalError);
+        }
+    }
+}
+
+
+Foam::label Foam::refinementHistory::allocateSplitCell
+(
+    const label parent,
+    const label i
+)
+{
+    label index = -1;
+
+    if (freeSplitCells_.size())
+    {
+        index = freeSplitCells_.remove();
+
+        splitCells_[index] = splitCell8(parent);
+    }
+    else
+    {
+        index = splitCells_.size();
+
+        splitCells_.append(splitCell8(parent));
+    }
+
+
+    // Update the parent field
+    if (parent >= 0)
+    {
+        splitCell8& parentSplit = splitCells_[parent];
+
+        if (parentSplit.addedCellsPtr_.empty())
+        {
+            // Allocate storage on parent for the 8 subcells.
+            parentSplit.addedCellsPtr_.reset(new FixedList<label, 8>(-1));
+        }
+
+
+        // Store me on my parent
+        FixedList<label, 8>& parentSplits = parentSplit.addedCellsPtr_();
+
+        parentSplits[i] = index;
+    }
+
+    return index;
+}
+
+
+void Foam::refinementHistory::freeSplitCell(const label index)
+{
+    splitCell8& split = splitCells_[index];
+
+    // Make sure parent does not point to me anymore.
+    if (split.parent_ >= 0)
+    {
+        autoPtr<FixedList<label, 8>>& subCellsPtr =
+            splitCells_[split.parent_].addedCellsPtr_;
+
+        if (subCellsPtr.valid())
+        {
+            FixedList<label, 8>& subCells = subCellsPtr();
+
+            label myPos = findIndex(subCells, index);
+
+            if (myPos == -1)
+            {
+                FatalErrorInFunction
+                    << "Problem: cannot find myself in"
+                    << " parents' children" << abort(FatalError);
+            }
+            else
+            {
+                subCells[myPos] = -1;
+            }
+        }
+    }
+
+    // Mark splitCell as free
+    split.parent_ = -2;
+
+    // Add to cache of free splitCells
+    freeSplitCells_.append(index);
+}
+
+
+void Foam::refinementHistory::markSplit
+(
+    const label index,
+    labelList& oldToNew,
+    DynamicList<splitCell8>& newSplitCells
+) const
+{
+    if (oldToNew[index] == -1)
+    {
+        // Not yet compacted.
+
+        const splitCell8& split = splitCells_[index];
+
+        oldToNew[index] = newSplitCells.size();
+        newSplitCells.append(split);
+
+        if (split.parent_ >= 0)
+        {
+            markSplit(split.parent_, oldToNew, newSplitCells);
+        }
+        if (split.addedCellsPtr_.valid())
+        {
+            const FixedList<label, 8>& splits = split.addedCellsPtr_();
+
+            forAll(splits, i)
+            {
+                if (splits[i] >= 0)
+                {
+                    markSplit(splits[i], oldToNew, newSplitCells);
+                }
+            }
+        }
+    }
+}
+
+
+void Foam::refinementHistory::mark
+(
+    const label val,
+    const label index,
+    labelList& splitToVal
+) const
+{
+    splitToVal[index] = val;
+
+    const splitCell8& split = splitCells_[index];
+
+    if (split.addedCellsPtr_.valid())
+    {
+        const FixedList<label, 8>& splits = split.addedCellsPtr_();
+
+        forAll(splits, i)
+        {
+            if (splits[i] >= 0)
+            {
+                mark(val, splits[i], splitToVal);
+            }
+        }
+    }
+}
+
+
+Foam::label Foam::refinementHistory::markCommonCells
+(
+    labelList& cellToCluster
+) const
+{
+    label clusterI = 0;
+
+    labelList splitToCluster(splitCells_.size(), -1);
+
+    // Pass1: find top of all clusters
+    forAll(visibleCells_, cellI)
+    {
+        label index = visibleCells_[cellI];
+
+        if (index >= 0)
+        {
+            // Find highest ancestor
+            while (splitCells_[index].parent_ != -1)
+            {
+                index = splitCells_[index].parent_;
+            }
+
+            // Mark tree with clusterI
+            if (splitToCluster[index] == -1)
+            {
+                mark(clusterI, index, splitToCluster);
+                clusterI++;
+            }
+        }
+    }
+
+    // Pass2: mark all cells with cluster
+    cellToCluster.setSize(visibleCells_.size(), -1);
+
+    forAll(visibleCells_, cellI)
+    {
+        label index = visibleCells_[cellI];
+
+        if (index >= 0)
+        {
+            cellToCluster[cellI] = splitToCluster[index];
+        }
+    }
+
+    return clusterI;
+}
+
+
+void Foam::refinementHistory::add
+(
+    boolList& blockedFace,
+    PtrList<labelList>& specifiedProcessorFaces,
+    labelList& specifiedProcessor,
+    List<labelPair>& explicitConnections
+) const
+{
+    const polyMesh& mesh = dynamic_cast<const polyMesh&>(db());
+
+    blockedFace.setSize(mesh.nFaces(), true);
+
+    // Find common parent for all cells
+    labelList cellToCluster;
+    markCommonCells(cellToCluster);
+
+
+    // Unblock all faces inbetween same cluster
+
+    label nUnblocked = 0;
+
+    forAll(mesh.faceNeighbour(), faceI)
+    {
+        label ownCluster = cellToCluster[mesh.faceOwner()[faceI]];
+        label neiCluster = cellToCluster[mesh.faceNeighbour()[faceI]];
+
+        if (ownCluster != -1 && ownCluster == neiCluster)
+        {
+            if (blockedFace[faceI])
+            {
+                blockedFace[faceI] = false;
+                nUnblocked++;
+            }
+        }
+    }
+
+    if (refinementHistory::debug)
+    {
+        reduce(nUnblocked, sumOp<label>());
+        Info<< type() << " : unblocked " << nUnblocked << " faces" << endl;
+    }
+
+    syncTools::syncFaceList(mesh, blockedFace, andEqOp<bool>());
+}
+
+
+void Foam::refinementHistory::apply
+(
+    const boolList& blockedFace,
+    const PtrList<labelList>& specifiedProcessorFaces,
+    const labelList& specifiedProcessor,
+    const List<labelPair>& explicitConnections,
+    labelList& decomposition
+) const
+{
+    const polyMesh& mesh = dynamic_cast<const polyMesh&>(db());
+
+    // Find common parent for all cells
+    labelList cellToCluster;
+    label nClusters = markCommonCells(cellToCluster);
+
+    // Unblock all faces inbetween same cluster
+
+
+    labelList clusterToProc(nClusters, -1);
+
+    label nChanged = 0;
+
+    forAll(mesh.faceNeighbour(), faceI)
+    {
+        label own = mesh.faceOwner()[faceI];
+        label nei = mesh.faceNeighbour()[faceI];
+
+        label ownCluster = cellToCluster[own];
+        label neiCluster = cellToCluster[nei];
+
+        if (ownCluster != -1 && ownCluster == neiCluster)
+        {
+            if (clusterToProc[ownCluster] == -1)
+            {
+                clusterToProc[ownCluster] = decomposition[own];
+            }
+
+            if (decomposition[own] != clusterToProc[ownCluster])
+            {
+                decomposition[own] = clusterToProc[ownCluster];
+                nChanged++;
+            }
+            if (decomposition[nei] != clusterToProc[ownCluster])
+            {
+                decomposition[nei] = clusterToProc[ownCluster];
+                nChanged++;
+            }
+        }
+    }
+
+    if (refinementHistory::debug)
+    {
+        reduce(nChanged, sumOp<label>());
+        Info<< type() << " : changed decomposition on " << nChanged
+            << " cells" << endl;
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::refinementHistory::refinementHistory(const IOobject& io)
+:
+    regIOobject(io),
+    active_(false)
+{
+    // Temporary warning
+    if (io.readOpt() == IOobject::MUST_READ_IF_MODIFIED)
+    {
+        WarningInFunction
+            << "Specified IOobject::MUST_READ_IF_MODIFIED but class"
+            << " does not support automatic rereading."
+            << endl;
+    }
+
+    if
+    (
+        io.readOpt() == IOobject::MUST_READ
+     || io.readOpt() == IOobject::MUST_READ_IF_MODIFIED
+     || (io.readOpt() == IOobject::READ_IF_PRESENT && headerOk())
+    )
+    {
+        readStream(typeName) >> *this;
+        close();
+    }
+
+    // When running in redistributPar + READ_IF_PRESENT it can happen
+    // that some processors do have refinementHistory and some don't so
+    // test for active has to be outside of above condition.
+    active_ = (returnReduce(visibleCells_.size(), sumOp<label>()) > 0);
+
+    if (debug)
+    {
+        Pout<< "refinementHistory::refinementHistory :"
+            << " constructed history from IOobject :"
+            << " splitCells:" << splitCells_.size()
+            << " visibleCells:" << visibleCells_.size()
+            << " active:" << active_
+            << endl;
+    }
+}
+
+
+Foam::refinementHistory::refinementHistory
+(
+    const IOobject& io,
+    const List<splitCell8>& splitCells,
+    const labelList& visibleCells,
+    const bool active
+)
+:
+    regIOobject(io),
+    active_(active),
+    splitCells_(splitCells),
+    freeSplitCells_(0),
+    visibleCells_(visibleCells)
+{
+    // Temporary warning
+    if (io.readOpt() == IOobject::MUST_READ_IF_MODIFIED)
+    {
+        WarningInFunction
+            << "Specified IOobject::MUST_READ_IF_MODIFIED but class"
+            << " does not support automatic rereading."
+            << endl;
+    }
+
+    if
+    (
+        io.readOpt() == IOobject::MUST_READ
+     || io.readOpt() == IOobject::MUST_READ_IF_MODIFIED
+     || (io.readOpt() == IOobject::READ_IF_PRESENT && headerOk())
+    )
+    {
+        readStream(typeName) >> *this;
+        close();
+    }
+
+    // Check indices.
+    checkIndices();
+
+    if (debug)
+    {
+        Pout<< "refinementHistory::refinementHistory :"
+            << " constructed history from IOobject or components :"
+            << " splitCells:" << splitCells_.size()
+            << " visibleCells:" << visibleCells_.size()
+            << " active:" << active_
+            << endl;
+    }
+}
+
+
+Foam::refinementHistory::refinementHistory
+(
+    const IOobject& io,
+    const label nCells
+)
+:
+    regIOobject(io),
+    active_(false),
+    freeSplitCells_(0)
+{
+    // Temporary warning
+    if (io.readOpt() == IOobject::MUST_READ_IF_MODIFIED)
+    {
+        WarningInFunction
+            << "Specified IOobject::MUST_READ_IF_MODIFIED but class"
+            << " does not support automatic rereading."
+            << endl;
+    }
+
+    if
+    (
+        io.readOpt() == IOobject::MUST_READ
+     || io.readOpt() == IOobject::MUST_READ_IF_MODIFIED
+     || (io.readOpt() == IOobject::READ_IF_PRESENT && headerOk())
+    )
+    {
+        readStream(typeName) >> *this;
+        close();
+    }
+    else
+    {
+        visibleCells_.setSize(nCells);
+        splitCells_.setCapacity(nCells);
+
+        for (label cellI = 0; cellI < nCells; cellI++)
+        {
+            visibleCells_[cellI] = cellI;
+            splitCells_.append(splitCell8());
+        }
+    }
+
+    active_ = (returnReduce(visibleCells_.size(), sumOp<label>()) > 0);
+
+
+    // Check indices.
+    checkIndices();
+
+    if (debug)
+    {
+        Pout<< "refinementHistory::refinementHistory :"
+            << " constructed history from IOobject or initial size :"
+            << " splitCells:" << splitCells_.size()
+            << " visibleCells:" << visibleCells_.size()
+            << " active:" << active_
+            << endl;
+    }
+}
+
+
+// Construct from initial number of cells (all visible)
+Foam::refinementHistory::refinementHistory
+(
+    const IOobject& io,
+    const label nCells,
+    const bool active
+)
+:
+    regIOobject(io),
+    active_(active),
+    freeSplitCells_(0)
+{
+    // Warn for MUST_READ_IF_MODIFIED
+    if (io.readOpt() == IOobject::MUST_READ_IF_MODIFIED)
+    {
+        WarningInFunction
+            << "Specified IOobject::MUST_READ_IF_MODIFIED but class"
+            << " does not support automatic rereading."
+            << endl;
+    }
+
+    if
+    (
+        io.readOpt() == IOobject::MUST_READ
+     || io.readOpt() == IOobject::MUST_READ_IF_MODIFIED
+     || (io.readOpt() == IOobject::READ_IF_PRESENT && headerOk())
+    )
+    {
+        readStream(typeName) >> *this;
+        close();
+    }
+    else
+    {
+        visibleCells_.setSize(nCells);
+        splitCells_.setCapacity(nCells);
+
+        for (label celli = 0; celli < nCells; celli++)
+        {
+            visibleCells_[celli] = celli;
+            splitCells_.append(splitCell8());
+        }
+    }
+
+    // Check indices.
+    checkIndices();
+
+    if (debug)
+    {
+        Pout<< "refinementHistory::refinementHistory :"
+            << " constructed history from IOobject or initial size :"
+            << " splitCells:" << splitCells_.size()
+            << " visibleCells:" << visibleCells_.size()
+            << " active:" << active_
+            << endl;
+    }
+}
+
+
+Foam::refinementHistory::refinementHistory
+(
+    const IOobject& io,
+    const refinementHistory& rh
+)
+:
+    regIOobject(io),
+    active_(rh.active_),
+    splitCells_(rh.splitCells()),
+    freeSplitCells_(rh.freeSplitCells()),
+    visibleCells_(rh.visibleCells())
+{
+    if (debug)
+    {
+        Pout<< "refinementHistory::refinementHistory : constructed initial"
+            << " history." << endl;
+    }
+}
+
+
+Foam::refinementHistory::refinementHistory
+(
+    const IOobject& io,
+    const UPtrList<const labelList>& cellMaps,
+    const UPtrList<const refinementHistory>& refs
+)
+:
+    regIOobject(io),
+    active_(false)
+{
+    if
+    (
+        io.readOpt() == IOobject::MUST_READ
+     || io.readOpt() == IOobject::MUST_READ_IF_MODIFIED
+     || (io.readOpt() == IOobject::READ_IF_PRESENT && headerOk())
+    )
+    {
+        WarningIn
+        (
+            "refinementHistory::refinementHistory(const IOobject&"
+            ", const labelListList&, const PtrList<refinementHistory>&)"
+        )   << "read option IOobject::MUST_READ, READ_IF_PRESENT or "
+            << "MUST_READ_IF_MODIFIED"
+            << " suggests that a read constructor would be more appropriate."
+            << endl;
+    }
+
+    const polyMesh& mesh = dynamic_cast<const polyMesh&>(db());
+
+
+    // Determine offsets into splitCells
+    labelList offsets(refs.size()+1);
+    offsets[0] = 0;
+    forAll(refs, refI)
+    {
+        const DynamicList<splitCell8>& subSplits = refs[refI].splitCells();
+        offsets[refI+1] = offsets[refI]+subSplits.size();
+    }
+
+    // Construct merged splitCells
+    splitCells_.setSize(offsets.last());
+    forAll(refs, refI)
+    {
+        const DynamicList<splitCell8>& subSplits = refs[refI].splitCells();
+        forAll(subSplits, i)
+        {
+            splitCell8& newSplit = splitCells_[offsets[refI]+i];
+
+            // Copy
+            newSplit = subSplits[i];
+
+            // Offset indices
+            if (newSplit.parent_ >= 0)
+            {
+                newSplit.parent_ += offsets[refI];
+            }
+
+            if (newSplit.addedCellsPtr_.valid())
+            {
+                FixedList<label, 8>& splits = newSplit.addedCellsPtr_();
+
+                forAll(splits, i)
+                {
+                    if (splits[i] >= 0)
+                    {
+                        splits[i] += offsets[refI];
+                    }
+                }
+            }
+        }
+    }
+
+
+    // Construct merged visibleCells
+    visibleCells_.setSize(mesh.nCells(), -1);
+    forAll(refs, refI)
+    {
+        const labelList& cellMap = cellMaps[refI];
+        const labelList& subVis = refs[refI].visibleCells();
+
+        forAll(subVis, i)
+        {
+            label& newVis = visibleCells_[cellMap[i]];
+
+            newVis = subVis[i];
+            if (newVis >= 0)
+            {
+                newVis += offsets[refI];
+            }
+        }
+    }
+
+
+    // Is active if any of the refinementHistories is active (assumes active
+    // flag parallel synchronised)
+    active_ = false;
+    forAll(refs, refI)
+    {
+        if (refs[refI].active())
+        {
+            active_ = true;
+            break;
+        }
+    }
+
+    // Check indices.
+    checkIndices();
+
+    if (debug)
+    {
+        Pout<< "refinementHistory::refinementHistory :"
+            << " constructed history from multiple refinementHistories :"
+            << " splitCells:" << splitCells_.size()
+            << " visibleCells:" << visibleCells_.size()
+            << endl;
+    }
+}
+
+
+Foam::refinementHistory::refinementHistory(const IOobject& io, Istream& is)
+:
+    regIOobject(io),
+    splitCells_(is),
+    freeSplitCells_(0),
+    visibleCells_(is)
+{
+    active_ = (returnReduce(visibleCells_.size(), sumOp<label>()) > 0);
+
+    // Check indices.
+    checkIndices();
+
+    if (debug)
+    {
+        Pout<< "refinementHistory::refinementHistory :"
+            << " constructed history from Istream"
+            << " splitCells:" << splitCells_.size()
+            << " visibleCells:" << visibleCells_.size()
+            << endl;
+    }
+}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+Foam::autoPtr<Foam::refinementHistory> Foam::refinementHistory::clone
+(
+    const IOobject& io,
+    // Per visible cell the processor it is going to
+    const labelList& decomposition,
+    // Per splitCell entry the processor it moves to
+    const labelList& splitCellProc,
+    // Per splitCell entry the number of live cells that move to that processor
+    const labelList& splitCellNum,
+
+    const label procI,
+
+    // From old to new splitCells
+    labelList& oldToNewSplit
+) const
+{
+    oldToNewSplit.setSize(splitCells_.size());
+    oldToNewSplit = -1;
+
+    // Compacted splitCells
+    DynamicList<splitCell8> newSplitCells(splitCells_.size());
+
+    // Loop over all entries. Note: could recurse like countProc so only
+    // visit used entries but is probably not worth it.
+
+    forAll(splitCells_, index)
+    {
+        if (splitCellProc[index] == procI && splitCellNum[index] == 8)
+        {
+            // Entry moves in its whole to procI
+            oldToNewSplit[index] = newSplitCells.size();
+            newSplitCells.append(splitCells_[index]);
+        }
+    }
+
+    // Add live cells that are subsetted.
+    forAll(visibleCells_, cellI)
+    {
+        label index = visibleCells_[cellI];
+
+        if (index >= 0 && decomposition[cellI] == procI)
+        {
+            label parent = splitCells_[index].parent_;
+
+            // Create new splitCell with parent
+            oldToNewSplit[index] = newSplitCells.size();
+            newSplitCells.append(splitCell8(parent));
+        }
+    }
+
+    //forAll(oldToNewSplit, index)
+    //{
+    //    Pout<< "old:" << index << " new:" << oldToNewSplit[index]
+    //        << endl;
+    //}
+
+    newSplitCells.shrink();
+
+    // Renumber contents of newSplitCells
+    forAll(newSplitCells, index)
+    {
+        splitCell8& split = newSplitCells[index];
+
+        if (split.parent_ >= 0)
+        {
+            split.parent_ = oldToNewSplit[split.parent_];
+        }
+        if (split.addedCellsPtr_.valid())
+        {
+            FixedList<label, 8>& splits = split.addedCellsPtr_();
+
+            forAll(splits, i)
+            {
+                if (splits[i] >= 0)
+                {
+                    splits[i] = oldToNewSplit[splits[i]];
+                }
+            }
+        }
+    }
+
+
+    // Count number of cells
+    label nSub = 0;
+    forAll(decomposition, cellI)
+    {
+        if (decomposition[cellI] == procI)
+        {
+            nSub++;
+        }
+    }
+
+    labelList newVisibleCells(nSub);
+    nSub = 0;
+
+    forAll(visibleCells_, cellI)
+    {
+        if (decomposition[cellI] == procI)
+        {
+            label index = visibleCells_[cellI];
+            if (index >= 0)
+            {
+                index = oldToNewSplit[index];
+            }
+            newVisibleCells[nSub++] = index;
+        }
+    }
+
+    return autoPtr<refinementHistory>
+    (
+        new refinementHistory
+        (
+            io,
+            newSplitCells,
+            newVisibleCells,
+            active_
+        )
+    );
+}
+
+
+Foam::autoPtr<Foam::refinementHistory> Foam::refinementHistory::clone
+(
+    const IOobject& io,
+    const labelList& cellMap
+) const
+{
+    if (active_)
+    {
+        // Mark selected cells with '1'
+        labelList decomposition(visibleCells_.size(), 0);
+        forAll(cellMap, i)
+        {
+            decomposition[cellMap[i]] = 1;
+        }
+
+
+        // Per splitCell entry the processor it moves to
+        labelList splitCellProc(splitCells_.size(), -1);
+        // Per splitCell entry the number of live cells that move to that
+        // processor
+        labelList splitCellNum(splitCells_.size(), 0);
+
+        forAll(visibleCells_, cellI)
+        {
+            label index = visibleCells_[cellI];
+
+            if (index >= 0)
+            {
+                countProc
+                (
+                    splitCells_[index].parent_,
+                    decomposition[cellI],
+                    splitCellProc,
+                    splitCellNum
+                );
+            }
+        }
+
+        labelList oldToNewSplit;
+        return clone
+        (
+            io,
+            decomposition,
+            splitCellProc,
+            splitCellNum,
+            1,      //procI,
+            oldToNewSplit
+        );
+    }
+    else
+    {
+        return autoPtr<refinementHistory>
+        (
+            new refinementHistory
+            (
+                io,
+                DynamicList<splitCell8>(0),
+                labelList(0),
+                false
+            )
+        );
+    }
+}
+
+
+void Foam::refinementHistory::resize(const label size)
+{
+    label oldSize = visibleCells_.size();
+
+    if (debug)
+    {
+        Pout<< "refinementHistory::resize from " << oldSize << " to " << size
+            << " cells" << endl;
+    }
+
+    visibleCells_.setSize(size);
+
+    // Set additional elements to -1.
+    for (label i = oldSize; i < visibleCells_.size(); i++)
+    {
+        visibleCells_[i] = -1;
+    }
+}
+
+
+void Foam::refinementHistory::updateMesh(const mapPolyMesh& map)
+{
+    if (active())
+    {
+        const labelList& reverseCellMap = map.reverseCellMap();
+
+        // Note that only the live cells need to be renumbered.
+
+        labelList newVisibleCells(map.cellMap().size(), -1);
+
+        forAll(visibleCells_, celli)
+        {
+            if (visibleCells_[celli] != -1)
+            {
+                label index = visibleCells_[celli];
+
+                // Check not already set
+                if (splitCells_[index].addedCellsPtr_.valid())
+                {
+                    FatalErrorInFunction
+                        << "Problem" << abort(FatalError);
+                }
+
+                label newCelli = reverseCellMap[celli];
+
+                if (newCelli >= 0)
+                {
+                    newVisibleCells[newCelli] = index;
+                }
+            }
+        }
+
+        if (debug)
+        {
+            Pout<< "refinementHistory::updateMesh : from "
+                << visibleCells_.size()
+                << " to " << newVisibleCells.size()
+                << " cells" << endl;
+        }
+
+        visibleCells_.transfer(newVisibleCells);
+    }
+}
+
+
+void Foam::refinementHistory::subset
+(
+    const labelList& pointMap,
+    const labelList& faceMap,
+    const labelList& cellMap
+)
+{
+    if (active())
+    {
+        labelList newVisibleCells(cellMap.size(), -1);
+
+        forAll(newVisibleCells, celli)
+        {
+            label oldCelli = cellMap[celli];
+
+            label index = visibleCells_[oldCelli];
+
+            // Check that cell is live (so its parent has no refinement)
+            if (index >= 0 && splitCells_[index].addedCellsPtr_.valid())
+            {
+                FatalErrorInFunction
+                    << "Problem" << abort(FatalError);
+            }
+
+            newVisibleCells[celli] = index;
+        }
+
+        if (debug)
+        {
+            Pout<< "refinementHistory::updateMesh : from "
+                << visibleCells_.size()
+                << " to " << newVisibleCells.size()
+                << " cells" << endl;
+        }
+
+        visibleCells_.transfer(newVisibleCells);
+    }
+}
+
+
+void Foam::refinementHistory::countProc
+(
+    const label index,
+    const label newProcNo,
+    labelList& splitCellProc,
+    labelList& splitCellNum
+) const
+{
+
+    const polyMesh& mesh = dynamic_cast<const polyMesh&>(db());
+    label nSubCellsPerCell = 1 << mesh.nGeometricD();
+
+    if (splitCellProc[index] != newProcNo)
+    {
+        // Different destination processor from other cells using this
+        // parent. Reset count.
+        splitCellProc[index] = newProcNo;
+        splitCellNum[index] = 1;
+    }
+    else
+    {
+        splitCellNum[index]++;
+
+        // Increment parent if whole splitCell moves to same processor
+        if (splitCellNum[index] == nSubCellsPerCell)
+        {
+            if (debug)
+            {
+                Pout<< "Moving " << splitCellNum[index]
+                    << " cells originating from cell " << index
+                    << " from processor " << Pstream::myProcNo()
+                    << " to processor " << splitCellProc[index]
+                    << endl;
+            }
+
+            label parent = splitCells_[index].parent_;
+
+            if (parent >= 0)
+            {
+                countProc(parent, newProcNo, splitCellProc, splitCellNum);
+            }
+        }
+    }
+}
+
+
+void Foam::refinementHistory::distribute(const mapDistributePolyMesh& map)
+{
+    if (!active())
+    {
+        FatalErrorInFunction
+            << "Calling distribute on inactive history" << abort(FatalError);
+    }
+
+
+    if (!Pstream::parRun())
+    {
+        return;
+    }
+
+    // Remove unreferenced history.
+    compact();
+
+    //Pout<< nl << "--BEFORE:" << endl;
+    //writeDebug();
+    //Pout<< "---------" << nl << endl;
+
+
+    // Distribution is only partially functional.
+    // If all 8 cells resulting from a single parent are sent across in one
+    // go it will also send across that part of the refinement history.
+    // If however e.g. first 1 and then the other 7 are sent across the
+    // history will not be reconstructed.
+
+    // Determine clusters. This is per every entry in splitCells_ (that is
+    // a parent of some refinement) a label giving the processor it goes to
+    // if all its children are going to the same processor.
+
+    // Per visible cell the processor it goes to.
+    labelList destination(visibleCells_.size());
+
+    const labelListList& subCellMap = map.cellMap().subMap();
+
+    forAll(subCellMap, proci)
+    {
+        const labelList& newToOld = subCellMap[proci];
+
+        forAll(newToOld, i)
+        {
+            label oldCelli = newToOld[i];
+
+            destination[oldCelli] = proci;
+        }
+    }
+
+    // Per splitCell entry the processor it moves to
+    labelList splitCellProc(splitCells_.size(), -1);
+    // Per splitCell entry the number of live cells that move to that processor
+    labelList splitCellNum(splitCells_.size(), 0);
+
+    forAll(visibleCells_, celli)
+    {
+        label index = visibleCells_[celli];
+
+        if (index >= 0)
+        {
+            countProc
+            (
+                splitCells_[index].parent_,
+                destination[celli],
+                splitCellProc,
+                splitCellNum
+            );
+        }
+    }
+
+    //Pout<< "refinementHistory::distribute :"
+    //    << " splitCellProc:" << splitCellProc << endl;
+    //
+    //Pout<< "refinementHistory::distribute :"
+    //    << " splitCellNum:" << splitCellNum << endl;
+
+    const polyMesh& mesh = dynamic_cast<const polyMesh&>(db());
+    label nSubCellsPerCell = 1 << mesh.nGeometricD();
+
+
+    // Create subsetted refinement tree consisting of all parents that
+    // move in their whole to other processor.
+    for (label proci = 0; proci < Pstream::nProcs(); proci++)
+    {
+        //Pout<< "-- Subetting for processor " << proci << endl;
+
+        // From uncompacted to compacted splitCells.
+        labelList oldToNew(splitCells_.size(), -1);
+
+        // Compacted splitCells. Similar to subset routine below.
+        DynamicList<splitCell8> newSplitCells(splitCells_.size());
+
+        // Loop over all entries. Note: could recurse like countProc so only
+        // visit used entries but is probably not worth it.
+
+        forAll(splitCells_, index)
+        {
+            if (splitCellProc[index] == proci && splitCellNum[index] == nSubCellsPerCell)
+            {
+                // Entry moves in its whole to proci
+                oldToNew[index] = newSplitCells.size();
+                newSplitCells.append(splitCells_[index]);
+            }
+        }
+
+        // Add live cells that are subsetted.
+        forAll(visibleCells_, celli)
+        {
+            label index = visibleCells_[celli];
+
+            if (index >= 0 && destination[celli] == proci)
+            {
+                label parent = splitCells_[index].parent_;
+
+                // Create new splitCell with parent
+                oldToNew[index] = newSplitCells.size();
+                newSplitCells.append(splitCell8(parent));
+            }
+        }
+
+        //forAll(oldToNew, index)
+        //{
+        //    Pout<< "old:" << index << " new:" << oldToNew[index]
+        //        << endl;
+        //}
+
+        newSplitCells.shrink();
+
+        // Renumber contents of newSplitCells
+        forAll(newSplitCells, index)
+        {
+            splitCell8& split = newSplitCells[index];
+
+            if (split.parent_ >= 0)
+            {
+                split.parent_ = oldToNew[split.parent_];
+            }
+            if (split.addedCellsPtr_.valid())
+            {
+                FixedList<label, 8>& splits = split.addedCellsPtr_();
+
+                forAll(splits, i)
+                {
+                    if (splits[i] >= 0)
+                    {
+                        splits[i] = oldToNew[splits[i]];
+                    }
+                }
+            }
+        }
+
+
+        const labelList& subMap = subCellMap[proci];
+
+        // New visible cells.
+        labelList newVisibleCells(subMap.size(), -1);
+
+        forAll(subMap, newCelli)
+        {
+            label oldCelli = subMap[newCelli];
+
+            label oldIndex = visibleCells_[oldCelli];
+
+            if (oldIndex >= 0)
+            {
+                newVisibleCells[newCelli] = oldToNew[oldIndex];
+            }
+        }
+
+        //Pout<< nl << "--Subset for domain:" << proci << endl;
+        //writeDebug(newVisibleCells, newSplitCells);
+        //Pout<< "---------" << nl << endl;
+
+
+        // Send to neighbours
+        // OPstream toNbr(Pstream::blocking, proci);
+        OPstream toNbr(Pstream::commsTypes::blocking, proci);
+        toNbr << newSplitCells << newVisibleCells;
+    }
+
+
+    // Receive from neighbours and merge
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    // Remove all entries. Leave storage intact.
+    splitCells_.clear();
+
+    visibleCells_.setSize(mesh.nCells());
+    visibleCells_ = -1;
+
+    for (label proci = 0; proci < Pstream::nProcs(); proci++)
+    {
+        // IPstream fromNbr(Pstream::blocking, proci);
+        IPstream fromNbr(Pstream::commsTypes::blocking, proci);
+        List<splitCell8> newSplitCells(fromNbr);
+        labelList newVisibleCells(fromNbr);
+
+        //Pout<< nl << "--Received from domain:" << proci << endl;
+        //writeDebug(newVisibleCells, newSplitCells);
+        //Pout<< "---------" << nl << endl;
+
+
+        // newSplitCells contain indices only into newSplitCells so
+        // renumbering can be done here.
+        label offset = splitCells_.size();
+
+        //Pout<< "**Renumbering data from proc " << proci << " with offset "
+        //    << offset << endl;
+
+        forAll(newSplitCells, index)
+        {
+            splitCell8& split = newSplitCells[index];
+
+            if (split.parent_ >= 0)
+            {
+                split.parent_ += offset;
+            }
+            if (split.addedCellsPtr_.valid())
+            {
+                FixedList<label, 8>& splits = split.addedCellsPtr_();
+
+                forAll(splits, i)
+                {
+                    if (splits[i] >= 0)
+                    {
+                        splits[i] += offset;
+                    }
+                }
+            }
+
+            splitCells_.append(split);
+        }
+
+
+        // Combine visibleCell.
+        const labelList& constructMap = map.cellMap().constructMap()[proci];
+
+        forAll(newVisibleCells, i)
+        {
+            if (newVisibleCells[i] >= 0)
+            {
+                visibleCells_[constructMap[i]] = newVisibleCells[i] + offset;
+            }
+        }
+    }
+    splitCells_.shrink();
+
+    //Pout<< nl << "--AFTER:" << endl;
+    //writeDebug();
+    //Pout<< "---------" << nl << endl;
+}
+
+
+void Foam::refinementHistory::compact()
+{
+    if (debug)
+    {
+        Pout<< "refinementHistory::compact() Entering with:"
+            << " freeSplitCells_:" << freeSplitCells_.size()
+            << " splitCells_:" << splitCells_.size()
+            << " visibleCells_:" << visibleCells_.size()
+            << endl;
+
+        // Check all free splitCells are marked as such
+        forAll(freeSplitCells_, i)
+        {
+            label index = freeSplitCells_[i];
+
+            if (splitCells_[index].parent_ != -2)
+            {
+                FatalErrorInFunction
+                    << "Problem index:" << index
+                    << abort(FatalError);
+            }
+        }
+
+        // Check none of the visible cells are marked as free
+        forAll(visibleCells_, celli)
+        {
+            if
+            (
+                visibleCells_[celli] >= 0
+             && splitCells_[visibleCells_[celli]].parent_ == -2
+            )
+            {
+                FatalErrorInFunction
+                    << "Problem : visible cell:" << celli
+                    << " is marked as being free." << abort(FatalError);
+            }
+        }
+    }
+
+    DynamicList<splitCell8> newSplitCells(splitCells_.size());
+
+    // From uncompacted to compacted splitCells.
+    labelList oldToNew(splitCells_.size(), -1);
+
+    // Mark all used splitCell entries. These are either indexed by visibleCells
+    // or indexed from other splitCell entries.
+
+    // Mark from visibleCells
+    forAll(visibleCells_, celli)
+    {
+        label index = visibleCells_[celli];
+
+        if (index >= 0)
+        {
+            // Make sure we only mark visible indices if they either have a
+            // parent or subsplits.
+            if
+            (
+                splitCells_[index].parent_ != -1
+             || splitCells_[index].addedCellsPtr_.valid()
+            )
+            {
+                markSplit(index, oldToNew, newSplitCells);
+            }
+        }
+    }
+
+    // Mark from splitCells
+    forAll(splitCells_, index)
+    {
+        if (splitCells_[index].parent_ == -2)
+        {
+            // freed cell.
+        }
+        else if
+        (
+            splitCells_[index].parent_ == -1
+         && splitCells_[index].addedCellsPtr_.empty()
+        )
+        {
+            // recombined cell. No need to keep since no parent and no subsplits
+            // Note that gets marked if reachable from other index!
+        }
+        else
+        {
+            // Is used element.
+            markSplit(index, oldToNew, newSplitCells);
+        }
+    }
+
+
+    // Now oldToNew is fully complete and compacted elements are in
+    // newSplitCells.
+    // Renumber contents of newSplitCells and visibleCells.
+    forAll(newSplitCells, index)
+    {
+        splitCell8& split = newSplitCells[index];
+
+        if (split.parent_ >= 0)
+        {
+            split.parent_ = oldToNew[split.parent_];
+        }
+        if (split.addedCellsPtr_.valid())
+        {
+            FixedList<label, 8>& splits = split.addedCellsPtr_();
+
+            forAll(splits, i)
+            {
+                if (splits[i] >= 0)
+                {
+                    splits[i] = oldToNew[splits[i]];
+                }
+            }
+        }
+    }
+
+
+    if (debug)
+    {
+        Pout<< "refinementHistory::compact : compacted splitCells from "
+            << splitCells_.size() << " to " << newSplitCells.size() << endl;
+    }
+
+    splitCells_.transfer(newSplitCells);
+    freeSplitCells_.clearStorage();
+
+
+    if (debug)
+    {
+        Pout<< "refinementHistory::compact() NOW:"
+            << " freeSplitCells_:" << freeSplitCells_.size()
+            << " splitCells_:" << splitCells_.size()
+            << " newSplitCells:" << newSplitCells.size()
+            << " visibleCells_:" << visibleCells_.size()
+            << endl;
+    }
+
+
+    // Adapt indices in visibleCells_
+    forAll(visibleCells_, celli)
+    {
+        label index = visibleCells_[celli];
+
+        if (index >= 0)
+        {
+            // Note that oldToNew can be -1 so it resets newVisibleCells.
+            visibleCells_[celli] = oldToNew[index];
+        }
+        else
+        {
+            // Keep -1 value.
+        }
+    }
+}
+
+
+void Foam::refinementHistory::writeDebug() const
+{
+    writeDebug(visibleCells_, splitCells_);
+}
+
+
+void Foam::refinementHistory::storeSplit
+(
+    const label celli,
+    const labelList& addedCells
+)
+{
+    label parentIndex = -1;
+
+    if (visibleCells_[celli] != -1)
+    {
+        // Was already live. The current live cell becomes the
+        // parent of the cells split off from it.
+
+        parentIndex = visibleCells_[celli];
+
+        // It is no longer live (note that actually celli gets alive
+        // again below since is addedCells[0])
+        visibleCells_[celli] = -1;
+    }
+    else
+    {
+        // Create 0th level. -1 parent to denote this.
+        parentIndex = allocateSplitCell(-1, -1);
+    }
+
+    // Create live entries for added cells that point to the
+    // cell they were created from (parentIndex)
+    forAll(addedCells, i)
+    {
+        label addedCelli = addedCells[i];
+
+        // Create entries for the split off cells. All of them
+        // are visible.
+        visibleCells_[addedCelli] = allocateSplitCell(parentIndex, i);
+    }
+}
+
+
+void Foam::refinementHistory::combineCells
+(
+    const label masterCelli,
+    const labelList& combinedCells
+)
+{
+    // Save the parent structure
+    label parentIndex = splitCells_[visibleCells_[masterCelli]].parent_;
+
+    // Remove the information for the combined cells
+    forAll(combinedCells, i)
+    {
+        label celli = combinedCells[i];
+
+        freeSplitCell(visibleCells_[celli]);
+        visibleCells_[celli] = -1;
+    }
+
+    splitCell8& parentSplit = splitCells_[parentIndex];
+    parentSplit.addedCellsPtr_.reset(nullptr);
+    visibleCells_[masterCelli] = parentIndex;
+}
+
+
+bool Foam::refinementHistory::read()
+{
+    bool ok = readData(readStream(typeName));
+    close();
+
+    active_ = (returnReduce(visibleCells_.size(), sumOp<label>()) > 0);
+
+    return ok;
+}
+
+
+bool Foam::refinementHistory::readData(Istream& is)
+{
+    is >> *this;
+    return !is.bad();
+}
+
+
+bool Foam::refinementHistory::writeData(Ostream& os) const
+{
+    os << *this;
+
+    return os.good();
+}
+
+
+// * * * * * * * * * * * * * * * Friend Operators  * * * * * * * * * * * * * //
+
+Foam::Istream& Foam::operator>>(Istream& is, refinementHistory& rh)
+{
+    rh.freeSplitCells_.clearStorage();
+
+    is >> rh.splitCells_ >> rh.visibleCells_;
+
+    // Check indices.
+    rh.checkIndices();
+
+    return is;
+}
+
+
+Foam::Ostream& Foam::operator<<(Ostream& os, const refinementHistory& rh)
+{
+    const_cast<refinementHistory&>(rh).compact();
+
+    return os   << "// splitCells" << nl
+                << rh.splitCells_ << nl
+                << "// visibleCells" << nl
+                << rh.visibleCells_;
+}
+
+
+// ************************************************************************* //
diff --git a/AMR_tidy/hexRef/refinementHistory.H b/AMR_tidy/hexRef/refinementHistory.H
new file mode 100644
index 00000000..72ed8ea5
--- /dev/null
+++ b/AMR_tidy/hexRef/refinementHistory.H
@@ -0,0 +1,426 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::refinementHistory
+
+Description
+    All refinement history. Used in unrefinement.
+
+    - visibleCells: valid for the current mesh and contains per cell -1
+      (cell unrefined) or an index into splitCells_.
+    - splitCells: for every split contains the parent (also index into
+      splitCells) and optionally a subsplit as 8 indices into splitCells.
+      Note that the numbers in splitCells are not cell labels, they are purely
+      indices into splitCells.
+
+    E.g. 2 cells, cell 1 gets refined so end up with 9 cells:
+    \verbatim
+        // splitCells
+        9
+        (
+        -1 (1 2 3 4 5 6 7 8)
+        0 0()
+        0 0()
+        0 0()
+        0 0()
+        0 0()
+        0 0()
+        0 0()
+        0 0()
+        )
+
+        // visibleCells
+        9(-1 1 2 3 4 5 6 7 8)
+    \endverbatim
+
+
+    So cell0 (visibleCells=-1) is unrefined.
+    Cells 1-8 have all valid splitCells entries which are:
+      - parent:0
+      - subsplits:0()
+
+    The parent 0 refers back to the splitcell entries.
+
+
+SourceFiles
+    refinementHistory.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef refinementHistory_H
+#define refinementHistory_H
+
+#include "DynamicList.H"
+#include "labelList.H"
+#include "FixedList.H"
+#include "autoPtr.H"
+#include "regIOobject.H"
+#include "boolList.H"
+#include "labelPair.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// Forward declaration of classes
+class mapPolyMesh;
+class mapDistributePolyMesh;
+
+
+// Forward declaration of friend functions and operators
+
+class refinementHistory;
+
+Istream& operator>>(Istream&, refinementHistory&);
+Ostream& operator<<(Ostream&, const refinementHistory&);
+
+
+/*---------------------------------------------------------------------------*\
+                           Class refinementHistory Declaration
+\*---------------------------------------------------------------------------*/
+
+class refinementHistory
+:
+    public regIOobject
+{
+public:
+
+    class splitCell8
+    {
+    public:
+
+        // Index to original splitCell this cell was refined off from
+        // -1: top level cell
+        // -2: free splitCell (so should also be in freeSplitCells_)
+        label parent_;
+
+        //- Cells this cell was refined into
+        autoPtr<FixedList<label, 8>> addedCellsPtr_;
+
+        //- Construct null (parent = -1)
+        splitCell8();
+
+        //- Construct from parent
+        splitCell8(const label parent);
+
+        //- Construct from Istream
+        splitCell8(Istream& is);
+
+        //- Construct as deep copy
+        splitCell8(const splitCell8&);
+
+        //- Copy operator since autoPtr otherwise 'steals' storage.
+        void operator=(const splitCell8& s);
+
+        bool operator==(const splitCell8& s) const;
+
+        bool operator!=(const splitCell8& s) const;
+
+        friend Istream& operator>>(Istream&, splitCell8&);
+        friend Ostream& operator<<(Ostream&, const splitCell8&);
+    };
+
+
+private:
+
+    // Private data
+
+        //- Is active?
+        bool active_;
+
+        //- Storage for splitCells
+        DynamicList<splitCell8> splitCells_;
+
+        //- Unused indices in splitCells
+        DynamicList<label> freeSplitCells_;
+
+        //- Currently visible cells. Indices into splitCells.
+        labelList visibleCells_;
+
+
+    // Private Member Functions
+
+        //- Debug write
+        static void writeEntry
+        (
+            const List<splitCell8>&,
+            const splitCell8&
+        );
+        //- Debug write
+        static void writeDebug
+        (
+            const labelList&,
+            const List<splitCell8>&
+        );
+
+        //- Check consistency of structure, i.e. indices into splitCells_.
+        void checkIndices() const;
+
+        //- Allocate a splitCell. Return index in splitCells_.
+        label allocateSplitCell(const label parent, const label i);
+
+        //- Free a splitCell.
+        void freeSplitCell(const label index);
+
+        //- Mark entry in splitCells. Recursively mark its parent and subs.
+        void markSplit
+        (
+            const label,
+            labelList& oldToNew,
+            DynamicList<splitCell8>&
+        ) const;
+
+        void countProc
+        (
+            const label index,
+            const label newProcNo,
+            labelList& splitCellProc,
+            labelList& splitCellNum
+        ) const;
+
+        // For distribution:
+
+            //- Mark index and all its descendants
+            void mark(const label, const label, labelList&) const;
+
+            //- Mark cells according to top parent. Return number of clusters
+            //  (set of cells originating from same parent)
+            label markCommonCells(labelList& cellToCluster) const;
+
+public:
+
+    // Declare name of the class and its debug switch
+    TypeName("refinementHistory");
+
+
+    // Constructors
+
+        //- Construct (read) given an IOobject. If global number of visible
+        //  cells > 0 becomes active
+        refinementHistory(const IOobject&);
+
+        //- Construct (read) or construct from components
+        refinementHistory
+        (
+            const IOobject&,
+            const List<splitCell8>& splitCells,
+            const labelList& visibleCells,
+            const bool active
+        );
+
+        //- Construct (read) or construct from initial number of cells
+        //  (all visible). If global number of visible
+        //  cells > 0 becomes active
+        refinementHistory(const IOobject&, const label nCells);
+
+        //- Construct (read) or construct from initial number of cells
+        //  (all visible) and active flag
+        refinementHistory
+        (
+            const IOobject&,
+            const label nCells,
+            const bool active
+        );
+
+        //- Construct as copy
+        refinementHistory(const IOobject&, const refinementHistory&);
+
+        //- Construct from multiple refinement histories. If global number of
+        //  visible cells > 0 becomes active
+        refinementHistory
+        (
+            const IOobject&,
+            const UPtrList<const labelList>& cellMaps,
+            const UPtrList<const refinementHistory>&
+        );
+
+        //- Construct from Istream. If global number of
+        //  visible cells > 0 becomes active
+        refinementHistory(const IOobject&, Istream&);
+
+
+    // Member Functions
+
+
+        //- Per cell in the current mesh (i.e. visible) either -1 (unrefined)
+        //  or an index into splitCells.
+        const labelList& visibleCells() const
+        {
+            return visibleCells_;
+        }
+
+        //- Storage for splitCell8s.
+        const DynamicList<splitCell8>& splitCells() const
+        {
+            return splitCells_;
+        }
+
+        //- Cache of unused indices in splitCells
+        const DynamicList<label>& freeSplitCells() const
+        {
+            return freeSplitCells_;
+        }
+
+        //- Is there unrefinement history?
+        bool active() const
+        {
+            return active_;
+        }
+
+        //- Is there unrefinement history?
+        bool& active()
+        {
+            return active_;
+        }
+
+        //- Get parent of cell
+        label parentIndex(const label celli) const
+        {
+            label index = visibleCells_[celli];
+
+            if (index < 0)
+            {
+                FatalErrorInFunction
+                    << "Cell " << celli << " is not visible"
+                    << abort(FatalError);
+            }
+            return splitCells_[index].parent_;
+        }
+
+        //- Store splitting of cell into 8
+        void storeSplit
+        (
+            const label celli,
+            const labelList& addedCells
+        );
+
+        //- Store combining 8 cells into master
+        void combineCells
+        (
+            const label masterCelli,
+            const labelList& combinedCells
+        );
+
+        //- Low level clone
+        autoPtr<refinementHistory> clone
+        (
+            const IOobject& io,
+            const labelList& decomposition,
+            const labelList& splitCellProc,
+            const labelList& splitCellNum,
+            const label procI,
+            labelList& oldToNewSplit
+        ) const;
+
+        //- Create clone from subset
+        autoPtr<refinementHistory> clone
+        (
+            const IOobject& io,
+            const labelList& cellMap
+        ) const;
+
+        //- Update numbering for mesh changes
+        void updateMesh(const mapPolyMesh&);
+
+        //- Update numbering for subsetting
+        void subset
+        (
+            const labelList& pointMap,
+            const labelList& faceMap,
+            const labelList& cellMap
+        );
+
+        //- Update local numbering for mesh redistribution.
+        //  Can only distribute clusters sent across in one go; cannot
+        //  handle parts recombined in multiple passes.
+        void distribute(const mapDistributePolyMesh&);
+
+
+        //- Compact splitCells_. Removes all freeSplitCells_ elements.
+        void compact();
+
+        //- Extend/shrink storage. additional visibleCells_ elements get
+        //  set to -1.
+        void resize(const label nCells);
+
+        //- Debug write
+        void writeDebug() const;
+
+
+        //- Read object. If global number of visible cells > 0 becomes active
+        virtual bool read();
+
+        //- ReadData function required for regIOobject read operation. Note:
+        //  does not do a reduction - does not set active_ flag
+        virtual bool readData(Istream&);
+
+        //- WriteData function required for regIOobject write operation
+        virtual bool writeData(Ostream&) const;
+
+        // Helpers for decompositionConstraint
+
+            //- Add my decomposition constraints
+            void add
+            (
+                boolList& blockedFace,
+                PtrList<labelList>& specifiedProcessorFaces,
+                labelList& specifiedProcessor,
+                List<labelPair>& explicitConnections
+            ) const;
+
+            //- Apply any additional post-decomposition constraints
+            void apply
+            (
+                const boolList& blockedFace,
+                const PtrList<labelList>& specifiedProcessorFaces,
+                const labelList& specifiedProcessor,
+                const List<labelPair>& explicitConnections,
+                labelList& decomposition
+            ) const;
+
+
+    // IOstream Operators
+
+        //- Istream operator. Note: does not do a reduction - does not set
+        //  active_ flag
+        friend Istream& operator>>(Istream&, refinementHistory&);
+
+        friend Ostream& operator<<(Ostream&, const refinementHistory&);
+};
+
+
+Istream& operator>>(Istream&, refinementHistory::splitCell8&);
+Ostream& operator<<(Ostream&, const refinementHistory::splitCell8&);
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

From 1bf0e9d94cc12ad91f7ae6275949950ee25f0f69 Mon Sep 17 00:00:00 2001
From: pkuLmq <1900011062@pku.edu.cn>
Date: Sun, 31 Jul 2022 21:15:47 +0800
Subject: [PATCH 02/10] add AMR and update code

---
 applications/solvers/dfHighSpeedFoam/dfHighSpeedFoam.C | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/applications/solvers/dfHighSpeedFoam/dfHighSpeedFoam.C b/applications/solvers/dfHighSpeedFoam/dfHighSpeedFoam.C
index 042d1a6a..a561db72 100644
--- a/applications/solvers/dfHighSpeedFoam/dfHighSpeedFoam.C
+++ b/applications/solvers/dfHighSpeedFoam/dfHighSpeedFoam.C
@@ -80,6 +80,15 @@ int main(int argc, char *argv[])
     {
         #include "readTimeControls.H"
 
+        tmp<volScalarField> tmagGradP = mag(fvc::grad(p));
+        volScalarField normalisedGradP
+        (
+            "normalisedGradP",
+            tmagGradP()/max(tmagGradP())
+        );
+        normalisedGradP.writeOpt() = IOobject::AUTO_WRITE;
+        tmagGradP.clear();
+
         if (!LTS)
         {
             #include "setDeltaT.H"

From 6c4331d4fcf5dfde384186ae676298c9f75500be Mon Sep 17 00:00:00 2001
From: pkuLmq <1900011062@pku.edu.cn>
Date: Tue, 16 Aug 2022 10:41:48 +0800
Subject: [PATCH 03/10] update AMR and examples

---
 .../multiCritRefinement.C                     |   2 +-
 AMR_tidy/hexRef/hexRef2/hexRef2.C             |  23 +-
 .../solvers/dfHighSpeedFoam/dfHighSpeedFoam.C |  21 +-
 .../0_orig/H2.gz                              | Bin
 .../0_orig/N2.gz                              | Bin
 .../0_orig/O2.gz                              | Bin
 .../0_orig/T.gz                               | Bin
 .../0_orig/U.gz                               | Bin
 .../0_orig/Ydefault.gz                        | Bin
 .../0_orig/p.gz                               | Bin
 .../Allclean                                  |   0
 .../Allrun                                    |   0
 .../H2_Li.xml                                 |   0
 .../constant/CanteraTorchProperties           |   9 +-
 .../constant/dynamicMeshDict                  |  68 +++
 .../constant/thermophysicalProperties         |   2 +-
 .../constant/turbulenceProperties             |   0
 .../system/blockMeshDict                      |   2 +-
 .../system/controlDict                        |  11 +-
 .../oneD_detonationH2/system/decomposeParDict |  32 ++
 .../system/fvSchemes                          |   0
 .../system/fvSolution                         |   0
 .../system/sample                             |   0
 .../system/setFieldsDict                      |   0
 .../oneD_reactiveShockTube/0_orig/AR          |  42 ++
 .../oneD_reactiveShockTube/0_orig/H2          |  41 ++
 .../oneD_reactiveShockTube/0_orig/O2          |  41 ++
 .../oneD_reactiveShockTube/0_orig/T           |  42 ++
 .../oneD_reactiveShockTube/0_orig/U           |  42 ++
 .../oneD_reactiveShockTube/0_orig/Ydefault    |  42 ++
 .../oneD_reactiveShockTube/0_orig/p           |  40 ++
 .../oneD_reactiveShockTube/Allclean           |  13 +
 .../oneD_reactiveShockTube/Allrun             |  13 +
 .../oneD_reactiveShockTube/H2_AR.xml          | 531 ++++++++++++++++++
 .../constant/CanteraTorchProperties           |  35 ++
 .../constant/thermophysicalProperties         |  18 +
 .../constant/turbulenceProperties             |  21 +
 .../system/blockMeshDict                      |  75 +++
 .../oneD_reactiveShockTube/system/controlDict |  59 ++
 .../system/decomposeParDict                   |   2 +-
 .../oneD_reactiveShockTube/system/fvSchemes   |  58 ++
 .../oneD_reactiveShockTube/system/fvSolution  |  67 +++
 .../oneD_reactiveShockTube/system/sample      |  39 ++
 .../system/setFieldsDict                      |  40 ++
 44 files changed, 1391 insertions(+), 40 deletions(-)
 rename examples/dfHighSpeedFoam/{det_1D_H2_01mm => oneD_detonationH2}/0_orig/H2.gz (100%)
 rename examples/dfHighSpeedFoam/{det_1D_H2_01mm => oneD_detonationH2}/0_orig/N2.gz (100%)
 rename examples/dfHighSpeedFoam/{det_1D_H2_01mm => oneD_detonationH2}/0_orig/O2.gz (100%)
 rename examples/dfHighSpeedFoam/{det_1D_H2_01mm => oneD_detonationH2}/0_orig/T.gz (100%)
 rename examples/dfHighSpeedFoam/{det_1D_H2_01mm => oneD_detonationH2}/0_orig/U.gz (100%)
 rename examples/dfHighSpeedFoam/{det_1D_H2_01mm => oneD_detonationH2}/0_orig/Ydefault.gz (100%)
 rename examples/dfHighSpeedFoam/{det_1D_H2_01mm => oneD_detonationH2}/0_orig/p.gz (100%)
 rename examples/dfHighSpeedFoam/{det_1D_H2_01mm => oneD_detonationH2}/Allclean (100%)
 rename examples/dfHighSpeedFoam/{det_1D_H2_01mm => oneD_detonationH2}/Allrun (100%)
 rename examples/dfHighSpeedFoam/{det_1D_H2_01mm => oneD_detonationH2}/H2_Li.xml (100%)
 rename examples/dfHighSpeedFoam/{det_1D_H2_01mm => oneD_detonationH2}/constant/CanteraTorchProperties (91%)
 create mode 100644 examples/dfHighSpeedFoam/oneD_detonationH2/constant/dynamicMeshDict
 rename examples/dfHighSpeedFoam/{det_1D_H2_01mm => oneD_detonationH2}/constant/thermophysicalProperties (97%)
 rename examples/dfHighSpeedFoam/{det_1D_H2_01mm => oneD_detonationH2}/constant/turbulenceProperties (100%)
 rename examples/dfHighSpeedFoam/{det_1D_H2_01mm => oneD_detonationH2}/system/blockMeshDict (95%)
 rename examples/dfHighSpeedFoam/{det_1D_H2_01mm => oneD_detonationH2}/system/controlDict (87%)
 create mode 100755 examples/dfHighSpeedFoam/oneD_detonationH2/system/decomposeParDict
 rename examples/dfHighSpeedFoam/{det_1D_H2_01mm => oneD_detonationH2}/system/fvSchemes (100%)
 rename examples/dfHighSpeedFoam/{det_1D_H2_01mm => oneD_detonationH2}/system/fvSolution (100%)
 rename examples/dfHighSpeedFoam/{det_1D_H2_01mm => oneD_detonationH2}/system/sample (100%)
 rename examples/dfHighSpeedFoam/{det_1D_H2_01mm => oneD_detonationH2}/system/setFieldsDict (100%)
 create mode 100755 examples/dfHighSpeedFoam/oneD_reactiveShockTube/0_orig/AR
 create mode 100755 examples/dfHighSpeedFoam/oneD_reactiveShockTube/0_orig/H2
 create mode 100755 examples/dfHighSpeedFoam/oneD_reactiveShockTube/0_orig/O2
 create mode 100755 examples/dfHighSpeedFoam/oneD_reactiveShockTube/0_orig/T
 create mode 100755 examples/dfHighSpeedFoam/oneD_reactiveShockTube/0_orig/U
 create mode 100755 examples/dfHighSpeedFoam/oneD_reactiveShockTube/0_orig/Ydefault
 create mode 100755 examples/dfHighSpeedFoam/oneD_reactiveShockTube/0_orig/p
 create mode 100755 examples/dfHighSpeedFoam/oneD_reactiveShockTube/Allclean
 create mode 100755 examples/dfHighSpeedFoam/oneD_reactiveShockTube/Allrun
 create mode 100755 examples/dfHighSpeedFoam/oneD_reactiveShockTube/H2_AR.xml
 create mode 100755 examples/dfHighSpeedFoam/oneD_reactiveShockTube/constant/CanteraTorchProperties
 create mode 100755 examples/dfHighSpeedFoam/oneD_reactiveShockTube/constant/thermophysicalProperties
 create mode 100755 examples/dfHighSpeedFoam/oneD_reactiveShockTube/constant/turbulenceProperties
 create mode 100755 examples/dfHighSpeedFoam/oneD_reactiveShockTube/system/blockMeshDict
 create mode 100755 examples/dfHighSpeedFoam/oneD_reactiveShockTube/system/controlDict
 rename examples/dfHighSpeedFoam/{det_1D_H2_01mm => oneD_reactiveShockTube}/system/decomposeParDict (96%)
 create mode 100755 examples/dfHighSpeedFoam/oneD_reactiveShockTube/system/fvSchemes
 create mode 100755 examples/dfHighSpeedFoam/oneD_reactiveShockTube/system/fvSolution
 create mode 100755 examples/dfHighSpeedFoam/oneD_reactiveShockTube/system/sample
 create mode 100755 examples/dfHighSpeedFoam/oneD_reactiveShockTube/system/setFieldsDict

diff --git a/AMR_tidy/dynamicRefineFvMeshNew/multiCritRefinement.C b/AMR_tidy/dynamicRefineFvMeshNew/multiCritRefinement.C
index 556763c1..9ac82af2 100644
--- a/AMR_tidy/dynamicRefineFvMeshNew/multiCritRefinement.C
+++ b/AMR_tidy/dynamicRefineFvMeshNew/multiCritRefinement.C
@@ -317,7 +317,7 @@ void Foam::multiCritRefinement::updateRefinementField()
                 IOobject::NO_WRITE,
                 false
             )
-        ).subDict("dynamicRefineFvMeshCoeffs")
+        ).subDict("dynamicRefineFvMeshNewCoeffs")
     );
     scalar globalMaxRefLevel = readScalar(refineDict.lookup("maxRefinement"));
 
diff --git a/AMR_tidy/hexRef/hexRef2/hexRef2.C b/AMR_tidy/hexRef/hexRef2/hexRef2.C
index fbcc9ea2..c1aaef5a 100644
--- a/AMR_tidy/hexRef/hexRef2/hexRef2.C
+++ b/AMR_tidy/hexRef/hexRef2/hexRef2.C
@@ -336,23 +336,6 @@ Foam::labelListList Foam::hexRef2::setRefinement
         isDivisibleEdge[edgeI] = false;
     }
 
-    // for (label facei = mesh_.nInternalFaces(); facei < mesh_.nFaces(); facei++)
-    // {
-    //     const label & patchID = mesh_.boundaryMesh().whichPatch(facei);
-
-    //     if (mesh_.boundaryMesh()[patchID].type() != "empty")
-    //     {
-    //         isDivisibleFace[facei] = false;
-    //         const labelList& fEdges = mesh_.faceEdges(facei);
-
-    //         forAll(fEdges, i)
-    //         {
-    //             label edgeI = fEdges[i];
-    //             isDivisibleEdge[edgeI] = false;
-    //         }
-    //     }
-    // }
-
     for (label facei = 0; facei < mesh_.nInternalFaces(); facei++)
     {
         isDivisibleFace[facei] = false;
@@ -898,11 +881,13 @@ Foam::labelListList Foam::hexRef2::setRefinement
                 face newFace(2);
 
                 // maybe need to adjust the point order
-                DynamicList<label> faceVerts(4);
-                
+                // DynamicList<label> faceVerts(4);              
 
                 forAll(f, fp)
                 {
+                    //maybe need to put inside (but nothing wrong to be put outside)
+                    DynamicList<label> faceVerts(4);
+
                     label pointi = f[fp];
 
                     label nextpointi = f[f.fcIndex(fp)];
diff --git a/applications/solvers/dfHighSpeedFoam/dfHighSpeedFoam.C b/applications/solvers/dfHighSpeedFoam/dfHighSpeedFoam.C
index a561db72..3088e778 100644
--- a/applications/solvers/dfHighSpeedFoam/dfHighSpeedFoam.C
+++ b/applications/solvers/dfHighSpeedFoam/dfHighSpeedFoam.C
@@ -60,6 +60,7 @@ int main(int argc, char *argv[])
     double time_monitor_flow;
     double time_monitor_chem;
     double time_monitor_Y;
+    double time_monitor_AMR;
     clock_t start, end;
 
     turbulence->validate();
@@ -69,6 +70,7 @@ int main(int argc, char *argv[])
     #include "readFluxScheme.H"
 
     dimensionedScalar v_zero("v_zero", dimVolume/dimTime, 0.0);
+    dimensionedScalar refCri("refCri", dimensionSet(1, -4, 0, 0, 0), 0.0);
 
     // Courant numbers used to adjust the time-step
     scalar CoNum = 0.0;
@@ -80,14 +82,16 @@ int main(int argc, char *argv[])
     {
         #include "readTimeControls.H"
 
-        tmp<volScalarField> tmagGradP = mag(fvc::grad(p));
-        volScalarField normalisedGradP
+        //used for AMR
+        refCri = max(mag(fvc::grad(rho)));
+        tmp<volScalarField> tmagGradrho = mag(fvc::grad(rho));
+        volScalarField normalisedGradrho
         (
-            "normalisedGradP",
-            tmagGradP()/max(tmagGradP())
+            "normalisedGradrho",
+            tmagGradrho()/refCri
         );
-        normalisedGradP.writeOpt() = IOobject::AUTO_WRITE;
-        tmagGradP.clear();
+        normalisedGradrho.writeOpt() = IOobject::AUTO_WRITE;
+        tmagGradrho.clear();
 
         if (!LTS)
         {
@@ -95,7 +99,11 @@ int main(int argc, char *argv[])
             runTime++;
 
             // Do any mesh changes
+            start = std::clock();
             mesh.update();
+            end = std::clock();
+            time_monitor_AMR += double(end - start) / double(CLOCKS_PER_SEC);
+            
         }
 
         // --- Directed interpolation of primitive fields onto faces
@@ -234,6 +242,7 @@ int main(int argc, char *argv[])
         Info<< "MonitorTime_chem = " << time_monitor_chem << " s" << nl << endl;
         Info<< "MonitorTime_Y = " << time_monitor_Y << " s" << nl << endl;
         Info<< "MonitorTime_flow = " << time_monitor_flow << " s" << nl << endl;
+        Info<< "MonitorTime_AMR = " << time_monitor_AMR << " s" << nl << endl;
 
         Info<< "ExecutionTime = " << runTime.elapsedCpuTime() << " s"
             << "  ClockTime = " << runTime.elapsedClockTime() << " s"
diff --git a/examples/dfHighSpeedFoam/det_1D_H2_01mm/0_orig/H2.gz b/examples/dfHighSpeedFoam/oneD_detonationH2/0_orig/H2.gz
similarity index 100%
rename from examples/dfHighSpeedFoam/det_1D_H2_01mm/0_orig/H2.gz
rename to examples/dfHighSpeedFoam/oneD_detonationH2/0_orig/H2.gz
diff --git a/examples/dfHighSpeedFoam/det_1D_H2_01mm/0_orig/N2.gz b/examples/dfHighSpeedFoam/oneD_detonationH2/0_orig/N2.gz
similarity index 100%
rename from examples/dfHighSpeedFoam/det_1D_H2_01mm/0_orig/N2.gz
rename to examples/dfHighSpeedFoam/oneD_detonationH2/0_orig/N2.gz
diff --git a/examples/dfHighSpeedFoam/det_1D_H2_01mm/0_orig/O2.gz b/examples/dfHighSpeedFoam/oneD_detonationH2/0_orig/O2.gz
similarity index 100%
rename from examples/dfHighSpeedFoam/det_1D_H2_01mm/0_orig/O2.gz
rename to examples/dfHighSpeedFoam/oneD_detonationH2/0_orig/O2.gz
diff --git a/examples/dfHighSpeedFoam/det_1D_H2_01mm/0_orig/T.gz b/examples/dfHighSpeedFoam/oneD_detonationH2/0_orig/T.gz
similarity index 100%
rename from examples/dfHighSpeedFoam/det_1D_H2_01mm/0_orig/T.gz
rename to examples/dfHighSpeedFoam/oneD_detonationH2/0_orig/T.gz
diff --git a/examples/dfHighSpeedFoam/det_1D_H2_01mm/0_orig/U.gz b/examples/dfHighSpeedFoam/oneD_detonationH2/0_orig/U.gz
similarity index 100%
rename from examples/dfHighSpeedFoam/det_1D_H2_01mm/0_orig/U.gz
rename to examples/dfHighSpeedFoam/oneD_detonationH2/0_orig/U.gz
diff --git a/examples/dfHighSpeedFoam/det_1D_H2_01mm/0_orig/Ydefault.gz b/examples/dfHighSpeedFoam/oneD_detonationH2/0_orig/Ydefault.gz
similarity index 100%
rename from examples/dfHighSpeedFoam/det_1D_H2_01mm/0_orig/Ydefault.gz
rename to examples/dfHighSpeedFoam/oneD_detonationH2/0_orig/Ydefault.gz
diff --git a/examples/dfHighSpeedFoam/det_1D_H2_01mm/0_orig/p.gz b/examples/dfHighSpeedFoam/oneD_detonationH2/0_orig/p.gz
similarity index 100%
rename from examples/dfHighSpeedFoam/det_1D_H2_01mm/0_orig/p.gz
rename to examples/dfHighSpeedFoam/oneD_detonationH2/0_orig/p.gz
diff --git a/examples/dfHighSpeedFoam/det_1D_H2_01mm/Allclean b/examples/dfHighSpeedFoam/oneD_detonationH2/Allclean
similarity index 100%
rename from examples/dfHighSpeedFoam/det_1D_H2_01mm/Allclean
rename to examples/dfHighSpeedFoam/oneD_detonationH2/Allclean
diff --git a/examples/dfHighSpeedFoam/det_1D_H2_01mm/Allrun b/examples/dfHighSpeedFoam/oneD_detonationH2/Allrun
similarity index 100%
rename from examples/dfHighSpeedFoam/det_1D_H2_01mm/Allrun
rename to examples/dfHighSpeedFoam/oneD_detonationH2/Allrun
diff --git a/examples/dfHighSpeedFoam/det_1D_H2_01mm/H2_Li.xml b/examples/dfHighSpeedFoam/oneD_detonationH2/H2_Li.xml
similarity index 100%
rename from examples/dfHighSpeedFoam/det_1D_H2_01mm/H2_Li.xml
rename to examples/dfHighSpeedFoam/oneD_detonationH2/H2_Li.xml
diff --git a/examples/dfHighSpeedFoam/det_1D_H2_01mm/constant/CanteraTorchProperties b/examples/dfHighSpeedFoam/oneD_detonationH2/constant/CanteraTorchProperties
similarity index 91%
rename from examples/dfHighSpeedFoam/det_1D_H2_01mm/constant/CanteraTorchProperties
rename to examples/dfHighSpeedFoam/oneD_detonationH2/constant/CanteraTorchProperties
index 3436a18a..640b9e14 100755
--- a/examples/dfHighSpeedFoam/det_1D_H2_01mm/constant/CanteraTorchProperties
+++ b/examples/dfHighSpeedFoam/oneD_detonationH2/constant/CanteraTorchProperties
@@ -21,8 +21,8 @@ CanteraMechanismFile "H2_Li.xml";
 transportModel "UnityLewis";
 loadbalancing
 {
-        active  false;
-        //log   true;
+        active  true;
+        log   true;
 }
 odeCoeffs
 {}
@@ -32,9 +32,4 @@ zeroDReactor
 {
     //cvorcp "UV";
 }
-loadbalancing
-{
-        active  true;
-        //log   true;
-}
 // ************************************************************************* //
diff --git a/examples/dfHighSpeedFoam/oneD_detonationH2/constant/dynamicMeshDict b/examples/dfHighSpeedFoam/oneD_detonationH2/constant/dynamicMeshDict
new file mode 100644
index 00000000..cf838491
--- /dev/null
+++ b/examples/dfHighSpeedFoam/oneD_detonationH2/constant/dynamicMeshDict
@@ -0,0 +1,68 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Version:  7
+     \\/     M anipulation  |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    location    "constant";
+    object      dynamicMeshDict;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+dynamicFvMesh   dynamicRefineFvMeshNew;
+
+multiCritRefinementControls
+{
+    enableMultiCritRefinementControl  false;
+}
+
+dynamicRefineFvMeshNewCoeffs
+{
+    // How often to refine
+    refineInterval  1; 
+
+    // Field to be refinement on
+    field           normalisedGradrho;
+
+    // Refine field in between lower..upper
+    lowerRefineLevel 0.2;
+    upperRefineLevel 1;
+
+    // If value < unrefineLevel unrefine
+    unrefineLevel   0.2;
+
+    // Have slower than 2:1 refinement
+    nBufferLayers   3;
+
+    // Refine cells only up to maxRefinement levels
+    maxRefinement   3;
+
+    // Stop refinement if maxCells reached
+    maxCells        1000000;
+
+    // Flux field and corresponding velocity field. Fluxes on changed
+    // faces get recalculated by interpolating the velocity. Use 'none'
+    // on surfaceScalarFields that do not need to be reinterpolated.
+    correctFluxes
+    (
+        (phi none)
+        //(nHatf none) 
+        //(rhoPhi none)
+        //(alphaPhi0.water none)
+        //(ghf none)
+        (neg none)
+        (pos none)
+    );
+
+    // Write the refinement level as a volScalarField
+    dumpLevel       true;
+}
+
+
+// ************************************************************************* //
diff --git a/examples/dfHighSpeedFoam/det_1D_H2_01mm/constant/thermophysicalProperties b/examples/dfHighSpeedFoam/oneD_detonationH2/constant/thermophysicalProperties
similarity index 97%
rename from examples/dfHighSpeedFoam/det_1D_H2_01mm/constant/thermophysicalProperties
rename to examples/dfHighSpeedFoam/oneD_detonationH2/constant/thermophysicalProperties
index e983a193..873b8e16 100755
--- a/examples/dfHighSpeedFoam/det_1D_H2_01mm/constant/thermophysicalProperties
+++ b/examples/dfHighSpeedFoam/oneD_detonationH2/constant/thermophysicalProperties
@@ -14,5 +14,5 @@ FoamFile
     object      thermophysicalProperties;
 }
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-inviscid      true;
+inviscid      false;
 // ************************************************************************* //
diff --git a/examples/dfHighSpeedFoam/det_1D_H2_01mm/constant/turbulenceProperties b/examples/dfHighSpeedFoam/oneD_detonationH2/constant/turbulenceProperties
similarity index 100%
rename from examples/dfHighSpeedFoam/det_1D_H2_01mm/constant/turbulenceProperties
rename to examples/dfHighSpeedFoam/oneD_detonationH2/constant/turbulenceProperties
diff --git a/examples/dfHighSpeedFoam/det_1D_H2_01mm/system/blockMeshDict b/examples/dfHighSpeedFoam/oneD_detonationH2/system/blockMeshDict
similarity index 95%
rename from examples/dfHighSpeedFoam/det_1D_H2_01mm/system/blockMeshDict
rename to examples/dfHighSpeedFoam/oneD_detonationH2/system/blockMeshDict
index 1a73e764..921bd986 100755
--- a/examples/dfHighSpeedFoam/det_1D_H2_01mm/system/blockMeshDict
+++ b/examples/dfHighSpeedFoam/oneD_detonationH2/system/blockMeshDict
@@ -30,7 +30,7 @@ vertices
 
 blocks
 (
-    hex (0 1 2 3 4 5 6 7) (5000 1 1) simpleGrading (1 1 1)
+    hex (0 1 2 3 4 5 6 7) (625 1 1) simpleGrading (1 1 1)
 );
 
 edges
diff --git a/examples/dfHighSpeedFoam/det_1D_H2_01mm/system/controlDict b/examples/dfHighSpeedFoam/oneD_detonationH2/system/controlDict
similarity index 87%
rename from examples/dfHighSpeedFoam/det_1D_H2_01mm/system/controlDict
rename to examples/dfHighSpeedFoam/oneD_detonationH2/system/controlDict
index 57ed5645..d897bd2d 100755
--- a/examples/dfHighSpeedFoam/det_1D_H2_01mm/system/controlDict
+++ b/examples/dfHighSpeedFoam/oneD_detonationH2/system/controlDict
@@ -14,7 +14,10 @@ FoamFile
     object      controlDict;
 }
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-libs ("libfieldFunctionObjects.so");
+libs (
+      "libfieldFunctionObjects.so"
+      "libnewdynamicFvMesh.so"
+      );
 
 application     dfHighSpeedFoam;
 
@@ -24,7 +27,7 @@ startTime       0;
 
 stopAt          endTime;
 
-endTime         2.4e-4;
+endTime         2.2e-4;
 
 deltaT          1e-09;
 
@@ -48,7 +51,7 @@ runTimeModifiable true;
 
 adjustTimeStep  yes;
 
-maxCo           0.02;
+maxCo           0.1;
 
 maxDeltaT       1;
 
@@ -58,7 +61,7 @@ functions
     {
       type          fieldMinMax;
       libs          ("libfieldFunctionObjects.so");
-      writeControl  timeStep; //writeTime;
+      writeControl  writeTime; //timeStep;
       fields        (p);
     }
 }
diff --git a/examples/dfHighSpeedFoam/oneD_detonationH2/system/decomposeParDict b/examples/dfHighSpeedFoam/oneD_detonationH2/system/decomposeParDict
new file mode 100755
index 00000000..a9715975
--- /dev/null
+++ b/examples/dfHighSpeedFoam/oneD_detonationH2/system/decomposeParDict
@@ -0,0 +1,32 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Version:  7
+     \\/     M anipulation  |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    location    "system";
+    object      decomposeParDict;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+numberOfSubdomains  4;
+
+method          scotch;
+
+constraints
+{
+    refinementHistory
+    {
+        //- Decompose cells such that all cell originating from single cell
+        //  end up on same processor
+        type    refinementHistory;
+    }
+}
+
+// ************************************************************************* //
diff --git a/examples/dfHighSpeedFoam/det_1D_H2_01mm/system/fvSchemes b/examples/dfHighSpeedFoam/oneD_detonationH2/system/fvSchemes
similarity index 100%
rename from examples/dfHighSpeedFoam/det_1D_H2_01mm/system/fvSchemes
rename to examples/dfHighSpeedFoam/oneD_detonationH2/system/fvSchemes
diff --git a/examples/dfHighSpeedFoam/det_1D_H2_01mm/system/fvSolution b/examples/dfHighSpeedFoam/oneD_detonationH2/system/fvSolution
similarity index 100%
rename from examples/dfHighSpeedFoam/det_1D_H2_01mm/system/fvSolution
rename to examples/dfHighSpeedFoam/oneD_detonationH2/system/fvSolution
diff --git a/examples/dfHighSpeedFoam/det_1D_H2_01mm/system/sample b/examples/dfHighSpeedFoam/oneD_detonationH2/system/sample
similarity index 100%
rename from examples/dfHighSpeedFoam/det_1D_H2_01mm/system/sample
rename to examples/dfHighSpeedFoam/oneD_detonationH2/system/sample
diff --git a/examples/dfHighSpeedFoam/det_1D_H2_01mm/system/setFieldsDict b/examples/dfHighSpeedFoam/oneD_detonationH2/system/setFieldsDict
similarity index 100%
rename from examples/dfHighSpeedFoam/det_1D_H2_01mm/system/setFieldsDict
rename to examples/dfHighSpeedFoam/oneD_detonationH2/system/setFieldsDict
diff --git a/examples/dfHighSpeedFoam/oneD_reactiveShockTube/0_orig/AR b/examples/dfHighSpeedFoam/oneD_reactiveShockTube/0_orig/AR
new file mode 100755
index 00000000..4a7914aa
--- /dev/null
+++ b/examples/dfHighSpeedFoam/oneD_reactiveShockTube/0_orig/AR
@@ -0,0 +1,42 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Version:  7
+     \\/     M anipulation  |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       volScalarField;
+    location    "0";
+    object      AR;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+dimensions      [0 0 0 0 0 0 0];
+
+internalField   uniform 0.8861; 
+
+
+boundaryField
+{
+    Left
+    {
+        type            zeroGradient;
+    }
+    
+    Right
+    {
+        type            zeroGradient;
+    }
+
+    empty
+    {
+        type            empty;
+    }
+}
+
+
+// ************************************************************************* //
diff --git a/examples/dfHighSpeedFoam/oneD_reactiveShockTube/0_orig/H2 b/examples/dfHighSpeedFoam/oneD_reactiveShockTube/0_orig/H2
new file mode 100755
index 00000000..6c9c8e4c
--- /dev/null
+++ b/examples/dfHighSpeedFoam/oneD_reactiveShockTube/0_orig/H2
@@ -0,0 +1,41 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Version:  7
+     \\/     M anipulation  |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       volScalarField;
+    location    "0";
+    object      H2;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+dimensions      [0 0 0 0 0 0 0];
+
+internalField   uniform 0.01266;
+
+
+boundaryField
+{
+    Left
+    {
+        type            zeroGradient;
+    }
+    
+    Right
+    {
+        type            zeroGradient;
+    }
+
+    empty
+    {
+        type            empty;
+    }
+}
+
+// ************************************************************************* //
diff --git a/examples/dfHighSpeedFoam/oneD_reactiveShockTube/0_orig/O2 b/examples/dfHighSpeedFoam/oneD_reactiveShockTube/0_orig/O2
new file mode 100755
index 00000000..4d6f7000
--- /dev/null
+++ b/examples/dfHighSpeedFoam/oneD_reactiveShockTube/0_orig/O2
@@ -0,0 +1,41 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Version:  7
+     \\/     M anipulation  |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       volScalarField;
+    location    "0";
+    object      O2;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+dimensions      [0 0 0 0 0 0 0];
+
+internalField   uniform 0.101266;
+
+
+boundaryField
+{
+    Left
+    {
+        type            zeroGradient;
+    }
+    
+    Right
+    {
+        type            zeroGradient;
+    }
+
+    empty
+    {
+        type            empty;
+    }
+}
+
+// ************************************************************************* //
diff --git a/examples/dfHighSpeedFoam/oneD_reactiveShockTube/0_orig/T b/examples/dfHighSpeedFoam/oneD_reactiveShockTube/0_orig/T
new file mode 100755
index 00000000..eecff994
--- /dev/null
+++ b/examples/dfHighSpeedFoam/oneD_reactiveShockTube/0_orig/T
@@ -0,0 +1,42 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Version:  7
+     \\/     M anipulation  |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       volScalarField;
+    object      T;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+dimensions      [0 0 0 1 0 0 0];
+
+internalField   uniform 0.913683;
+//internalField   uniform 300;
+
+boundaryField
+{
+    Left
+    {
+        type            zeroGradient;
+    }
+    
+    Right
+    {
+        type            inletOutlet;
+        inletValue      uniform 748.472;
+        value           uniform 748.472;
+    }
+
+    empty
+    {
+        type            empty;
+    }
+}
+
+// ************************************************************************* //
diff --git a/examples/dfHighSpeedFoam/oneD_reactiveShockTube/0_orig/U b/examples/dfHighSpeedFoam/oneD_reactiveShockTube/0_orig/U
new file mode 100755
index 00000000..4d76526e
--- /dev/null
+++ b/examples/dfHighSpeedFoam/oneD_reactiveShockTube/0_orig/U
@@ -0,0 +1,42 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Version:  7
+     \\/     M anipulation  |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       volVectorField;
+    object      U;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+dimensions      [0 1 -1 0 0 0 0];
+
+internalField   uniform (0 0 0);
+
+boundaryField
+{
+    Left
+    {
+        type            fixedValue;
+        value           uniform (0 0 0);
+    }
+    
+    Right
+    {
+        type            inletOutlet;
+        inletValue      uniform (-487.34 0 0);
+        value           uniform (-487.34 0 0);
+    }
+
+    empty
+    {
+        type            empty;
+    }
+}
+
+// ************************************************************************* //
diff --git a/examples/dfHighSpeedFoam/oneD_reactiveShockTube/0_orig/Ydefault b/examples/dfHighSpeedFoam/oneD_reactiveShockTube/0_orig/Ydefault
new file mode 100755
index 00000000..7e583b1e
--- /dev/null
+++ b/examples/dfHighSpeedFoam/oneD_reactiveShockTube/0_orig/Ydefault
@@ -0,0 +1,42 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Version:  7
+     \\/     M anipulation  |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       volScalarField;
+    location    "0";
+    object      Ydefault;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+dimensions      [0 0 0 0 0 0 0];
+
+internalField   uniform 0.0;
+
+boundaryField
+{
+    Left
+    {
+        type            zeroGradient;
+    }
+    
+    Right
+    {
+        type            zeroGradient;
+    }
+
+    empty
+    {
+        type            empty;
+    }
+}
+
+
+
+// ************************************************************************* //
diff --git a/examples/dfHighSpeedFoam/oneD_reactiveShockTube/0_orig/p b/examples/dfHighSpeedFoam/oneD_reactiveShockTube/0_orig/p
new file mode 100755
index 00000000..2b26b604
--- /dev/null
+++ b/examples/dfHighSpeedFoam/oneD_reactiveShockTube/0_orig/p
@@ -0,0 +1,40 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Version:  7
+     \\/     M anipulation  |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       volScalarField;
+    object      p;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+dimensions      [1 -1 -2 0 0 0 0];
+
+internalField   uniform 35594;
+
+boundaryField
+{
+    Left
+    {
+        type            zeroGradient;
+    }
+    
+    Right
+    {
+        type            fixedValue;
+        value           uniform 35594;
+    }
+
+    empty
+    {
+        type            empty;
+    }
+}
+
+// ************************************************************************* //
diff --git a/examples/dfHighSpeedFoam/oneD_reactiveShockTube/Allclean b/examples/dfHighSpeedFoam/oneD_reactiveShockTube/Allclean
new file mode 100755
index 00000000..e40b9408
--- /dev/null
+++ b/examples/dfHighSpeedFoam/oneD_reactiveShockTube/Allclean
@@ -0,0 +1,13 @@
+#!/bin/sh
+cd ${0%/*} || exit 1    # Run from this directory
+
+echo "Cleaning log.*"
+rm log.*
+echo "Cleaning processor*"
+rm -r processor*
+echo "Cleaning polyMesh/"
+rm -r constant/polyMesh
+echo "Cleaning postProcessing/"
+rm -r postProcessing
+echo "Cleaning 0/"
+rm -r 0
\ No newline at end of file
diff --git a/examples/dfHighSpeedFoam/oneD_reactiveShockTube/Allrun b/examples/dfHighSpeedFoam/oneD_reactiveShockTube/Allrun
new file mode 100755
index 00000000..f9647173
--- /dev/null
+++ b/examples/dfHighSpeedFoam/oneD_reactiveShockTube/Allrun
@@ -0,0 +1,13 @@
+#!/bin/sh
+cd ${0%/*} || exit 1    # Run from this directory
+
+# Source tutorial run functions
+. $WM_PROJECT_DIR/bin/tools/RunFunctions
+
+application=dfHighSpeedFoam
+
+cp -r 0_orig/ 0/
+runApplication blockMesh
+runApplication setFields
+runApplication decomposePar
+runApplication mpirun -np 5 $application -parallel
diff --git a/examples/dfHighSpeedFoam/oneD_reactiveShockTube/H2_AR.xml b/examples/dfHighSpeedFoam/oneD_reactiveShockTube/H2_AR.xml
new file mode 100755
index 00000000..4945c984
--- /dev/null
+++ b/examples/dfHighSpeedFoam/oneD_reactiveShockTube/H2_AR.xml
@@ -0,0 +1,531 @@
+<?xml version="1.0"?>
+<ctml>
+  <validate species="yes" reactions="yes"/>
+
+  <!-- phase gas     -->
+  <phase id="gas" dim="3">
+    <elementArray datasrc="elements.xml">H O Ar</elementArray>
+    <speciesArray datasrc="#species_data">H2    O2    H     O     OH    HO2   H2O2  H2O   AR</speciesArray>
+    <reactionArray datasrc="#reaction_data"/>
+    <state>
+      <temperature units="K">300.0</temperature>
+      <pressure units="Pa">101325.0</pressure>
+    </state>
+    <thermo model="IdealGas"/>
+    <kinetics model="GasKinetics"/>
+    <transport model="Mix"/>
+  </phase>
+
+  <!-- species definitions     -->
+  <speciesData id="species_data">
+
+    <!-- species H2    -->
+    <species name="H2">
+      <atomArray>H:2 </atomArray>
+      <note>TPIS78</note>
+      <thermo>
+        <NASA Tmin="200.0" Tmax="1000.0" P0="100000.0">
+           <floatArray size="7" name="coeffs">
+             2.344331120E+00,   7.980520750E-03,  -1.947815100E-05,   2.015720940E-08, 
+             -7.376117610E-12,  -9.179351730E+02,   6.830102380E-01</floatArray>
+        </NASA>
+        <NASA Tmin="1000.0" Tmax="3500.0" P0="100000.0">
+           <floatArray size="7" name="coeffs">
+             3.337279200E+00,  -4.940247310E-05,   4.994567780E-07,  -1.795663940E-10, 
+             2.002553760E-14,  -9.501589220E+02,  -3.205023310E+00</floatArray>
+        </NASA>
+      </thermo>
+      <transport model="gas_transport">
+        <string title="geometry">linear</string>
+        <LJ_welldepth units="K">38.000</LJ_welldepth>
+        <LJ_diameter units="A">2.920</LJ_diameter>
+        <dipoleMoment units="Debye">0.000</dipoleMoment>
+        <polarizability units="A3">0.790</polarizability>
+        <rotRelax>280.000</rotRelax>
+        <dispersion_coefficient units="A5">0.000</dispersion_coefficient>
+        <quadrupole_polarizability units="A5">0.000</quadrupole_polarizability>
+      </transport>
+    </species>
+
+    <!-- species O2    -->
+    <species name="O2">
+      <atomArray>O:2 </atomArray>
+      <note>TPIS89</note>
+      <thermo>
+        <NASA Tmin="200.0" Tmax="1000.0" P0="100000.0">
+           <floatArray size="7" name="coeffs">
+             3.782456360E+00,  -2.996734160E-03,   9.847302010E-06,  -9.681295090E-09, 
+             3.243728370E-12,  -1.063943560E+03,   3.657675730E+00</floatArray>
+        </NASA>
+        <NASA Tmin="1000.0" Tmax="3500.0" P0="100000.0">
+           <floatArray size="7" name="coeffs">
+             3.282537840E+00,   1.483087540E-03,  -7.579666690E-07,   2.094705550E-10, 
+             -2.167177940E-14,  -1.088457720E+03,   5.453231290E+00</floatArray>
+        </NASA>
+      </thermo>
+      <transport model="gas_transport">
+        <string title="geometry">linear</string>
+        <LJ_welldepth units="K">107.400</LJ_welldepth>
+        <LJ_diameter units="A">3.458</LJ_diameter>
+        <dipoleMoment units="Debye">0.000</dipoleMoment>
+        <polarizability units="A3">1.600</polarizability>
+        <rotRelax>3.800</rotRelax>
+        <dispersion_coefficient units="A5">0.000</dispersion_coefficient>
+        <quadrupole_polarizability units="A5">0.000</quadrupole_polarizability>
+      </transport>
+    </species>
+
+    <!-- species H    -->
+    <species name="H">
+      <atomArray>H:1 </atomArray>
+      <note>L7/88</note>
+      <thermo>
+        <NASA Tmin="200.0" Tmax="1000.0" P0="100000.0">
+           <floatArray size="7" name="coeffs">
+             2.500000000E+00,   7.053328190E-13,  -1.995919640E-15,   2.300816320E-18, 
+             -9.277323320E-22,   2.547365990E+04,  -4.466828530E-01</floatArray>
+        </NASA>
+        <NASA Tmin="1000.0" Tmax="3500.0" P0="100000.0">
+           <floatArray size="7" name="coeffs">
+             2.500000010E+00,  -2.308429730E-11,   1.615619480E-14,  -4.735152350E-18, 
+             4.981973570E-22,   2.547365990E+04,  -4.466829140E-01</floatArray>
+        </NASA>
+      </thermo>
+      <transport model="gas_transport">
+        <string title="geometry">atom</string>
+        <LJ_welldepth units="K">145.000</LJ_welldepth>
+        <LJ_diameter units="A">2.050</LJ_diameter>
+        <dipoleMoment units="Debye">0.000</dipoleMoment>
+        <polarizability units="A3">0.000</polarizability>
+        <rotRelax>0.000</rotRelax>
+        <dispersion_coefficient units="A5">0.000</dispersion_coefficient>
+        <quadrupole_polarizability units="A5">0.000</quadrupole_polarizability>
+      </transport>
+    </species>
+
+    <!-- species O    -->
+    <species name="O">
+      <atomArray>O:1 </atomArray>
+      <note>L1/90</note>
+      <thermo>
+        <NASA Tmin="200.0" Tmax="1000.0" P0="100000.0">
+           <floatArray size="7" name="coeffs">
+             3.168267100E+00,  -3.279318840E-03,   6.643063960E-06,  -6.128066240E-09, 
+             2.112659710E-12,   2.912225920E+04,   2.051933460E+00</floatArray>
+        </NASA>
+        <NASA Tmin="1000.0" Tmax="3500.0" P0="100000.0">
+           <floatArray size="7" name="coeffs">
+             2.569420780E+00,  -8.597411370E-05,   4.194845890E-08,  -1.001777990E-11, 
+             1.228336910E-15,   2.921757910E+04,   4.784338640E+00</floatArray>
+        </NASA>
+      </thermo>
+      <transport model="gas_transport">
+        <string title="geometry">atom</string>
+        <LJ_welldepth units="K">80.000</LJ_welldepth>
+        <LJ_diameter units="A">2.750</LJ_diameter>
+        <dipoleMoment units="Debye">0.000</dipoleMoment>
+        <polarizability units="A3">0.000</polarizability>
+        <rotRelax>0.000</rotRelax>
+        <dispersion_coefficient units="A5">0.000</dispersion_coefficient>
+        <quadrupole_polarizability units="A5">0.000</quadrupole_polarizability>
+      </transport>
+    </species>
+
+    <!-- species OH    -->
+    <species name="OH">
+      <atomArray>H:1 O:1 </atomArray>
+      <note>S9/01</note>
+      <thermo>
+        <NASA Tmin="200.0" Tmax="1000.0" P0="100000.0">
+           <floatArray size="7" name="coeffs">
+             4.125305610E+00,  -3.225449390E-03,   6.527646910E-06,  -5.798536430E-09, 
+             2.062373790E-12,   3.381538120E+03,  -6.904329600E-01</floatArray>
+        </NASA>
+        <NASA Tmin="1000.0" Tmax="6000.0" P0="100000.0">
+           <floatArray size="7" name="coeffs">
+             2.864728860E+00,   1.056504480E-03,  -2.590827580E-07,   3.052186740E-11, 
+             -1.331958760E-15,   3.718857740E+03,   5.701640730E+00</floatArray>
+        </NASA>
+      </thermo>
+      <transport model="gas_transport">
+        <string title="geometry">linear</string>
+        <LJ_welldepth units="K">80.000</LJ_welldepth>
+        <LJ_diameter units="A">2.750</LJ_diameter>
+        <dipoleMoment units="Debye">0.000</dipoleMoment>
+        <polarizability units="A3">0.000</polarizability>
+        <rotRelax>0.000</rotRelax>
+        <dispersion_coefficient units="A5">0.000</dispersion_coefficient>
+        <quadrupole_polarizability units="A5">0.000</quadrupole_polarizability>
+      </transport>
+    </species>
+
+    <!-- species HO2    -->
+    <species name="HO2">
+      <atomArray>H:1 O:2 </atomArray>
+      <note>L5/89</note>
+      <thermo>
+        <NASA Tmin="200.0" Tmax="1000.0" P0="100000.0">
+           <floatArray size="7" name="coeffs">
+             4.301798010E+00,  -4.749120510E-03,   2.115828910E-05,  -2.427638940E-08, 
+             9.292251240E-12,   2.948080400E+02,   3.716662450E+00</floatArray>
+        </NASA>
+        <NASA Tmin="1000.0" Tmax="3500.0" P0="100000.0">
+           <floatArray size="7" name="coeffs">
+             4.017210900E+00,   2.239820130E-03,  -6.336581500E-07,   1.142463700E-10, 
+             -1.079085350E-14,   1.118567130E+02,   3.785102150E+00</floatArray>
+        </NASA>
+      </thermo>
+      <transport model="gas_transport">
+        <string title="geometry">nonlinear</string>
+        <LJ_welldepth units="K">107.400</LJ_welldepth>
+        <LJ_diameter units="A">3.458</LJ_diameter>
+        <dipoleMoment units="Debye">0.000</dipoleMoment>
+        <polarizability units="A3">0.000</polarizability>
+        <rotRelax>1.000</rotRelax>
+        <dispersion_coefficient units="A5">0.000</dispersion_coefficient>
+        <quadrupole_polarizability units="A5">0.000</quadrupole_polarizability>
+      </transport>
+    </species>
+
+    <!-- species H2O2    -->
+    <species name="H2O2">
+      <atomArray>H:2 O:2 </atomArray>
+      <note>L7/88</note>
+      <thermo>
+        <NASA Tmin="200.0" Tmax="1000.0" P0="100000.0">
+           <floatArray size="7" name="coeffs">
+             4.276112690E+00,  -5.428224170E-04,   1.673357010E-05,  -2.157708130E-08, 
+             8.624543630E-12,  -1.770258210E+04,   3.435050740E+00</floatArray>
+        </NASA>
+        <NASA Tmin="1000.0" Tmax="3500.0" P0="100000.0">
+           <floatArray size="7" name="coeffs">
+             4.165002850E+00,   4.908316940E-03,  -1.901392250E-06,   3.711859860E-10, 
+             -2.879083050E-14,  -1.786178770E+04,   2.916156620E+00</floatArray>
+        </NASA>
+      </thermo>
+      <transport model="gas_transport">
+        <string title="geometry">nonlinear</string>
+        <LJ_welldepth units="K">107.400</LJ_welldepth>
+        <LJ_diameter units="A">3.458</LJ_diameter>
+        <dipoleMoment units="Debye">0.000</dipoleMoment>
+        <polarizability units="A3">0.000</polarizability>
+        <rotRelax>3.800</rotRelax>
+        <dispersion_coefficient units="A5">0.000</dispersion_coefficient>
+        <quadrupole_polarizability units="A5">0.000</quadrupole_polarizability>
+      </transport>
+    </species>
+
+    <!-- species H2O    -->
+    <species name="H2O">
+      <atomArray>H:2 O:1 </atomArray>
+      <note>L8/89</note>
+      <thermo>
+        <NASA Tmin="200.0" Tmax="1000.0" P0="100000.0">
+           <floatArray size="7" name="coeffs">
+             4.198640560E+00,  -2.036434100E-03,   6.520402110E-06,  -5.487970620E-09, 
+             1.771978170E-12,  -3.029372670E+04,  -8.490322080E-01</floatArray>
+        </NASA>
+        <NASA Tmin="1000.0" Tmax="3500.0" P0="100000.0">
+           <floatArray size="7" name="coeffs">
+             3.033992490E+00,   2.176918040E-03,  -1.640725180E-07,  -9.704198700E-11, 
+             1.682009920E-14,  -3.000429710E+04,   4.966770100E+00</floatArray>
+        </NASA>
+      </thermo>
+      <transport model="gas_transport">
+        <string title="geometry">nonlinear</string>
+        <LJ_welldepth units="K">572.400</LJ_welldepth>
+        <LJ_diameter units="A">2.605</LJ_diameter>
+        <dipoleMoment units="Debye">1.844</dipoleMoment>
+        <polarizability units="A3">0.000</polarizability>
+        <rotRelax>4.000</rotRelax>
+        <dispersion_coefficient units="A5">0.000</dispersion_coefficient>
+        <quadrupole_polarizability units="A5">0.000</quadrupole_polarizability>
+      </transport>
+    </species>
+
+    <!-- species AR    -->
+    <species name="AR">
+      <atomArray>Ar:1 </atomArray>
+      <note>120186</note>
+      <thermo>
+        <NASA Tmin="200.0" Tmax="1000.0" P0="100000.0">
+           <floatArray size="7" name="coeffs">
+             2.500000000E+00,   0.000000000E+00,   0.000000000E+00,   0.000000000E+00, 
+             0.000000000E+00,  -7.453750000E+02,   4.366000000E+00</floatArray>
+        </NASA>
+        <NASA Tmin="1000.0" Tmax="5000.0" P0="100000.0">
+           <floatArray size="7" name="coeffs">
+             2.500000000E+00,   0.000000000E+00,   0.000000000E+00,   0.000000000E+00, 
+             0.000000000E+00,  -7.453750000E+02,   4.366000000E+00</floatArray>
+        </NASA>
+      </thermo>
+      <transport model="gas_transport">
+        <string title="geometry">atom</string>
+        <LJ_welldepth units="K">136.500</LJ_welldepth>
+        <LJ_diameter units="A">3.330</LJ_diameter>
+        <dipoleMoment units="Debye">0.000</dipoleMoment>
+        <polarizability units="A3">0.000</polarizability>
+        <rotRelax>0.000</rotRelax>
+        <dispersion_coefficient units="A5">0.000</dispersion_coefficient>
+        <quadrupole_polarizability units="A5">0.000</quadrupole_polarizability>
+      </transport>
+    </species>
+  </speciesData>
+  <reactionData id="reaction_data">
+
+    <!-- reaction 0001    -->
+    <reaction id="0001" reversible="yes">
+      <equation>H2 + O2 [=] 2 OH</equation>
+      <rateCoeff>
+        <Arrhenius>
+           <A>1.700000E+10</A>
+           <b>0.0</b>
+           <E units="cal/mol">47780.000000</E>
+        </Arrhenius>
+      </rateCoeff>
+      <reactants>H2:1.0 O2:1</reactants>
+      <products>OH:2.0</products>
+    </reaction>
+
+    <!-- reaction 0002    -->
+    <reaction id="0002" reversible="yes">
+      <equation>OH + H2 [=] H2O + H</equation>
+      <rateCoeff>
+        <Arrhenius>
+           <A>1.170000E+06</A>
+           <b>1.3</b>
+           <E units="cal/mol">3626.000000</E>
+        </Arrhenius>
+      </rateCoeff>
+      <reactants>OH:1.0 H2:1</reactants>
+      <products>H2O:1.0 H:1</products>
+    </reaction>
+
+    <!-- reaction 0003    -->
+    <reaction id="0003" reversible="yes">
+      <equation>H + O2 [=] OH + O</equation>
+      <rateCoeff>
+        <Arrhenius>
+           <A>5.130000E+13</A>
+           <b>-0.816</b>
+           <E units="cal/mol">16507.000000</E>
+        </Arrhenius>
+      </rateCoeff>
+      <reactants>H:1.0 O2:1</reactants>
+      <products>OH:1.0 O:1</products>
+    </reaction>
+
+    <!-- reaction 0004    -->
+    <reaction id="0004" reversible="yes">
+      <equation>O + H2 [=] OH + H</equation>
+      <rateCoeff>
+        <Arrhenius>
+           <A>1.800000E+07</A>
+           <b>1.0</b>
+           <E units="cal/mol">8826.000000</E>
+        </Arrhenius>
+      </rateCoeff>
+      <reactants>O:1.0 H2:1</reactants>
+      <products>OH:1.0 H:1</products>
+    </reaction>
+
+    <!-- reaction 0005    -->
+    <reaction id="0005" reversible="yes" type="threeBody">
+      <equation>H + O2 + M [=] HO2 + M</equation>
+      <rateCoeff>
+        <Arrhenius>
+           <A>2.100000E+12</A>
+           <b>-1.0</b>
+           <E units="cal/mol">0.000000</E>
+        </Arrhenius>
+        <efficiencies default="1.0">H2:3.3 H2O:21.0 O2:0.0</efficiencies>
+      </rateCoeff>
+      <reactants>H:1.0 O2:1</reactants>
+      <products>HO2:1.0</products>
+    </reaction>
+
+    <!-- reaction 0006    -->
+    <reaction id="0006" reversible="yes">
+      <equation>H + O2 + O2 [=] HO2 + O2</equation>
+      <rateCoeff>
+        <Arrhenius>
+           <A>6.700000E+13</A>
+           <b>-1.42</b>
+           <E units="cal/mol">0.000000</E>
+        </Arrhenius>
+      </rateCoeff>
+      <reactants>H:1.0 O2:2</reactants>
+      <products>HO2:1.0 O2:1</products>
+    </reaction>
+
+    <!-- reaction 0007    -->
+    <reaction id="0007" reversible="yes">
+      <equation>OH + HO2 [=] H2O + O2</equation>
+      <rateCoeff>
+        <Arrhenius>
+           <A>5.000000E+10</A>
+           <b>0.0</b>
+           <E units="cal/mol">1000.000000</E>
+        </Arrhenius>
+      </rateCoeff>
+      <reactants>OH:1.0 HO2:1</reactants>
+      <products>H2O:1.0 O2:1</products>
+    </reaction>
+
+    <!-- reaction 0008    -->
+    <reaction id="0008" reversible="yes">
+      <equation>H + HO2 [=] 2 OH</equation>
+      <rateCoeff>
+        <Arrhenius>
+           <A>2.500000E+11</A>
+           <b>0.0</b>
+           <E units="cal/mol">1900.000000</E>
+        </Arrhenius>
+      </rateCoeff>
+      <reactants>H:1.0 HO2:1</reactants>
+      <products>OH:2.0</products>
+    </reaction>
+
+    <!-- reaction 0009    -->
+    <reaction id="0009" reversible="yes">
+      <equation>O + HO2 [=] O2 + OH</equation>
+      <rateCoeff>
+        <Arrhenius>
+           <A>4.800000E+10</A>
+           <b>0.0</b>
+           <E units="cal/mol">1000.000000</E>
+        </Arrhenius>
+      </rateCoeff>
+      <reactants>O:1.0 HO2:1</reactants>
+      <products>O2:1.0 OH:1</products>
+    </reaction>
+
+    <!-- reaction 0010    -->
+    <reaction id="0010" reversible="yes">
+      <equation>2 OH [=] O + H2O</equation>
+      <rateCoeff>
+        <Arrhenius>
+           <A>6.000000E+05</A>
+           <b>1.3</b>
+           <E units="cal/mol">0.000000</E>
+        </Arrhenius>
+      </rateCoeff>
+      <reactants>OH:2.0</reactants>
+      <products>O:1.0 H2O:1</products>
+    </reaction>
+
+    <!-- reaction 0011    -->
+    <reaction id="0011" reversible="yes" type="threeBody">
+      <equation>H2 + M [=] H + H + M</equation>
+      <rateCoeff>
+        <Arrhenius>
+           <A>2.230000E+09</A>
+           <b>0.5</b>
+           <E units="cal/mol">92600.000000</E>
+        </Arrhenius>
+        <efficiencies default="1.0">H:2.0 H2:3.0 H2O:6.0</efficiencies>
+      </rateCoeff>
+      <reactants>H2:1.0</reactants>
+      <products>H:2.0</products>
+    </reaction>
+
+    <!-- reaction 0012    -->
+    <reaction id="0012" reversible="yes" type="threeBody">
+      <equation>O2 + M [=] O + O + M</equation>
+      <rateCoeff>
+        <Arrhenius>
+           <A>1.850000E+08</A>
+           <b>0.5</b>
+           <E units="cal/mol">95560.000000</E>
+        </Arrhenius>
+      </rateCoeff>
+      <reactants>O2:1.0</reactants>
+      <products>O:2.0</products>
+    </reaction>
+
+    <!-- reaction 0013    -->
+    <reaction id="0013" reversible="yes" type="threeBody">
+      <equation>H + OH + M [=] H2O + M</equation>
+      <rateCoeff>
+        <Arrhenius>
+           <A>7.500000E+17</A>
+           <b>-2.6</b>
+           <E units="cal/mol">0.000000</E>
+        </Arrhenius>
+        <efficiencies default="1.0">H2O:20.0</efficiencies>
+      </rateCoeff>
+      <reactants>H:1.0 OH:1</reactants>
+      <products>H2O:1.0</products>
+    </reaction>
+
+    <!-- reaction 0014    -->
+    <reaction id="0014" reversible="yes">
+      <equation>H + HO2 [=] H2 + O2</equation>
+      <rateCoeff>
+        <Arrhenius>
+           <A>2.500000E+10</A>
+           <b>0.0</b>
+           <E units="cal/mol">700.000000</E>
+        </Arrhenius>
+      </rateCoeff>
+      <reactants>H:1.0 HO2:1</reactants>
+      <products>H2:1.0 O2:1</products>
+    </reaction>
+
+    <!-- reaction 0015    -->
+    <reaction id="0015" reversible="yes">
+      <equation>HO2 + HO2 [=] H2O2 + O2</equation>
+      <rateCoeff>
+        <Arrhenius>
+           <A>2.000000E+09</A>
+           <b>0.0</b>
+           <E units="cal/mol">0.000000</E>
+        </Arrhenius>
+      </rateCoeff>
+      <reactants>HO2:2.0</reactants>
+      <products>H2O2:1.0 O2:1</products>
+    </reaction>
+
+    <!-- reaction 0016    -->
+    <reaction id="0016" reversible="yes" type="threeBody">
+      <equation>H2O2 + M [=] OH + OH + M</equation>
+      <rateCoeff>
+        <Arrhenius>
+           <A>1.300000E+14</A>
+           <b>0.0</b>
+           <E units="cal/mol">45500.000000</E>
+        </Arrhenius>
+      </rateCoeff>
+      <reactants>H2O2:1.0</reactants>
+      <products>OH:2.0</products>
+    </reaction>
+
+    <!-- reaction 0017    -->
+    <reaction id="0017" reversible="yes">
+      <equation>H2O2 + H [=] HO2 + H2</equation>
+      <rateCoeff>
+        <Arrhenius>
+           <A>1.600000E+09</A>
+           <b>0.0</b>
+           <E units="cal/mol">3800.000000</E>
+        </Arrhenius>
+      </rateCoeff>
+      <reactants>H2O2:1.0 H:1</reactants>
+      <products>HO2:1.0 H2:1</products>
+    </reaction>
+
+    <!-- reaction 0018    -->
+    <reaction id="0018" reversible="yes">
+      <equation>H2O2 + OH [=] H2O + HO2</equation>
+      <rateCoeff>
+        <Arrhenius>
+           <A>1.000000E+10</A>
+           <b>0.0</b>
+           <E units="cal/mol">1800.000000</E>
+        </Arrhenius>
+      </rateCoeff>
+      <reactants>H2O2:1.0 OH:1</reactants>
+      <products>H2O:1.0 HO2:1</products>
+    </reaction>
+  </reactionData>
+</ctml>
diff --git a/examples/dfHighSpeedFoam/oneD_reactiveShockTube/constant/CanteraTorchProperties b/examples/dfHighSpeedFoam/oneD_reactiveShockTube/constant/CanteraTorchProperties
new file mode 100755
index 00000000..4640968d
--- /dev/null
+++ b/examples/dfHighSpeedFoam/oneD_reactiveShockTube/constant/CanteraTorchProperties
@@ -0,0 +1,35 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Version:  7
+     \\/     M anipulation  |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    location    "constant";
+    object      chemistryProperties;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+
+chemistry           on;
+CanteraMechanismFile "H2_AR.xml";
+transportModel "UnityLewis";
+loadbalancing
+{
+        active  true;
+        log   true;
+}
+odeCoeffs
+{}
+inertSpecie        "AR";
+
+zeroDReactor
+{
+    //cvorcp "UV";
+}
+// ************************************************************************* //
diff --git a/examples/dfHighSpeedFoam/oneD_reactiveShockTube/constant/thermophysicalProperties b/examples/dfHighSpeedFoam/oneD_reactiveShockTube/constant/thermophysicalProperties
new file mode 100755
index 00000000..873b8e16
--- /dev/null
+++ b/examples/dfHighSpeedFoam/oneD_reactiveShockTube/constant/thermophysicalProperties
@@ -0,0 +1,18 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Version:  7
+     \\/     M anipulation  |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    location    "constant";
+    object      thermophysicalProperties;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+inviscid      false;
+// ************************************************************************* //
diff --git a/examples/dfHighSpeedFoam/oneD_reactiveShockTube/constant/turbulenceProperties b/examples/dfHighSpeedFoam/oneD_reactiveShockTube/constant/turbulenceProperties
new file mode 100755
index 00000000..ab70e94d
--- /dev/null
+++ b/examples/dfHighSpeedFoam/oneD_reactiveShockTube/constant/turbulenceProperties
@@ -0,0 +1,21 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Version:  7
+     \\/     M anipulation  |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    location    "constant";
+    object      turbulenceProperties;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+simulationType  laminar;
+
+
+// ************************************************************************* //
diff --git a/examples/dfHighSpeedFoam/oneD_reactiveShockTube/system/blockMeshDict b/examples/dfHighSpeedFoam/oneD_reactiveShockTube/system/blockMeshDict
new file mode 100755
index 00000000..c4112e99
--- /dev/null
+++ b/examples/dfHighSpeedFoam/oneD_reactiveShockTube/system/blockMeshDict
@@ -0,0 +1,75 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Version:  7
+     \\/     M anipulation  |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    object      blockMeshDict;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+convertToMeters 0.1;
+
+vertices
+(
+    (0 0 0)
+    (1.2 0 0)
+    (1.2 1 0)
+    (0 1 0)
+    (0 0 1)
+    (1.2 0 1)
+    (1.2 1 1)
+    (0 1 1)
+);
+
+blocks
+(
+    hex (0 1 2 3 4 5 6 7) (2400 1 1) simpleGrading (1 1 1)
+);
+
+edges
+(
+);
+
+boundary
+(
+    Left
+    {
+        type patch;
+        faces
+        (
+            (0 4 7 3)
+        );
+    }
+    Right
+    {
+        type patch;
+        faces
+        (
+            (1 2 6 5)
+        );
+    }
+    empty
+    {
+        type empty;
+        faces
+        (
+            (0 1 5 4)
+            (5 6 7 4)
+            (3 7 6 2)
+            (0 3 2 1)
+        );
+    }
+);
+
+mergePatchPairs
+(
+);
+
+// ************************************************************************* //
diff --git a/examples/dfHighSpeedFoam/oneD_reactiveShockTube/system/controlDict b/examples/dfHighSpeedFoam/oneD_reactiveShockTube/system/controlDict
new file mode 100755
index 00000000..7567b959
--- /dev/null
+++ b/examples/dfHighSpeedFoam/oneD_reactiveShockTube/system/controlDict
@@ -0,0 +1,59 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Version:  7
+     \\/     M anipulation  |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    location    "system";
+    object      controlDict;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+application     dfHighSpeedFoam;
+
+startFrom       startTime;
+
+startTime       0;
+
+stopAt          endTime;
+
+endTime         23e-5;
+
+deltaT          1e-08;
+
+writeControl    adjustableRunTime;
+
+writeInterval   5e-6;
+
+cycleWrite      0;
+
+writeFormat     ascii;
+
+writePrecision  6;
+
+writeCompression on;
+
+timeFormat      general;
+
+timePrecision   6;
+
+runTimeModifiable true;
+
+adjustTimeStep  yes;
+
+maxCo           0.1;
+
+maxDeltaT       1;
+
+functions
+{
+    #includeFunc mag(U)
+}
+
+// ************************************************************************* //
diff --git a/examples/dfHighSpeedFoam/det_1D_H2_01mm/system/decomposeParDict b/examples/dfHighSpeedFoam/oneD_reactiveShockTube/system/decomposeParDict
similarity index 96%
rename from examples/dfHighSpeedFoam/det_1D_H2_01mm/system/decomposeParDict
rename to examples/dfHighSpeedFoam/oneD_reactiveShockTube/system/decomposeParDict
index 470777a2..dc84190c 100755
--- a/examples/dfHighSpeedFoam/det_1D_H2_01mm/system/decomposeParDict
+++ b/examples/dfHighSpeedFoam/oneD_reactiveShockTube/system/decomposeParDict
@@ -15,7 +15,7 @@ FoamFile
 }
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-numberOfSubdomains  4;
+numberOfSubdomains  5;
 
 method          scotch;
 
diff --git a/examples/dfHighSpeedFoam/oneD_reactiveShockTube/system/fvSchemes b/examples/dfHighSpeedFoam/oneD_reactiveShockTube/system/fvSchemes
new file mode 100755
index 00000000..b8df2960
--- /dev/null
+++ b/examples/dfHighSpeedFoam/oneD_reactiveShockTube/system/fvSchemes
@@ -0,0 +1,58 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Version:  7
+     \\/     M anipulation  |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    location    "system";
+    object      fvSchemes;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+fluxScheme		Kurganov;
+
+ddtSchemes
+{
+    default               Euler;
+}
+
+gradSchemes
+{
+    default               Gauss linear;
+}
+
+divSchemes
+{
+    default               none;
+    div(tauMC)            Gauss linear;
+    div(hDiffCorrFlux)    Gauss cubic;
+    div(phi,Yi_h)         Gauss vanLeer;
+}
+
+laplacianSchemes
+{
+    default               Gauss linear uncorrected;	
+}
+
+interpolationSchemes
+{
+    default               linear;
+    reconstruct(rho)      Minmod;
+    reconstruct(U)        MinmodV;
+    reconstruct(T)        Minmod;
+    reconstruct(Yi)       Minmod;
+}
+
+snGradSchemes
+{
+    default               uncorrected;
+}
+
+
+// ************************************************************************* //
diff --git a/examples/dfHighSpeedFoam/oneD_reactiveShockTube/system/fvSolution b/examples/dfHighSpeedFoam/oneD_reactiveShockTube/system/fvSolution
new file mode 100755
index 00000000..17c77b5d
--- /dev/null
+++ b/examples/dfHighSpeedFoam/oneD_reactiveShockTube/system/fvSolution
@@ -0,0 +1,67 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Version:  7
+     \\/     M anipulation  |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    location    "system";
+    object      fvSolution;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+solvers
+{
+	U
+	{
+		//solver		smoothSolver;
+		//smoother	GaussSeidel;
+		//nSweeps		2;
+		//tolerance	1e-17;
+		//relTol		0;
+
+		solver			PBiCGStab;
+		preconditioner	DIC;
+		tolerance		1e-11;
+		relTol			0;
+	}
+	
+	h
+	{
+		$U;
+		tolerance	1e-11;
+		relTol		0;
+	}
+
+	e
+	{
+		$U;
+		tolerance	1e-11;
+		relTol		0;
+	}
+
+	"rho.*"
+	{
+		solver		diagonal;
+	}
+
+	"(O2|N2|Yi)"
+	{
+		solver          PBiCGStab;
+        preconditioner	DILU;
+        tolerance       1e-11;
+        relTol          0;
+	}
+	
+}
+
+CENTRAL
+{
+}
+
+// ************************************************************************* //
diff --git a/examples/dfHighSpeedFoam/oneD_reactiveShockTube/system/sample b/examples/dfHighSpeedFoam/oneD_reactiveShockTube/system/sample
new file mode 100755
index 00000000..f5ac29bb
--- /dev/null
+++ b/examples/dfHighSpeedFoam/oneD_reactiveShockTube/system/sample
@@ -0,0 +1,39 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Version:  7
+     \\/     M anipulation  |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    location    "system";
+    object      sample;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+type sets;
+libs            ("libsampling.so");
+
+interpolationScheme cellPoint;
+
+setFormat       raw;
+
+sets
+(
+    data
+    {
+        type    lineFace;
+        axis    x;
+        start   (-4.995 0 0);
+        end     (4.995 0 0);
+        nPoints 1000;
+    }
+);
+
+fields          (T mag(U) p);
+
+// ************************************************************************* //
diff --git a/examples/dfHighSpeedFoam/oneD_reactiveShockTube/system/setFieldsDict b/examples/dfHighSpeedFoam/oneD_reactiveShockTube/system/setFieldsDict
new file mode 100755
index 00000000..4f686528
--- /dev/null
+++ b/examples/dfHighSpeedFoam/oneD_reactiveShockTube/system/setFieldsDict
@@ -0,0 +1,40 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Version:  7
+     \\/     M anipulation  |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    location    "system";
+    object      setFieldsDict;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+defaultFieldValues
+(
+    volVectorFieldValue U (0 0 0)
+    volScalarFieldValue T 378.656
+    volScalarFieldValue p 7173
+);
+
+regions
+(
+    boxToCell
+    {
+        box (0.06 -0.1 -0.1) (0.12 0.1 0.1);
+        fieldValues
+        (
+            volVectorFieldValue U (-487.34 0 0)
+            volScalarFieldValue T 748.472
+            volScalarFieldValue p 35594
+        );
+    }
+);
+
+
+// ************************************************************************* //

From b98ae5885e05d85d2e01e20c3d89d6e68bd2b8ee Mon Sep 17 00:00:00 2001
From: pkuLmq <1900011062@pku.edu.cn>
Date: Tue, 16 Aug 2022 16:21:00 +0800
Subject: [PATCH 04/10] place AMR in src

---
 AMR_tidy/Make/files                           | 14 -------------
 Allwmake                                      |  2 ++
 src/dynamicFvMesh/Make/files                  |  4 ++++
 src/dynamicFvMesh/Make/options                | 21 +++++++++++++++++++
 .../dynamicRefineFvMeshNew/dynamicMeshDict    |  0
 .../dynamicRefineFvMeshNew.C                  |  0
 .../dynamicRefineFvMeshNew.H                  |  0
 .../multiCritRefinement.C                     |  0
 .../multiCritRefinement.H                     |  0
 src/dynamicMesh/Make/files                    | 13 ++++++++++++
 {AMR_tidy => src/dynamicMesh}/Make/options    |  0
 .../polyTopoChange}/hexRef/hexRef.C           |  0
 .../polyTopoChange}/hexRef/hexRef.H           |  0
 .../polyTopoChange}/hexRef/hexRef2/hexRef2.C  |  0
 .../polyTopoChange}/hexRef/hexRef2/hexRef2.H  |  0
 .../polyTopoChange}/hexRef/hexRef4/hexRef4.C  |  0
 .../polyTopoChange}/hexRef/hexRef4/hexRef4.H  |  0
 .../hexRef/hexRef4Axi/hexRef4Axi.C            |  0
 .../hexRef/hexRef4Axi/hexRef4Axi.H            |  0
 .../polyTopoChange}/hexRef/hexRef8/hexRef8.C  |  0
 .../polyTopoChange}/hexRef/hexRef8/hexRef8.H  |  0
 .../polyTopoChange}/hexRef/hexRefData.C       |  0
 .../polyTopoChange}/hexRef/hexRefData.H       |  0
 .../polyTopoChange}/hexRef/hexRefNew.C        |  0
 .../hexRef/refinementHistory.C                |  0
 .../hexRef/refinementHistory.H                |  0
 26 files changed, 40 insertions(+), 14 deletions(-)
 delete mode 100644 AMR_tidy/Make/files
 create mode 100644 src/dynamicFvMesh/Make/files
 create mode 100644 src/dynamicFvMesh/Make/options
 rename {AMR_tidy => src/dynamicFvMesh}/dynamicRefineFvMeshNew/dynamicMeshDict (100%)
 rename {AMR_tidy => src/dynamicFvMesh}/dynamicRefineFvMeshNew/dynamicRefineFvMeshNew.C (100%)
 rename {AMR_tidy => src/dynamicFvMesh}/dynamicRefineFvMeshNew/dynamicRefineFvMeshNew.H (100%)
 rename {AMR_tidy => src/dynamicFvMesh}/dynamicRefineFvMeshNew/multiCritRefinement.C (100%)
 rename {AMR_tidy => src/dynamicFvMesh}/dynamicRefineFvMeshNew/multiCritRefinement.H (100%)
 create mode 100644 src/dynamicMesh/Make/files
 rename {AMR_tidy => src/dynamicMesh}/Make/options (100%)
 rename {AMR_tidy => src/dynamicMesh/polyTopoChange/polyTopoChange}/hexRef/hexRef.C (100%)
 rename {AMR_tidy => src/dynamicMesh/polyTopoChange/polyTopoChange}/hexRef/hexRef.H (100%)
 rename {AMR_tidy => src/dynamicMesh/polyTopoChange/polyTopoChange}/hexRef/hexRef2/hexRef2.C (100%)
 rename {AMR_tidy => src/dynamicMesh/polyTopoChange/polyTopoChange}/hexRef/hexRef2/hexRef2.H (100%)
 rename {AMR_tidy => src/dynamicMesh/polyTopoChange/polyTopoChange}/hexRef/hexRef4/hexRef4.C (100%)
 rename {AMR_tidy => src/dynamicMesh/polyTopoChange/polyTopoChange}/hexRef/hexRef4/hexRef4.H (100%)
 rename {AMR_tidy => src/dynamicMesh/polyTopoChange/polyTopoChange}/hexRef/hexRef4Axi/hexRef4Axi.C (100%)
 rename {AMR_tidy => src/dynamicMesh/polyTopoChange/polyTopoChange}/hexRef/hexRef4Axi/hexRef4Axi.H (100%)
 rename {AMR_tidy => src/dynamicMesh/polyTopoChange/polyTopoChange}/hexRef/hexRef8/hexRef8.C (100%)
 rename {AMR_tidy => src/dynamicMesh/polyTopoChange/polyTopoChange}/hexRef/hexRef8/hexRef8.H (100%)
 rename {AMR_tidy => src/dynamicMesh/polyTopoChange/polyTopoChange}/hexRef/hexRefData.C (100%)
 rename {AMR_tidy => src/dynamicMesh/polyTopoChange/polyTopoChange}/hexRef/hexRefData.H (100%)
 rename {AMR_tidy => src/dynamicMesh/polyTopoChange/polyTopoChange}/hexRef/hexRefNew.C (100%)
 rename {AMR_tidy => src/dynamicMesh/polyTopoChange/polyTopoChange}/hexRef/refinementHistory.C (100%)
 rename {AMR_tidy => src/dynamicMesh/polyTopoChange/polyTopoChange}/hexRef/refinementHistory.H (100%)

diff --git a/AMR_tidy/Make/files b/AMR_tidy/Make/files
deleted file mode 100644
index 66c8f4ce..00000000
--- a/AMR_tidy/Make/files
+++ /dev/null
@@ -1,14 +0,0 @@
-hexRef/hexRef.C
-hexRef/hexRefData.C
-hexRef/refinementHistory.C
-hexRef/hexRefNew.C
-
-hexRef/hexRef8/hexRef8.C
-hexRef/hexRef4/hexRef4.C
-hexRef/hexRef4Axi/hexRef4Axi.C
-hexRef/hexRef2/hexRef2.C
-
-dynamicRefineFvMeshNew/multiCritRefinement.C
-dynamicRefineFvMeshNew/dynamicRefineFvMeshNew.C
-
-LIB = $(FOAM_USER_LIBBIN)/libnewdynamicFvMesh
diff --git a/Allwmake b/Allwmake
index 923b8ec4..017ba567 100755
--- a/Allwmake
+++ b/Allwmake
@@ -12,6 +12,8 @@ wmake src/dfChemistryModel
 wmake src/TurbulenceModels/compressible
 wmake src/regionModels/surfaceFilmModels
 src/lagrangian/Allwmake $targetType $*
+wmake src/dynamicMesh
+wmake src/dynamicFvMesh
 
 wmake applications/solvers/df0DFoam
 wmake applications/solvers/dfLowMachFoam
diff --git a/src/dynamicFvMesh/Make/files b/src/dynamicFvMesh/Make/files
new file mode 100644
index 00000000..3666cae7
--- /dev/null
+++ b/src/dynamicFvMesh/Make/files
@@ -0,0 +1,4 @@
+dynamicRefineFvMeshNew/multiCritRefinement.C
+dynamicRefineFvMeshNew/dynamicRefineFvMeshNew.C
+
+LIB = $(FOAM_USER_LIBBIN)/libnewdynamicFvMesh
diff --git a/src/dynamicFvMesh/Make/options b/src/dynamicFvMesh/Make/options
new file mode 100644
index 00000000..e4f8715a
--- /dev/null
+++ b/src/dynamicFvMesh/Make/options
@@ -0,0 +1,21 @@
+EXE_INC = -std=c++14\
+    -I$(LIB_SRC)/triSurface/lnInclude \
+    -I$(LIB_SRC)/meshTools/lnInclude \
+    -I$(LIB_SRC)/dynamicFvMesh/lnInclude \
+    -I$(LIB_SRC)/dynamicMesh/lnInclude \
+    -I$(DF_SRC)/dynamicMesh/lnInclude \
+    -I$(LIB_SRC)/finiteVolume/lnInclude \
+    -I$(LIB_SRC)/parallel/decompose/decompositionMethods/lnInclude
+
+LIB_LIBS = \
+    -ltriSurface \
+    -lmeshTools \
+    -ldynamicMesh \
+    -ldynamicFvMesh \
+    -lfiniteVolume \
+    -lextrudeModel \
+    -ldecompositionMethods \
+    $(FOAM_USER_LIBBIN)/libnewdynamicMesh.so\
+    -L$(FOAM_LIBBIN)/dummy \
+    -lmetisDecomp -lptscotchDecomp -lscotchDecomp
+    
diff --git a/AMR_tidy/dynamicRefineFvMeshNew/dynamicMeshDict b/src/dynamicFvMesh/dynamicRefineFvMeshNew/dynamicMeshDict
similarity index 100%
rename from AMR_tidy/dynamicRefineFvMeshNew/dynamicMeshDict
rename to src/dynamicFvMesh/dynamicRefineFvMeshNew/dynamicMeshDict
diff --git a/AMR_tidy/dynamicRefineFvMeshNew/dynamicRefineFvMeshNew.C b/src/dynamicFvMesh/dynamicRefineFvMeshNew/dynamicRefineFvMeshNew.C
similarity index 100%
rename from AMR_tidy/dynamicRefineFvMeshNew/dynamicRefineFvMeshNew.C
rename to src/dynamicFvMesh/dynamicRefineFvMeshNew/dynamicRefineFvMeshNew.C
diff --git a/AMR_tidy/dynamicRefineFvMeshNew/dynamicRefineFvMeshNew.H b/src/dynamicFvMesh/dynamicRefineFvMeshNew/dynamicRefineFvMeshNew.H
similarity index 100%
rename from AMR_tidy/dynamicRefineFvMeshNew/dynamicRefineFvMeshNew.H
rename to src/dynamicFvMesh/dynamicRefineFvMeshNew/dynamicRefineFvMeshNew.H
diff --git a/AMR_tidy/dynamicRefineFvMeshNew/multiCritRefinement.C b/src/dynamicFvMesh/dynamicRefineFvMeshNew/multiCritRefinement.C
similarity index 100%
rename from AMR_tidy/dynamicRefineFvMeshNew/multiCritRefinement.C
rename to src/dynamicFvMesh/dynamicRefineFvMeshNew/multiCritRefinement.C
diff --git a/AMR_tidy/dynamicRefineFvMeshNew/multiCritRefinement.H b/src/dynamicFvMesh/dynamicRefineFvMeshNew/multiCritRefinement.H
similarity index 100%
rename from AMR_tidy/dynamicRefineFvMeshNew/multiCritRefinement.H
rename to src/dynamicFvMesh/dynamicRefineFvMeshNew/multiCritRefinement.H
diff --git a/src/dynamicMesh/Make/files b/src/dynamicMesh/Make/files
new file mode 100644
index 00000000..d634b9ed
--- /dev/null
+++ b/src/dynamicMesh/Make/files
@@ -0,0 +1,13 @@
+hexRef = polyTopoChange/polyTopoChange/hexRef
+
+$(hexRef)/hexRef.C
+$(hexRef)/hexRefData.C
+$(hexRef)/refinementHistory.C
+$(hexRef)/hexRefNew.C
+
+$(hexRef)/hexRef8/hexRef8.C
+$(hexRef)/hexRef4/hexRef4.C
+$(hexRef)/hexRef4Axi/hexRef4Axi.C
+$(hexRef)/hexRef2/hexRef2.C
+
+LIB = $(FOAM_USER_LIBBIN)/libnewdynamicMesh
diff --git a/AMR_tidy/Make/options b/src/dynamicMesh/Make/options
similarity index 100%
rename from AMR_tidy/Make/options
rename to src/dynamicMesh/Make/options
diff --git a/AMR_tidy/hexRef/hexRef.C b/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef.C
similarity index 100%
rename from AMR_tidy/hexRef/hexRef.C
rename to src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef.C
diff --git a/AMR_tidy/hexRef/hexRef.H b/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef.H
similarity index 100%
rename from AMR_tidy/hexRef/hexRef.H
rename to src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef.H
diff --git a/AMR_tidy/hexRef/hexRef2/hexRef2.C b/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef2/hexRef2.C
similarity index 100%
rename from AMR_tidy/hexRef/hexRef2/hexRef2.C
rename to src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef2/hexRef2.C
diff --git a/AMR_tidy/hexRef/hexRef2/hexRef2.H b/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef2/hexRef2.H
similarity index 100%
rename from AMR_tidy/hexRef/hexRef2/hexRef2.H
rename to src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef2/hexRef2.H
diff --git a/AMR_tidy/hexRef/hexRef4/hexRef4.C b/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef4/hexRef4.C
similarity index 100%
rename from AMR_tidy/hexRef/hexRef4/hexRef4.C
rename to src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef4/hexRef4.C
diff --git a/AMR_tidy/hexRef/hexRef4/hexRef4.H b/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef4/hexRef4.H
similarity index 100%
rename from AMR_tidy/hexRef/hexRef4/hexRef4.H
rename to src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef4/hexRef4.H
diff --git a/AMR_tidy/hexRef/hexRef4Axi/hexRef4Axi.C b/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef4Axi/hexRef4Axi.C
similarity index 100%
rename from AMR_tidy/hexRef/hexRef4Axi/hexRef4Axi.C
rename to src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef4Axi/hexRef4Axi.C
diff --git a/AMR_tidy/hexRef/hexRef4Axi/hexRef4Axi.H b/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef4Axi/hexRef4Axi.H
similarity index 100%
rename from AMR_tidy/hexRef/hexRef4Axi/hexRef4Axi.H
rename to src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef4Axi/hexRef4Axi.H
diff --git a/AMR_tidy/hexRef/hexRef8/hexRef8.C b/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef8/hexRef8.C
similarity index 100%
rename from AMR_tidy/hexRef/hexRef8/hexRef8.C
rename to src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef8/hexRef8.C
diff --git a/AMR_tidy/hexRef/hexRef8/hexRef8.H b/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef8/hexRef8.H
similarity index 100%
rename from AMR_tidy/hexRef/hexRef8/hexRef8.H
rename to src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef8/hexRef8.H
diff --git a/AMR_tidy/hexRef/hexRefData.C b/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRefData.C
similarity index 100%
rename from AMR_tidy/hexRef/hexRefData.C
rename to src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRefData.C
diff --git a/AMR_tidy/hexRef/hexRefData.H b/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRefData.H
similarity index 100%
rename from AMR_tidy/hexRef/hexRefData.H
rename to src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRefData.H
diff --git a/AMR_tidy/hexRef/hexRefNew.C b/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRefNew.C
similarity index 100%
rename from AMR_tidy/hexRef/hexRefNew.C
rename to src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRefNew.C
diff --git a/AMR_tidy/hexRef/refinementHistory.C b/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/refinementHistory.C
similarity index 100%
rename from AMR_tidy/hexRef/refinementHistory.C
rename to src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/refinementHistory.C
diff --git a/AMR_tidy/hexRef/refinementHistory.H b/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/refinementHistory.H
similarity index 100%
rename from AMR_tidy/hexRef/refinementHistory.H
rename to src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/refinementHistory.H

From c6dcc412e53aadcf11f6a11745d32660e75e76bd Mon Sep 17 00:00:00 2001
From: pkuLmq <1900011062@pku.edu.cn>
Date: Thu, 25 Aug 2022 13:06:32 +0800
Subject: [PATCH 05/10] fix conflict

---
 examples/dfHighSpeedFoam/oneD_detonationH2/system/controlDict | 3 +--
 src/dynamicFvMesh/dynamicRefineFvMeshNew/dynamicMeshDict      | 4 ++--
 2 files changed, 3 insertions(+), 4 deletions(-)

diff --git a/examples/dfHighSpeedFoam/oneD_detonationH2/system/controlDict b/examples/dfHighSpeedFoam/oneD_detonationH2/system/controlDict
index d897bd2d..06aebc8b 100755
--- a/examples/dfHighSpeedFoam/oneD_detonationH2/system/controlDict
+++ b/examples/dfHighSpeedFoam/oneD_detonationH2/system/controlDict
@@ -15,7 +15,6 @@ FoamFile
 }
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 libs (
-      "libfieldFunctionObjects.so"
       "libnewdynamicFvMesh.so"
       );
 
@@ -60,7 +59,7 @@ functions
     minMax
     {
       type          fieldMinMax;
-      libs          ("libfieldFunctionObjects.so");
+      libs          ("libdfFieldFunctionObjects.so");
       writeControl  writeTime; //timeStep;
       fields        (p);
     }
diff --git a/src/dynamicFvMesh/dynamicRefineFvMeshNew/dynamicMeshDict b/src/dynamicFvMesh/dynamicRefineFvMeshNew/dynamicMeshDict
index 7c020ccd..26ece91a 100644
--- a/src/dynamicFvMesh/dynamicRefineFvMeshNew/dynamicMeshDict
+++ b/src/dynamicFvMesh/dynamicRefineFvMeshNew/dynamicMeshDict
@@ -14,7 +14,7 @@ FoamFile
 }
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-dynamicFvMesh      dynamicRefineFvMesh;
+dynamicFvMesh      dynamicRefineFvMeshNew;
 // dynamicFvMesh    staticFvMesh;
 
 multiCritRefinementControls
@@ -97,7 +97,7 @@ multiCritRefinementControls
 }
 
 // Refinement
-dynamicRefineFvMeshCoeffs
+dynamicRefineFvMeshNewCoeffs
 {
     // Refine every refineInterval timesteps
     refineInterval 3;

From 80a933ce4f3f59ac8f85ab5d47b7ae668554a7da Mon Sep 17 00:00:00 2001
From: pkuLmq <1900011062@pku.edu.cn>
Date: Sun, 28 Aug 2022 11:29:45 +0800
Subject: [PATCH 06/10] fix AMR

---
 .../dynamicRefineFvMeshNew.C                  | 10 ++++----
 .../dynamicRefineFvMeshNew.H                  |  3 ++-
 .../polyTopoChange/hexRef/hexRef.C            | 23 +++++++++++++------
 .../polyTopoChange/hexRef/hexRef.H            |  2 +-
 4 files changed, 25 insertions(+), 13 deletions(-)

diff --git a/src/dynamicFvMesh/dynamicRefineFvMeshNew/dynamicRefineFvMeshNew.C b/src/dynamicFvMesh/dynamicRefineFvMeshNew/dynamicRefineFvMeshNew.C
index d1548a60..778bb43b 100644
--- a/src/dynamicFvMesh/dynamicRefineFvMeshNew/dynamicRefineFvMeshNew.C
+++ b/src/dynamicFvMesh/dynamicRefineFvMeshNew/dynamicRefineFvMeshNew.C
@@ -1804,7 +1804,8 @@ bool Foam::dynamicRefineFvMeshNew::writeObject
 (
     IOstream::streamFormat fmt,
     IOstream::versionNumber ver,
-    IOstream::compressionType cmp
+    IOstream::compressionType cmp,
+    const bool write
 ) const
 {
     // Force refinement data to go to the current time directory.
@@ -1812,8 +1813,8 @@ bool Foam::dynamicRefineFvMeshNew::writeObject
 
     bool writeOk =
     (
-        dynamicFvMesh::writeObject(fmt, ver, cmp)
-     && meshCutter_->write()
+        dynamicFvMesh::writeObject(fmt, ver, cmp, write)
+     && meshCutter_->write(write)
     );
 
     if (dumpLevel_)
@@ -1830,7 +1831,8 @@ bool Foam::dynamicRefineFvMeshNew::writeObject
                 false
             ),
             *this,
-            dimensionedScalar("level", dimless, 0)
+            // dimensionedScalar("level", dimless, 0) IOobject::READ_IF_PRESENT,
+            dimensionedScalar(dimless, 0)
         );
 
         const labelList& cellLevel = meshCutter_->cellLevel();
diff --git a/src/dynamicFvMesh/dynamicRefineFvMeshNew/dynamicRefineFvMeshNew.H b/src/dynamicFvMesh/dynamicRefineFvMeshNew/dynamicRefineFvMeshNew.H
index 6b686d20..4ab4d580 100644
--- a/src/dynamicFvMesh/dynamicRefineFvMeshNew/dynamicRefineFvMeshNew.H
+++ b/src/dynamicFvMesh/dynamicRefineFvMeshNew/dynamicRefineFvMeshNew.H
@@ -282,7 +282,8 @@ public:
         (
             IOstream::streamFormat fmt,
             IOstream::versionNumber ver,
-            IOstream::compressionType cmp
+            IOstream::compressionType cmp,
+            const bool write = true
         ) const;
 
 };
diff --git a/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef.C b/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef.C
index 51d7c022..e26f1809 100644
--- a/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef.C
+++ b/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef.C
@@ -1468,9 +1468,18 @@ Foam::hexRef::hexRef(const polyMesh& mesh, const bool readHistory)
             mesh_.facesInstance(),
             polyMesh::meshSubDir,
             mesh_,
-            IOobject::NO_READ,
+            IOobject::READ_IF_PRESENT,
             IOobject::NO_WRITE
         ),
+        // IOobject
+        // (
+        //     "refinementHistory",
+        //     mesh_.facesInstance(),
+        //     polyMesh::meshSubDir,
+        //     mesh_,
+        //     IOobject::NO_READ,
+        //     IOobject::NO_WRITE
+        // ),
         // All cells visible if not read or readHistory = false
         (readHistory ? mesh_.nCells() : 0)
     ),
@@ -1645,7 +1654,7 @@ Foam::hexRef::hexRef
 }
 
 
-// Construct from components
+// Construct from components IOobject::READ_IF_PRESENT,
 Foam::hexRef::hexRef
 (
     const polyMesh& mesh,
@@ -3598,16 +3607,16 @@ const Foam::cellShapeList& Foam::hexRef::cellShapes() const
 
 
 // Write refinement to polyMesh directory.
-bool Foam::hexRef::write() const
+bool Foam::hexRef::write(const bool write) const
 {
     bool writeOk =
-        cellLevel_.write()
-     && pointLevel_.write()
-     && level0Edge_.write();
+        cellLevel_.write(write)
+     && pointLevel_.write(write)
+     && level0Edge_.write(write);
 
     if (history_.active())
     {
-        writeOk = writeOk && history_.write();
+        writeOk = writeOk && history_.write(write);
     }
 
     return writeOk;
diff --git a/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef.H b/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef.H
index 888ead7a..a426c69b 100644
--- a/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef.H
+++ b/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef.H
@@ -649,7 +649,7 @@ public:
             void setInstance(const fileName& inst);
 
             //- Force writing refinement+history to polyMesh directory.
-            bool write() const;
+            bool write(const bool write = true) const;
 
 };
 

From a22745875373331c4f3826002cc5c2466719073d Mon Sep 17 00:00:00 2001
From: pkuLmq <1900011062@pku.edu.cn>
Date: Sun, 28 Aug 2022 11:35:51 +0800
Subject: [PATCH 07/10] fix AMR for restart

---
 src/dynamicFvMesh/dynamicRefineFvMeshNew/dynamicMeshDict | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/dynamicFvMesh/dynamicRefineFvMeshNew/dynamicMeshDict b/src/dynamicFvMesh/dynamicRefineFvMeshNew/dynamicMeshDict
index 26ece91a..7eb414ca 100644
--- a/src/dynamicFvMesh/dynamicRefineFvMeshNew/dynamicMeshDict
+++ b/src/dynamicFvMesh/dynamicRefineFvMeshNew/dynamicMeshDict
@@ -140,6 +140,9 @@ dynamicRefineFvMeshNewCoeffs
     // be interpolated and inner-producted with the face area vector.
     correctFluxes ((phi U));
 
+    // Write the refinement level as a volScalarField
+    dumpLevel       true;
+    
     // List of non-flux surface<Type>Fields to be mapped
     // only for new internal faces (AMR refine)
     mapSurfaceFields

From f8c91c28db68cc86c2ce35c6c85890207fdea55e Mon Sep 17 00:00:00 2001
From: pkuLmq <1900011062@pku.edu.cn>
Date: Sun, 28 Aug 2022 11:41:18 +0800
Subject: [PATCH 08/10] delete unnnecessary words

---
 .../dynamicRefineFvMeshNew/dynamicRefineFvMeshNew.C             | 2 +-
 src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef.C   | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/dynamicFvMesh/dynamicRefineFvMeshNew/dynamicRefineFvMeshNew.C b/src/dynamicFvMesh/dynamicRefineFvMeshNew/dynamicRefineFvMeshNew.C
index 778bb43b..5915e95c 100644
--- a/src/dynamicFvMesh/dynamicRefineFvMeshNew/dynamicRefineFvMeshNew.C
+++ b/src/dynamicFvMesh/dynamicRefineFvMeshNew/dynamicRefineFvMeshNew.C
@@ -1831,7 +1831,7 @@ bool Foam::dynamicRefineFvMeshNew::writeObject
                 false
             ),
             *this,
-            // dimensionedScalar("level", dimless, 0) IOobject::READ_IF_PRESENT,
+            // dimensionedScalar("level", dimless, 0)
             dimensionedScalar(dimless, 0)
         );
 
diff --git a/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef.C b/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef.C
index e26f1809..49cc3101 100644
--- a/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef.C
+++ b/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef.C
@@ -1654,7 +1654,7 @@ Foam::hexRef::hexRef
 }
 
 
-// Construct from components IOobject::READ_IF_PRESENT,
+// Construct from components
 Foam::hexRef::hexRef
 (
     const polyMesh& mesh,

From d57b36af27bb6a3305a22a60fd6ff97aaf8fd438 Mon Sep 17 00:00:00 2001
From: pkuLmq <1900011062@pku.edu.cn>
Date: Sun, 28 Aug 2022 15:33:49 +0800
Subject: [PATCH 09/10] apply refinementHistoryNew which was ignored before

---
 .../oneD_detonationH2/system/decomposeParDict |   4 +-
 src/dynamicFvMesh/Make/files                  |   2 +
 .../dynamicRefineFvMeshNew.C                  |   2 +-
 .../refinementHistoryNewConstraint.C          | 224 ++++++++++++++++++
 .../refinementHistoryNewConstraint.H          | 115 +++++++++
 src/dynamicMesh/Make/files                    |   2 +-
 .../polyTopoChange/hexRef/hexRef.C            |  10 +-
 .../polyTopoChange/hexRef/hexRef.H            |  12 +-
 .../polyTopoChange/hexRef/hexRef2/hexRef2.C   |   2 +-
 .../polyTopoChange/hexRef/hexRef2/hexRef2.H   |   2 +-
 .../polyTopoChange/hexRef/hexRef4/hexRef4.C   |   2 +-
 .../polyTopoChange/hexRef/hexRef4/hexRef4.H   |   2 +-
 .../hexRef/hexRef4Axi/hexRef4Axi.C            |   2 +-
 .../hexRef/hexRef4Axi/hexRef4Axi.H            |   2 +-
 .../polyTopoChange/hexRef/hexRef8/hexRef8.C   |   2 +-
 .../polyTopoChange/hexRef/hexRef8/hexRef8.H   |   2 +-
 .../polyTopoChange/hexRef/hexRefData.C        |  32 +--
 .../polyTopoChange/hexRef/hexRefData.H        |  36 ++-
 .../polyTopoChange/hexRef/hexRefNew.C         |   2 +-
 ...nementHistory.C => refinementHistoryNew.C} | 142 +++++------
 ...nementHistory.H => refinementHistoryNew.H} |  48 ++--
 21 files changed, 493 insertions(+), 154 deletions(-)
 create mode 100644 src/dynamicFvMesh/refinementHistoryNewConstraint/refinementHistoryNewConstraint.C
 create mode 100644 src/dynamicFvMesh/refinementHistoryNewConstraint/refinementHistoryNewConstraint.H
 rename src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/{refinementHistory.C => refinementHistoryNew.C} (91%)
 rename src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/{refinementHistory.H => refinementHistoryNew.H} (91%)

diff --git a/examples/dfHighSpeedFoam/oneD_detonationH2/system/decomposeParDict b/examples/dfHighSpeedFoam/oneD_detonationH2/system/decomposeParDict
index a9715975..2078fe99 100755
--- a/examples/dfHighSpeedFoam/oneD_detonationH2/system/decomposeParDict
+++ b/examples/dfHighSpeedFoam/oneD_detonationH2/system/decomposeParDict
@@ -21,11 +21,11 @@ method          scotch;
 
 constraints
 {
-    refinementHistory
+    refinementHistoryNew
     {
         //- Decompose cells such that all cell originating from single cell
         //  end up on same processor
-        type    refinementHistory;
+        type    refinementHistoryNew;
     }
 }
 
diff --git a/src/dynamicFvMesh/Make/files b/src/dynamicFvMesh/Make/files
index 3666cae7..c10b618c 100644
--- a/src/dynamicFvMesh/Make/files
+++ b/src/dynamicFvMesh/Make/files
@@ -1,4 +1,6 @@
 dynamicRefineFvMeshNew/multiCritRefinement.C
 dynamicRefineFvMeshNew/dynamicRefineFvMeshNew.C
 
+refinementHistoryNewConstraint/refinementHistoryNewConstraint.C
+
 LIB = $(FOAM_USER_LIBBIN)/libnewdynamicFvMesh
diff --git a/src/dynamicFvMesh/dynamicRefineFvMeshNew/dynamicRefineFvMeshNew.C b/src/dynamicFvMesh/dynamicRefineFvMeshNew/dynamicRefineFvMeshNew.C
index 5915e95c..9227c620 100644
--- a/src/dynamicFvMesh/dynamicRefineFvMeshNew/dynamicRefineFvMeshNew.C
+++ b/src/dynamicFvMesh/dynamicRefineFvMeshNew/dynamicRefineFvMeshNew.C
@@ -1783,7 +1783,7 @@ bool Foam::dynamicRefineFvMeshNew::update()
         {
             // Compact refinement history occassionally (how often?).
             // Unrefinement causes holes in the refinementHistory.
-            const_cast<refinementHistory&>(meshCutter()->history()).compact();
+            const_cast<refinementHistoryNew&>(meshCutter()->history()).compact();
         }
         nRefinementIterations_++;
     }
diff --git a/src/dynamicFvMesh/refinementHistoryNewConstraint/refinementHistoryNewConstraint.C b/src/dynamicFvMesh/refinementHistoryNewConstraint/refinementHistoryNewConstraint.C
new file mode 100644
index 00000000..59af8139
--- /dev/null
+++ b/src/dynamicFvMesh/refinementHistoryNewConstraint/refinementHistoryNewConstraint.C
@@ -0,0 +1,224 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2015-2016 OpenFOAM Foundation
+     \\/     M anipulation  | Copyright (C) 2018 OpenCFD Ltd.
+-------------------------------------------------------------------------------
+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 "refinementHistoryNewConstraint.H"
+#include "addToRunTimeSelectionTable.H"
+#include "syncTools.H"
+#include "refinementHistoryNew.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace decompositionConstraints
+{
+    defineTypeName(refinementHistoryNewConstraint);
+
+    addToRunTimeSelectionTable
+    (
+        decompositionConstraint,
+        refinementHistoryNewConstraint,
+        dictionary
+    );
+}
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::decompositionConstraints::refinementHistoryNewConstraint::refinementHistoryNewConstraint
+(
+    const dictionary& dict,
+    const word& modelType
+)
+:
+    decompositionConstraint(dict, typeName)
+{
+    if (decompositionConstraint::debug)
+    {
+        Info<< type()
+            << " : setting constraints to refinement history New" << endl;
+    }
+}
+
+
+Foam::decompositionConstraints::refinementHistoryNewConstraint::refinementHistoryNewConstraint()
+:
+    decompositionConstraint(dictionary(), typeName)
+{
+    if (decompositionConstraint::debug)
+    {
+        Info<< type()
+            << " : setting constraints to refinement history New" << endl;
+    }
+}
+
+
+// * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
+
+void Foam::decompositionConstraints::refinementHistoryNewConstraint::add
+(
+    const polyMesh& mesh,
+    boolList& blockedFace,
+    PtrList<labelList>& specifiedProcessorFaces,
+    labelList& specifiedProcessor,
+    List<labelPair>& explicitConnections
+) const
+{
+    // The refinement history type
+    typedef ::Foam::refinementHistoryNew HistoryType;
+    // typedef Foam::decompositionConstraints::refinementHistoryNew HistoryType;
+
+    // Local storage if read from file
+    autoPtr<const HistoryType> readFromFile;
+
+    const HistoryType* historyPtr = nullptr;
+
+    if (mesh.foundObject<HistoryType>("refinementHistoryNew"))
+    {
+        if (decompositionConstraint::debug)
+        {
+            Info<< type() << " : found refinementHistoryNew" << endl;
+        }
+        historyPtr = &mesh.lookupObject<HistoryType>("refinementHistoryNew");
+    }
+    else
+    {
+        if (decompositionConstraint::debug)
+        {
+            Info<< type() << " : reading refinementHistoryNew from time "
+                << mesh.facesInstance() << endl;
+        }
+
+        readFromFile.reset
+        (
+            new HistoryType
+            (
+                IOobject
+                (
+                    "refinementHistoryNew",
+                    mesh.facesInstance(),
+                    polyMesh::meshSubDir,
+                    mesh,
+                    IOobject::READ_IF_PRESENT,
+                    IOobject::NO_WRITE
+                ),
+                mesh.nCells()
+            )
+        );
+
+        // historyPtr = readFromFile.get();  // get(), not release()
+    }
+
+    // const auto& history = *historyPtr;
+    const auto& history =
+    (
+        readFromFile.valid()
+       ? readFromFile()
+       : *historyPtr
+    );
+
+    if (history.active())
+    {
+        // refinementHistoryNew itself implements decompositionConstraint
+        history.add
+        (
+            blockedFace,
+            specifiedProcessorFaces,
+            specifiedProcessor,
+            explicitConnections
+        );
+    }
+}
+
+
+void Foam::decompositionConstraints::refinementHistoryNewConstraint::apply
+(
+    const polyMesh& mesh,
+    const boolList& blockedFace,
+    const PtrList<labelList>& specifiedProcessorFaces,
+    const labelList& specifiedProcessor,
+    const List<labelPair>& explicitConnections,
+    labelList& decomposition
+) const
+{
+    // The refinement history type
+    typedef ::Foam::refinementHistoryNew HistoryType;
+
+    // Local storage if read from file
+    autoPtr<const HistoryType> readFromFile;
+
+    const HistoryType* historyPtr = nullptr;
+
+    if(mesh.foundObject<HistoryType>("refinementHistoryNew"))
+    {
+        historyPtr = &mesh.lookupObject<HistoryType>("refinementHistoryNew");
+    }
+    else
+    {
+        readFromFile.reset
+        (
+            new HistoryType
+            (
+                IOobject
+                (
+                    "refinementHistoryNew",
+                    mesh.facesInstance(),
+                    polyMesh::meshSubDir,
+                    mesh,
+                    IOobject::READ_IF_PRESENT,
+                    IOobject::NO_WRITE
+                ),
+                mesh.nCells()
+            )
+        );
+
+        // historyPtr = readFromFile.get();  // get(), not release()
+    }
+
+    // const auto& history = *historyPtr;
+    const auto& history =
+    (
+        readFromFile.valid()
+       ? readFromFile()
+       : *historyPtr
+    );
+
+    if (history.active())
+    {
+        // refinementHistoryNew itself implements decompositionConstraint
+        history.apply
+        (
+            blockedFace,
+            specifiedProcessorFaces,
+            specifiedProcessor,
+            explicitConnections,
+            decomposition
+        );
+    }
+}
+
+
+// ************************************************************************* //
\ No newline at end of file
diff --git a/src/dynamicFvMesh/refinementHistoryNewConstraint/refinementHistoryNewConstraint.H b/src/dynamicFvMesh/refinementHistoryNewConstraint/refinementHistoryNewConstraint.H
new file mode 100644
index 00000000..428aa882
--- /dev/null
+++ b/src/dynamicFvMesh/refinementHistoryNewConstraint/refinementHistoryNewConstraint.H
@@ -0,0 +1,115 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2015-2016 OpenFOAM Foundation
+     \\/     M anipulation  | Copyright (C) 2018 OpenCFD Ltd.
+-------------------------------------------------------------------------------
+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/>.
+
+Class
+    Foam::decompositionConstraints::refinementHistoryNew
+
+Description
+    Constraint to keep all cells originating from refining the same cell
+    onto the same processor. Reads polyMesh/refinementHistoryNew.
+
+    \heading Dictionary parameters
+    \table
+        Property    | Description                       | Required  | Default
+        type        | refinementHistoryNew                 | yes   |
+    \endtable
+
+SourceFiles
+    refinementHistoryNewConstraint.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef refinementHistoryNewConstraint_H
+#define refinementHistoryNewConstraint_H
+
+#include "decompositionConstraint.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace decompositionConstraints
+{
+
+/*---------------------------------------------------------------------------*\
+                      Class refinementHistoryNewConstraint Declaration
+\*---------------------------------------------------------------------------*/
+
+class refinementHistoryNewConstraint
+:
+    public decompositionConstraint
+{
+public:
+
+    //- Runtime type information
+    TypeName("refinementHistoryNew");
+
+
+    // Constructors
+
+        //- Construct with constraint dictionary
+        explicit refinementHistoryNewConstraint(const dictionary& dict,const word& type);
+
+        //- Construct from components
+        refinementHistoryNewConstraint();
+
+
+    //- Destructor
+    virtual ~refinementHistoryNewConstraint() = default;
+
+
+    // Member Functions
+
+        //- Add this constraint to list of constraints
+        virtual void add
+        (
+            const polyMesh& mesh,
+            boolList& blockedFace,
+            PtrList<labelList>& specifiedProcessorFaces,
+            labelList& specifiedProcessor,
+            List<labelPair>& explicitConnections
+        ) const;
+
+        //- Apply this constraint post-decomposition
+        virtual void apply
+        (
+            const polyMesh& mesh,
+            const boolList& blockedFace,
+            const PtrList<labelList>& specifiedProcessorFaces,
+            const labelList& specifiedProcessor,
+            const List<labelPair>& explicitConnections,
+            labelList& decomposition
+        ) const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace decompositionConstraints
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
\ No newline at end of file
diff --git a/src/dynamicMesh/Make/files b/src/dynamicMesh/Make/files
index d634b9ed..503e4041 100644
--- a/src/dynamicMesh/Make/files
+++ b/src/dynamicMesh/Make/files
@@ -2,7 +2,7 @@ hexRef = polyTopoChange/polyTopoChange/hexRef
 
 $(hexRef)/hexRef.C
 $(hexRef)/hexRefData.C
-$(hexRef)/refinementHistory.C
+$(hexRef)/refinementHistoryNew.C
 $(hexRef)/hexRefNew.C
 
 $(hexRef)/hexRef8/hexRef8.C
diff --git a/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef.C b/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef.C
index 49cc3101..c8c3d3ae 100644
--- a/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef.C
+++ b/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef.C
@@ -1464,7 +1464,7 @@ Foam::hexRef::hexRef(const polyMesh& mesh, const bool readHistory)
     (
         IOobject
         (
-            "refinementHistory",
+            "refinementHistoryNew",
             mesh_.facesInstance(),
             polyMesh::meshSubDir,
             mesh_,
@@ -1551,7 +1551,7 @@ Foam::hexRef::hexRef
     const polyMesh& mesh,
     const labelList& cellLevel,
     const labelList& pointLevel,
-    const refinementHistory& history,
+    const refinementHistoryNew& history,
     const scalar level0Edge
 )
 :
@@ -1604,7 +1604,7 @@ Foam::hexRef::hexRef
     (
         IOobject
         (
-            "refinementHistory",
+            "refinementHistoryNew",
             mesh_.facesInstance(),
             polyMesh::meshSubDir,
             mesh_,
@@ -1712,14 +1712,14 @@ Foam::hexRef::hexRef
     (
         IOobject
         (
-            "refinementHistory",
+            "refinementHistoryNew",
             mesh_.facesInstance(),
             polyMesh::meshSubDir,
             mesh_,
             IOobject::NO_READ,
             IOobject::NO_WRITE
         ),
-        List<refinementHistory::splitCell8>(0),
+        List<refinementHistoryNew::splitCell8>(0),
         labelList(0),
         false
     ),
diff --git a/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef.H b/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef.H
index a426c69b..ade41d54 100644
--- a/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef.H
+++ b/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef.H
@@ -51,7 +51,7 @@ Authors
 #include "DynamicList.H"
 #include "primitivePatch.H"
 #include "removeFaces.H"
-#include "refinementHistory.H"
+#include "refinementHistoryNew.H"
 #include "PackedBoolList.H"
 #include "uniformDimensionedFields.H"
 #include "cellShapeList.H"
@@ -93,7 +93,7 @@ protected:
         uniformDimensionedScalarField level0Edge_;
 
         //- Refinement history
-        refinementHistory history_;
+        refinementHistoryNew history_;
 
         //- Face remover engine
         removeFaces faceRemover_;
@@ -385,7 +385,7 @@ public:
             const polyMesh& mesh,
             const labelList& cellLevel,
             const labelList& pointLevel,
-            const refinementHistory& history,
+            const refinementHistoryNew& history,
             const scalar level0Edge
         ),
         (mesh, cellLevel, pointLevel, history, level0Edge)
@@ -420,7 +420,7 @@ public:
             const polyMesh& mesh,
             const labelList& cellLevel,
             const labelList& pointLevel,
-            const refinementHistory& history,
+            const refinementHistoryNew& history,
             const scalar level0Edge = -GREAT
         );
 
@@ -446,7 +446,7 @@ public:
             const polyMesh& mesh,
             const labelList& cellLevel,
             const labelList& pointLevel,
-            const refinementHistory& history,
+            const refinementHistoryNew& history,
             const scalar level0Edge = -GREAT
         );
 
@@ -480,7 +480,7 @@ public:
                 return pointLevel_;
             }
 
-            const refinementHistory& history() const
+            const refinementHistoryNew& history() const
             {
                 return history_;
             }
diff --git a/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef2/hexRef2.C b/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef2/hexRef2.C
index c1aaef5a..fb577a4f 100644
--- a/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef2/hexRef2.C
+++ b/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef2/hexRef2.C
@@ -206,7 +206,7 @@ Foam::hexRef2::hexRef2
     const polyMesh& mesh,
     const labelList& cellLevel,
     const labelList& pointLevel,
-    const refinementHistory& history,
+    const refinementHistoryNew& history,
     const scalar level0Edge
 )
 :
diff --git a/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef2/hexRef2.H b/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef2/hexRef2.H
index 921183a0..c122ef33 100644
--- a/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef2/hexRef2.H
+++ b/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef2/hexRef2.H
@@ -138,7 +138,7 @@ public:
             const polyMesh& mesh,
             const labelList& cellLevel,
             const labelList& pointLevel,
-            const refinementHistory& history,
+            const refinementHistoryNew& history,
             const scalar level0Edge = -GREAT
         );
 
diff --git a/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef4/hexRef4.C b/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef4/hexRef4.C
index 1b63b9b0..4b607ae4 100644
--- a/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef4/hexRef4.C
+++ b/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef4/hexRef4.C
@@ -733,7 +733,7 @@ Foam::hexRef4::hexRef4
     const polyMesh& mesh,
     const labelList& cellLevel,
     const labelList& pointLevel,
-    const refinementHistory& history,
+    const refinementHistoryNew& history,
     const scalar level0Edge
 )
 :
diff --git a/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef4/hexRef4.H b/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef4/hexRef4.H
index 4f5f3561..62c9c003 100644
--- a/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef4/hexRef4.H
+++ b/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef4/hexRef4.H
@@ -127,7 +127,7 @@ public:
             const polyMesh& mesh,
             const labelList& cellLevel,
             const labelList& pointLevel,
-            const refinementHistory& history,
+            const refinementHistoryNew& history,
             const scalar level0Edge = -GREAT
         );
 
diff --git a/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef4Axi/hexRef4Axi.C b/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef4Axi/hexRef4Axi.C
index d84a7814..ea0b665e 100644
--- a/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef4Axi/hexRef4Axi.C
+++ b/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef4Axi/hexRef4Axi.C
@@ -738,7 +738,7 @@ Foam::hexRef4Axi::hexRef4Axi
     const polyMesh& mesh,
     const labelList& cellLevel,
     const labelList& pointLevel,
-    const refinementHistory& history,
+    const refinementHistoryNew& history,
     const scalar level0Edge
 )
 :
diff --git a/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef4Axi/hexRef4Axi.H b/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef4Axi/hexRef4Axi.H
index 2399b469..0bcb3813 100644
--- a/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef4Axi/hexRef4Axi.H
+++ b/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef4Axi/hexRef4Axi.H
@@ -126,7 +126,7 @@ public:
             const polyMesh& mesh,
             const labelList& cellLevel,
             const labelList& pointLevel,
-            const refinementHistory& history,
+            const refinementHistoryNew& history,
             const scalar level0Edge = -GREAT
         );
 
diff --git a/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef8/hexRef8.C b/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef8/hexRef8.C
index ecd0851d..f8193747 100644
--- a/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef8/hexRef8.C
+++ b/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef8/hexRef8.C
@@ -655,7 +655,7 @@ Foam::hexRef8::hexRef8
     const polyMesh& mesh,
     const labelList& cellLevel,
     const labelList& pointLevel,
-    const refinementHistory& history,
+    const refinementHistoryNew& history,
     const scalar level0Edge
 )
 :
diff --git a/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef8/hexRef8.H b/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef8/hexRef8.H
index c953b2bf..7112e5dd 100644
--- a/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef8/hexRef8.H
+++ b/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef8/hexRef8.H
@@ -142,7 +142,7 @@ public:
             const polyMesh& mesh,
             const labelList& cellLevel,
             const labelList& pointLevel,
-            const refinementHistory& history,
+            const refinementHistoryNew& history,
             const scalar level0Edge = -GREAT
         );
 
diff --git a/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRefData.C b/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRefData.C
index 1b1045e9..49ab765c 100644
--- a/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRefData.C
+++ b/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRefData.C
@@ -31,12 +31,12 @@ License
 #include "mapDistributePolyMesh.H"
 #include "polyMesh.H"
 #include "syncTools.H"
-#include "refinementHistory.H"
+#include "refinementHistoryNew.H"
 #include "fvMesh.H"
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
-Foam::hexRef8Data::hexRef8Data(const IOobject& io)
+Foam::hexRefData::hexRefData(const IOobject& io)
 {
     {
         IOobject rio(io);
@@ -73,22 +73,22 @@ Foam::hexRef8Data::hexRef8Data(const IOobject& io)
     }
     {
         IOobject rio(io);
-        rio.rename("refinementHistory");
+        rio.rename("refinementHistoryNew");
         // bool haveFile = returnReduce(rio.headerOk(), orOp<bool>());
         bool haveFile = returnReduce(rio.typeHeaderOk<labelIOList>(), orOp<bool>());
         if (haveFile)
         {
             Info<< "Reading hexRef data : " << rio.name() << endl;
-            refHistoryPtr_.reset(new refinementHistory(rio));
+            refHistoryPtr_.reset(new refinementHistoryNew(rio));
         }
     }
 }
 
 
-Foam::hexRef8Data::hexRef8Data
+Foam::hexRefData::hexRefData
 (
     const IOobject& io,
-    const hexRef8Data& data,
+    const hexRefData& data,
     const labelList& cellMap,
     const labelList& pointMap
 )
@@ -141,12 +141,12 @@ Foam::hexRef8Data::hexRef8Data
 }
 
 
-Foam::hexRef8Data::hexRef8Data
+Foam::hexRefData::hexRefData
 (
     const IOobject& io,
     const UPtrList<const labelList>& cellMaps,
     const UPtrList<const labelList>& pointMaps,
-    const UPtrList<const hexRef8Data>& procDatas
+    const UPtrList<const hexRefData>& procDatas
 )
 {
     const polyMesh& mesh = dynamic_cast<const polyMesh&>(io.db());
@@ -212,7 +212,7 @@ Foam::hexRef8Data::hexRef8Data
         IOobject rio(io);
         rio.rename(procDatas[0].refHistoryPtr_().name());
 
-        UPtrList<const refinementHistory> procRefs(procDatas.size());
+        UPtrList<const refinementHistoryNew> procRefs(procDatas.size());
         forAll(procDatas, i)
         {
             procRefs.set(i, &procDatas[i].refHistoryPtr_());
@@ -220,7 +220,7 @@ Foam::hexRef8Data::hexRef8Data
 
         refHistoryPtr_.reset
         (
-            new refinementHistory
+            new refinementHistoryNew
             (
                 rio,
                 cellMaps,
@@ -233,13 +233,13 @@ Foam::hexRef8Data::hexRef8Data
 
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
-Foam::hexRef8Data::~hexRef8Data()
+Foam::hexRefData::~hexRefData()
 {}
 
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
-void Foam::hexRef8Data::sync(const IOobject& io)
+void Foam::hexRefData::sync(const IOobject& io)
 {
     const polyMesh& mesh = dynamic_cast<const polyMesh&>(io.db());
 
@@ -290,14 +290,14 @@ void Foam::hexRef8Data::sync(const IOobject& io)
     if (hasHistory && !refHistoryPtr_.valid())
     {
         IOobject rio(io);
-        rio.rename("refinementHistory");
+        rio.rename("refinementHistoryNew");
         rio.readOpt() = IOobject::NO_READ;
-        refHistoryPtr_.reset(new refinementHistory(rio, mesh.nCells(), true));
+        refHistoryPtr_.reset(new refinementHistoryNew(rio, mesh.nCells(), true));
     }
 }
 
 
-void Foam::hexRef8Data::distribute(const mapDistributePolyMesh& map)
+void Foam::hexRefData::distribute(const mapDistributePolyMesh& map)
 {
     if (cellLevelPtr_.valid())
     {
@@ -317,7 +317,7 @@ void Foam::hexRef8Data::distribute(const mapDistributePolyMesh& map)
 }
 
 
-bool Foam::hexRef8Data::write() const
+bool Foam::hexRefData::write() const
 {
     bool ok = true;
     if (cellLevelPtr_.valid())
diff --git a/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRefData.H b/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRefData.H
index b8f1272d..69e5427c 100644
--- a/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRefData.H
+++ b/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRefData.H
@@ -22,19 +22,19 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Class
-    Foam::hexRef8Data
+    Foam::hexRefData
 
 Description
     Various for reading/decomposing/reconstructing/distributing refinement
     data.
 
 SourceFiles
-    hexRef8Data.C
+    hexRefData.C
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef hexRef8Data_H
-#define hexRef8Data_H
+#ifndef hexRefData_H
+#define hexRefData_H
 
 #include "labelIOList.H"
 #include "uniformDimensionedFields.H"
@@ -48,14 +48,14 @@ namespace Foam
 // Forward declaration of classes
 class mapPolyMesh;
 class mapDistributePolyMesh;
-class refinementHistory;
+class refinementHistoryNew;
 class fvMesh;
 
 /*---------------------------------------------------------------------------*\
-                           Class hexRef8Data Declaration
+                           Class hexRefData Declaration
 \*---------------------------------------------------------------------------*/
 
-class hexRef8Data
+class hexRefData
 {
 
 private:
@@ -68,16 +68,16 @@ private:
 
         autoPtr<uniformDimensionedScalarField> level0EdgePtr_;
 
-        autoPtr<refinementHistory> refHistoryPtr_;
+        autoPtr<refinementHistoryNew> refHistoryPtr_;
 
 
     // Private Member Functions
 
         //- Disallow default bitwise copy construct
-        hexRef8Data(const hexRef8Data&);
+        hexRefData(const hexRefData&);
 
         //- Disallow default bitwise assignment
-        void operator=(const hexRef8Data&);
+        void operator=(const hexRefData&);
 
 
 public:
@@ -86,29 +86,29 @@ public:
 
         //- Construct read. Has special provision for only some processors
         //  having the files so can be used in redistribution.
-        hexRef8Data(const IOobject& io);
+        hexRefData(const IOobject& io);
 
         //- Construct as subset
-        hexRef8Data
+        hexRefData
         (
             const IOobject& io,
-            const hexRef8Data&,
+            const hexRefData&,
             const labelList& cellMap,
             const labelList& pointMap
         );
 
-        //- Construct from multiple hexRef8Data
-        hexRef8Data
+        //- Construct from multiple hexRefData
+        hexRefData
         (
             const IOobject& io,
             const UPtrList<const labelList>& cellMaps,
             const UPtrList<const labelList>& pointMaps,
-            const UPtrList<const hexRef8Data>&
+            const UPtrList<const hexRefData>&
         );
 
 
     //- Destructor
-    ~hexRef8Data();
+    ~hexRefData();
 
 
     // Member Functions
@@ -124,8 +124,6 @@ public:
         bool write() const;
 };
 
-typedef hexRef8Data hexRefData;
-
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 } // End namespace Foam
diff --git a/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRefNew.C b/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRefNew.C
index 369442d5..c18cda4d 100644
--- a/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRefNew.C
+++ b/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRefNew.C
@@ -89,7 +89,7 @@ Foam::autoPtr<Foam::hexRef> Foam::hexRef::New
     const polyMesh& mesh,
     const labelList& cellLevel,
     const labelList& pointLevel,
-    const refinementHistory& history,
+    const refinementHistoryNew& history,
     const scalar level0Edge
 )
 {
diff --git a/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/refinementHistory.C b/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/refinementHistoryNew.C
similarity index 91%
rename from src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/refinementHistory.C
rename to src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/refinementHistoryNew.C
index a72a64a7..9d939027 100644
--- a/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/refinementHistory.C
+++ b/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/refinementHistoryNew.C
@@ -23,7 +23,7 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-#include "refinementHistory.H"
+#include "refinementHistoryNew.H"
 #include "mapPolyMesh.H"
 #include "mapDistributePolyMesh.H"
 #include "polyMesh.H"
@@ -33,13 +33,13 @@ License
 
 namespace Foam
 {
-    defineTypeNameAndDebug(refinementHistory, 0);
+    defineTypeNameAndDebug(refinementHistoryNew, 0);
 }
 
 
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 
-void Foam::refinementHistory::writeEntry
+void Foam::refinementHistoryNew::writeEntry
 (
     const List<splitCell8>& splitCells,
     const splitCell8& split
@@ -71,7 +71,7 @@ void Foam::refinementHistory::writeEntry
 }
 
 
-void Foam::refinementHistory::writeDebug
+void Foam::refinementHistoryNew::writeDebug
 (
     const labelList& visibleCells,
     const List<splitCell8>& splitCells
@@ -105,27 +105,27 @@ void Foam::refinementHistory::writeDebug
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
-Foam::refinementHistory::splitCell8::splitCell8()
+Foam::refinementHistoryNew::splitCell8::splitCell8()
 :
     parent_(-1),
     addedCellsPtr_(nullptr)
 {}
 
 
-Foam::refinementHistory::splitCell8::splitCell8(const label parent)
+Foam::refinementHistoryNew::splitCell8::splitCell8(const label parent)
 :
     parent_(parent),
     addedCellsPtr_(nullptr)
 {}
 
 
-Foam::refinementHistory::splitCell8::splitCell8(Istream& is)
+Foam::refinementHistoryNew::splitCell8::splitCell8(Istream& is)
 {
     is >> *this;
 }
 
 
-Foam::refinementHistory::splitCell8::splitCell8(const splitCell8& sc)
+Foam::refinementHistoryNew::splitCell8::splitCell8(const splitCell8& sc)
 :
     parent_(sc.parent_),
     addedCellsPtr_
@@ -139,7 +139,7 @@ Foam::refinementHistory::splitCell8::splitCell8(const splitCell8& sc)
 
 // * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * * //
 
-void Foam::refinementHistory::splitCell8::operator=(const splitCell8& s)
+void Foam::refinementHistoryNew::splitCell8::operator=(const splitCell8& s)
 {
     //- Assignment operator since autoPtr otherwise 'steals' storage.
 
@@ -162,7 +162,7 @@ void Foam::refinementHistory::splitCell8::operator=(const splitCell8& s)
 }
 
 
-bool Foam::refinementHistory::splitCell8::operator==(const splitCell8& s) const
+bool Foam::refinementHistoryNew::splitCell8::operator==(const splitCell8& s) const
 {
     if (addedCellsPtr_.valid() != s.addedCellsPtr_.valid())
     {
@@ -183,7 +183,7 @@ bool Foam::refinementHistory::splitCell8::operator==(const splitCell8& s) const
 }
 
 
-bool Foam::refinementHistory::splitCell8::operator!=(const splitCell8& s) const
+bool Foam::refinementHistoryNew::splitCell8::operator!=(const splitCell8& s) const
 {
     return !operator==(s);
 }
@@ -191,7 +191,7 @@ bool Foam::refinementHistory::splitCell8::operator!=(const splitCell8& s) const
 
 // * * * * * * * * * * * * * * Friend Operators  * * * * * * * * * * * * * * //
 
-Foam::Istream& Foam::operator>>(Istream& is, refinementHistory::splitCell8& sc)
+Foam::Istream& Foam::operator>>(Istream& is, refinementHistoryNew::splitCell8& sc)
 {
     labelList addedCells;
 
@@ -213,7 +213,7 @@ Foam::Istream& Foam::operator>>(Istream& is, refinementHistory::splitCell8& sc)
 Foam::Ostream& Foam::operator<<
 (
     Ostream& os,
-    const refinementHistory::splitCell8& sc
+    const refinementHistoryNew::splitCell8& sc
 )
 {
     // Output as labelList so we can have 0 sized lists. Alternative is to
@@ -236,7 +236,7 @@ Foam::Ostream& Foam::operator<<
 
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 
-void Foam::refinementHistory::checkIndices() const
+void Foam::refinementHistoryNew::checkIndices() const
 {
     // Check indices.
     forAll(visibleCells_, i)
@@ -254,7 +254,7 @@ void Foam::refinementHistory::checkIndices() const
 }
 
 
-Foam::label Foam::refinementHistory::allocateSplitCell
+Foam::label Foam::refinementHistoryNew::allocateSplitCell
 (
     const label parent,
     const label i
@@ -298,7 +298,7 @@ Foam::label Foam::refinementHistory::allocateSplitCell
 }
 
 
-void Foam::refinementHistory::freeSplitCell(const label index)
+void Foam::refinementHistoryNew::freeSplitCell(const label index)
 {
     splitCell8& split = splitCells_[index];
 
@@ -335,7 +335,7 @@ void Foam::refinementHistory::freeSplitCell(const label index)
 }
 
 
-void Foam::refinementHistory::markSplit
+void Foam::refinementHistoryNew::markSplit
 (
     const label index,
     labelList& oldToNew,
@@ -371,7 +371,7 @@ void Foam::refinementHistory::markSplit
 }
 
 
-void Foam::refinementHistory::mark
+void Foam::refinementHistoryNew::mark
 (
     const label val,
     const label index,
@@ -397,7 +397,7 @@ void Foam::refinementHistory::mark
 }
 
 
-Foam::label Foam::refinementHistory::markCommonCells
+Foam::label Foam::refinementHistoryNew::markCommonCells
 (
     labelList& cellToCluster
 ) const
@@ -445,7 +445,7 @@ Foam::label Foam::refinementHistory::markCommonCells
 }
 
 
-void Foam::refinementHistory::add
+void Foam::refinementHistoryNew::add
 (
     boolList& blockedFace,
     PtrList<labelList>& specifiedProcessorFaces,
@@ -481,7 +481,7 @@ void Foam::refinementHistory::add
         }
     }
 
-    if (refinementHistory::debug)
+    if (refinementHistoryNew::debug)
     {
         reduce(nUnblocked, sumOp<label>());
         Info<< type() << " : unblocked " << nUnblocked << " faces" << endl;
@@ -491,7 +491,7 @@ void Foam::refinementHistory::add
 }
 
 
-void Foam::refinementHistory::apply
+void Foam::refinementHistoryNew::apply
 (
     const boolList& blockedFace,
     const PtrList<labelList>& specifiedProcessorFaces,
@@ -541,7 +541,7 @@ void Foam::refinementHistory::apply
         }
     }
 
-    if (refinementHistory::debug)
+    if (refinementHistoryNew::debug)
     {
         reduce(nChanged, sumOp<label>());
         Info<< type() << " : changed decomposition on " << nChanged
@@ -552,7 +552,7 @@ void Foam::refinementHistory::apply
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
-Foam::refinementHistory::refinementHistory(const IOobject& io)
+Foam::refinementHistoryNew::refinementHistoryNew(const IOobject& io)
 :
     regIOobject(io),
     active_(false)
@@ -578,13 +578,13 @@ Foam::refinementHistory::refinementHistory(const IOobject& io)
     }
 
     // When running in redistributPar + READ_IF_PRESENT it can happen
-    // that some processors do have refinementHistory and some don't so
+    // that some processors do have refinementHistoryNew and some don't so
     // test for active has to be outside of above condition.
     active_ = (returnReduce(visibleCells_.size(), sumOp<label>()) > 0);
 
     if (debug)
     {
-        Pout<< "refinementHistory::refinementHistory :"
+        Pout<< "refinementHistoryNew::refinementHistoryNew :"
             << " constructed history from IOobject :"
             << " splitCells:" << splitCells_.size()
             << " visibleCells:" << visibleCells_.size()
@@ -594,7 +594,7 @@ Foam::refinementHistory::refinementHistory(const IOobject& io)
 }
 
 
-Foam::refinementHistory::refinementHistory
+Foam::refinementHistoryNew::refinementHistoryNew
 (
     const IOobject& io,
     const List<splitCell8>& splitCells,
@@ -633,7 +633,7 @@ Foam::refinementHistory::refinementHistory
 
     if (debug)
     {
-        Pout<< "refinementHistory::refinementHistory :"
+        Pout<< "refinementHistoryNew::refinementHistoryNew :"
             << " constructed history from IOobject or components :"
             << " splitCells:" << splitCells_.size()
             << " visibleCells:" << visibleCells_.size()
@@ -643,7 +643,7 @@ Foam::refinementHistory::refinementHistory
 }
 
 
-Foam::refinementHistory::refinementHistory
+Foam::refinementHistoryNew::refinementHistoryNew
 (
     const IOobject& io,
     const label nCells
@@ -692,7 +692,7 @@ Foam::refinementHistory::refinementHistory
 
     if (debug)
     {
-        Pout<< "refinementHistory::refinementHistory :"
+        Pout<< "refinementHistoryNew::refinementHistoryNew :"
             << " constructed history from IOobject or initial size :"
             << " splitCells:" << splitCells_.size()
             << " visibleCells:" << visibleCells_.size()
@@ -703,7 +703,7 @@ Foam::refinementHistory::refinementHistory
 
 
 // Construct from initial number of cells (all visible)
-Foam::refinementHistory::refinementHistory
+Foam::refinementHistoryNew::refinementHistoryNew
 (
     const IOobject& io,
     const label nCells,
@@ -750,7 +750,7 @@ Foam::refinementHistory::refinementHistory
 
     if (debug)
     {
-        Pout<< "refinementHistory::refinementHistory :"
+        Pout<< "refinementHistoryNew::refinementHistoryNew :"
             << " constructed history from IOobject or initial size :"
             << " splitCells:" << splitCells_.size()
             << " visibleCells:" << visibleCells_.size()
@@ -760,10 +760,10 @@ Foam::refinementHistory::refinementHistory
 }
 
 
-Foam::refinementHistory::refinementHistory
+Foam::refinementHistoryNew::refinementHistoryNew
 (
     const IOobject& io,
-    const refinementHistory& rh
+    const refinementHistoryNew& rh
 )
 :
     regIOobject(io),
@@ -774,17 +774,17 @@ Foam::refinementHistory::refinementHistory
 {
     if (debug)
     {
-        Pout<< "refinementHistory::refinementHistory : constructed initial"
+        Pout<< "refinementHistoryNew::refinementHistoryNew : constructed initial"
             << " history." << endl;
     }
 }
 
 
-Foam::refinementHistory::refinementHistory
+Foam::refinementHistoryNew::refinementHistoryNew
 (
     const IOobject& io,
     const UPtrList<const labelList>& cellMaps,
-    const UPtrList<const refinementHistory>& refs
+    const UPtrList<const refinementHistoryNew>& refs
 )
 :
     regIOobject(io),
@@ -799,8 +799,8 @@ Foam::refinementHistory::refinementHistory
     {
         WarningIn
         (
-            "refinementHistory::refinementHistory(const IOobject&"
-            ", const labelListList&, const PtrList<refinementHistory>&)"
+            "refinementHistoryNew::refinementHistoryNew(const IOobject&"
+            ", const labelListList&, const PtrList<refinementHistoryNew>&)"
         )   << "read option IOobject::MUST_READ, READ_IF_PRESENT or "
             << "MUST_READ_IF_MODIFIED"
             << " suggests that a read constructor would be more appropriate."
@@ -890,7 +890,7 @@ Foam::refinementHistory::refinementHistory
 
     if (debug)
     {
-        Pout<< "refinementHistory::refinementHistory :"
+        Pout<< "refinementHistoryNew::refinementHistoryNew :"
             << " constructed history from multiple refinementHistories :"
             << " splitCells:" << splitCells_.size()
             << " visibleCells:" << visibleCells_.size()
@@ -899,7 +899,7 @@ Foam::refinementHistory::refinementHistory
 }
 
 
-Foam::refinementHistory::refinementHistory(const IOobject& io, Istream& is)
+Foam::refinementHistoryNew::refinementHistoryNew(const IOobject& io, Istream& is)
 :
     regIOobject(io),
     splitCells_(is),
@@ -913,7 +913,7 @@ Foam::refinementHistory::refinementHistory(const IOobject& io, Istream& is)
 
     if (debug)
     {
-        Pout<< "refinementHistory::refinementHistory :"
+        Pout<< "refinementHistoryNew::refinementHistoryNew :"
             << " constructed history from Istream"
             << " splitCells:" << splitCells_.size()
             << " visibleCells:" << visibleCells_.size()
@@ -924,7 +924,7 @@ Foam::refinementHistory::refinementHistory(const IOobject& io, Istream& is)
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
-Foam::autoPtr<Foam::refinementHistory> Foam::refinementHistory::clone
+Foam::autoPtr<Foam::refinementHistoryNew> Foam::refinementHistoryNew::clone
 (
     const IOobject& io,
     // Per visible cell the processor it is going to
@@ -1032,9 +1032,9 @@ Foam::autoPtr<Foam::refinementHistory> Foam::refinementHistory::clone
         }
     }
 
-    return autoPtr<refinementHistory>
+    return autoPtr<refinementHistoryNew>
     (
-        new refinementHistory
+        new refinementHistoryNew
         (
             io,
             newSplitCells,
@@ -1045,7 +1045,7 @@ Foam::autoPtr<Foam::refinementHistory> Foam::refinementHistory::clone
 }
 
 
-Foam::autoPtr<Foam::refinementHistory> Foam::refinementHistory::clone
+Foam::autoPtr<Foam::refinementHistoryNew> Foam::refinementHistoryNew::clone
 (
     const IOobject& io,
     const labelList& cellMap
@@ -1096,9 +1096,9 @@ Foam::autoPtr<Foam::refinementHistory> Foam::refinementHistory::clone
     }
     else
     {
-        return autoPtr<refinementHistory>
+        return autoPtr<refinementHistoryNew>
         (
-            new refinementHistory
+            new refinementHistoryNew
             (
                 io,
                 DynamicList<splitCell8>(0),
@@ -1110,13 +1110,13 @@ Foam::autoPtr<Foam::refinementHistory> Foam::refinementHistory::clone
 }
 
 
-void Foam::refinementHistory::resize(const label size)
+void Foam::refinementHistoryNew::resize(const label size)
 {
     label oldSize = visibleCells_.size();
 
     if (debug)
     {
-        Pout<< "refinementHistory::resize from " << oldSize << " to " << size
+        Pout<< "refinementHistoryNew::resize from " << oldSize << " to " << size
             << " cells" << endl;
     }
 
@@ -1130,7 +1130,7 @@ void Foam::refinementHistory::resize(const label size)
 }
 
 
-void Foam::refinementHistory::updateMesh(const mapPolyMesh& map)
+void Foam::refinementHistoryNew::updateMesh(const mapPolyMesh& map)
 {
     if (active())
     {
@@ -1164,7 +1164,7 @@ void Foam::refinementHistory::updateMesh(const mapPolyMesh& map)
 
         if (debug)
         {
-            Pout<< "refinementHistory::updateMesh : from "
+            Pout<< "refinementHistoryNew::updateMesh : from "
                 << visibleCells_.size()
                 << " to " << newVisibleCells.size()
                 << " cells" << endl;
@@ -1175,7 +1175,7 @@ void Foam::refinementHistory::updateMesh(const mapPolyMesh& map)
 }
 
 
-void Foam::refinementHistory::subset
+void Foam::refinementHistoryNew::subset
 (
     const labelList& pointMap,
     const labelList& faceMap,
@@ -1204,7 +1204,7 @@ void Foam::refinementHistory::subset
 
         if (debug)
         {
-            Pout<< "refinementHistory::updateMesh : from "
+            Pout<< "refinementHistoryNew::updateMesh : from "
                 << visibleCells_.size()
                 << " to " << newVisibleCells.size()
                 << " cells" << endl;
@@ -1215,7 +1215,7 @@ void Foam::refinementHistory::subset
 }
 
 
-void Foam::refinementHistory::countProc
+void Foam::refinementHistoryNew::countProc
 (
     const label index,
     const label newProcNo,
@@ -1261,7 +1261,7 @@ void Foam::refinementHistory::countProc
 }
 
 
-void Foam::refinementHistory::distribute(const mapDistributePolyMesh& map)
+void Foam::refinementHistoryNew::distribute(const mapDistributePolyMesh& map)
 {
     if (!active())
     {
@@ -1331,10 +1331,10 @@ void Foam::refinementHistory::distribute(const mapDistributePolyMesh& map)
         }
     }
 
-    //Pout<< "refinementHistory::distribute :"
+    //Pout<< "refinementHistoryNew::distribute :"
     //    << " splitCellProc:" << splitCellProc << endl;
     //
-    //Pout<< "refinementHistory::distribute :"
+    //Pout<< "refinementHistoryNew::distribute :"
     //    << " splitCellNum:" << splitCellNum << endl;
 
     const polyMesh& mesh = dynamic_cast<const polyMesh&>(db());
@@ -1514,11 +1514,11 @@ void Foam::refinementHistory::distribute(const mapDistributePolyMesh& map)
 }
 
 
-void Foam::refinementHistory::compact()
+void Foam::refinementHistoryNew::compact()
 {
     if (debug)
     {
-        Pout<< "refinementHistory::compact() Entering with:"
+        Pout<< "refinementHistoryNew::compact() Entering with:"
             << " freeSplitCells_:" << freeSplitCells_.size()
             << " splitCells_:" << splitCells_.size()
             << " visibleCells_:" << visibleCells_.size()
@@ -1633,7 +1633,7 @@ void Foam::refinementHistory::compact()
 
     if (debug)
     {
-        Pout<< "refinementHistory::compact : compacted splitCells from "
+        Pout<< "refinementHistoryNew::compact : compacted splitCells from "
             << splitCells_.size() << " to " << newSplitCells.size() << endl;
     }
 
@@ -1643,7 +1643,7 @@ void Foam::refinementHistory::compact()
 
     if (debug)
     {
-        Pout<< "refinementHistory::compact() NOW:"
+        Pout<< "refinementHistoryNew::compact() NOW:"
             << " freeSplitCells_:" << freeSplitCells_.size()
             << " splitCells_:" << splitCells_.size()
             << " newSplitCells:" << newSplitCells.size()
@@ -1670,13 +1670,13 @@ void Foam::refinementHistory::compact()
 }
 
 
-void Foam::refinementHistory::writeDebug() const
+void Foam::refinementHistoryNew::writeDebug() const
 {
     writeDebug(visibleCells_, splitCells_);
 }
 
 
-void Foam::refinementHistory::storeSplit
+void Foam::refinementHistoryNew::storeSplit
 (
     const label celli,
     const labelList& addedCells
@@ -1714,7 +1714,7 @@ void Foam::refinementHistory::storeSplit
 }
 
 
-void Foam::refinementHistory::combineCells
+void Foam::refinementHistoryNew::combineCells
 (
     const label masterCelli,
     const labelList& combinedCells
@@ -1738,7 +1738,7 @@ void Foam::refinementHistory::combineCells
 }
 
 
-bool Foam::refinementHistory::read()
+bool Foam::refinementHistoryNew::read()
 {
     bool ok = readData(readStream(typeName));
     close();
@@ -1749,14 +1749,14 @@ bool Foam::refinementHistory::read()
 }
 
 
-bool Foam::refinementHistory::readData(Istream& is)
+bool Foam::refinementHistoryNew::readData(Istream& is)
 {
     is >> *this;
     return !is.bad();
 }
 
 
-bool Foam::refinementHistory::writeData(Ostream& os) const
+bool Foam::refinementHistoryNew::writeData(Ostream& os) const
 {
     os << *this;
 
@@ -1766,7 +1766,7 @@ bool Foam::refinementHistory::writeData(Ostream& os) const
 
 // * * * * * * * * * * * * * * * Friend Operators  * * * * * * * * * * * * * //
 
-Foam::Istream& Foam::operator>>(Istream& is, refinementHistory& rh)
+Foam::Istream& Foam::operator>>(Istream& is, refinementHistoryNew& rh)
 {
     rh.freeSplitCells_.clearStorage();
 
@@ -1779,9 +1779,9 @@ Foam::Istream& Foam::operator>>(Istream& is, refinementHistory& rh)
 }
 
 
-Foam::Ostream& Foam::operator<<(Ostream& os, const refinementHistory& rh)
+Foam::Ostream& Foam::operator<<(Ostream& os, const refinementHistoryNew& rh)
 {
-    const_cast<refinementHistory&>(rh).compact();
+    const_cast<refinementHistoryNew&>(rh).compact();
 
     return os   << "// splitCells" << nl
                 << rh.splitCells_ << nl
diff --git a/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/refinementHistory.H b/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/refinementHistoryNew.H
similarity index 91%
rename from src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/refinementHistory.H
rename to src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/refinementHistoryNew.H
index 72ed8ea5..c2a870ab 100644
--- a/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/refinementHistory.H
+++ b/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/refinementHistoryNew.H
@@ -22,7 +22,7 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Class
-    Foam::refinementHistory
+    Foam::refinementHistoryNew
 
 Description
     All refinement history. Used in unrefinement.
@@ -64,12 +64,12 @@ Description
 
 
 SourceFiles
-    refinementHistory.C
+    refinementHistoryNew.C
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef refinementHistory_H
-#define refinementHistory_H
+#ifndef refinementHistoryNew_H
+#define refinementHistoryNew_H
 
 #include "DynamicList.H"
 #include "labelList.H"
@@ -91,17 +91,17 @@ class mapDistributePolyMesh;
 
 // Forward declaration of friend functions and operators
 
-class refinementHistory;
+class refinementHistoryNew;
 
-Istream& operator>>(Istream&, refinementHistory&);
-Ostream& operator<<(Ostream&, const refinementHistory&);
+Istream& operator>>(Istream&, refinementHistoryNew&);
+Ostream& operator<<(Ostream&, const refinementHistoryNew&);
 
 
 /*---------------------------------------------------------------------------*\
-                           Class refinementHistory Declaration
+                           Class refinementHistoryNew Declaration
 \*---------------------------------------------------------------------------*/
 
-class refinementHistory
+class refinementHistoryNew
 :
     public regIOobject
 {
@@ -212,17 +212,17 @@ private:
 public:
 
     // Declare name of the class and its debug switch
-    TypeName("refinementHistory");
+    TypeName("refinementHistoryNew");
 
 
     // Constructors
 
         //- Construct (read) given an IOobject. If global number of visible
         //  cells > 0 becomes active
-        refinementHistory(const IOobject&);
+        refinementHistoryNew(const IOobject&);
 
         //- Construct (read) or construct from components
-        refinementHistory
+        refinementHistoryNew
         (
             const IOobject&,
             const List<splitCell8>& splitCells,
@@ -233,11 +233,11 @@ public:
         //- Construct (read) or construct from initial number of cells
         //  (all visible). If global number of visible
         //  cells > 0 becomes active
-        refinementHistory(const IOobject&, const label nCells);
+        refinementHistoryNew(const IOobject&, const label nCells);
 
         //- Construct (read) or construct from initial number of cells
         //  (all visible) and active flag
-        refinementHistory
+        refinementHistoryNew
         (
             const IOobject&,
             const label nCells,
@@ -245,20 +245,20 @@ public:
         );
 
         //- Construct as copy
-        refinementHistory(const IOobject&, const refinementHistory&);
+        refinementHistoryNew(const IOobject&, const refinementHistoryNew&);
 
         //- Construct from multiple refinement histories. If global number of
         //  visible cells > 0 becomes active
-        refinementHistory
+        refinementHistoryNew
         (
             const IOobject&,
             const UPtrList<const labelList>& cellMaps,
-            const UPtrList<const refinementHistory>&
+            const UPtrList<const refinementHistoryNew>&
         );
 
         //- Construct from Istream. If global number of
         //  visible cells > 0 becomes active
-        refinementHistory(const IOobject&, Istream&);
+        refinementHistoryNew(const IOobject&, Istream&);
 
 
     // Member Functions
@@ -324,7 +324,7 @@ public:
         );
 
         //- Low level clone
-        autoPtr<refinementHistory> clone
+        autoPtr<refinementHistoryNew> clone
         (
             const IOobject& io,
             const labelList& decomposition,
@@ -335,7 +335,7 @@ public:
         ) const;
 
         //- Create clone from subset
-        autoPtr<refinementHistory> clone
+        autoPtr<refinementHistoryNew> clone
         (
             const IOobject& io,
             const labelList& cellMap
@@ -405,14 +405,14 @@ public:
 
         //- Istream operator. Note: does not do a reduction - does not set
         //  active_ flag
-        friend Istream& operator>>(Istream&, refinementHistory&);
+        friend Istream& operator>>(Istream&, refinementHistoryNew&);
 
-        friend Ostream& operator<<(Ostream&, const refinementHistory&);
+        friend Ostream& operator<<(Ostream&, const refinementHistoryNew&);
 };
 
 
-Istream& operator>>(Istream&, refinementHistory::splitCell8&);
-Ostream& operator<<(Ostream&, const refinementHistory::splitCell8&);
+Istream& operator>>(Istream&, refinementHistoryNew::splitCell8&);
+Ostream& operator<<(Ostream&, const refinementHistoryNew::splitCell8&);
 
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

From 49ee79d2b07cadc3f16a81c7111ba2504f4f05d2 Mon Sep 17 00:00:00 2001
From: pkuLmq <1900011062@pku.edu.cn>
Date: Sun, 28 Aug 2022 20:55:47 +0800
Subject: [PATCH 10/10] change name

---
 .../constant/dynamicMeshDict                  |   4 +-
 .../oneD_detonationH2/system/controlDict      |   2 +-
 .../oneD_detonationH2/system/decomposeParDict |   4 +-
 src/dynamicFvMesh/Make/files                  |   8 +-
 .../dfDynamicRefineFvMesh.C}                  |  52 +++----
 .../dfDynamicRefineFvMesh.H}                  |  20 +--
 .../dynamicMeshDict                           |   0
 .../multiCritRefinement.C                     |   4 +-
 .../multiCritRefinement.H                     |   0
 .../dfRefinementHistoryConstraint.C}          |  42 +++---
 .../dfRefinementHistoryConstraint.H}          |  24 +--
 src/dynamicMesh/Make/files                    |   2 +-
 ...mentHistoryNew.C => dfRefinementHistory.C} | 142 +++++++++---------
 ...mentHistoryNew.H => dfRefinementHistory.H} |  48 +++---
 .../polyTopoChange/hexRef/hexRef.C            |  10 +-
 .../polyTopoChange/hexRef/hexRef.H            |  12 +-
 .../polyTopoChange/hexRef/hexRef2/hexRef2.C   |   2 +-
 .../polyTopoChange/hexRef/hexRef2/hexRef2.H   |   2 +-
 .../polyTopoChange/hexRef/hexRef4/hexRef4.C   |   2 +-
 .../polyTopoChange/hexRef/hexRef4/hexRef4.H   |   2 +-
 .../hexRef/hexRef4Axi/hexRef4Axi.C            |   2 +-
 .../hexRef/hexRef4Axi/hexRef4Axi.H            |   2 +-
 .../polyTopoChange/hexRef/hexRef8/hexRef8.C   |   2 +-
 .../polyTopoChange/hexRef/hexRef8/hexRef8.H   |   2 +-
 .../polyTopoChange/hexRef/hexRefData.C        |  14 +-
 .../polyTopoChange/hexRef/hexRefData.H        |   4 +-
 .../polyTopoChange/hexRef/hexRefNew.C         |   2 +-
 27 files changed, 205 insertions(+), 205 deletions(-)
 rename src/dynamicFvMesh/{dynamicRefineFvMeshNew/dynamicRefineFvMeshNew.C => dfDynamicRefineFvMesh/dfDynamicRefineFvMesh.C} (97%)
 rename src/dynamicFvMesh/{dynamicRefineFvMeshNew/dynamicRefineFvMeshNew.H => dfDynamicRefineFvMesh/dfDynamicRefineFvMesh.H} (95%)
 rename src/dynamicFvMesh/{dynamicRefineFvMeshNew => dfDynamicRefineFvMesh}/dynamicMeshDict (100%)
 rename src/dynamicFvMesh/{dynamicRefineFvMeshNew => dfDynamicRefineFvMesh}/multiCritRefinement.C (99%)
 rename src/dynamicFvMesh/{dynamicRefineFvMeshNew => dfDynamicRefineFvMesh}/multiCritRefinement.H (100%)
 rename src/dynamicFvMesh/{refinementHistoryNewConstraint/refinementHistoryNewConstraint.C => dfRefinementHistoryConstraint/dfRefinementHistoryConstraint.C} (79%)
 rename src/dynamicFvMesh/{refinementHistoryNewConstraint/refinementHistoryNewConstraint.H => dfRefinementHistoryConstraint/dfRefinementHistoryConstraint.H} (82%)
 rename src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/{refinementHistoryNew.C => dfRefinementHistory.C} (90%)
 rename src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/{refinementHistoryNew.H => dfRefinementHistory.H} (90%)

diff --git a/examples/dfHighSpeedFoam/oneD_detonationH2/constant/dynamicMeshDict b/examples/dfHighSpeedFoam/oneD_detonationH2/constant/dynamicMeshDict
index cf838491..b6057554 100644
--- a/examples/dfHighSpeedFoam/oneD_detonationH2/constant/dynamicMeshDict
+++ b/examples/dfHighSpeedFoam/oneD_detonationH2/constant/dynamicMeshDict
@@ -15,14 +15,14 @@ FoamFile
 }
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-dynamicFvMesh   dynamicRefineFvMeshNew;
+dynamicFvMesh   dfDynamicRefineFvMesh;
 
 multiCritRefinementControls
 {
     enableMultiCritRefinementControl  false;
 }
 
-dynamicRefineFvMeshNewCoeffs
+dfDynamicRefineFvMeshCoeffs
 {
     // How often to refine
     refineInterval  1; 
diff --git a/examples/dfHighSpeedFoam/oneD_detonationH2/system/controlDict b/examples/dfHighSpeedFoam/oneD_detonationH2/system/controlDict
index 06aebc8b..515e99b6 100755
--- a/examples/dfHighSpeedFoam/oneD_detonationH2/system/controlDict
+++ b/examples/dfHighSpeedFoam/oneD_detonationH2/system/controlDict
@@ -15,7 +15,7 @@ FoamFile
 }
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 libs (
-      "libnewdynamicFvMesh.so"
+      "libdfDynamicFvMesh.so"
       );
 
 application     dfHighSpeedFoam;
diff --git a/examples/dfHighSpeedFoam/oneD_detonationH2/system/decomposeParDict b/examples/dfHighSpeedFoam/oneD_detonationH2/system/decomposeParDict
index 2078fe99..e6fbae05 100755
--- a/examples/dfHighSpeedFoam/oneD_detonationH2/system/decomposeParDict
+++ b/examples/dfHighSpeedFoam/oneD_detonationH2/system/decomposeParDict
@@ -21,11 +21,11 @@ method          scotch;
 
 constraints
 {
-    refinementHistoryNew
+    dfRefinementHistory
     {
         //- Decompose cells such that all cell originating from single cell
         //  end up on same processor
-        type    refinementHistoryNew;
+        type    dfRefinementHistory;
     }
 }
 
diff --git a/src/dynamicFvMesh/Make/files b/src/dynamicFvMesh/Make/files
index c10b618c..7b6a909f 100644
--- a/src/dynamicFvMesh/Make/files
+++ b/src/dynamicFvMesh/Make/files
@@ -1,6 +1,6 @@
-dynamicRefineFvMeshNew/multiCritRefinement.C
-dynamicRefineFvMeshNew/dynamicRefineFvMeshNew.C
+dfDynamicRefineFvMesh/multiCritRefinement.C
+dfDynamicRefineFvMesh/dfDynamicRefineFvMesh.C
 
-refinementHistoryNewConstraint/refinementHistoryNewConstraint.C
+dfRefinementHistoryConstraint/dfRefinementHistoryConstraint.C
 
-LIB = $(FOAM_USER_LIBBIN)/libnewdynamicFvMesh
+LIB = $(FOAM_USER_LIBBIN)/libdfDynamicFvMesh
diff --git a/src/dynamicFvMesh/dynamicRefineFvMeshNew/dynamicRefineFvMeshNew.C b/src/dynamicFvMesh/dfDynamicRefineFvMesh/dfDynamicRefineFvMesh.C
similarity index 97%
rename from src/dynamicFvMesh/dynamicRefineFvMeshNew/dynamicRefineFvMeshNew.C
rename to src/dynamicFvMesh/dfDynamicRefineFvMesh/dfDynamicRefineFvMesh.C
index 9227c620..586d4821 100644
--- a/src/dynamicFvMesh/dynamicRefineFvMeshNew/dynamicRefineFvMeshNew.C
+++ b/src/dynamicFvMesh/dfDynamicRefineFvMesh/dfDynamicRefineFvMesh.C
@@ -23,7 +23,7 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-#include "dynamicRefineFvMeshNew.H"
+#include "dfDynamicRefineFvMesh.H"
 #include "addToRunTimeSelectionTable.H"
 #include "surfaceInterpolate.H"
 #include "volFields.H"
@@ -40,8 +40,8 @@ License
 
 namespace Foam
 {
-    defineTypeNameAndDebug(dynamicRefineFvMeshNew, 0);
-    addToRunTimeSelectionTable(dynamicFvMesh, dynamicRefineFvMeshNew, IOobject);
+    defineTypeNameAndDebug(dfDynamicRefineFvMesh, 0);
+    addToRunTimeSelectionTable(dynamicFvMesh, dfDynamicRefineFvMesh, IOobject);
 
 
     // Helper class for accessing max cell level of faces accross processor patches
@@ -58,7 +58,7 @@ namespace Foam
 
 // * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
 
-Foam::label Foam::dynamicRefineFvMeshNew::count
+Foam::label Foam::dfDynamicRefineFvMesh::count
 (
     const PackedBoolList& l,
     const unsigned int val
@@ -84,7 +84,7 @@ Foam::label Foam::dynamicRefineFvMeshNew::count
 }
 
 
-void Foam::dynamicRefineFvMeshNew::calculateProtectedCells
+void Foam::dfDynamicRefineFvMesh::calculateProtectedCells
 (
     PackedBoolList& unrefineableCell
 ) const
@@ -190,7 +190,7 @@ void Foam::dynamicRefineFvMeshNew::calculateProtectedCells
 }
 
 
-void Foam::dynamicRefineFvMeshNew::readDict()
+void Foam::dfDynamicRefineFvMesh::readDict()
 {
     dictionary refineDict
     (
@@ -239,7 +239,7 @@ void Foam::dynamicRefineFvMeshNew::readDict()
 
 // Refines cells, maps fields and recalculates (an approximate) flux
 Foam::autoPtr<Foam::mapPolyMesh>
-Foam::dynamicRefineFvMeshNew::refine
+Foam::dfDynamicRefineFvMesh::refine
 (
     const labelList& cellsToRefine
 )
@@ -501,7 +501,7 @@ Foam::dynamicRefineFvMeshNew::refine
 
 
 Foam::autoPtr<Foam::mapPolyMesh>
-Foam::dynamicRefineFvMeshNew::unrefine
+Foam::dfDynamicRefineFvMesh::unrefine
 (
     const labelList& splitElems
 )
@@ -667,7 +667,7 @@ Foam::dynamicRefineFvMeshNew::unrefine
 
 
 Foam::scalarField
-Foam::dynamicRefineFvMeshNew::maxPointField(const scalarField& pFld) const
+Foam::dfDynamicRefineFvMesh::maxPointField(const scalarField& pFld) const
 {
     scalarField vFld(nCells(), -GREAT);
 
@@ -684,7 +684,7 @@ Foam::dynamicRefineFvMeshNew::maxPointField(const scalarField& pFld) const
 }
 
 Foam::scalarField
-Foam::dynamicRefineFvMeshNew::maxCellField(const volScalarField& vFld) const
+Foam::dfDynamicRefineFvMesh::maxCellField(const volScalarField& vFld) const
 {
     scalarField pFld(nPoints(), -GREAT);
 
@@ -702,7 +702,7 @@ Foam::dynamicRefineFvMeshNew::maxCellField(const volScalarField& vFld) const
 
 /*
 Foam::scalarField
-Foam::dynamicRefineFvMeshNew::minCellField(const volScalarField& vFld) const
+Foam::dfDynamicRefineFvMesh::minCellField(const volScalarField& vFld) const
 {
     scalarField pFld(nPoints(), -GREAT);
 
@@ -721,7 +721,7 @@ Foam::dynamicRefineFvMeshNew::minCellField(const volScalarField& vFld) const
 
 // Simple (non-parallel) interpolation by averaging.
 Foam::scalarField
-Foam::dynamicRefineFvMeshNew::cellToPoint(const scalarField& vFld) const
+Foam::dfDynamicRefineFvMesh::cellToPoint(const scalarField& vFld) const
 {
     scalarField pFld(nPoints());
 
@@ -740,7 +740,7 @@ Foam::dynamicRefineFvMeshNew::cellToPoint(const scalarField& vFld) const
 }
 
 
-Foam::scalarField Foam::dynamicRefineFvMeshNew::error
+Foam::scalarField Foam::dfDynamicRefineFvMesh::error
 (
     const scalarField& fld,
     const scalar minLevel,
@@ -762,7 +762,7 @@ Foam::scalarField Foam::dynamicRefineFvMeshNew::error
 }
 
 
-void Foam::dynamicRefineFvMeshNew::selectRefineCandidates
+void Foam::dfDynamicRefineFvMesh::selectRefineCandidates
 (
     const scalar lowerRefineLevel,
     const scalar upperRefineLevel,
@@ -810,7 +810,7 @@ void Foam::dynamicRefineFvMeshNew::selectRefineCandidates
 }
 
 
-Foam::labelList Foam::dynamicRefineFvMeshNew::selectRefineCells
+Foam::labelList Foam::dfDynamicRefineFvMesh::selectRefineCells
 (
     const label maxCells,
     const label maxRefinement,
@@ -900,7 +900,7 @@ Foam::labelList Foam::dynamicRefineFvMeshNew::selectRefineCells
 // YO- This is here only to preserve compatibility with the official release.
 //     It is not used by the refinement procedure, but some utilities such as
 //     decomposePar rely on it.
-Foam::labelList Foam::dynamicRefineFvMeshNew::selectUnrefinePoints
+Foam::labelList Foam::dfDynamicRefineFvMesh::selectUnrefinePoints
 (
     const scalar unrefineLevel,
     const PackedBoolList& markedCell,
@@ -960,7 +960,7 @@ Foam::labelList Foam::dynamicRefineFvMeshNew::selectUnrefinePoints
 }
 //-YO
 
-void Foam::dynamicRefineFvMeshNew::extendMarkedCells
+void Foam::dfDynamicRefineFvMesh::extendMarkedCells
 (
     PackedBoolList& markedCell
 ) const
@@ -1002,7 +1002,7 @@ void Foam::dynamicRefineFvMeshNew::extendMarkedCells
 }
 
 
-void Foam::dynamicRefineFvMeshNew::checkEightAnchorPoints
+void Foam::dfDynamicRefineFvMesh::checkEightAnchorPoints
 (
     PackedBoolList& protectedCell,
     label& nProtected
@@ -1053,7 +1053,7 @@ void Foam::dynamicRefineFvMeshNew::checkEightAnchorPoints
 
 
 template <class T>
-void Foam::dynamicRefineFvMeshNew::mapNewInternalFaces
+void Foam::dfDynamicRefineFvMesh::mapNewInternalFaces
 (
     const labelList& faceMap
 )
@@ -1073,7 +1073,7 @@ void Foam::dynamicRefineFvMeshNew::mapNewInternalFaces
         {   
             if (debug)
             {
-                Info << "dynamicRefineFvMeshNew::mapNewInternalFaces(): " <<iter.key()<< endl;
+                Info << "dfDynamicRefineFvMesh::mapNewInternalFaces(): " <<iter.key()<< endl;
             }
 
             Field<T> tsFld(this->nFaces(), pTraits<T>::zero);
@@ -1183,7 +1183,7 @@ void Foam::dynamicRefineFvMeshNew::mapNewInternalFaces
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
-Foam::dynamicRefineFvMeshNew::dynamicRefineFvMeshNew(const IOobject& io)
+Foam::dfDynamicRefineFvMesh::dfDynamicRefineFvMesh(const IOobject& io)
 :
     dynamicFvMesh(io),
     meshCutter_(hexRef::New(*this)),
@@ -1574,13 +1574,13 @@ Foam::dynamicRefineFvMeshNew::dynamicRefineFvMeshNew(const IOobject& io)
 
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
-Foam::dynamicRefineFvMeshNew::~dynamicRefineFvMeshNew()
+Foam::dfDynamicRefineFvMesh::~dfDynamicRefineFvMesh()
 {}
 
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
-bool Foam::dynamicRefineFvMeshNew::update()
+bool Foam::dfDynamicRefineFvMesh::update()
 {
     // Re-read dictionary. Choosen since usually -small so trivial amount
     // of time compared to actual refinement. Also very useful to be able
@@ -1633,7 +1633,7 @@ bool Foam::dynamicRefineFvMeshNew::update()
             // reads multiple refinement criteria if subdict multiCritRefinementControls
             // in dynamicMeshDict is present or else does nothing
             // calculates the multiCritRefinementField which needs to be set as field in
-            // dynamicRefineFvMeshNewCoeffs.field multiCritRefinementField;
+            // dfDynamicRefineFvMeshCoeffs.field multiCritRefinementField;
             multiCritRefinement_.updateRefinementField();
         }
 
@@ -1783,7 +1783,7 @@ bool Foam::dynamicRefineFvMeshNew::update()
         {
             // Compact refinement history occassionally (how often?).
             // Unrefinement causes holes in the refinementHistory.
-            const_cast<refinementHistoryNew&>(meshCutter()->history()).compact();
+            const_cast<dfRefinementHistory&>(meshCutter()->history()).compact();
         }
         nRefinementIterations_++;
     }
@@ -1800,7 +1800,7 @@ bool Foam::dynamicRefineFvMeshNew::update()
 }
 
 
-bool Foam::dynamicRefineFvMeshNew::writeObject
+bool Foam::dfDynamicRefineFvMesh::writeObject
 (
     IOstream::streamFormat fmt,
     IOstream::versionNumber ver,
diff --git a/src/dynamicFvMesh/dynamicRefineFvMeshNew/dynamicRefineFvMeshNew.H b/src/dynamicFvMesh/dfDynamicRefineFvMesh/dfDynamicRefineFvMesh.H
similarity index 95%
rename from src/dynamicFvMesh/dynamicRefineFvMeshNew/dynamicRefineFvMeshNew.H
rename to src/dynamicFvMesh/dfDynamicRefineFvMesh/dfDynamicRefineFvMesh.H
index 4ab4d580..8f0d4487 100644
--- a/src/dynamicFvMesh/dynamicRefineFvMeshNew/dynamicRefineFvMeshNew.H
+++ b/src/dynamicFvMesh/dfDynamicRefineFvMesh/dfDynamicRefineFvMesh.H
@@ -22,7 +22,7 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Class
-    Foam::dynamicRefineFvMesh
+    Foam::dfDynamicRefineFvMesh
 
 Description
     A fvMesh with built-in multi-criteria refinement.
@@ -89,8 +89,8 @@ Authors:
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef dynamicRefineFvMeshNew_H
-#define dynamicRefineFvMeshNew_H
+#ifndef dfDynamicRefineFvMesh_H
+#define dfDynamicRefineFvMesh_H
 
 #include "dynamicFvMesh.H"
 #include "hexRef.H"
@@ -105,10 +105,10 @@ namespace Foam
 {
 
 /*---------------------------------------------------------------------------*\
-                     Class dynamicRefineFvMeshNew Declaration
+                     Class dfDynamicRefineFvMesh Declaration
 \*---------------------------------------------------------------------------*/
 
-class dynamicRefineFvMeshNew
+class dfDynamicRefineFvMesh
 :
     public dynamicFvMesh
 {
@@ -230,25 +230,25 @@ protected:
 private:
 
         //- Disallow default bitwise copy construct
-        dynamicRefineFvMeshNew(const dynamicRefineFvMeshNew&);
+        dfDynamicRefineFvMesh(const dfDynamicRefineFvMesh&);
 
         //- Disallow default bitwise assignment
-        void operator=(const dynamicRefineFvMeshNew&);
+        void operator=(const dfDynamicRefineFvMesh&);
 
 public:
 
     //- Runtime type information
-    TypeName("dynamicRefineFvMeshNew");
+    TypeName("dfDynamicRefineFvMesh");
 
 
     // Constructors
 
         //- Construct from IOobject
-        explicit dynamicRefineFvMeshNew(const IOobject& io);
+        explicit dfDynamicRefineFvMesh(const IOobject& io);
 
 
     //- Destructor
-    virtual ~dynamicRefineFvMeshNew();
+    virtual ~dfDynamicRefineFvMesh();
 
 
     // Member Functions
diff --git a/src/dynamicFvMesh/dynamicRefineFvMeshNew/dynamicMeshDict b/src/dynamicFvMesh/dfDynamicRefineFvMesh/dynamicMeshDict
similarity index 100%
rename from src/dynamicFvMesh/dynamicRefineFvMeshNew/dynamicMeshDict
rename to src/dynamicFvMesh/dfDynamicRefineFvMesh/dynamicMeshDict
diff --git a/src/dynamicFvMesh/dynamicRefineFvMeshNew/multiCritRefinement.C b/src/dynamicFvMesh/dfDynamicRefineFvMesh/multiCritRefinement.C
similarity index 99%
rename from src/dynamicFvMesh/dynamicRefineFvMeshNew/multiCritRefinement.C
rename to src/dynamicFvMesh/dfDynamicRefineFvMesh/multiCritRefinement.C
index 9ac82af2..120ae0c9 100644
--- a/src/dynamicFvMesh/dynamicRefineFvMeshNew/multiCritRefinement.C
+++ b/src/dynamicFvMesh/dfDynamicRefineFvMesh/multiCritRefinement.C
@@ -45,7 +45,7 @@ bool Foam::multiCritRefinement::readMultiCritRefinementDict()
         )
     );
 
-    nBufferLayers_ = readLabel(dynamicMeshDict.subDict("dynamicRefineFvMeshNewCoeffs").lookup("nBufferLayers"));
+    nBufferLayers_ = readLabel(dynamicMeshDict.subDict("dfDynamicRefineFvMeshCoeffs").lookup("nBufferLayers"));
 
     if( dynamicMeshDict.isDict("multiCritRefinementControls") )
     {
@@ -317,7 +317,7 @@ void Foam::multiCritRefinement::updateRefinementField()
                 IOobject::NO_WRITE,
                 false
             )
-        ).subDict("dynamicRefineFvMeshNewCoeffs")
+        ).subDict("dfDynamicRefineFvMeshCoeffs")
     );
     scalar globalMaxRefLevel = readScalar(refineDict.lookup("maxRefinement"));
 
diff --git a/src/dynamicFvMesh/dynamicRefineFvMeshNew/multiCritRefinement.H b/src/dynamicFvMesh/dfDynamicRefineFvMesh/multiCritRefinement.H
similarity index 100%
rename from src/dynamicFvMesh/dynamicRefineFvMeshNew/multiCritRefinement.H
rename to src/dynamicFvMesh/dfDynamicRefineFvMesh/multiCritRefinement.H
diff --git a/src/dynamicFvMesh/refinementHistoryNewConstraint/refinementHistoryNewConstraint.C b/src/dynamicFvMesh/dfRefinementHistoryConstraint/dfRefinementHistoryConstraint.C
similarity index 79%
rename from src/dynamicFvMesh/refinementHistoryNewConstraint/refinementHistoryNewConstraint.C
rename to src/dynamicFvMesh/dfRefinementHistoryConstraint/dfRefinementHistoryConstraint.C
index 59af8139..9dc26467 100644
--- a/src/dynamicFvMesh/refinementHistoryNewConstraint/refinementHistoryNewConstraint.C
+++ b/src/dynamicFvMesh/dfRefinementHistoryConstraint/dfRefinementHistoryConstraint.C
@@ -23,10 +23,10 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-#include "refinementHistoryNewConstraint.H"
+#include "dfRefinementHistoryConstraint.H"
 #include "addToRunTimeSelectionTable.H"
 #include "syncTools.H"
-#include "refinementHistoryNew.H"
+#include "dfRefinementHistory.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -34,12 +34,12 @@ namespace Foam
 {
 namespace decompositionConstraints
 {
-    defineTypeName(refinementHistoryNewConstraint);
+    defineTypeName(dfRefinementHistoryConstraint);
 
     addToRunTimeSelectionTable
     (
         decompositionConstraint,
-        refinementHistoryNewConstraint,
+        dfRefinementHistoryConstraint,
         dictionary
     );
 }
@@ -48,7 +48,7 @@ namespace decompositionConstraints
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
-Foam::decompositionConstraints::refinementHistoryNewConstraint::refinementHistoryNewConstraint
+Foam::decompositionConstraints::dfRefinementHistoryConstraint::dfRefinementHistoryConstraint
 (
     const dictionary& dict,
     const word& modelType
@@ -64,7 +64,7 @@ Foam::decompositionConstraints::refinementHistoryNewConstraint::refinementHistor
 }
 
 
-Foam::decompositionConstraints::refinementHistoryNewConstraint::refinementHistoryNewConstraint()
+Foam::decompositionConstraints::dfRefinementHistoryConstraint::dfRefinementHistoryConstraint()
 :
     decompositionConstraint(dictionary(), typeName)
 {
@@ -78,7 +78,7 @@ Foam::decompositionConstraints::refinementHistoryNewConstraint::refinementHistor
 
 // * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
 
-void Foam::decompositionConstraints::refinementHistoryNewConstraint::add
+void Foam::decompositionConstraints::dfRefinementHistoryConstraint::add
 (
     const polyMesh& mesh,
     boolList& blockedFace,
@@ -88,27 +88,27 @@ void Foam::decompositionConstraints::refinementHistoryNewConstraint::add
 ) const
 {
     // The refinement history type
-    typedef ::Foam::refinementHistoryNew HistoryType;
-    // typedef Foam::decompositionConstraints::refinementHistoryNew HistoryType;
+    typedef ::Foam::dfRefinementHistory HistoryType;
+    // typedef Foam::decompositionConstraints::dfRefinementHistory HistoryType;
 
     // Local storage if read from file
     autoPtr<const HistoryType> readFromFile;
 
     const HistoryType* historyPtr = nullptr;
 
-    if (mesh.foundObject<HistoryType>("refinementHistoryNew"))
+    if (mesh.foundObject<HistoryType>("dfRefinementHistory"))
     {
         if (decompositionConstraint::debug)
         {
-            Info<< type() << " : found refinementHistoryNew" << endl;
+            Info<< type() << " : found dfRefinementHistory" << endl;
         }
-        historyPtr = &mesh.lookupObject<HistoryType>("refinementHistoryNew");
+        historyPtr = &mesh.lookupObject<HistoryType>("dfRefinementHistory");
     }
     else
     {
         if (decompositionConstraint::debug)
         {
-            Info<< type() << " : reading refinementHistoryNew from time "
+            Info<< type() << " : reading dfRefinementHistory from time "
                 << mesh.facesInstance() << endl;
         }
 
@@ -118,7 +118,7 @@ void Foam::decompositionConstraints::refinementHistoryNewConstraint::add
             (
                 IOobject
                 (
-                    "refinementHistoryNew",
+                    "dfRefinementHistory",
                     mesh.facesInstance(),
                     polyMesh::meshSubDir,
                     mesh,
@@ -142,7 +142,7 @@ void Foam::decompositionConstraints::refinementHistoryNewConstraint::add
 
     if (history.active())
     {
-        // refinementHistoryNew itself implements decompositionConstraint
+        // dfRefinementHistory itself implements decompositionConstraint
         history.add
         (
             blockedFace,
@@ -154,7 +154,7 @@ void Foam::decompositionConstraints::refinementHistoryNewConstraint::add
 }
 
 
-void Foam::decompositionConstraints::refinementHistoryNewConstraint::apply
+void Foam::decompositionConstraints::dfRefinementHistoryConstraint::apply
 (
     const polyMesh& mesh,
     const boolList& blockedFace,
@@ -165,16 +165,16 @@ void Foam::decompositionConstraints::refinementHistoryNewConstraint::apply
 ) const
 {
     // The refinement history type
-    typedef ::Foam::refinementHistoryNew HistoryType;
+    typedef ::Foam::dfRefinementHistory HistoryType;
 
     // Local storage if read from file
     autoPtr<const HistoryType> readFromFile;
 
     const HistoryType* historyPtr = nullptr;
 
-    if(mesh.foundObject<HistoryType>("refinementHistoryNew"))
+    if(mesh.foundObject<HistoryType>("dfRefinementHistory"))
     {
-        historyPtr = &mesh.lookupObject<HistoryType>("refinementHistoryNew");
+        historyPtr = &mesh.lookupObject<HistoryType>("dfRefinementHistory");
     }
     else
     {
@@ -184,7 +184,7 @@ void Foam::decompositionConstraints::refinementHistoryNewConstraint::apply
             (
                 IOobject
                 (
-                    "refinementHistoryNew",
+                    "dfRefinementHistory",
                     mesh.facesInstance(),
                     polyMesh::meshSubDir,
                     mesh,
@@ -208,7 +208,7 @@ void Foam::decompositionConstraints::refinementHistoryNewConstraint::apply
 
     if (history.active())
     {
-        // refinementHistoryNew itself implements decompositionConstraint
+        // dfRefinementHistory itself implements decompositionConstraint
         history.apply
         (
             blockedFace,
diff --git a/src/dynamicFvMesh/refinementHistoryNewConstraint/refinementHistoryNewConstraint.H b/src/dynamicFvMesh/dfRefinementHistoryConstraint/dfRefinementHistoryConstraint.H
similarity index 82%
rename from src/dynamicFvMesh/refinementHistoryNewConstraint/refinementHistoryNewConstraint.H
rename to src/dynamicFvMesh/dfRefinementHistoryConstraint/dfRefinementHistoryConstraint.H
index 428aa882..4a17e68e 100644
--- a/src/dynamicFvMesh/refinementHistoryNewConstraint/refinementHistoryNewConstraint.H
+++ b/src/dynamicFvMesh/dfRefinementHistoryConstraint/dfRefinementHistoryConstraint.H
@@ -22,25 +22,25 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Class
-    Foam::decompositionConstraints::refinementHistoryNew
+    Foam::decompositionConstraints::dfRefinementHistoryConstraint
 
 Description
     Constraint to keep all cells originating from refining the same cell
-    onto the same processor. Reads polyMesh/refinementHistoryNew.
+    onto the same processor. Reads polyMesh/dfRefinementHistory.
 
     \heading Dictionary parameters
     \table
         Property    | Description                       | Required  | Default
-        type        | refinementHistoryNew                 | yes   |
+        type        | dfRefinementHistory                 | yes   |
     \endtable
 
 SourceFiles
-    refinementHistoryNewConstraint.C
+    dfRefinementHistoryConstraint.C
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef refinementHistoryNewConstraint_H
-#define refinementHistoryNewConstraint_H
+#ifndef dfRefinementHistoryConstraint_H
+#define dfRefinementHistoryConstraint_H
 
 #include "decompositionConstraint.H"
 
@@ -52,30 +52,30 @@ namespace decompositionConstraints
 {
 
 /*---------------------------------------------------------------------------*\
-                      Class refinementHistoryNewConstraint Declaration
+                      Class dfRefinementHistoryConstraint Declaration
 \*---------------------------------------------------------------------------*/
 
-class refinementHistoryNewConstraint
+class dfRefinementHistoryConstraint
 :
     public decompositionConstraint
 {
 public:
 
     //- Runtime type information
-    TypeName("refinementHistoryNew");
+    TypeName("dfRefinementHistory");
 
 
     // Constructors
 
         //- Construct with constraint dictionary
-        explicit refinementHistoryNewConstraint(const dictionary& dict,const word& type);
+        explicit dfRefinementHistoryConstraint(const dictionary& dict,const word& type);
 
         //- Construct from components
-        refinementHistoryNewConstraint();
+        dfRefinementHistoryConstraint();
 
 
     //- Destructor
-    virtual ~refinementHistoryNewConstraint() = default;
+    virtual ~dfRefinementHistoryConstraint() = default;
 
 
     // Member Functions
diff --git a/src/dynamicMesh/Make/files b/src/dynamicMesh/Make/files
index 503e4041..dd07c5b7 100644
--- a/src/dynamicMesh/Make/files
+++ b/src/dynamicMesh/Make/files
@@ -2,7 +2,7 @@ hexRef = polyTopoChange/polyTopoChange/hexRef
 
 $(hexRef)/hexRef.C
 $(hexRef)/hexRefData.C
-$(hexRef)/refinementHistoryNew.C
+$(hexRef)/dfRefinementHistory.C
 $(hexRef)/hexRefNew.C
 
 $(hexRef)/hexRef8/hexRef8.C
diff --git a/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/refinementHistoryNew.C b/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/dfRefinementHistory.C
similarity index 90%
rename from src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/refinementHistoryNew.C
rename to src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/dfRefinementHistory.C
index 9d939027..3ac295f5 100644
--- a/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/refinementHistoryNew.C
+++ b/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/dfRefinementHistory.C
@@ -23,7 +23,7 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-#include "refinementHistoryNew.H"
+#include "dfRefinementHistory.H"
 #include "mapPolyMesh.H"
 #include "mapDistributePolyMesh.H"
 #include "polyMesh.H"
@@ -33,13 +33,13 @@ License
 
 namespace Foam
 {
-    defineTypeNameAndDebug(refinementHistoryNew, 0);
+    defineTypeNameAndDebug(dfRefinementHistory, 0);
 }
 
 
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 
-void Foam::refinementHistoryNew::writeEntry
+void Foam::dfRefinementHistory::writeEntry
 (
     const List<splitCell8>& splitCells,
     const splitCell8& split
@@ -71,7 +71,7 @@ void Foam::refinementHistoryNew::writeEntry
 }
 
 
-void Foam::refinementHistoryNew::writeDebug
+void Foam::dfRefinementHistory::writeDebug
 (
     const labelList& visibleCells,
     const List<splitCell8>& splitCells
@@ -105,27 +105,27 @@ void Foam::refinementHistoryNew::writeDebug
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
-Foam::refinementHistoryNew::splitCell8::splitCell8()
+Foam::dfRefinementHistory::splitCell8::splitCell8()
 :
     parent_(-1),
     addedCellsPtr_(nullptr)
 {}
 
 
-Foam::refinementHistoryNew::splitCell8::splitCell8(const label parent)
+Foam::dfRefinementHistory::splitCell8::splitCell8(const label parent)
 :
     parent_(parent),
     addedCellsPtr_(nullptr)
 {}
 
 
-Foam::refinementHistoryNew::splitCell8::splitCell8(Istream& is)
+Foam::dfRefinementHistory::splitCell8::splitCell8(Istream& is)
 {
     is >> *this;
 }
 
 
-Foam::refinementHistoryNew::splitCell8::splitCell8(const splitCell8& sc)
+Foam::dfRefinementHistory::splitCell8::splitCell8(const splitCell8& sc)
 :
     parent_(sc.parent_),
     addedCellsPtr_
@@ -139,7 +139,7 @@ Foam::refinementHistoryNew::splitCell8::splitCell8(const splitCell8& sc)
 
 // * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * * //
 
-void Foam::refinementHistoryNew::splitCell8::operator=(const splitCell8& s)
+void Foam::dfRefinementHistory::splitCell8::operator=(const splitCell8& s)
 {
     //- Assignment operator since autoPtr otherwise 'steals' storage.
 
@@ -162,7 +162,7 @@ void Foam::refinementHistoryNew::splitCell8::operator=(const splitCell8& s)
 }
 
 
-bool Foam::refinementHistoryNew::splitCell8::operator==(const splitCell8& s) const
+bool Foam::dfRefinementHistory::splitCell8::operator==(const splitCell8& s) const
 {
     if (addedCellsPtr_.valid() != s.addedCellsPtr_.valid())
     {
@@ -183,7 +183,7 @@ bool Foam::refinementHistoryNew::splitCell8::operator==(const splitCell8& s) con
 }
 
 
-bool Foam::refinementHistoryNew::splitCell8::operator!=(const splitCell8& s) const
+bool Foam::dfRefinementHistory::splitCell8::operator!=(const splitCell8& s) const
 {
     return !operator==(s);
 }
@@ -191,7 +191,7 @@ bool Foam::refinementHistoryNew::splitCell8::operator!=(const splitCell8& s) con
 
 // * * * * * * * * * * * * * * Friend Operators  * * * * * * * * * * * * * * //
 
-Foam::Istream& Foam::operator>>(Istream& is, refinementHistoryNew::splitCell8& sc)
+Foam::Istream& Foam::operator>>(Istream& is, dfRefinementHistory::splitCell8& sc)
 {
     labelList addedCells;
 
@@ -213,7 +213,7 @@ Foam::Istream& Foam::operator>>(Istream& is, refinementHistoryNew::splitCell8& s
 Foam::Ostream& Foam::operator<<
 (
     Ostream& os,
-    const refinementHistoryNew::splitCell8& sc
+    const dfRefinementHistory::splitCell8& sc
 )
 {
     // Output as labelList so we can have 0 sized lists. Alternative is to
@@ -236,7 +236,7 @@ Foam::Ostream& Foam::operator<<
 
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 
-void Foam::refinementHistoryNew::checkIndices() const
+void Foam::dfRefinementHistory::checkIndices() const
 {
     // Check indices.
     forAll(visibleCells_, i)
@@ -254,7 +254,7 @@ void Foam::refinementHistoryNew::checkIndices() const
 }
 
 
-Foam::label Foam::refinementHistoryNew::allocateSplitCell
+Foam::label Foam::dfRefinementHistory::allocateSplitCell
 (
     const label parent,
     const label i
@@ -298,7 +298,7 @@ Foam::label Foam::refinementHistoryNew::allocateSplitCell
 }
 
 
-void Foam::refinementHistoryNew::freeSplitCell(const label index)
+void Foam::dfRefinementHistory::freeSplitCell(const label index)
 {
     splitCell8& split = splitCells_[index];
 
@@ -335,7 +335,7 @@ void Foam::refinementHistoryNew::freeSplitCell(const label index)
 }
 
 
-void Foam::refinementHistoryNew::markSplit
+void Foam::dfRefinementHistory::markSplit
 (
     const label index,
     labelList& oldToNew,
@@ -371,7 +371,7 @@ void Foam::refinementHistoryNew::markSplit
 }
 
 
-void Foam::refinementHistoryNew::mark
+void Foam::dfRefinementHistory::mark
 (
     const label val,
     const label index,
@@ -397,7 +397,7 @@ void Foam::refinementHistoryNew::mark
 }
 
 
-Foam::label Foam::refinementHistoryNew::markCommonCells
+Foam::label Foam::dfRefinementHistory::markCommonCells
 (
     labelList& cellToCluster
 ) const
@@ -445,7 +445,7 @@ Foam::label Foam::refinementHistoryNew::markCommonCells
 }
 
 
-void Foam::refinementHistoryNew::add
+void Foam::dfRefinementHistory::add
 (
     boolList& blockedFace,
     PtrList<labelList>& specifiedProcessorFaces,
@@ -481,7 +481,7 @@ void Foam::refinementHistoryNew::add
         }
     }
 
-    if (refinementHistoryNew::debug)
+    if (dfRefinementHistory::debug)
     {
         reduce(nUnblocked, sumOp<label>());
         Info<< type() << " : unblocked " << nUnblocked << " faces" << endl;
@@ -491,7 +491,7 @@ void Foam::refinementHistoryNew::add
 }
 
 
-void Foam::refinementHistoryNew::apply
+void Foam::dfRefinementHistory::apply
 (
     const boolList& blockedFace,
     const PtrList<labelList>& specifiedProcessorFaces,
@@ -541,7 +541,7 @@ void Foam::refinementHistoryNew::apply
         }
     }
 
-    if (refinementHistoryNew::debug)
+    if (dfRefinementHistory::debug)
     {
         reduce(nChanged, sumOp<label>());
         Info<< type() << " : changed decomposition on " << nChanged
@@ -552,7 +552,7 @@ void Foam::refinementHistoryNew::apply
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
-Foam::refinementHistoryNew::refinementHistoryNew(const IOobject& io)
+Foam::dfRefinementHistory::dfRefinementHistory(const IOobject& io)
 :
     regIOobject(io),
     active_(false)
@@ -578,13 +578,13 @@ Foam::refinementHistoryNew::refinementHistoryNew(const IOobject& io)
     }
 
     // When running in redistributPar + READ_IF_PRESENT it can happen
-    // that some processors do have refinementHistoryNew and some don't so
+    // that some processors do have dfRefinementHistory and some don't so
     // test for active has to be outside of above condition.
     active_ = (returnReduce(visibleCells_.size(), sumOp<label>()) > 0);
 
     if (debug)
     {
-        Pout<< "refinementHistoryNew::refinementHistoryNew :"
+        Pout<< "dfRefinementHistory::dfRefinementHistory :"
             << " constructed history from IOobject :"
             << " splitCells:" << splitCells_.size()
             << " visibleCells:" << visibleCells_.size()
@@ -594,7 +594,7 @@ Foam::refinementHistoryNew::refinementHistoryNew(const IOobject& io)
 }
 
 
-Foam::refinementHistoryNew::refinementHistoryNew
+Foam::dfRefinementHistory::dfRefinementHistory
 (
     const IOobject& io,
     const List<splitCell8>& splitCells,
@@ -633,7 +633,7 @@ Foam::refinementHistoryNew::refinementHistoryNew
 
     if (debug)
     {
-        Pout<< "refinementHistoryNew::refinementHistoryNew :"
+        Pout<< "dfRefinementHistory::dfRefinementHistory :"
             << " constructed history from IOobject or components :"
             << " splitCells:" << splitCells_.size()
             << " visibleCells:" << visibleCells_.size()
@@ -643,7 +643,7 @@ Foam::refinementHistoryNew::refinementHistoryNew
 }
 
 
-Foam::refinementHistoryNew::refinementHistoryNew
+Foam::dfRefinementHistory::dfRefinementHistory
 (
     const IOobject& io,
     const label nCells
@@ -692,7 +692,7 @@ Foam::refinementHistoryNew::refinementHistoryNew
 
     if (debug)
     {
-        Pout<< "refinementHistoryNew::refinementHistoryNew :"
+        Pout<< "dfRefinementHistory::dfRefinementHistory :"
             << " constructed history from IOobject or initial size :"
             << " splitCells:" << splitCells_.size()
             << " visibleCells:" << visibleCells_.size()
@@ -703,7 +703,7 @@ Foam::refinementHistoryNew::refinementHistoryNew
 
 
 // Construct from initial number of cells (all visible)
-Foam::refinementHistoryNew::refinementHistoryNew
+Foam::dfRefinementHistory::dfRefinementHistory
 (
     const IOobject& io,
     const label nCells,
@@ -750,7 +750,7 @@ Foam::refinementHistoryNew::refinementHistoryNew
 
     if (debug)
     {
-        Pout<< "refinementHistoryNew::refinementHistoryNew :"
+        Pout<< "dfRefinementHistory::dfRefinementHistory :"
             << " constructed history from IOobject or initial size :"
             << " splitCells:" << splitCells_.size()
             << " visibleCells:" << visibleCells_.size()
@@ -760,10 +760,10 @@ Foam::refinementHistoryNew::refinementHistoryNew
 }
 
 
-Foam::refinementHistoryNew::refinementHistoryNew
+Foam::dfRefinementHistory::dfRefinementHistory
 (
     const IOobject& io,
-    const refinementHistoryNew& rh
+    const dfRefinementHistory& rh
 )
 :
     regIOobject(io),
@@ -774,17 +774,17 @@ Foam::refinementHistoryNew::refinementHistoryNew
 {
     if (debug)
     {
-        Pout<< "refinementHistoryNew::refinementHistoryNew : constructed initial"
+        Pout<< "dfRefinementHistory::dfRefinementHistory : constructed initial"
             << " history." << endl;
     }
 }
 
 
-Foam::refinementHistoryNew::refinementHistoryNew
+Foam::dfRefinementHistory::dfRefinementHistory
 (
     const IOobject& io,
     const UPtrList<const labelList>& cellMaps,
-    const UPtrList<const refinementHistoryNew>& refs
+    const UPtrList<const dfRefinementHistory>& refs
 )
 :
     regIOobject(io),
@@ -799,8 +799,8 @@ Foam::refinementHistoryNew::refinementHistoryNew
     {
         WarningIn
         (
-            "refinementHistoryNew::refinementHistoryNew(const IOobject&"
-            ", const labelListList&, const PtrList<refinementHistoryNew>&)"
+            "dfRefinementHistory::dfRefinementHistory(const IOobject&"
+            ", const labelListList&, const PtrList<dfRefinementHistory>&)"
         )   << "read option IOobject::MUST_READ, READ_IF_PRESENT or "
             << "MUST_READ_IF_MODIFIED"
             << " suggests that a read constructor would be more appropriate."
@@ -890,7 +890,7 @@ Foam::refinementHistoryNew::refinementHistoryNew
 
     if (debug)
     {
-        Pout<< "refinementHistoryNew::refinementHistoryNew :"
+        Pout<< "dfRefinementHistory::dfRefinementHistory :"
             << " constructed history from multiple refinementHistories :"
             << " splitCells:" << splitCells_.size()
             << " visibleCells:" << visibleCells_.size()
@@ -899,7 +899,7 @@ Foam::refinementHistoryNew::refinementHistoryNew
 }
 
 
-Foam::refinementHistoryNew::refinementHistoryNew(const IOobject& io, Istream& is)
+Foam::dfRefinementHistory::dfRefinementHistory(const IOobject& io, Istream& is)
 :
     regIOobject(io),
     splitCells_(is),
@@ -913,7 +913,7 @@ Foam::refinementHistoryNew::refinementHistoryNew(const IOobject& io, Istream& is
 
     if (debug)
     {
-        Pout<< "refinementHistoryNew::refinementHistoryNew :"
+        Pout<< "dfRefinementHistory::dfRefinementHistory :"
             << " constructed history from Istream"
             << " splitCells:" << splitCells_.size()
             << " visibleCells:" << visibleCells_.size()
@@ -924,7 +924,7 @@ Foam::refinementHistoryNew::refinementHistoryNew(const IOobject& io, Istream& is
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
-Foam::autoPtr<Foam::refinementHistoryNew> Foam::refinementHistoryNew::clone
+Foam::autoPtr<Foam::dfRefinementHistory> Foam::dfRefinementHistory::clone
 (
     const IOobject& io,
     // Per visible cell the processor it is going to
@@ -1032,9 +1032,9 @@ Foam::autoPtr<Foam::refinementHistoryNew> Foam::refinementHistoryNew::clone
         }
     }
 
-    return autoPtr<refinementHistoryNew>
+    return autoPtr<dfRefinementHistory>
     (
-        new refinementHistoryNew
+        new dfRefinementHistory
         (
             io,
             newSplitCells,
@@ -1045,7 +1045,7 @@ Foam::autoPtr<Foam::refinementHistoryNew> Foam::refinementHistoryNew::clone
 }
 
 
-Foam::autoPtr<Foam::refinementHistoryNew> Foam::refinementHistoryNew::clone
+Foam::autoPtr<Foam::dfRefinementHistory> Foam::dfRefinementHistory::clone
 (
     const IOobject& io,
     const labelList& cellMap
@@ -1096,9 +1096,9 @@ Foam::autoPtr<Foam::refinementHistoryNew> Foam::refinementHistoryNew::clone
     }
     else
     {
-        return autoPtr<refinementHistoryNew>
+        return autoPtr<dfRefinementHistory>
         (
-            new refinementHistoryNew
+            new dfRefinementHistory
             (
                 io,
                 DynamicList<splitCell8>(0),
@@ -1110,13 +1110,13 @@ Foam::autoPtr<Foam::refinementHistoryNew> Foam::refinementHistoryNew::clone
 }
 
 
-void Foam::refinementHistoryNew::resize(const label size)
+void Foam::dfRefinementHistory::resize(const label size)
 {
     label oldSize = visibleCells_.size();
 
     if (debug)
     {
-        Pout<< "refinementHistoryNew::resize from " << oldSize << " to " << size
+        Pout<< "dfRefinementHistory::resize from " << oldSize << " to " << size
             << " cells" << endl;
     }
 
@@ -1130,7 +1130,7 @@ void Foam::refinementHistoryNew::resize(const label size)
 }
 
 
-void Foam::refinementHistoryNew::updateMesh(const mapPolyMesh& map)
+void Foam::dfRefinementHistory::updateMesh(const mapPolyMesh& map)
 {
     if (active())
     {
@@ -1164,7 +1164,7 @@ void Foam::refinementHistoryNew::updateMesh(const mapPolyMesh& map)
 
         if (debug)
         {
-            Pout<< "refinementHistoryNew::updateMesh : from "
+            Pout<< "dfRefinementHistory::updateMesh : from "
                 << visibleCells_.size()
                 << " to " << newVisibleCells.size()
                 << " cells" << endl;
@@ -1175,7 +1175,7 @@ void Foam::refinementHistoryNew::updateMesh(const mapPolyMesh& map)
 }
 
 
-void Foam::refinementHistoryNew::subset
+void Foam::dfRefinementHistory::subset
 (
     const labelList& pointMap,
     const labelList& faceMap,
@@ -1204,7 +1204,7 @@ void Foam::refinementHistoryNew::subset
 
         if (debug)
         {
-            Pout<< "refinementHistoryNew::updateMesh : from "
+            Pout<< "dfRefinementHistory::updateMesh : from "
                 << visibleCells_.size()
                 << " to " << newVisibleCells.size()
                 << " cells" << endl;
@@ -1215,7 +1215,7 @@ void Foam::refinementHistoryNew::subset
 }
 
 
-void Foam::refinementHistoryNew::countProc
+void Foam::dfRefinementHistory::countProc
 (
     const label index,
     const label newProcNo,
@@ -1261,7 +1261,7 @@ void Foam::refinementHistoryNew::countProc
 }
 
 
-void Foam::refinementHistoryNew::distribute(const mapDistributePolyMesh& map)
+void Foam::dfRefinementHistory::distribute(const mapDistributePolyMesh& map)
 {
     if (!active())
     {
@@ -1331,10 +1331,10 @@ void Foam::refinementHistoryNew::distribute(const mapDistributePolyMesh& map)
         }
     }
 
-    //Pout<< "refinementHistoryNew::distribute :"
+    //Pout<< "dfRefinementHistory::distribute :"
     //    << " splitCellProc:" << splitCellProc << endl;
     //
-    //Pout<< "refinementHistoryNew::distribute :"
+    //Pout<< "dfRefinementHistory::distribute :"
     //    << " splitCellNum:" << splitCellNum << endl;
 
     const polyMesh& mesh = dynamic_cast<const polyMesh&>(db());
@@ -1514,11 +1514,11 @@ void Foam::refinementHistoryNew::distribute(const mapDistributePolyMesh& map)
 }
 
 
-void Foam::refinementHistoryNew::compact()
+void Foam::dfRefinementHistory::compact()
 {
     if (debug)
     {
-        Pout<< "refinementHistoryNew::compact() Entering with:"
+        Pout<< "dfRefinementHistory::compact() Entering with:"
             << " freeSplitCells_:" << freeSplitCells_.size()
             << " splitCells_:" << splitCells_.size()
             << " visibleCells_:" << visibleCells_.size()
@@ -1633,7 +1633,7 @@ void Foam::refinementHistoryNew::compact()
 
     if (debug)
     {
-        Pout<< "refinementHistoryNew::compact : compacted splitCells from "
+        Pout<< "dfRefinementHistory::compact : compacted splitCells from "
             << splitCells_.size() << " to " << newSplitCells.size() << endl;
     }
 
@@ -1643,7 +1643,7 @@ void Foam::refinementHistoryNew::compact()
 
     if (debug)
     {
-        Pout<< "refinementHistoryNew::compact() NOW:"
+        Pout<< "dfRefinementHistory::compact() NOW:"
             << " freeSplitCells_:" << freeSplitCells_.size()
             << " splitCells_:" << splitCells_.size()
             << " newSplitCells:" << newSplitCells.size()
@@ -1670,13 +1670,13 @@ void Foam::refinementHistoryNew::compact()
 }
 
 
-void Foam::refinementHistoryNew::writeDebug() const
+void Foam::dfRefinementHistory::writeDebug() const
 {
     writeDebug(visibleCells_, splitCells_);
 }
 
 
-void Foam::refinementHistoryNew::storeSplit
+void Foam::dfRefinementHistory::storeSplit
 (
     const label celli,
     const labelList& addedCells
@@ -1714,7 +1714,7 @@ void Foam::refinementHistoryNew::storeSplit
 }
 
 
-void Foam::refinementHistoryNew::combineCells
+void Foam::dfRefinementHistory::combineCells
 (
     const label masterCelli,
     const labelList& combinedCells
@@ -1738,7 +1738,7 @@ void Foam::refinementHistoryNew::combineCells
 }
 
 
-bool Foam::refinementHistoryNew::read()
+bool Foam::dfRefinementHistory::read()
 {
     bool ok = readData(readStream(typeName));
     close();
@@ -1749,14 +1749,14 @@ bool Foam::refinementHistoryNew::read()
 }
 
 
-bool Foam::refinementHistoryNew::readData(Istream& is)
+bool Foam::dfRefinementHistory::readData(Istream& is)
 {
     is >> *this;
     return !is.bad();
 }
 
 
-bool Foam::refinementHistoryNew::writeData(Ostream& os) const
+bool Foam::dfRefinementHistory::writeData(Ostream& os) const
 {
     os << *this;
 
@@ -1766,7 +1766,7 @@ bool Foam::refinementHistoryNew::writeData(Ostream& os) const
 
 // * * * * * * * * * * * * * * * Friend Operators  * * * * * * * * * * * * * //
 
-Foam::Istream& Foam::operator>>(Istream& is, refinementHistoryNew& rh)
+Foam::Istream& Foam::operator>>(Istream& is, dfRefinementHistory& rh)
 {
     rh.freeSplitCells_.clearStorage();
 
@@ -1779,9 +1779,9 @@ Foam::Istream& Foam::operator>>(Istream& is, refinementHistoryNew& rh)
 }
 
 
-Foam::Ostream& Foam::operator<<(Ostream& os, const refinementHistoryNew& rh)
+Foam::Ostream& Foam::operator<<(Ostream& os, const dfRefinementHistory& rh)
 {
-    const_cast<refinementHistoryNew&>(rh).compact();
+    const_cast<dfRefinementHistory&>(rh).compact();
 
     return os   << "// splitCells" << nl
                 << rh.splitCells_ << nl
diff --git a/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/refinementHistoryNew.H b/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/dfRefinementHistory.H
similarity index 90%
rename from src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/refinementHistoryNew.H
rename to src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/dfRefinementHistory.H
index c2a870ab..1c1096f6 100644
--- a/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/refinementHistoryNew.H
+++ b/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/dfRefinementHistory.H
@@ -22,7 +22,7 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Class
-    Foam::refinementHistoryNew
+    Foam::dfRefinementHistory
 
 Description
     All refinement history. Used in unrefinement.
@@ -64,12 +64,12 @@ Description
 
 
 SourceFiles
-    refinementHistoryNew.C
+    dfRefinementHistory.C
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef refinementHistoryNew_H
-#define refinementHistoryNew_H
+#ifndef dfRefinementHistory_H
+#define dfRefinementHistory_H
 
 #include "DynamicList.H"
 #include "labelList.H"
@@ -91,17 +91,17 @@ class mapDistributePolyMesh;
 
 // Forward declaration of friend functions and operators
 
-class refinementHistoryNew;
+class dfRefinementHistory;
 
-Istream& operator>>(Istream&, refinementHistoryNew&);
-Ostream& operator<<(Ostream&, const refinementHistoryNew&);
+Istream& operator>>(Istream&, dfRefinementHistory&);
+Ostream& operator<<(Ostream&, const dfRefinementHistory&);
 
 
 /*---------------------------------------------------------------------------*\
-                           Class refinementHistoryNew Declaration
+                           Class dfRefinementHistory Declaration
 \*---------------------------------------------------------------------------*/
 
-class refinementHistoryNew
+class dfRefinementHistory
 :
     public regIOobject
 {
@@ -212,17 +212,17 @@ private:
 public:
 
     // Declare name of the class and its debug switch
-    TypeName("refinementHistoryNew");
+    TypeName("dfRefinementHistory");
 
 
     // Constructors
 
         //- Construct (read) given an IOobject. If global number of visible
         //  cells > 0 becomes active
-        refinementHistoryNew(const IOobject&);
+        dfRefinementHistory(const IOobject&);
 
         //- Construct (read) or construct from components
-        refinementHistoryNew
+        dfRefinementHistory
         (
             const IOobject&,
             const List<splitCell8>& splitCells,
@@ -233,11 +233,11 @@ public:
         //- Construct (read) or construct from initial number of cells
         //  (all visible). If global number of visible
         //  cells > 0 becomes active
-        refinementHistoryNew(const IOobject&, const label nCells);
+        dfRefinementHistory(const IOobject&, const label nCells);
 
         //- Construct (read) or construct from initial number of cells
         //  (all visible) and active flag
-        refinementHistoryNew
+        dfRefinementHistory
         (
             const IOobject&,
             const label nCells,
@@ -245,20 +245,20 @@ public:
         );
 
         //- Construct as copy
-        refinementHistoryNew(const IOobject&, const refinementHistoryNew&);
+        dfRefinementHistory(const IOobject&, const dfRefinementHistory&);
 
         //- Construct from multiple refinement histories. If global number of
         //  visible cells > 0 becomes active
-        refinementHistoryNew
+        dfRefinementHistory
         (
             const IOobject&,
             const UPtrList<const labelList>& cellMaps,
-            const UPtrList<const refinementHistoryNew>&
+            const UPtrList<const dfRefinementHistory>&
         );
 
         //- Construct from Istream. If global number of
         //  visible cells > 0 becomes active
-        refinementHistoryNew(const IOobject&, Istream&);
+        dfRefinementHistory(const IOobject&, Istream&);
 
 
     // Member Functions
@@ -324,7 +324,7 @@ public:
         );
 
         //- Low level clone
-        autoPtr<refinementHistoryNew> clone
+        autoPtr<dfRefinementHistory> clone
         (
             const IOobject& io,
             const labelList& decomposition,
@@ -335,7 +335,7 @@ public:
         ) const;
 
         //- Create clone from subset
-        autoPtr<refinementHistoryNew> clone
+        autoPtr<dfRefinementHistory> clone
         (
             const IOobject& io,
             const labelList& cellMap
@@ -405,14 +405,14 @@ public:
 
         //- Istream operator. Note: does not do a reduction - does not set
         //  active_ flag
-        friend Istream& operator>>(Istream&, refinementHistoryNew&);
+        friend Istream& operator>>(Istream&, dfRefinementHistory&);
 
-        friend Ostream& operator<<(Ostream&, const refinementHistoryNew&);
+        friend Ostream& operator<<(Ostream&, const dfRefinementHistory&);
 };
 
 
-Istream& operator>>(Istream&, refinementHistoryNew::splitCell8&);
-Ostream& operator<<(Ostream&, const refinementHistoryNew::splitCell8&);
+Istream& operator>>(Istream&, dfRefinementHistory::splitCell8&);
+Ostream& operator<<(Ostream&, const dfRefinementHistory::splitCell8&);
 
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
diff --git a/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef.C b/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef.C
index c8c3d3ae..6c75913e 100644
--- a/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef.C
+++ b/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef.C
@@ -1464,7 +1464,7 @@ Foam::hexRef::hexRef(const polyMesh& mesh, const bool readHistory)
     (
         IOobject
         (
-            "refinementHistoryNew",
+            "dfRefinementHistory",
             mesh_.facesInstance(),
             polyMesh::meshSubDir,
             mesh_,
@@ -1551,7 +1551,7 @@ Foam::hexRef::hexRef
     const polyMesh& mesh,
     const labelList& cellLevel,
     const labelList& pointLevel,
-    const refinementHistoryNew& history,
+    const dfRefinementHistory& history,
     const scalar level0Edge
 )
 :
@@ -1604,7 +1604,7 @@ Foam::hexRef::hexRef
     (
         IOobject
         (
-            "refinementHistoryNew",
+            "dfRefinementHistory",
             mesh_.facesInstance(),
             polyMesh::meshSubDir,
             mesh_,
@@ -1712,14 +1712,14 @@ Foam::hexRef::hexRef
     (
         IOobject
         (
-            "refinementHistoryNew",
+            "dfRefinementHistory",
             mesh_.facesInstance(),
             polyMesh::meshSubDir,
             mesh_,
             IOobject::NO_READ,
             IOobject::NO_WRITE
         ),
-        List<refinementHistoryNew::splitCell8>(0),
+        List<dfRefinementHistory::splitCell8>(0),
         labelList(0),
         false
     ),
diff --git a/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef.H b/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef.H
index ade41d54..3106502b 100644
--- a/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef.H
+++ b/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef.H
@@ -51,7 +51,7 @@ Authors
 #include "DynamicList.H"
 #include "primitivePatch.H"
 #include "removeFaces.H"
-#include "refinementHistoryNew.H"
+#include "dfRefinementHistory.H"
 #include "PackedBoolList.H"
 #include "uniformDimensionedFields.H"
 #include "cellShapeList.H"
@@ -93,7 +93,7 @@ protected:
         uniformDimensionedScalarField level0Edge_;
 
         //- Refinement history
-        refinementHistoryNew history_;
+        dfRefinementHistory history_;
 
         //- Face remover engine
         removeFaces faceRemover_;
@@ -385,7 +385,7 @@ public:
             const polyMesh& mesh,
             const labelList& cellLevel,
             const labelList& pointLevel,
-            const refinementHistoryNew& history,
+            const dfRefinementHistory& history,
             const scalar level0Edge
         ),
         (mesh, cellLevel, pointLevel, history, level0Edge)
@@ -420,7 +420,7 @@ public:
             const polyMesh& mesh,
             const labelList& cellLevel,
             const labelList& pointLevel,
-            const refinementHistoryNew& history,
+            const dfRefinementHistory& history,
             const scalar level0Edge = -GREAT
         );
 
@@ -446,7 +446,7 @@ public:
             const polyMesh& mesh,
             const labelList& cellLevel,
             const labelList& pointLevel,
-            const refinementHistoryNew& history,
+            const dfRefinementHistory& history,
             const scalar level0Edge = -GREAT
         );
 
@@ -480,7 +480,7 @@ public:
                 return pointLevel_;
             }
 
-            const refinementHistoryNew& history() const
+            const dfRefinementHistory& history() const
             {
                 return history_;
             }
diff --git a/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef2/hexRef2.C b/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef2/hexRef2.C
index fb577a4f..5dd16ec1 100644
--- a/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef2/hexRef2.C
+++ b/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef2/hexRef2.C
@@ -206,7 +206,7 @@ Foam::hexRef2::hexRef2
     const polyMesh& mesh,
     const labelList& cellLevel,
     const labelList& pointLevel,
-    const refinementHistoryNew& history,
+    const dfRefinementHistory& history,
     const scalar level0Edge
 )
 :
diff --git a/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef2/hexRef2.H b/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef2/hexRef2.H
index c122ef33..68898f86 100644
--- a/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef2/hexRef2.H
+++ b/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef2/hexRef2.H
@@ -138,7 +138,7 @@ public:
             const polyMesh& mesh,
             const labelList& cellLevel,
             const labelList& pointLevel,
-            const refinementHistoryNew& history,
+            const dfRefinementHistory& history,
             const scalar level0Edge = -GREAT
         );
 
diff --git a/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef4/hexRef4.C b/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef4/hexRef4.C
index 4b607ae4..12903be2 100644
--- a/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef4/hexRef4.C
+++ b/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef4/hexRef4.C
@@ -733,7 +733,7 @@ Foam::hexRef4::hexRef4
     const polyMesh& mesh,
     const labelList& cellLevel,
     const labelList& pointLevel,
-    const refinementHistoryNew& history,
+    const dfRefinementHistory& history,
     const scalar level0Edge
 )
 :
diff --git a/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef4/hexRef4.H b/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef4/hexRef4.H
index 62c9c003..e0b375a6 100644
--- a/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef4/hexRef4.H
+++ b/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef4/hexRef4.H
@@ -127,7 +127,7 @@ public:
             const polyMesh& mesh,
             const labelList& cellLevel,
             const labelList& pointLevel,
-            const refinementHistoryNew& history,
+            const dfRefinementHistory& history,
             const scalar level0Edge = -GREAT
         );
 
diff --git a/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef4Axi/hexRef4Axi.C b/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef4Axi/hexRef4Axi.C
index ea0b665e..baf4cc18 100644
--- a/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef4Axi/hexRef4Axi.C
+++ b/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef4Axi/hexRef4Axi.C
@@ -738,7 +738,7 @@ Foam::hexRef4Axi::hexRef4Axi
     const polyMesh& mesh,
     const labelList& cellLevel,
     const labelList& pointLevel,
-    const refinementHistoryNew& history,
+    const dfRefinementHistory& history,
     const scalar level0Edge
 )
 :
diff --git a/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef4Axi/hexRef4Axi.H b/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef4Axi/hexRef4Axi.H
index 0bcb3813..3a1c0055 100644
--- a/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef4Axi/hexRef4Axi.H
+++ b/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef4Axi/hexRef4Axi.H
@@ -126,7 +126,7 @@ public:
             const polyMesh& mesh,
             const labelList& cellLevel,
             const labelList& pointLevel,
-            const refinementHistoryNew& history,
+            const dfRefinementHistory& history,
             const scalar level0Edge = -GREAT
         );
 
diff --git a/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef8/hexRef8.C b/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef8/hexRef8.C
index f8193747..6b47861a 100644
--- a/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef8/hexRef8.C
+++ b/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef8/hexRef8.C
@@ -655,7 +655,7 @@ Foam::hexRef8::hexRef8
     const polyMesh& mesh,
     const labelList& cellLevel,
     const labelList& pointLevel,
-    const refinementHistoryNew& history,
+    const dfRefinementHistory& history,
     const scalar level0Edge
 )
 :
diff --git a/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef8/hexRef8.H b/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef8/hexRef8.H
index 7112e5dd..9641a82b 100644
--- a/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef8/hexRef8.H
+++ b/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRef8/hexRef8.H
@@ -142,7 +142,7 @@ public:
             const polyMesh& mesh,
             const labelList& cellLevel,
             const labelList& pointLevel,
-            const refinementHistoryNew& history,
+            const dfRefinementHistory& history,
             const scalar level0Edge = -GREAT
         );
 
diff --git a/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRefData.C b/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRefData.C
index 49ab765c..814f51ad 100644
--- a/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRefData.C
+++ b/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRefData.C
@@ -31,7 +31,7 @@ License
 #include "mapDistributePolyMesh.H"
 #include "polyMesh.H"
 #include "syncTools.H"
-#include "refinementHistoryNew.H"
+#include "dfRefinementHistory.H"
 #include "fvMesh.H"
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
@@ -73,13 +73,13 @@ Foam::hexRefData::hexRefData(const IOobject& io)
     }
     {
         IOobject rio(io);
-        rio.rename("refinementHistoryNew");
+        rio.rename("dfRefinementHistory");
         // bool haveFile = returnReduce(rio.headerOk(), orOp<bool>());
         bool haveFile = returnReduce(rio.typeHeaderOk<labelIOList>(), orOp<bool>());
         if (haveFile)
         {
             Info<< "Reading hexRef data : " << rio.name() << endl;
-            refHistoryPtr_.reset(new refinementHistoryNew(rio));
+            refHistoryPtr_.reset(new dfRefinementHistory(rio));
         }
     }
 }
@@ -212,7 +212,7 @@ Foam::hexRefData::hexRefData
         IOobject rio(io);
         rio.rename(procDatas[0].refHistoryPtr_().name());
 
-        UPtrList<const refinementHistoryNew> procRefs(procDatas.size());
+        UPtrList<const dfRefinementHistory> procRefs(procDatas.size());
         forAll(procDatas, i)
         {
             procRefs.set(i, &procDatas[i].refHistoryPtr_());
@@ -220,7 +220,7 @@ Foam::hexRefData::hexRefData
 
         refHistoryPtr_.reset
         (
-            new refinementHistoryNew
+            new dfRefinementHistory
             (
                 rio,
                 cellMaps,
@@ -290,9 +290,9 @@ void Foam::hexRefData::sync(const IOobject& io)
     if (hasHistory && !refHistoryPtr_.valid())
     {
         IOobject rio(io);
-        rio.rename("refinementHistoryNew");
+        rio.rename("dfRefinementHistory");
         rio.readOpt() = IOobject::NO_READ;
-        refHistoryPtr_.reset(new refinementHistoryNew(rio, mesh.nCells(), true));
+        refHistoryPtr_.reset(new dfRefinementHistory(rio, mesh.nCells(), true));
     }
 }
 
diff --git a/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRefData.H b/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRefData.H
index 69e5427c..51b1d7f1 100644
--- a/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRefData.H
+++ b/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRefData.H
@@ -48,7 +48,7 @@ namespace Foam
 // Forward declaration of classes
 class mapPolyMesh;
 class mapDistributePolyMesh;
-class refinementHistoryNew;
+class dfRefinementHistory;
 class fvMesh;
 
 /*---------------------------------------------------------------------------*\
@@ -68,7 +68,7 @@ private:
 
         autoPtr<uniformDimensionedScalarField> level0EdgePtr_;
 
-        autoPtr<refinementHistoryNew> refHistoryPtr_;
+        autoPtr<dfRefinementHistory> refHistoryPtr_;
 
 
     // Private Member Functions
diff --git a/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRefNew.C b/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRefNew.C
index c18cda4d..23578390 100644
--- a/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRefNew.C
+++ b/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef/hexRefNew.C
@@ -89,7 +89,7 @@ Foam::autoPtr<Foam::hexRef> Foam::hexRef::New
     const polyMesh& mesh,
     const labelList& cellLevel,
     const labelList& pointLevel,
-    const refinementHistoryNew& history,
+    const dfRefinementHistory& history,
     const scalar level0Edge
 )
 {