diff --git a/applications/solvers/combustion/chemFoam/Make/options b/applications/solvers/combustion/chemFoam/Make/options
index 7b95c2f16f..9facf7ac9c 100644
--- a/applications/solvers/combustion/chemFoam/Make/options
+++ b/applications/solvers/combustion/chemFoam/Make/options
@@ -12,6 +12,7 @@ EXE_INC = \
 
 EXE_LIBS = \
     -lfiniteVolume \
+    -lcompressibleTurbulenceModel \
     -lcompressibleRASModels \
     -lreactionThermophysicalModels \
     -lfluidThermophysicalModels \
diff --git a/applications/solvers/incompressible/pimpleFoam/pimpleDyMFoam/Make/options b/applications/solvers/incompressible/pimpleFoam/pimpleDyMFoam/Make/options
index 8aa441b18e..11c10272ff 100644
--- a/applications/solvers/incompressible/pimpleFoam/pimpleDyMFoam/Make/options
+++ b/applications/solvers/incompressible/pimpleFoam/pimpleDyMFoam/Make/options
@@ -17,6 +17,7 @@ EXE_LIBS = \
     -ldynamicMesh \
     -lmeshTools \
     -lincompressibleTransportModels \
+    -lincompressibleTurbulenceModel \
     -lincompressibleRASModels \
     -lincompressibleLESModels \
     -lfiniteVolume \
diff --git a/applications/solvers/multiphase/compressibleInterFoam/Make/options b/applications/solvers/multiphase/compressibleInterFoam/Make/options
index ca9a90cf77..48c253b213 100644
--- a/applications/solvers/multiphase/compressibleInterFoam/Make/options
+++ b/applications/solvers/multiphase/compressibleInterFoam/Make/options
@@ -7,6 +7,7 @@ EXE_INC = \
     -I$(LIB_SRC)/finiteVolume/lnInclude
 
 EXE_LIBS = \
+    -linterfaceProperties \
     -ltwoPhaseInterfaceProperties \
     -lincompressibleTransportModels \
     -lphaseEquationsOfState \
diff --git a/applications/solvers/multiphase/compressibleInterFoam/compressibleInterDyMFoam/Make/options b/applications/solvers/multiphase/compressibleInterFoam/compressibleInterDyMFoam/Make/options
index db259cfbc0..d4d0fa9b5a 100644
--- a/applications/solvers/multiphase/compressibleInterFoam/compressibleInterDyMFoam/Make/options
+++ b/applications/solvers/multiphase/compressibleInterFoam/compressibleInterDyMFoam/Make/options
@@ -11,6 +11,7 @@ EXE_INC = \
     -I$(LIB_SRC)/dynamicFvMesh/lnInclude
 
 EXE_LIBS = \
+    -linterfaceProperties \
     -ltwoPhaseInterfaceProperties \
     -lincompressibleTransportModels \
     -lphaseEquationsOfState \
diff --git a/applications/solvers/multiphase/interFoam/LTSInterFoam/Make/options b/applications/solvers/multiphase/interFoam/LTSInterFoam/Make/options
index 24349f694e..054a8dbbd4 100644
--- a/applications/solvers/multiphase/interFoam/LTSInterFoam/Make/options
+++ b/applications/solvers/multiphase/interFoam/LTSInterFoam/Make/options
@@ -7,6 +7,7 @@ EXE_INC = \
     -I$(LIB_SRC)/finiteVolume/lnInclude
 
 EXE_LIBS = \
+    -linterfaceProperties \
     -ltwoPhaseInterfaceProperties \
     -lincompressibleTransportModels \
     -lincompressibleTurbulenceModel \
diff --git a/applications/solvers/multiphase/interFoam/MRFInterFoam/Make/options b/applications/solvers/multiphase/interFoam/MRFInterFoam/Make/options
index 24349f694e..054a8dbbd4 100644
--- a/applications/solvers/multiphase/interFoam/MRFInterFoam/Make/options
+++ b/applications/solvers/multiphase/interFoam/MRFInterFoam/Make/options
@@ -7,6 +7,7 @@ EXE_INC = \
     -I$(LIB_SRC)/finiteVolume/lnInclude
 
 EXE_LIBS = \
+    -linterfaceProperties \
     -ltwoPhaseInterfaceProperties \
     -lincompressibleTransportModels \
     -lincompressibleTurbulenceModel \
diff --git a/applications/solvers/multiphase/interFoam/Make/options b/applications/solvers/multiphase/interFoam/Make/options
index c8ce69c074..599567b54d 100644
--- a/applications/solvers/multiphase/interFoam/Make/options
+++ b/applications/solvers/multiphase/interFoam/Make/options
@@ -6,6 +6,7 @@ EXE_INC = \
     -I$(LIB_SRC)/finiteVolume/lnInclude
 
 EXE_LIBS = \
+    -linterfaceProperties \
     -ltwoPhaseInterfaceProperties \
     -lincompressibleTransportModels \
     -lincompressibleTurbulenceModel \
diff --git a/applications/solvers/multiphase/interFoam/interDyMFoam/Make/options b/applications/solvers/multiphase/interFoam/interDyMFoam/Make/options
index 102475c1ed..ba60cb1981 100644
--- a/applications/solvers/multiphase/interFoam/interDyMFoam/Make/options
+++ b/applications/solvers/multiphase/interFoam/interDyMFoam/Make/options
@@ -10,6 +10,7 @@ EXE_INC = \
     -I$(LIB_SRC)/dynamicFvMesh/lnInclude
 
 EXE_LIBS = \
+    -linterfaceProperties \
     -ltwoPhaseInterfaceProperties \
     -lincompressibleTransportModels \
     -lincompressibleTurbulenceModel \
diff --git a/applications/solvers/multiphase/interFoam/porousInterFoam/Make/options b/applications/solvers/multiphase/interFoam/porousInterFoam/Make/options
index a33b9c82be..6fc987453b 100644
--- a/applications/solvers/multiphase/interFoam/porousInterFoam/Make/options
+++ b/applications/solvers/multiphase/interFoam/porousInterFoam/Make/options
@@ -8,6 +8,7 @@ EXE_INC = \
     -I$(LIB_SRC)/meshTools/lnInclude
 
 EXE_LIBS = \
+    -linterfaceProperties \
     -ltwoPhaseInterfaceProperties \
     -lincompressibleTransportModels \
     -lincompressibleTurbulenceModel \
diff --git a/applications/solvers/multiphase/interPhaseChangeFoam/Make/options b/applications/solvers/multiphase/interPhaseChangeFoam/Make/options
index 960639f66a..5416a161a8 100644
--- a/applications/solvers/multiphase/interPhaseChangeFoam/Make/options
+++ b/applications/solvers/multiphase/interPhaseChangeFoam/Make/options
@@ -7,6 +7,7 @@ EXE_INC = \
     -I$(LIB_SRC)/finiteVolume/lnInclude
 
 EXE_LIBS = \
+    -linterfaceProperties \
     -ltwoPhaseInterfaceProperties \
     -lincompressibleTransportModels \
     -lincompressibleTurbulenceModel \
diff --git a/applications/test/Circulator/Make/files b/applications/test/Circulator/Make/files
new file mode 100644
index 0000000000..b6a4e63dc2
--- /dev/null
+++ b/applications/test/Circulator/Make/files
@@ -0,0 +1,3 @@
+Test-Circulator.C
+
+EXE = $(FOAM_USER_APPBIN)/Test-Circulator
diff --git a/applications/test/Circulator/Make/options b/applications/test/Circulator/Make/options
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/applications/test/Circulator/Test-Circulator.C b/applications/test/Circulator/Test-Circulator.C
new file mode 100644
index 0000000000..19a21f6b79
--- /dev/null
+++ b/applications/test/Circulator/Test-Circulator.C
@@ -0,0 +1,268 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 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/>.
+
+Application
+    Test-circulator
+
+Description
+
+\*---------------------------------------------------------------------------*/
+
+#include "List.H"
+#include "ListOps.H"
+#include "face.H"
+#include "circulator.H"
+#include "const_circulator.H"
+
+
+using namespace Foam;
+
+
+// return
+//   0: no match
+//  +1: identical
+//  -1: same face, but different orientation
+label compare(const face& a, const face& b)
+{
+    // Basic rule: we assume that the sequence of labels in each list
+    // will be circular in the same order (but not necessarily in the
+    // same direction or from the same starting point).
+
+    // Trivial reject: faces are different size
+    label sizeA = a.size();
+    label sizeB = b.size();
+
+    if (sizeA != sizeB || sizeA == 0)
+    {
+        return 0;
+    }
+
+    const_circulator<face> aCirc(a);
+    const_circulator<face> bCirc(b);
+
+    // Rotate face b until its element matches the starting element of face a.
+    do
+    {
+        if (aCirc() == bCirc())
+        {
+            // Set bCirc fulcrum to its iterator and increment the iterators
+            bCirc.setFulcrumToIterator();
+            ++aCirc;
+            ++bCirc;
+
+            break;
+        }
+    } while (bCirc.circulate(CirculatorBase::CLOCKWISE));
+
+    // Look forwards around the faces for a match
+    do
+    {
+        if (aCirc() != bCirc())
+        {
+            break;
+        }
+    }
+    while
+    (
+        aCirc.circulate(CirculatorBase::CLOCKWISE),
+        bCirc.circulate(CirculatorBase::CLOCKWISE)
+    );
+
+    // If the circulator has stopped then faces a and b matched.
+    if (!aCirc.circulate())
+    {
+        return 1;
+    }
+    else
+    {
+        // Reset the circulators back to their fulcrum
+        aCirc.setIteratorToFulcrum();
+        bCirc.setIteratorToFulcrum();
+        ++aCirc;
+        --bCirc;
+    }
+
+    // Look backwards around the faces for a match
+    do
+    {
+        if (aCirc() != bCirc())
+        {
+            break;
+        }
+    }
+    while
+    (
+        aCirc.circulate(CirculatorBase::CLOCKWISE),
+        bCirc.circulate(CirculatorBase::ANTICLOCKWISE)
+    );
+
+    // If the circulator has stopped then faces a and b matched.
+    if (!aCirc.circulate())
+    {
+        return -1;
+    }
+
+    return 0;
+}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+// Main program:
+
+int main(int argc, char *argv[])
+{
+    Info<< "Test the implementation of a circular iterator" << nl << endl;
+
+    Info<< "Test const circulator. First go forwards, then backwards."
+        << nl << endl;
+
+    face f(identity(4));
+
+    const_circulator<face> cStart(f);
+
+    if (cStart.size()) do
+    {
+        Info<< "Iterate forwards over face (prev/curr/next) : "
+            << cStart.prev() << " / " << cStart() << " / " << cStart.next()
+            << endl;
+
+    } while (cStart.circulate(CirculatorBase::CLOCKWISE));
+
+    if (cStart.size()) do
+    {
+        Info<< "Iterate backwards over face : " << cStart() << endl;
+
+    } while (cStart.circulate(CirculatorBase::ANTICLOCKWISE));
+
+
+    Info<< nl << nl << "Test non-const circulator" << nl << endl;
+
+    circulator<face> cStart2(f);
+
+    Info<< "Face before : " << f << endl;
+
+    if (cStart2.size()) do
+    {
+        Info<< "Iterate forwards over face (prev/curr/next) : "
+            << cStart2.prev() << " / " << cStart2() << " / " << cStart2.next()
+            << endl;
+
+    } while (cStart2.circulate(CirculatorBase::CLOCKWISE));
+
+    if (cStart2.size()) do
+    {
+        Info<< "Iterate forwards over face, adding 1 to each element : "
+            << cStart2();
+
+        cStart2() += 1;
+
+        Info<< " -> " << cStart2() << endl;
+    } while (cStart2.circulate(CirculatorBase::CLOCKWISE));
+
+    Info<< "Face after : " << f << endl;
+
+
+    Info<< nl << nl << "Compare two faces: " << endl;
+    face a(identity(5));
+    Info<< "Compare " << a << " and " << a << " Match = " << compare(a, a)
+        << endl;
+
+    face b(reverseList(a));
+    Info<< "Compare " << a << " and " << b << " Match = " << compare(a, b)
+        << endl;
+
+    face c(a);
+    c[4] = 3;
+    Info<< "Compare " << a << " and " << c << " Match = " << compare(a, c)
+        << endl;
+
+    face d(rotateList(a, 2));
+    Info<< "Compare " << a << " and " << d << " Match = " << compare(a, d)
+        << endl;
+
+    face g(labelList(5, 1));
+    face h(g);
+    Info<< "Compare " << g << " and " << h << " Match = " << compare(g, h)
+        << endl;
+
+    g[0] = 2;
+    h[3] = 2;
+    Info<< "Compare " << g << " and " << h << " Match = " << compare(g, h)
+        << endl;
+
+    g[4] = 3;
+    h[4] = 3;
+    Info<< "Compare " << g << " and " << h << " Match = " << compare(g, h)
+        << endl;
+
+    face face1(identity(1));
+    Info<< "Compare " << face1 << " and " << face1
+        << " Match = " << compare(face1, face1) << endl;
+
+    Info<< nl << nl << "Zero face" << nl << endl;
+
+    face fZero;
+    circulator<face> cZero(fZero);
+
+    if (cZero.size()) do
+    {
+        Info<< "Iterate forwards over face : " << cZero() << endl;
+
+    } while (cZero.circulate(CirculatorBase::CLOCKWISE));
+
+    fZero = face(identity(5));
+
+    // circulator was invalidated so reset
+    cZero = circulator<face>(fZero);
+
+    do
+    {
+        Info<< "Iterate forwards over face : " << cZero() << endl;
+
+    } while (cZero.circulate(CirculatorBase::CLOCKWISE));
+
+
+    Info<< nl << nl << "Simultaneously go forwards/backwards over face " << f
+        << nl << endl;
+
+    const_circulator<face> circForward(f);
+    const_circulator<face> circBackward(f);
+
+    if (circForward.size() && circBackward.size()) do
+    {
+        Info<< "Iterate over face forwards : " << circForward()
+            << ", backwards : " << circBackward() << endl;
+    }
+    while
+    (
+        circForward.circulate(CirculatorBase::CLOCKWISE),
+        circBackward.circulate(CirculatorBase::ANTICLOCKWISE)
+    );
+
+    Info<< "\nEnd\n" << endl;
+
+    return 0;
+}
+
+
+// ************************************************************************* //
diff --git a/applications/test/ListOps/Make/files b/applications/test/ListOps/Make/files
new file mode 100644
index 0000000000..645600a709
--- /dev/null
+++ b/applications/test/ListOps/Make/files
@@ -0,0 +1,2 @@
+Test-ListOps.C
+EXE = $(FOAM_USER_APPBIN)/Test-ListOps
diff --git a/applications/test/ListOps/Make/options b/applications/test/ListOps/Make/options
new file mode 100644
index 0000000000..9e79e9d733
--- /dev/null
+++ b/applications/test/ListOps/Make/options
@@ -0,0 +1,3 @@
+EXE_INC = /*-DFULLDEBUG -O0 -g*/ \
+
+EXE_LIBS = \
diff --git a/applications/test/ListOps/Test-ListOps.C b/applications/test/ListOps/Test-ListOps.C
new file mode 100644
index 0000000000..f6e5695164
--- /dev/null
+++ b/applications/test/ListOps/Test-ListOps.C
@@ -0,0 +1,120 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 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/>.
+
+Application
+    Test-ListOps
+
+Description
+
+\*---------------------------------------------------------------------------*/
+
+#include "argList.H"
+#include "List.H"
+#include "SubList.H"
+#include "ListOps.H"
+#include "face.H"
+
+using namespace Foam;
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+// Main program:
+
+int main(int argc, char *argv[])
+{
+    Info<< "Test Rotations:" << nl << endl;
+
+    List<label> forwardRotate(identity(5));
+    face testFace(identity(4));
+
+    for (label i = 0; i < 8; ++i)
+    {
+        Info<< "Rotate forward by " << i << " : "
+            << rotateList(forwardRotate, i) << endl;
+    }
+
+    for (label i = 0; i < 8; ++i)
+    {
+        Info<< "Rotate backward by " << i << " : "
+            << rotateList(forwardRotate, -i) << endl;
+    }
+
+    Info<< nl << "Face                 : " << testFace << endl;
+    Info<< "Rotate by 2          : " << rotateList(testFace, 2) << endl;
+    inplaceRotateList(testFace, -6);
+    Info<< "Rotate inplace by -6 : " << testFace << nl << endl;
+
+    Info<< "Test inplace rotate      : " << forwardRotate << endl;
+    inplaceRotateList(forwardRotate, 2);
+    Info<< "Rotate to the right by 2 : " << forwardRotate << endl;
+    inplaceRotateList(forwardRotate, -2);
+    Info<< "Rotate to the left by 2  : " << forwardRotate << endl;
+
+    List<label> subRotate(identity(10));
+    SubList<label> subL(subRotate, 5, 3);
+
+    Info<< "Test inplace rotate on sublist : " << subRotate << endl;
+    inplaceRotateList(subL, 3);
+    Info<< "Rotate to the right by 3       : " << subRotate << endl;
+    inplaceRotateList(subL, -8);
+    Info<< "Rotate to the left by 3        : " << subRotate << endl;
+
+    Info<< nl << nl << "Test Reversing:" << nl << endl;
+
+    Info<< "List    : " << identity(5) << endl;
+    Info<< "Reverse : " << reverseList(identity(5)) << endl;
+    Info<< "List    : " << identity(6) << endl;
+    Info<< "Reverse : " << reverseList(identity(6)) << nl << endl;
+
+    List<label> test1(identity(5));
+    Info<< "List            : " << test1 << endl;
+    inplaceReverseList(test1);
+    Info<< "Inplace Reverse : " << test1 << nl << endl;
+
+    List<label> test2(identity(6));
+    Info<< "List            : " << test2 << endl;
+    inplaceReverseList(test2);
+    Info<< "Inplace Reverse : " << test2 << nl << endl;
+
+    face test3(identity(6));
+    Info<< "Face            : " << test3 << endl;
+    inplaceReverseList(test3);
+    Info<< "Inplace Reverse : " << test3 << nl << endl;
+
+    FixedList<label, 6> test4(identity(6));
+    Info<< "FixedList       : " << test4 << endl;
+    inplaceReverseList(test4);
+    Info<< "Inplace Reverse : " << test4 << nl << endl;
+
+    List<label> test5(identity(9));
+    SubList<label> test5SubList(test5, 4, 3);
+    Info<< "List                            : " << test5 << endl;
+    inplaceReverseList(test5SubList);
+    Info<< "Reverse Sublist between 3 and 6 : " << test5 << endl;
+
+    Info<< "\nEnd\n" << endl;
+
+    return 0;
+}
+
+
+// ************************************************************************* //
diff --git a/applications/test/dynamicIndexedOctree/Test-dynamicIndexedOctree.C b/applications/test/dynamicIndexedOctree/Test-dynamicIndexedOctree.C
index b84b39c33b..0ccb8e377f 100644
--- a/applications/test/dynamicIndexedOctree/Test-dynamicIndexedOctree.C
+++ b/applications/test/dynamicIndexedOctree/Test-dynamicIndexedOctree.C
@@ -85,8 +85,8 @@ int main(int argc, char *argv[])
     (
         dynamicTreeDataPoint(pointList),
         overallBb,  // overall search domain
-        20,         // max levels; n/a
-        100,          // maximum ratio of cubes v.s. cells
+        20,         // max levels
+        100,        // maximum ratio of cubes v.s. cells
         100.0       // max. duplicity; n/a since no bounding boxes.
     );
 
diff --git a/applications/utilities/mesh/advanced/collapseEdges/Make/files b/applications/utilities/mesh/advanced/collapseEdges/Make/files
index a15838abe8..d89ca6e737 100644
--- a/applications/utilities/mesh/advanced/collapseEdges/Make/files
+++ b/applications/utilities/mesh/advanced/collapseEdges/Make/files
@@ -1,4 +1,3 @@
 collapseEdges.C
-pointEdgeCollapse/pointEdgeCollapse.C
 
 EXE = $(FOAM_APPBIN)/collapseEdges
diff --git a/applications/utilities/mesh/advanced/collapseEdges/Make/options b/applications/utilities/mesh/advanced/collapseEdges/Make/options
index d1efa61fd5..987eae5ed7 100644
--- a/applications/utilities/mesh/advanced/collapseEdges/Make/options
+++ b/applications/utilities/mesh/advanced/collapseEdges/Make/options
@@ -1,8 +1,7 @@
 EXE_INC = \
     -I$(LIB_SRC)/dynamicMesh/lnInclude \
     -I$(LIB_SRC)/meshTools/lnInclude \
-    -I$(LIB_SRC)/finiteVolume/lnInclude \
-    -IpointEdgeCollapse
+    -I$(LIB_SRC)/finiteVolume/lnInclude
 
 EXE_LIBS = \
     -ldynamicMesh \
diff --git a/applications/utilities/mesh/advanced/collapseEdges/collapseDict b/applications/utilities/mesh/advanced/collapseEdges/collapseDict
new file mode 100644
index 0000000000..78905475e3
--- /dev/null
+++ b/applications/utilities/mesh/advanced/collapseEdges/collapseDict
@@ -0,0 +1,85 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  dev                                   |
+|   \\  /    A nd           | Web:      http://www.openfoam.org               |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+
+FoamFile
+{
+    version         2.0;
+    format          ascii;
+
+    root            "";
+    case            "";
+    instance        "";
+    local           "";
+
+    class           dictionary;
+    object          collapseDict;
+}
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+collapseEdgesCoeffs
+{
+    // Edges shorter than this absolute value will be merged
+    minimumEdgeLength   1e-8;
+
+    // The maximum angle between two edges that share a point attached to
+    // no other edges
+    maximumMergeAngle   30;
+
+    // The amount that minimumEdgeLength will be reduced by for each
+    // edge if that edge's collapse generates a poor quality face
+    reductionFactor                         0.5;
+}
+
+
+collapseFacesCoeffs
+{
+    // The initial face length factor
+    initialFaceLengthFactor                 0.5;
+
+    // The amount that initialFaceLengthFactor will be reduced by for each
+    // face if its collapse generates a poor quality face
+    reductionFactor                         $initialFaceLengthFactor;
+
+    // If the face can't be collapsed to an edge, and it has a span less than
+    // the target face length multiplied by this coefficient, collapse it
+    // to a point.
+    maxCollapseFaceToPointSideLengthCoeff   0.3;
+
+    // Allow early collapse of edges to a point
+    allowEarlyCollapseToPoint               on;
+
+    // Fraction to premultiply maxCollapseFaceToPointSideLengthCoeff by if
+    // allowEarlyCollapseToPoint is enabled
+    allowEarlyCollapseCoeff                 0.2;
+
+    // Defining how close to the midpoint (M) of the projected
+    // vertices line a projected vertex (X) can be before making this
+    // an invalid edge collapse
+    //
+    // X---X-g----------------M----X-----------g----X--X
+    //
+    // Only allow a collapse if all projected vertices are outwith
+    // guardFraction (g) of the distance form the face centre to the
+    // furthest vertex in the considered direction
+    guardFraction                           0.1;
+}
+
+
+meshQualityCoeffs
+{
+    // Name of the dictionary that has the mesh quality coefficients used
+    // by motionSmoother::checkMesh
+    meshQualityCoeffDict    meshQualityDict;
+
+    // Maximum number of outer iterations is mesh quality checking is enabled
+    maximumIterations       30;
+}
+
+
+// ************************************************************************* //
diff --git a/applications/utilities/mesh/advanced/collapseEdges/collapseEdges.C b/applications/utilities/mesh/advanced/collapseEdges/collapseEdges.C
index c0523bf43b..132a602b1a 100644
--- a/applications/utilities/mesh/advanced/collapseEdges/collapseEdges.C
+++ b/applications/utilities/mesh/advanced/collapseEdges/collapseEdges.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2012 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -27,1425 +27,96 @@ Description
     - collapse short edges. Length of edges to collapse provided as argument.
     - merge two edges if they are in line. Maximum angle provided as argument.
     - remove unused points.
+    - collapse faces:
+        - with small areas to a single point
+        - that have a high aspect ratio (i.e. sliver face) to a single edge
 
-    Optionally removes cells. Can remove faces and points but does not check
-    for nonsense resulting topology.
+    Optionally checks the resulting mesh for bad faces and reduces the desired
+    face length factor for those faces attached to the bad faces.
 
     When collapsing an edge with one point on the boundary it will leave
     the boundary point intact. When both points inside it chooses random. When
     both points on boundary random again.
 
 Usage
-    - collapseEdges <edge length> <merge angle> [OPTION]
-
-    \param -allowCellCollapse \n
-    Allow collapsing of cells to a single point
-
-    \param -meshQuality \n
-    Only collapse if not exceeding user defined (in \a system/meshQualityDict)
-    quality settings
+    - collapseEdges [OPTION]
 
 \*---------------------------------------------------------------------------*/
 
 #include "argList.H"
 #include "Time.H"
+#include "timeSelector.H"
 #include "polyTopoChange.H"
 #include "fvMesh.H"
-#include "mapPolyMesh.H"
-#include "mathematicalConstants.H"
-#include "PackedBoolList.H"
-#include "unitConversion.H"
-#include "globalMeshData.H"
-#include "globalIndex.H"
-#include "PointEdgeWave.H"
-#include "pointEdgeCollapse.H"
-#include "motionSmoother.H"
-#include "removePoints.H"
+#include "polyMeshFilter.H"
 
 using namespace Foam;
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-void filterFace
-(
-    const label faceI,
-    face& f,
-    const List<pointEdgeCollapse>& allPointInfo,
-    const Map<DynamicList<label> >& collapseStrings
-)
-{
-    label newFp = 0;
-
-    face oldFace = f;
-
-    forAll(f, fp)
-    {
-        label pointI = f[fp];
-
-        label collapsePoint = allPointInfo[pointI].collapseIndex();
-
-        if (collapseStrings.found(collapsePoint))
-        {
-            collapsePoint = collapseStrings[collapsePoint][0];
-        }
-
-        if (collapsePoint == -1)
-        {
-            WarningIn
-                (
-                    "filterFace"
-                    "(const label, face&, const List<pointEdgeCollapse>&)"
-                )
-                << "Point " << pointI << " was not visited by PointEdgeWave"
-                << endl;
-        }
-        else if (collapsePoint == -2)
-        {
-            f[newFp++] = pointI;
-        }
-        else
-        {
-            if (findIndex(SubList<label>(f, newFp), collapsePoint) == -1)
-            {
-                f[newFp++] = collapsePoint;
-            }
-        }
-    }
-
-
-    // Check for pinched face. Tries to correct
-    // - consecutive duplicate vertex. Removes duplicate vertex.
-    // - duplicate vertex with one other vertex in between (spike).
-    // Both of these should not really occur! and should be checked before
-    // collapsing edges.
-
-    const label size = newFp;
-
-    newFp = 2;
-
-    for (label fp = 2; fp < size; fp++)
-    {
-        label fp1 = fp-1;
-        label fp2 = fp-2;
-
-        label pointI = f[fp];
-
-        // Search for previous occurrence.
-        label index = findIndex(SubList<label>(f, fp), pointI);
-
-        if (index == fp1)
-        {
-            WarningIn
-            (
-                "Foam::edgeCollapser::filterFace(const label faceI, "
-                "face& f) const"
-            )   << "Removing consecutive duplicate vertex in face "
-                << f << endl;
-            // Don't store current pointI
-        }
-        else if (index == fp2)
-        {
-            WarningIn
-            (
-                "Foam::edgeCollapser::filterFace(const label faceI, "
-                "face& f) const"
-            )   << "Removing non-consecutive duplicate vertex in face "
-                << f << endl;
-            // Don't store current pointI and remove previous
-            newFp--;
-        }
-        else if (index != -1)
-        {
-            WarningIn
-            (
-                "Foam::edgeCollapser::filterFace(const label faceI, "
-                "face& f) const"
-            )   << "Pinched face " << f << endl;
-            f[newFp++] = pointI;
-        }
-        else
-        {
-            f[newFp++] = pointI;
-        }
-    }
-
-    f.setSize(newFp);
-}
-
-
-bool setRefinement
-(
-    const polyMesh& mesh,
-    polyTopoChange& meshMod,
-    const List<pointEdgeCollapse>& allPointInfo
-)
-{
-    const cellList& cells = mesh.cells();
-    const labelList& faceOwner = mesh.faceOwner();
-    const labelList& faceNeighbour = mesh.faceNeighbour();
-    const labelListList& pointFaces = mesh.pointFaces();
-    const pointZoneMesh& pointZones = mesh.pointZones();
-
-    globalIndex globalStrings(mesh.nPoints());
-
-    boolList removedPoints(mesh.nPoints(), false);
-
-    // Create strings of edges.
-    // Map from collapseIndex(=global master point) to set of points
-    Map<DynamicList<label> > collapseStrings;
-    {
-        // 1. Count elements per collapseIndex
-        Map<label> nPerIndex(mesh.nPoints()/10);
-        forAll(allPointInfo, pointI)
-        {
-            const label collapseIndex = allPointInfo[pointI].collapseIndex();
-
-            if (collapseIndex != -1 && collapseIndex != -2)
-            {
-                Map<label>::iterator fnd = nPerIndex.find(collapseIndex);
-                if (fnd != nPerIndex.end())
-                {
-                    fnd()++;
-                }
-                else
-                {
-                    nPerIndex.insert(collapseIndex, 1);
-                }
-            }
-        }
-
-        // 2. Size
-        collapseStrings.resize(2*nPerIndex.size());
-        forAllConstIter(Map<label>, nPerIndex, iter)
-        {
-            collapseStrings.insert(iter.key(), DynamicList<label>(iter()));
-        }
-
-        // 3. Fill
-        forAll(allPointInfo, pointI)
-        {
-            const label collapseIndex = allPointInfo[pointI].collapseIndex();
-
-            if (collapseIndex != -1 && collapseIndex != -2)
-            {
-                collapseStrings[collapseIndex].append(pointI);
-            }
-        }
-    }
-
-
-    bool meshChanged = false;
-
-    // Current faces (is also collapseStatus: f.size() < 3)
-    faceList newFaces(mesh.faces());
-
-    // Current cellCollapse status
-    boolList cellRemoved(mesh.nCells(), false);
-
-    label nUnvisited = 0;
-    label nUncollapsed = 0;
-    label nCollapsed = 0;
-
-    forAll(allPointInfo, pI)
-    {
-        const pointEdgeCollapse& pec = allPointInfo[pI];
-
-        if (pec.collapseIndex() == -1)
-        {
-            nUnvisited++;
-        }
-        else if (pec.collapseIndex() == -2)
-        {
-            nUncollapsed++;
-        }
-        else if (pec.collapseIndex() >= 0)
-        {
-            nCollapsed++;
-        }
-    }
-
-    label nPoints = allPointInfo.size();
-
-    reduce(nPoints, sumOp<label>());
-    reduce(nUnvisited, sumOp<label>());
-    reduce(nUncollapsed, sumOp<label>());
-    reduce(nCollapsed, sumOp<label>());
-
-    Info<< incrIndent;
-    Info<< indent << "Number of points : " << nPoints << nl
-        << indent << "Not visited      : " << nUnvisited << nl
-        << indent << "Not collapsed    : " << nUncollapsed << nl
-        << indent << "Collapsed        : " << nCollapsed << nl
-        << endl;
-    Info<< decrIndent;
-
-    do
-    {
-        // Update face collapse from edge collapses
-        forAll(newFaces, faceI)
-        {
-            filterFace(faceI, newFaces[faceI], allPointInfo, collapseStrings);
-        }
-
-        // Check if faces to be collapsed cause cells to become collapsed.
-        label nCellCollapsed = 0;
-
-        forAll(cells, cellI)
-        {
-            if (!cellRemoved[cellI])
-            {
-                const cell& cFaces = cells[cellI];
-
-                label nFaces = cFaces.size();
-
-                forAll(cFaces, i)
-                {
-                    label faceI = cFaces[i];
-
-                    if (newFaces[faceI].size() < 3)
-                    {
-                        --nFaces;
-
-                        if (nFaces < 4)
-                        {
-                            Pout<< "Cell:" << cellI
-                                << " uses faces:" << cFaces
-                                << " of which too many are marked for removal:"
-                                << endl
-                                << "   ";
-                            forAll(cFaces, j)
-                            {
-                                if (newFaces[cFaces[j]].size() < 3)
-                                {
-                                    Pout<< ' '<< cFaces[j];
-                                }
-                            }
-                            Pout<< endl;
-
-                            cellRemoved[cellI] = true;
-
-                            // Collapse all edges of cell to nothing
-                            //collapseEdges(cellEdges[cellI]);
-
-                            nCellCollapsed++;
-
-                            break;
-                        }
-                    }
-                }
-            }
-        }
-
-        if (nCellCollapsed == 0)
-        {
-            break;
-        }
-    } while (true);
-
-
-    // Keep track of faces that have been done already.
-    boolList doneFace(mesh.nFaces(), false);
-
-    {
-        // Mark points used.
-        boolList usedPoint(mesh.nPoints(), false);
-
-        forAll(cellRemoved, cellI)
-        {
-            if (cellRemoved[cellI])
-            {
-                meshMod.removeCell(cellI, -1);
-            }
-        }
-
-        // Remove faces
-        forAll(newFaces, faceI)
-        {
-            const face& f = newFaces[faceI];
-
-            if (f.size() < 3)
-            {
-                meshMod.removeFace(faceI, -1);
-                meshChanged = true;
-
-                // Mark face as been done.
-                doneFace[faceI] = true;
-            }
-            else
-            {
-                // Kept face. Mark vertices
-                forAll(f, fp)
-                {
-                    usedPoint[f[fp]] = true;
-                }
-            }
-        }
-
-        // Remove unused vertices that have not been marked for removal already
-        forAll(usedPoint, pointI)
-        {
-            if (!usedPoint[pointI])
-            {
-                removedPoints[pointI] = true;
-                meshMod.removePoint(pointI, -1);
-                meshChanged = true;
-            }
-        }
-    }
-
-    // Modify the point location of the remaining points
-    forAll(allPointInfo, pointI)
-    {
-        const label collapseIndex = allPointInfo[pointI].collapseIndex();
-        const point& collapsePoint = allPointInfo[pointI].collapsePoint();
-
-        if
-        (
-            removedPoints[pointI] == false
-         && collapseIndex != -1
-         && collapseIndex != -2
-        )
-        {
-            meshMod.modifyPoint
-            (
-                pointI,
-                collapsePoint,
-                pointZones.whichZone(pointI),
-                false
-            );
-        }
-    }
-
-
-    const polyBoundaryMesh& boundaryMesh = mesh.boundaryMesh();
-    const faceZoneMesh& faceZones = mesh.faceZones();
-
-    // Renumber faces that use points
-    forAll(allPointInfo, pointI)
-    {
-        if (removedPoints[pointI] == true)
-        {
-            const labelList& changedFaces = pointFaces[pointI];
-
-            forAll(changedFaces, changedFaceI)
-            {
-                label faceI = changedFaces[changedFaceI];
-
-                if (!doneFace[faceI])
-                {
-                    doneFace[faceI] = true;
-
-                    // Get current zone info
-                    label zoneID = faceZones.whichZone(faceI);
-
-                    bool zoneFlip = false;
-
-                    if (zoneID >= 0)
-                    {
-                        const faceZone& fZone = faceZones[zoneID];
-
-                        zoneFlip = fZone.flipMap()[fZone.whichFace(faceI)];
-                    }
-
-                    // Get current connectivity
-                    label own = faceOwner[faceI];
-                    label nei = -1;
-                    label patchID = -1;
-
-                    if (mesh.isInternalFace(faceI))
-                    {
-                        nei = faceNeighbour[faceI];
-                    }
-                    else
-                    {
-                        patchID = boundaryMesh.whichPatch(faceI);
-                    }
-
-                    meshMod.modifyFace
-                    (
-                        newFaces[faceI],            // face
-                        faceI,                      // faceI to change
-                        own,                        // owner
-                        nei,                        // neighbour
-                        false,                      // flipFaceFlux
-                        patchID,                    // patch
-                        zoneID,
-                        zoneFlip
-                    );
-                    meshChanged = true;
-                }
-            }
-        }
-    }
-
-    return meshChanged;
-}
-
-
-// Get faceEdges in order of face points, i.e. faceEdges[0] is between
-// f[0] and f[1]
-labelList getSortedEdges
-(
-    const edgeList& edges,
-    const labelList& f,
-    const labelList& edgeLabels
-)
-{
-    labelList faceEdges(edgeLabels.size(), -1);
-
-    // Find starting pos in f for every edgeLabels
-    forAll(edgeLabels, i)
-    {
-        label edgeI = edgeLabels[i];
-
-        const edge& e = edges[edgeI];
-
-        label fp = findIndex(f, e[0]);
-        label fp1 = f.fcIndex(fp);
-
-        if (f[fp1] == e[1])
-        {
-            // EdgeI between fp -> fp1
-            faceEdges[fp] = edgeI;
-        }
-        else
-        {
-            // EdgeI between fp-1 -> fp
-            faceEdges[f.rcIndex(fp)] = edgeI;
-        }
-    }
-
-    return faceEdges;
-}
-
-
-// Return master point edge needs to be collapsed to (or -1)
-label edgeMaster
-(
-    const labelList& boundaryPoint,
-    const bool flipEdge,
-    const edge& e
-)
-{
-    label masterPoint = -1;
-
-    label e0 = e[0];
-    label e1 = e[1];
-
-    if (flipEdge)
-    {
-        e0 = e[1];
-        e1 = e[0];
-    }
-
-    // Check if one of the points is on a processor
-//    if
-//    (
-//        boundaryPoint[e0] > 0
-//     && boundaryPoint[e1] > 0
-//    )
-//    {
-//        if (boundaryPoint[e0] != boundaryPoint[e1])
-//        {
-//            return -1;
-//        }
-//    }
-//
-//    if (boundaryPoint[e0] > 0)
-//    {
-//        return e0;
-//    }
-//    else if (boundaryPoint[e1] > 0)
-//    {
-//        return e1;
-//    }
-
-    // Collapse edge to boundary point.
-    if (boundaryPoint[e0] == 0)
-    {
-        if (boundaryPoint[e1] == 0)
-        {
-            // Both points on boundary. Choose one to collapse to.
-            // Note: should look at feature edges/points!
-            masterPoint = e0;
-        }
-        else
-        {
-            masterPoint = e0;
-        }
-    }
-    else
-    {
-        if (boundaryPoint[e1] == 0)
-        {
-            masterPoint = e1;
-        }
-        else
-        {
-            // None on boundary. Choose arbitrary.
-            // Note: should look at geometry?
-            masterPoint = e0;
-        }
-    }
-
-    return masterPoint;
-}
-
-
-// Create consistent set of collapses.
-//  collapseEdge : per edge:
-//      -1 : do not collapse
-//       0 : collapse to start
-//       1 : collapse to end
-//  Note: collapseEdge has to be parallel consistent (in orientation)
-label syncCollapse
-(
-    const polyMesh& mesh,
-    const globalIndex& globalStrings,
-    const labelList& collapseEdge,
-    List<pointEdgeCollapse>& allPointInfo
-)
-{
-    const edgeList& edges = mesh.edges();
-    const pointField& points = mesh.points();
-
-    label nCollapsed = 0;
-
-    DynamicList<label> initPoints(mesh.nPoints());
-    DynamicList<pointEdgeCollapse> initPointInfo(mesh.nPoints());
-    allPointInfo.resize(mesh.nPoints());
-
-    // Initialise edges to no collapse
-    List<pointEdgeCollapse> allEdgeInfo
-    (
-        mesh.nEdges(),
-        pointEdgeCollapse(vector::zero, -1)
-    );
-
-    // Mark selected edges for collapse
-    forAll(edges, edgeI)
-    {
-        const edge& e = edges[edgeI];
-
-        if (collapseEdge[edgeI] != -1)
-        {
-            label masterPointI = e[collapseEdge[edgeI]];
-
-            const pointEdgeCollapse pec
-            (
-                points[masterPointI],
-                globalStrings.toGlobal(masterPointI)
-            );
-
-            // Mark as collapsable but with nonsense master so it gets
-            // overwritten and starts an update wave
-            allEdgeInfo[edgeI] = pointEdgeCollapse
-            (
-                points[masterPointI],
-                labelMax
-            );
-
-            initPointInfo.append(pec);
-            initPoints.append(e.start());
-
-            initPointInfo.append(pec);
-            initPoints.append(e.end());
-
-            nCollapsed++;
-        }
-    }
-
-    PointEdgeWave<pointEdgeCollapse> collapsePropagator
-    (
-        mesh,
-        initPoints,
-        initPointInfo,
-        allPointInfo,
-        allEdgeInfo,
-        mesh.globalData().nTotalPoints()  // Maximum number of iterations
-    );
-
-    return nCollapsed;
-}
-
-
-void syncCollapseEdge(const polyMesh& mesh, labelList& collapseEdge)
-{
-    // Check whether edge point order is reversed from mesh to coupledPatch
-    const globalMeshData& globalData = mesh.globalData();
-    const mapDistribute& map = globalData.globalEdgeSlavesMap();
-    const labelList& coupledMeshEdges = globalData.coupledPatchMeshEdges();
-    const indirectPrimitivePatch& coupledPatch = globalData.coupledPatch();
-    const PackedBoolList& cppOrientation = globalData.globalEdgeOrientation();
-    PackedBoolList meshToPatchSameOrientation(coupledMeshEdges.size(), true);
-
-    forAll(coupledMeshEdges, eI)
-    {
-        const label meshEdgeIndex = coupledMeshEdges[eI];
-
-        if (collapseEdge[meshEdgeIndex] != -1)
-        {
-            const edge& meshEdge = mesh.edges()[meshEdgeIndex];
-            const edge& coupledPatchEdge = coupledPatch.edges()[eI];
-
-            if
-            (
-                meshEdge[0] == coupledPatch.meshPoints()[coupledPatchEdge[1]]
-             && meshEdge[1] == coupledPatch.meshPoints()[coupledPatchEdge[0]]
-            )
-            {
-                meshToPatchSameOrientation[eI] = false;
-            }
-        }
-    }
-
-
-    labelList cppEdgeData(map.constructSize());
-
-    forAll(coupledMeshEdges, eI)
-    {
-        const label meshEdgeIndex = coupledMeshEdges[eI];
-
-        cppEdgeData[eI] = collapseEdge[meshEdgeIndex];
-
-        if
-        (
-            (collapseEdge[meshEdgeIndex] != -1)
-         && (meshToPatchSameOrientation[eI] != cppOrientation[eI])
-        )
-        {
-            cppEdgeData[eI] = 1-cppEdgeData[eI];
-        }
-    }
-
-
-    // Synchronise cppEdgeData
-    // Use minEqOp reduction, so that edge will only be collapsed on processor
-    // boundary if both processors agree to collapse it
-    globalData.syncData
-    (
-        cppEdgeData,
-        globalData.globalEdgeSlaves(),
-        globalData.globalEdgeTransformedSlaves(),
-        map,
-        minEqOp<label>()
-    );
-
-
-    forAll(coupledMeshEdges, eI)
-    {
-        const label meshEdgeIndex = coupledMeshEdges[eI];
-
-        collapseEdge[meshEdgeIndex] = cppEdgeData[eI];
-
-        if
-        (
-            (cppEdgeData[eI] != -1)
-         && (meshToPatchSameOrientation[eI] != cppOrientation[eI])
-        )
-        {
-            collapseEdge[meshEdgeIndex] = 1-collapseEdge[meshEdgeIndex];
-        }
-    }
-}
-
-
-// Mark (in collapseEdge) any edges to collapse
-label collapseSmallEdges
-(
-    const polyMesh& mesh,
-    const labelList& boundaryPoint,
-    const scalarField& minEdgeLen,
-    labelList& collapseEdge
-)
-{
-    // Work out which edges to collapse
-    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-    label nCollapsed = 0;
-
-    forAll(mesh.edges(), edgeI)
-    {
-        if (collapseEdge[edgeI] == -1)
-        {
-            const edge& e = mesh.edges()[edgeI];
-
-            if (e.mag(mesh.points()) < minEdgeLen[edgeI])
-            {
-                label masterPointI = edgeMaster(boundaryPoint, false, e);
-                if (masterPointI == e[0])
-                {
-                    collapseEdge[edgeI] = 0;
-                }
-                else
-                {
-                    collapseEdge[edgeI] = 1;
-                }
-                nCollapsed++;
-            }
-        }
-    }
-    return nCollapsed;
-}
-
-
-// Mark (in collapseEdge) any edges to merge
-label mergeEdges
-(
-    const polyMesh& mesh,
-    const scalar maxCos,
-    const labelList& boundaryPoint,
-    const scalarField& minEdgeLen,
-    labelList& collapseEdge
-)
-{
-    const edgeList& edges = mesh.edges();
-    const labelListList& pointEdges = mesh.pointEdges();
-
-    // Point removal engine
-    removePoints pointRemover(mesh, false);
-
-    // Find out points that can be deleted
-    boolList pointCanBeDeleted;
-    label nTotRemove = pointRemover.countPointUsage(maxCos, pointCanBeDeleted);
-
-
-    // Rework point-to-remove into edge-to-collapse.
-
-    label nCollapsed = 0;
-
-    if (nTotRemove > 0)
-    {
-        forAll(pointEdges, pointI)
-        {
-            if (pointCanBeDeleted[pointI])
-            {
-                const labelList& pEdges = pointEdges[pointI];
-
-                if (pEdges.size() == 2)
-                {
-                    // Always the case?
-
-                    label e0 = pEdges[0];
-                    label e1 = pEdges[1];
-
-                    if
-                    (
-                        collapseEdge[e0] == -1
-                     && minEdgeLen[e0] >= 0
-                     && collapseEdge[e1] == -1
-                     && minEdgeLen[e1] >= 0
-                    )
-                    {
-                        // Get the two vertices on both sides of the point
-                        label leftV = edges[e0].otherVertex(pointI);
-                        label rightV = edges[e1].otherVertex(pointI);
-
-                        // Can collapse pointI onto either leftV or rightV.
-                        // Preferentially choose an internal point to hopefully
-                        // give less distortion
-
-                        if (boundaryPoint[leftV] == -1)
-                        {
-                            collapseEdge[e0] = findIndex(edges[e0], leftV);
-                        }
-                        else
-                        {
-                            collapseEdge[e1] = findIndex(edges[e1], rightV);
-                        }
-                    }
-                }
-            }
-        }
-    }
-    return nCollapsed;
-}
-
-
-// Make consistent set of collapses that does not collapse any cells
-label consistentCollapse
-(
-    const bool allowCellCollapse,
-    const polyMesh& mesh,
-    const globalIndex& globalStrings,
-    labelList& collapseEdge,
-    List<pointEdgeCollapse>& allPointInfo
-)
-{
-    // Make sure we don't collapse cells
-    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-    while (true)
-    {
-        // Sync collapseEdge
-        syncCollapseEdge(mesh, collapseEdge);
-
-
-        // Get collapsed faces
-
-        label nAdditionalCollapsed = 0;
-
-        PackedBoolList isCollapsedFace(mesh.nFaces());
-        forAll(mesh.faceEdges(), faceI)
-        {
-            const labelList& fEdges = mesh.faceEdges()[faceI];
-
-            // Count number of remaining edges
-            label nEdges = fEdges.size();
-            forAll(fEdges, fEdgeI)
-            {
-                label edgeI = fEdges[fEdgeI];
-                if (collapseEdge[edgeI] != -1)
-                {
-                    nEdges--;
-                }
-            }
-
-            if (nEdges < 3)
-            {
-                // Face is collapsed.
-                isCollapsedFace[faceI] = 1;
-
-                if (nEdges == 1)
-                {
-                    // Cannot collapse face down to single edge.
-
-                    //- Option 1: collapse remaining edge as well. However
-                    //  if this edge is on the coupled processor patch this
-                    //  logic clashes with that of syncCollapseEdge
-                    //  (do not collapse if any not collapse)
-                    //forAll(fEdges, fEdgeI)
-                    //{
-                    //    label edgeI = fEdges[fEdgeI];
-                    //    if (collapseEdge[edgeI] == -1)
-                    //    {
-                    //        collapseEdge[edgeI] = 0;
-                    //        nAdditionalCollapsed++;
-                    //    }
-                    //}
-
-                    //- Option 2: uncollapse this face.
-                    forAll(fEdges, fEdgeI)
-                    {
-                        label edgeI = fEdges[fEdgeI];
-                        if (collapseEdge[edgeI] != -1)
-                        {
-                            collapseEdge[edgeI] = -1;
-                            nAdditionalCollapsed++;
-                        }
-                    }
-                }
-            }
-        }
-
-        //Pout<< "nAdditionalCollapsed : " << nAdditionalCollapsed << endl;
-
-
-        label nUncollapsed = 0;
-
-        if (!allowCellCollapse)
-        {
-            // Check collapsed cells
-
-            forAll(mesh.cells(), cellI)
-            {
-                const cell& cFaces = mesh.cells()[cellI];
-                label nFaces = cFaces.size();
-                forAll(cFaces, i)
-                {
-                    label faceI = cFaces[i];
-                    if (isCollapsedFace[faceI])
-                    {
-                        nFaces--;
-                        if (nFaces < 4)
-                        {
-                            // Unmark this face for collapse
-                            const labelList& fEdges = mesh.faceEdges()[faceI];
-
-                            forAll(fEdges, fEdgeI)
-                            {
-                                label edgeI = fEdges[fEdgeI];
-                                if (collapseEdge[edgeI] != -1)
-                                {
-                                    collapseEdge[edgeI] = -1;
-                                    nUncollapsed++;
-                                }
-                            }
-
-                            // Uncollapsed this face.
-                            isCollapsedFace[faceI] = 0;
-                            nFaces++;
-                        }
-                    }
-                }
-            }
-            //Pout<< "** disallowing cells : nUncollapsed : "
-            //    << nUncollapsed << endl;
-        }
-
-
-        if
-        (
-            returnReduce(nUncollapsed+nAdditionalCollapsed, sumOp<label>())
-            == 0
-        )
-        {
-            break;
-        }
-    }
-
-
-    // Create consistent set of collapses
-    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    // Note: requires collapseEdge to be synchronised. (above loop makes sure
-    //       of that)
-
-    return syncCollapse(mesh, globalStrings, collapseEdge, allPointInfo);
-}
-
-
-// Check mesh and mark points on faces in error
-// Returns boolList with points in error set
-PackedBoolList checkMeshQuality(const polyMesh& mesh)
-{
-    //mesh.checkMesh(true);
-
-    IOdictionary meshQualityDict
-    (
-        IOobject
-        (
-            "meshQualityDict",
-            mesh.time().system(),
-            mesh.time(),
-            IOobject::MUST_READ,
-            IOobject::NO_WRITE
-        )
-    );
-
-    labelHashSet badFaces(mesh.nFaces()/100);
-    DynamicList<label> checkFaces(mesh.nFaces());
-
-    const vectorField& fAreas = mesh.faceAreas();
-
-    scalar faceAreaLimit = SMALL;
-
-    forAll(fAreas, fI)
-    {
-        if (mag(fAreas[fI]) > faceAreaLimit)
-        {
-            checkFaces.append(fI);
-        }
-    }
-
-    motionSmoother::checkMesh
-    (
-        false,
-        mesh,
-        meshQualityDict,
-        checkFaces,
-        badFaces
-    );
-
-    label nBadFaces = badFaces.size();
-    reduce(nBadFaces, sumOp<label>());
-
-    Info<< nl << "Number of bad faces          : " << nBadFaces << endl;
-
-    PackedBoolList isErrorPoint(mesh.nPoints());
-    forAllConstIter(labelHashSet, badFaces, iter)
-    {
-        const face& f = mesh.faces()[iter.key()];
-
-        forAll(f, pI)
-        {
-            isErrorPoint[f[pI]] = 1;
-        }
-    }
-
-    syncTools::syncPointList
-    (
-        mesh,
-        isErrorPoint,
-        orEqOp<unsigned int>(),
-        0
-    );
-
-    return isErrorPoint;
-}
-
-
-// Check mesh with collapses (newMesh), updates minEdgeLen, nFrozenEdges
-void checkMeshAndFreezeEdges
-(
-    const polyMesh& newMesh,
-    const labelList& oldToNewMesh,
-    const polyMesh& oldMesh,
-    scalarField& minEdgeLen,
-    label& nFrozenEdges
-)
-{
-    PackedBoolList isErrorPoint = checkMeshQuality(newMesh);
-
-    forAll(oldMesh.edges(), edgeI)
-    {
-        const edge& e = oldMesh.edges()[edgeI];
-        label newStart = oldToNewMesh[e[0]];
-        label newEnd = oldToNewMesh[e[1]];
-
-        if
-        (
-            (newStart >= 0 && isErrorPoint[newStart])
-         || (newEnd >= 0 && isErrorPoint[newEnd])
-        )
-        {
-            // Gradual decrease? For now just hard disable
-            if (minEdgeLen[edgeI] > -GREAT/2)
-            {
-                minEdgeLen[edgeI] = -GREAT;
-                nFrozenEdges++;
-            }
-        }
-    }
-}
-
-
-// Mark boundary points
-// boundaryPoint:
-// + -1 : point not on boundary
-// +  0 : point on a real boundary
-// + >0 : point on a processor patch with that ID
-labelList findBoundaryPoints(const polyMesh& mesh)
-{
-    const faceList& faces = mesh.faces();
-    const polyBoundaryMesh& bMesh = mesh.boundaryMesh();
-
-
-    labelList boundaryPoint(mesh.nPoints(), -1);
-
-    // Get all points on a boundary
-    label nIntFaces = mesh.nInternalFaces();
-    for (label faceI = nIntFaces; faceI < mesh.nFaces(); faceI++)
-    {
-        const face& f = faces[faceI];
-
-        forAll(f, fp)
-        {
-           boundaryPoint[f[fp]] = 0;
-        }
-    }
-
-    // Get all processor boundary points and the processor patch label
-    // that they are on.
-    forAll(bMesh, patchI)
-    {
-        const polyPatch& patch = bMesh[patchI];
-
-        if (isA<coupledPolyPatch>(patch))
-        {
-            if (patchI == 0)
-            {
-                // We mark 'normal' boundary points with 0 so make sure this
-                // coupled patch is not 0.
-                FatalErrorIn("findBoundaryPoints(const polyMesh&)")
-                    << "Your patches should have non-coupled ones before any"
-                    << " coupled ones. Current patches " << bMesh.names()
-                    << exit(FatalError);
-            }
-
-            forAll(patch, fI)
-            {
-                const face& f = patch[fI];
-
-                forAll(f, fp)
-                {
-                    boundaryPoint[f[fp]] = patchI;
-                }
-            }
-        }
-    }
-
-    return boundaryPoint;
-}
-
-
 // Main program:
 int main(int argc, char *argv[])
 {
+    timeSelector::addOptions(true, false);
     argList::addNote
     (
-        "Merges small and in-line edges.\n"
-        "Collapses faces and optionally cells to a point."
+        "Collapses small edges to a point.\n"
+        "Optionally collapse small faces to a point and thin faces to an edge."
+    );
+
+    argList::addBoolOption
+    (
+        "collapseFaces",
+        "Collapse small and sliver faces as well as small edges"
     );
 
 #   include "addOverwriteOption.H"
-
-    argList::validArgs.append("edge length [m]");
-    argList::validArgs.append("merge angle (degrees)");
-    argList::addBoolOption
-    (
-        "allowCellCollapse",
-        "Allow collapsing of cells to a single point"
-    );
-    argList::addBoolOption
-    (
-        "meshQuality",
-        "Only collapse if not exceeding given meshQualityDict limits"
-    );
-
-
-
 #   include "setRootCase.H"
 #   include "createTime.H"
+
     runTime.functionObjects().off();
-#   include "createPolyMesh.H"
+    instantList timeDirs = timeSelector::selectIfPresent(runTime, args);
+
+#   include "createMesh.H"
+
     const word oldInstance = mesh.pointsInstance();
 
-    scalar minLen = args.argRead<scalar>(1);
-    const scalar angle = args.argRead<scalar>(2);
-
-    const bool allowCellCollapse = args.optionFound("allowCellCollapse");
     const bool overwrite = args.optionFound("overwrite");
-    const bool checkQuality = args.optionFound("meshQuality");
 
-    scalar maxCos = Foam::cos(degToRad(angle));
+    const bool collapseFaces = args.optionFound("collapseFaces");
 
-    Info<< "Merging:" << nl
-        << "    edges with length less than " << minLen << " meters" << nl
-        << "    edges split by a point with edges in line to within " << angle
-        << " degrees" << nl
-        << endl;
-
-    if (allowCellCollapse)
+    forAll(timeDirs, timeI)
     {
-        Info<< "Allowing collapse of cells down to a point." << nl
-            << endl;
-    }
-    else
-    {
-        Info<< "Disallowing collapse of cells down to a point." << nl
-            << endl;
-    }
+        runTime.setTime(timeDirs[timeI], timeI);
 
+        Info<< "Time = " << runTime.timeName() << endl;
 
-    if (checkQuality)
-    {
-        Info<< "Selectively disabling wanted collapses until resulting quality"
-            << " satisfies constraints in system/meshQualityDict" << nl
-            << endl;
-    }
+        polyMeshFilter meshFilter(mesh);
 
+        // newMesh will be empty until it is filtered
+        const autoPtr<fvMesh>& newMesh = meshFilter.filteredMesh();
 
-
-    // To mark master of collapes
-    globalIndex globalStrings(mesh.nPoints());
-
-
-    // Local collapse length. Any edge below this length gets (attempted)
-    // collapsed. Use either aa gradually decreasing value
-    // (so from minLen to e.g. 0.5*minLen) or a hard limit (GREAT)
-    scalarField minEdgeLen(mesh.nEdges(), minLen);
-    label nFrozenEdges = 0;
-
-
-
-    // Initial mesh check
-    // ~~~~~~~~~~~~~~~~~~
-    // Do not allow collapses in regions of error.
-    // Updates minEdgeLen, nFrozenEdges
-    if (checkQuality)
-    {
-        checkMeshAndFreezeEdges
-        (
-            mesh,
-            identity(mesh.nPoints()),
-            mesh,
-            minEdgeLen,
-            nFrozenEdges
-        );
-        Info<< "Initial frozen edges "
-            << returnReduce(nFrozenEdges, sumOp<label>())
-            << " out of " << returnReduce(mesh.nEdges(), sumOp<label>())
-            << endl;
-    }
-
-
-    // Mark points on boundary
-    const labelList boundaryPoint = findBoundaryPoints(mesh);
-
-    // Copy of current set of topology changes. Used to generate final mesh.
-    polyTopoChange savedMeshMod(mesh.boundaryMesh().size());
-
-    // Keep track of whether mesh has changed at all
-    bool meshChanged = false;
-
-
-
-    // Main loop
-    // ~~~~~~~~~
-    // It tries and do some collapses, checks the resulting mesh and
-    // 'freezes' some edges (by marking in minEdgeLen) and tries again.
-    // This will iterate ultimately to the situation where every edge is
-    // frozen and nothing gets collapsed.
-
-    do
-    {
-        // Per edge collapse status:
-        // -1 : not collapsed
-        //  0 : collapse to start
-        //  1 : collapse to end
-        labelList collapseEdge(mesh.nEdges(), -1);
-
-
-        // Work out which edges to collapse
-        // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-        // This is by looking at minEdgeLen (to avoid frozen edges)
-        // and marking in collapseEdge.
-
-        // Small edges
-        label nSmallCollapsed = collapseSmallEdges
-        (
-            mesh,
-            boundaryPoint,
-            minEdgeLen,
-            collapseEdge
-        );
-        reduce(nSmallCollapsed, sumOp<label>());
-
-        Info<< indent << "Collapsing " << nSmallCollapsed
-            << " small edges" << endl;
-
-
-        // Inline edges
-        label nMerged = mergeEdges
-        (
-            mesh,
-            maxCos,
-            boundaryPoint,
-            minEdgeLen,
-            collapseEdge
-        );
-
-        reduce(nMerged, sumOp<label>());
-        Info<< indent << "Collapsing " << nMerged << " in line edges"
-            << endl;
-
-
-        // Merge edge collapses into consistent collapse-network. Make sure
-        // no cells get collapsed.
-        List<pointEdgeCollapse> allPointInfo;
-        label nLocalCollapse = consistentCollapse
-        (
-            allowCellCollapse,
-            mesh,
-            globalStrings,
-            collapseEdge,
-            allPointInfo
-        );
-
-        reduce(nLocalCollapse, sumOp<label>());
-        Info<< "nLocalCollapse = " << nLocalCollapse << endl;
-
-        if (nLocalCollapse == 0)
+        // Filter small edges only. This reduces the number of faces so that
+        // the face filtering is sped up.
+        label nBadFaces = meshFilter.filterEdges(0);
         {
-            break;
+            polyTopoChange meshMod(newMesh);
+
+            meshMod.changeMesh(mesh, false);
         }
 
-
-        // There are collapses so mesh will get changed
-        meshChanged = true;
-
-
-        // Apply collapses to current mesh
-        polyTopoChange meshMod(mesh);
-
-        // Insert mesh refinement into polyTopoChange.
-        setRefinement(mesh, meshMod, allPointInfo);
-
-        // Do all changes
-        Info<< indent << "Applying changes to the mesh" << nl
-            //<< decrIndent
-            << endl;
-
-        savedMeshMod = meshMod;
-
-        autoPtr<fvMesh> newMeshPtr;
-        autoPtr<mapPolyMesh> mapPtr = meshMod.makeMesh
-        (
-            newMeshPtr,
-            IOobject
-            (
-                mesh.name(),
-                mesh.instance(),
-                mesh.time(),  // register with runTime
-                IOobject::NO_READ,
-                IOobject::NO_WRITE,
-                false
-            ),
-            mesh,
-            true        // parallel sync
-        );
-
-        fvMesh& newMesh = newMeshPtr();
-        const mapPolyMesh& map = mapPtr();
-
-        // Update fields
-        newMesh.updateMesh(map);
-        if (map.hasMotionPoints())
+        if (collapseFaces)
         {
-            newMesh.movePoints(map.preMotionPoints());
+            // Filter faces. Pass in the number of bad faces that are present
+            // from the previous edge filtering to use as a stopping criterion.
+            meshFilter.filter(nBadFaces);
+            {
+                polyTopoChange meshMod(newMesh);
+
+                meshMod.changeMesh(mesh, false);
+            }
         }
 
-
-
-
-        // If no checks needed exit.
-        if (!checkQuality)
-        {
-            break;
-        }
-
-        // Mesh check
-        // ~~~~~~~~~~~~~~~~~~
-        // Do not allow collapses in regions of error.
-        // Updates minEdgeLen, nFrozenEdges
-        label nOldFrozenEdges = returnReduce(nFrozenEdges, sumOp<label>());
-        checkMeshAndFreezeEdges
-        (
-            newMesh,
-            map.reversePointMap(),
-            mesh,
-            minEdgeLen,
-            nFrozenEdges
-        );
-        label nNewFrozenEdges = returnReduce(nFrozenEdges, sumOp<label>());
-
-        Info<< "Frozen edges "
-            << returnReduce(nFrozenEdges, sumOp<label>())
-            << " out of " << returnReduce(mesh.nEdges(), sumOp<label>())
-            << endl;
-
-        if (nNewFrozenEdges == nOldFrozenEdges)
-        {
-            break;
-        }
-
-    } while (true);
-
-
-    if (meshChanged)
-    {
-        // Apply changes to current mesh
-        autoPtr<mapPolyMesh> mapPtr = savedMeshMod.changeMesh(mesh, false);
-        const mapPolyMesh& map = mapPtr();
-
-        // Update fields
-        mesh.updateMesh(map);
-        if (map.hasMotionPoints())
-        {
-            mesh.movePoints(map.preMotionPoints());
-        }
-
-
         // Write resulting mesh
         if (!overwrite)
         {
@@ -1462,7 +133,6 @@ int main(int argc, char *argv[])
         mesh.write();
     }
 
-
     Info<< nl << "ExecutionTime = " << runTime.elapsedCpuTime() << " s"
         << "  ClockTime = " << runTime.elapsedClockTime() << " s"
         << nl << endl;
diff --git a/applications/utilities/mesh/advanced/modifyMesh/modifyMesh.C b/applications/utilities/mesh/advanced/modifyMesh/modifyMesh.C
index adb8bdcd5b..a7db08ba71 100644
--- a/applications/utilities/mesh/advanced/modifyMesh/modifyMesh.C
+++ b/applications/utilities/mesh/advanced/modifyMesh/modifyMesh.C
@@ -55,6 +55,7 @@ Description
 #include "edgeCollapser.H"
 #include "meshTools.H"
 #include "Pair.H"
+#include "globalIndex.H"
 
 using namespace Foam;
 
@@ -569,26 +570,47 @@ int main(int argc, char *argv[])
         // Mesh change engine
         edgeCollapser cutter(mesh);
 
-        pointField newPoints(mesh.points());
+        const edgeList& edges = mesh.edges();
+        const pointField& points = mesh.points();
+
+        pointField newPoints(points);
+
+        PackedBoolList collapseEdge(mesh.nEdges());
+        Map<point> collapsePointToLocation(mesh.nPoints());
 
         // Get new positions and construct collapse network
         forAllConstIter(Map<point>, edgeToPos, iter)
         {
             label edgeI = iter.key();
-            const edge& e = mesh.edges()[edgeI];
+            const edge& e = edges[edgeI];
+
+            collapseEdge[edgeI] = true;
+            collapsePointToLocation.set(e[1], points[e[0]]);
 
-            cutter.collapseEdge(edgeI, e[0]);
             newPoints[e[0]] = iter();
         }
 
         // Move master point to destination.
         mesh.movePoints(newPoints);
 
+        List<pointEdgeCollapse> allPointInfo;
+        const globalIndex globalPoints(mesh.nPoints());
+        labelList pointPriority(mesh.nPoints(), 0);
+
+        cutter.consistentCollapse
+        (
+            globalPoints,
+            pointPriority,
+            collapsePointToLocation,
+            collapseEdge,
+            allPointInfo
+        );
+
         // Topo change container
         polyTopoChange meshMod(mesh);
 
         // Insert
-        cutter.setRefinement(meshMod);
+        cutter.setRefinement(allPointInfo, meshMod);
 
         // Do changes
         autoPtr<mapPolyMesh> morphMap = meshMod.changeMesh(mesh, false);
diff --git a/applications/utilities/mesh/generation/cvMesh/Allwmake b/applications/utilities/mesh/generation/cvMesh/Allwmake
index eb453138ce..d88e8cee4a 100755
--- a/applications/utilities/mesh/generation/cvMesh/Allwmake
+++ b/applications/utilities/mesh/generation/cvMesh/Allwmake
@@ -4,7 +4,8 @@ set -x
 
 wmake libso conformalVoronoiMesh
 wmake
-wmake cvMeshBackgroundMesh
+#wmake cvMeshBackgroundMesh
 (cd cvMeshSurfaceSimplify && ./Allwmake)
+wmake cellSizeAndAlignmentGrid
 
 # ----------------------------------------------------------------- end-of-file
diff --git a/applications/utilities/mesh/generation/cvMesh/Make/options b/applications/utilities/mesh/generation/cvMesh/Make/options
index 27241b2965..9461fa3725 100644
--- a/applications/utilities/mesh/generation/cvMesh/Make/options
+++ b/applications/utilities/mesh/generation/cvMesh/Make/options
@@ -2,7 +2,7 @@ EXE_DEBUG = -DFULLDEBUG -g -O0
 EXE_FROUNDING_MATH = -frounding-math
 EXE_NDEBUG = -DNDEBUG
 
-CGAL_EXACT =
+CGAL_EXACT = /*-DCGAL_DONT_USE_LAZY_KERNEL*/
 CGAL_INEXACT = -DCGAL_INEXACT
 
 include $(GENERAL_RULES)/CGAL
@@ -19,7 +19,9 @@ EXE_INC = \
     -I$(LIB_SRC)/edgeMesh/lnInclude \
     -I$(LIB_SRC)/fileFormats/lnInclude \
     -I$(LIB_SRC)/dynamicMesh/lnInclude \
-    -I$(LIB_SRC)/triSurface/lnInclude
+    -I$(LIB_SRC)/triSurface/lnInclude \
+    -I$(LIB_SRC)/sampling/lnInclude \
+    -IvectorTools
 
 EXE_LIBS = \
     $(CGAL_LIBS) \
@@ -32,4 +34,5 @@ EXE_LIBS = \
     -ledgeMesh \
     -lfileFormats \
     -ltriSurface \
-    -ldynamicMesh
+    -ldynamicMesh \
+    -lsampling
diff --git a/applications/utilities/mesh/generation/cvMesh/cellSizeAndAlignmentGrid/Make/files b/applications/utilities/mesh/generation/cvMesh/cellSizeAndAlignmentGrid/Make/files
new file mode 100644
index 0000000000..83b77fdc77
--- /dev/null
+++ b/applications/utilities/mesh/generation/cvMesh/cellSizeAndAlignmentGrid/Make/files
@@ -0,0 +1,2 @@
+cellSizeAndAlignmentGrid.C
+EXE = $(FOAM_USER_APPBIN)/cellSizeAndAlignmentGrid
diff --git a/applications/utilities/mesh/generation/cvMesh/cellSizeAndAlignmentGrid/Make/options b/applications/utilities/mesh/generation/cvMesh/cellSizeAndAlignmentGrid/Make/options
new file mode 100644
index 0000000000..31d0d80858
--- /dev/null
+++ b/applications/utilities/mesh/generation/cvMesh/cellSizeAndAlignmentGrid/Make/options
@@ -0,0 +1,40 @@
+EXE_DEBUG = -DFULLDEBUG -g -O0
+EXE_FROUNDING_MATH = -frounding-math
+EXE_NDEBUG = -DNDEBUG
+
+CGAL_EXACT = /*-DCGAL_DONT_USE_LAZY_KERNEL*/
+CGAL_INEXACT = -DCGAL_INEXACT
+
+include $(GENERAL_RULES)/CGAL
+
+
+EXE_INC =  \
+    ${EXE_FROUNDING_MATH} \
+    ${EXE_NDEBUG} \
+    ${CGAL_INEXACT} \
+    ${CGAL_INC} \
+    -I$(LIB_SRC)/finiteVolume/lnInclude \
+    -I$(LIB_SRC)/dynamicMesh/lnInclude \
+    -I$(LIB_SRC)/triSurface/lnInclude \
+    -I$(LIB_SRC)/fileFormats/lnInclude \
+    -I$(LIB_SRC)/sampling/lnInclude \
+    -I$(LIB_SRC)/meshTools/lnInclude \
+    -I$(LIB_SRC)/parallel/decompose/decompositionMethods/lnInclude \
+    -I$(LIB_SRC)/edgeMesh/lnInclude \
+    -I$(HOME)/OpenFOAM/OpenFOAM-dev/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/lnInclude \
+    -I$(HOME)/OpenFOAM/OpenFOAM-dev/applications/utilities/mesh/generation/cvMesh/vectorTools
+
+EXE_LIBS =  \
+    $(CGAL_LIBS) \
+    -lmpfr \
+    -lboost_thread \
+    -lconformalVoronoiMesh \
+    -lfiniteVolume    \
+    -lmeshTools \
+    -ldecompositionMethods \
+    -L$(FOAM_LIBBIN)/dummy -lptscotchDecomp \
+    -ledgeMesh \
+    -ltriSurface \
+    -ldynamicMesh \
+    -lsampling \
+    -lfileFormats
diff --git a/applications/utilities/mesh/generation/cvMesh/cellSizeAndAlignmentGrid/cellSizeAndAlignmentGrid.C b/applications/utilities/mesh/generation/cvMesh/cellSizeAndAlignmentGrid/cellSizeAndAlignmentGrid.C
new file mode 100644
index 0000000000..27cc47f823
--- /dev/null
+++ b/applications/utilities/mesh/generation/cvMesh/cellSizeAndAlignmentGrid/cellSizeAndAlignmentGrid.C
@@ -0,0 +1,711 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 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/>.
+
+Application
+    Test-distributedDelaunayMesh
+
+Description
+
+\*---------------------------------------------------------------------------*/
+
+#include "CGALTriangulation3DKernel.H"
+
+#include "indexedVertex.H"
+#include "indexedCell.H"
+
+#include "argList.H"
+#include "Time.H"
+#include "DistributedDelaunayMesh.H"
+#include "backgroundMeshDecomposition.H"
+#include "searchableSurfaces.H"
+#include "conformationSurfaces.H"
+#include "PrintTable.H"
+#include "Random.H"
+#include "boundBox.H"
+#include "point.H"
+#include "cellShapeControlMesh.H"
+#include "triadField.H"
+#include "scalarIOField.H"
+#include "pointIOField.H"
+#include "triadIOField.H"
+
+using namespace Foam;
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+// Main program:
+
+template <class Triangulation, class Type>
+Foam::tmp<Foam::Field<Type> > filterFarPoints
+(
+    const Triangulation& mesh,
+    const Field<Type>& field
+)
+{
+    tmp<Field<Type> > tNewField(new Field<Type>(field.size()));
+    Field<Type>& newField = tNewField();
+
+    label added = 0;
+    label count = 0;
+
+    for
+    (
+        typename Triangulation::Finite_vertices_iterator vit =
+            mesh.finite_vertices_begin();
+        vit != mesh.finite_vertices_end();
+        ++vit
+    )
+    {
+        if (vit->real())
+        {
+            newField[added++] = field[count];
+        }
+
+        count++;
+    }
+
+    newField.resize(added);
+
+    return tNewField;
+}
+
+
+template <class T>
+autoPtr<mapDistribute> buildMap
+(
+    const T& mesh,
+    labelListList& pointPoints
+)
+{
+    pointPoints.setSize(mesh.vertexCount());
+
+    globalIndex globalIndexing(mesh.vertexCount());
+
+    for
+    (
+        typename T::Finite_vertices_iterator vit = mesh.finite_vertices_begin();
+        vit != mesh.finite_vertices_end();
+        ++vit
+    )
+    {
+        if (!vit->real())
+        {
+            continue;
+        }
+
+        std::list<typename T::Vertex_handle> adjVerts;
+        mesh.finite_adjacent_vertices(vit, std::back_inserter(adjVerts));
+
+        DynamicList<label> indices(adjVerts.size());
+
+        for
+        (
+            typename std::list<typename T::Vertex_handle>::const_iterator
+                adjVertI = adjVerts.begin();
+            adjVertI != adjVerts.end();
+            ++adjVertI
+        )
+        {
+            typename T::Vertex_handle vh = *adjVertI;
+
+            if (!vh->farPoint())
+            {
+                indices.append
+                (
+                    globalIndexing.toGlobal(vh->procIndex(), vh->index())
+                );
+            }
+        }
+
+        pointPoints[vit->index()].transfer(indices);
+    }
+
+    List<Map<label> > compactMap;
+
+    return autoPtr<mapDistribute>
+    (
+        new mapDistribute
+        (
+            globalIndexing,
+            pointPoints,
+            compactMap
+        )
+    );
+}
+
+
+template <class T>
+Foam::tmp<Foam::triadField> buildAlignmentField(const T& mesh)
+{
+    tmp<triadField> tAlignments
+    (
+        new triadField(mesh.vertexCount(), triad::unset)
+    );
+    triadField& alignments = tAlignments();
+
+    for
+    (
+        typename T::Finite_vertices_iterator vit = mesh.finite_vertices_begin();
+        vit != mesh.finite_vertices_end();
+        ++vit
+    )
+    {
+        if (!vit->real())
+        {
+            continue;
+        }
+
+        alignments[vit->index()] = triad
+        (
+            vit->alignment().x(),
+            vit->alignment().y(),
+            vit->alignment().z()
+        );
+    }
+
+    return tAlignments;
+}
+
+
+template <class T>
+Foam::tmp<Foam::pointField> buildPointField(const T& mesh)
+{
+    tmp<pointField> tPoints
+    (
+        new pointField(mesh.vertexCount(), point(GREAT, GREAT, GREAT))
+    );
+    pointField& points = tPoints();
+
+    for
+    (
+        typename T::Finite_vertices_iterator vit = mesh.finite_vertices_begin();
+        vit != mesh.finite_vertices_end();
+        ++vit
+    )
+    {
+        if (!vit->real())
+        {
+            continue;
+        }
+
+        points[vit->index()] = topoint(vit->point());
+    }
+
+    return tPoints;
+}
+
+
+int main(int argc, char *argv[])
+{
+    #include "setRootCase.H"
+    #include "createTime.H"
+
+    // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+    label maxRefinementIterations = 0;
+    label maxSmoothingIterations = 200;
+    scalar minResidual = 0;
+    scalar defaultCellSize = 0.0004;
+    scalar nearFeatDistSqrCoeff = 1e-8;
+
+
+    // Need to decouple vertex and cell type from this class?
+    // Vertex must have:
+    // + index
+    // + procIndex
+    // - type should be optional
+    cellShapeControlMesh mesh(runTime);
+
+    IOdictionary cvMeshDict
+    (
+        IOobject
+        (
+            "cvMeshDict",
+            runTime.system(),
+            runTime,
+            IOobject::MUST_READ,
+            IOobject::NO_WRITE
+        )
+    );
+
+    Random rndGen(64293*Pstream::myProcNo());
+
+    searchableSurfaces allGeometry
+    (
+        IOobject
+        (
+            "cvSearchableSurfaces",
+            runTime.constant(),
+            "triSurface",
+            runTime,
+            IOobject::MUST_READ,
+            IOobject::NO_WRITE
+        ),
+        cvMeshDict.subDict("geometry")
+    );
+
+    conformationSurfaces geometryToConformTo
+    (
+        runTime,
+        rndGen,
+        allGeometry,
+        cvMeshDict.subDict("surfaceConformation")
+    );
+
+    autoPtr<backgroundMeshDecomposition> bMesh;
+    if (Pstream::parRun())
+    {
+        bMesh.set
+        (
+            new backgroundMeshDecomposition
+            (
+                runTime,
+                rndGen,
+                geometryToConformTo,
+                cvMeshDict.subDict("backgroundMeshDecomposition")
+            )
+        );
+    }
+
+    // Nice to have IO for the delaunay mesh
+    // IO depend on vertex type.
+    //
+    // Define a delaunay mesh as:
+    // + list of points of the triangulation
+    // + optionally a list of cells
+
+    Info<< nl << "Loop over surfaces" << endl;
+
+    forAll(geometryToConformTo.surfaces(), sI)
+    {
+        const label surfI = geometryToConformTo.surfaces()[sI];
+
+        const searchableSurface& surface =
+            geometryToConformTo.geometry()[surfI];
+
+        Info<< nl << "Inserting points from surface " << surface.name()
+            << " (" << surface.type() << ")" << endl;
+
+        const tmp<pointField> tpoints = surface.points();
+        const pointField& points = tpoints();
+
+        Info<< "    Number of points = " << points.size() << endl;
+
+        forAll(points, pI)
+        {
+            // Is the point in the extendedFeatureEdgeMesh? If so get the
+            // point normal, otherwise get the surface normal from
+            // searchableSurface
+
+            pointIndexHit info;
+            label infoFeature;
+            geometryToConformTo.findFeaturePointNearest
+            (
+                points[pI],
+                nearFeatDistSqrCoeff,
+                info,
+                infoFeature
+            );
+
+
+            autoPtr<triad> pointAlignment;
+
+            if (info.hit())
+            {
+                const extendedFeatureEdgeMesh& features =
+                    geometryToConformTo.features()[infoFeature];
+
+                vectorField norms = features.featurePointNormals(info.index());
+
+                // Create a triad from these norms.
+                pointAlignment.set(new triad());
+                forAll(norms, nI)
+                {
+                    pointAlignment() += norms[nI];
+                }
+
+                pointAlignment().normalize();
+                pointAlignment().orthogonalize();
+            }
+            else
+            {
+                geometryToConformTo.findEdgeNearest
+                (
+                    points[pI],
+                    nearFeatDistSqrCoeff,
+                    info,
+                    infoFeature
+                );
+
+                if (info.hit())
+                {
+                    const extendedFeatureEdgeMesh& features =
+                        geometryToConformTo.features()[infoFeature];
+
+                    vectorField norms = features.edgeNormals(info.index());
+
+                    // Create a triad from these norms.
+                    pointAlignment.set(new triad());
+                    forAll(norms, nI)
+                    {
+                        pointAlignment() += norms[nI];
+                    }
+
+                    pointAlignment().normalize();
+                    pointAlignment().orthogonalize();
+                }
+                else
+                {
+                    pointField ptField(1, points[pI]);
+                    scalarField distField(1, nearFeatDistSqrCoeff);
+                    List<pointIndexHit> infoList(1, pointIndexHit());
+
+                    surface.findNearest(ptField, distField, infoList);
+
+                    vectorField normals(1);
+                    surface.getNormal(infoList, normals);
+
+                    pointAlignment.set(new triad(normals[0]));
+                }
+            }
+
+            if (Pstream::parRun())
+            {
+                if (bMesh().positionOnThisProcessor(points[pI]))
+                {
+                    CellSizeDelaunay::Vertex_handle vh = mesh.insert
+                    (
+                        points[pI],
+                        defaultCellSize,
+                        pointAlignment()
+                    );
+                }
+            }
+            else
+            {
+                CellSizeDelaunay::Vertex_handle vh = mesh.insert
+                (
+                    points[pI],
+                    defaultCellSize,
+                    pointAlignment()
+                );
+            }
+        }
+    }
+
+
+    for (label iter = 0; iter < maxRefinementIterations; ++iter)
+    {
+        DynamicList<point> ptsToInsert;
+
+        for
+        (
+            CellSizeDelaunay::Finite_cells_iterator cit =
+                mesh.finite_cells_begin();
+            cit != mesh.finite_cells_end();
+            ++cit
+        )
+        {
+            const point newPoint =
+                topoint
+                (
+                    CGAL::centroid
+                    (
+                        cit->vertex(0)->point(),
+                        cit->vertex(1)->point(),
+                        cit->vertex(2)->point(),
+                        cit->vertex(3)->point()
+                    )
+                );
+
+            if (geometryToConformTo.inside(newPoint))
+            {
+                ptsToInsert.append(newPoint);
+            }
+        }
+
+        Info<< "    Adding " << returnReduce(ptsToInsert.size(), sumOp<label>())
+            << endl;
+
+        forAll(ptsToInsert, ptI)
+        {
+            mesh.insert
+            (
+                ptsToInsert[ptI],
+                defaultCellSize,
+                triad::unset
+            );
+        }
+    }
+
+
+    if (Pstream::parRun())
+    {
+        mesh.distribute(bMesh);
+    }
+
+    labelListList pointPoints;
+    autoPtr<mapDistribute> meshDistributor = buildMap(mesh, pointPoints);
+
+    triadField alignments = buildAlignmentField(mesh);
+    pointField points = buildPointField(mesh);
+
+    mesh.printInfo(Info);
+
+
+    // Setup the sizes and alignments on each point
+    triadField fixedAlignments(mesh.vertexCount(), triad::unset);
+
+    for
+    (
+        CellSizeDelaunay::Finite_vertices_iterator vit =
+            mesh.finite_vertices_begin();
+        vit != mesh.finite_vertices_end();
+        ++vit
+    )
+    {
+        if (vit->real())
+        {
+            const tensor& alignment = vit->alignment();
+
+            fixedAlignments[vit->index()] = triad
+            (
+                alignment.x(),
+                alignment.y(),
+                alignment.z()
+            );
+        }
+    }
+
+
+    Info<< nl << "Smoothing alignments" << endl;
+
+    for (label iter = 0; iter < maxSmoothingIterations; iter++)
+    {
+        Info<< "Iteration " << iter;
+
+        meshDistributor().distribute(points);
+        meshDistributor().distribute(alignments);
+
+        scalar residual = 0;
+
+        triadField triadAv(alignments.size(), triad::unset);
+
+        forAll(pointPoints, pI)
+        {
+            const labelList& pPoints = pointPoints[pI];
+
+            if (pPoints.empty())
+            {
+                continue;
+            }
+
+            const triad& oldTriad = alignments[pI];
+            triad& newTriad = triadAv[pI];
+
+            forAll(pPoints, adjPointI)
+            {
+                const label adjPointIndex = pPoints[adjPointI];
+
+                scalar dist = mag(points[pI] - points[adjPointIndex]);
+
+                dist = max(dist, SMALL);
+
+                triad tmpTriad = alignments[adjPointIndex];
+
+                for (direction dir = 0; dir < 3; dir++)
+                {
+                    if (tmpTriad.set(dir))
+                    {
+                        tmpTriad[dir] *= (1.0/dist);
+                    }
+                }
+
+                newTriad += tmpTriad;
+            }
+
+            newTriad.normalize();
+            newTriad.orthogonalize();
+            newTriad = newTriad.sortxyz();
+
+            // Enforce the boundary conditions
+            const triad& fixedAlignment = fixedAlignments[pI];
+
+            label nFixed = 0;
+
+            forAll(fixedAlignment, dirI)
+            {
+                if (fixedAlignment[dirI] != triad::unset[dirI])
+                {
+                    nFixed++;
+                }
+            }
+
+            if (nFixed == 1)
+            {
+                forAll(fixedAlignment, dirI)
+                {
+                    if (fixedAlignment.set(dirI))
+                    {
+                        newTriad.align(fixedAlignment[dirI]);
+                    }
+                }
+            }
+            else if (nFixed == 2)
+            {
+                forAll(fixedAlignment, dirI)
+                {
+                    if (fixedAlignment.set(dirI))
+                    {
+                        newTriad[dirI] = fixedAlignment[dirI];
+                    }
+                    else
+                    {
+                        newTriad[dirI] = triad::unset[dirI];
+                    }
+                }
+
+                newTriad.orthogonalize();
+            }
+            else if (nFixed == 3)
+            {
+                forAll(fixedAlignment, dirI)
+                {
+                    if (fixedAlignment.set(dirI))
+                    {
+                        newTriad[dirI] = fixedAlignment[dirI];
+                    }
+                }
+            }
+
+            if (newTriad.set(vector::X) && oldTriad.set(vector::X))
+            {
+                scalar dotProd = (oldTriad.x() & newTriad.x());
+
+                scalar diff = mag(dotProd) - 1.0;
+                residual += mag(diff);
+            }
+            if (newTriad.set(vector::Y) && oldTriad.set(vector::Y))
+            {
+                scalar dotProd = (oldTriad.y() & newTriad.y());
+
+                scalar diff = mag(dotProd) - 1.0;
+                residual += mag(diff);
+            }
+            if (newTriad.set(vector::Z) && oldTriad.set(vector::Z))
+            {
+                scalar dotProd = (oldTriad.z() & newTriad.z());
+
+                scalar diff = mag(dotProd) - 1.0;
+                residual += mag(diff);
+            }
+        }
+
+        forAll(alignments, pI)
+        {
+            alignments[pI] = triadAv[pI].sortxyz();
+        }
+
+        reduce(residual, sumOp<scalar>());
+
+        Info<< ", Residual = " << residual << endl;
+
+        if (residual <= minResidual)
+        {
+            break;
+        }
+    }
+
+
+    // Write alignments to a .obj file
+    OFstream str(runTime.path()/"alignments.obj");
+
+    forAll(alignments, pI)
+    {
+        const triad& tri = alignments[pI];
+
+        if (tri.set())
+        {
+            forAll(tri, dirI)
+            {
+                meshTools::writeOBJ(str, points[pI], tri[dirI] + points[pI]);
+            }
+        }
+    }
+
+
+    // Remove the far points
+    pointIOField pointsIO
+    (
+        IOobject
+        (
+            "points",
+            runTime.constant(),
+            runTime,
+            IOobject::NO_READ,
+            IOobject::AUTO_WRITE
+        ),
+        filterFarPoints(mesh, points)
+    );
+
+    scalarField sizes(points.size(), defaultCellSize);
+    scalarIOField sizesIO
+    (
+        IOobject
+        (
+            "sizes",
+            runTime.constant(),
+            runTime,
+            IOobject::NO_READ,
+            IOobject::AUTO_WRITE
+        ),
+        filterFarPoints(mesh, sizes)
+    );
+
+    triadIOField alignmentsIO
+    (
+        IOobject
+        (
+            "alignments",
+            runTime.constant(),
+            runTime,
+            IOobject::NO_READ,
+            IOobject::AUTO_WRITE
+        ),
+        filterFarPoints(mesh, alignments)
+    );
+
+    pointsIO.write();
+    sizesIO.write();
+    alignmentsIO.write();
+
+    Info<< nl << "ExecutionTime = " << runTime.elapsedCpuTime() << " s"
+        << "  ClockTime = " << runTime.elapsedClockTime() << " s"
+        << nl << endl;
+
+    Info<< "\nEnd\n" << endl;
+
+    return 0;
+}
+
+
+// ************************************************************************* //
diff --git a/applications/utilities/mesh/generation/cvMesh/changesLaurence b/applications/utilities/mesh/generation/cvMesh/changesLaurence
deleted file mode 100644
index 5f55eff462..0000000000
--- a/applications/utilities/mesh/generation/cvMesh/changesLaurence
+++ /dev/null
@@ -1,5 +0,0 @@
-wmake/rules/General/CGAL
-
-    -lboost_thread
-    -lboost_thread-mt
-
diff --git a/applications/utilities/mesh/generation/cvMesh/checkCvMesh/meshQualityDict b/applications/utilities/mesh/generation/cvMesh/checkCvMesh/meshQualityDict
new file mode 100644
index 0000000000..fa5319e087
--- /dev/null
+++ b/applications/utilities/mesh/generation/cvMesh/checkCvMesh/meshQualityDict
@@ -0,0 +1,73 @@
+/*--------------------------------*- 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;
+
+    root            "";
+    case            "";
+    instance        "";
+    local           "";
+
+    class           dictionary;
+    object          meshQualityDict;
+}
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+//- Maximum non-orthogonality allowed. Set to 180 to disable.
+maxNonOrtho         65;
+
+//- Max skewness allowed. Set to <0 to disable.
+maxBoundarySkewness 50;
+maxInternalSkewness 10;
+
+//- Max concaveness allowed. Is angle (in degrees) below which concavity
+//  is allowed. 0 is straight face, <0 would be convex face.
+//  Set to 180 to disable.
+maxConcave          80;
+
+//- Minimum quality of the tet formed by the face-centre
+//  and variable base point minimum decomposition triangles and
+//  the cell centre. This has to be a positive number for tracking
+//  to work. Set to very negative number (e.g. -1E30) to
+//  disable.
+//     <0 = inside out tet,
+//      0 = flat tet
+//      1 = regular tet
+minTetQuality       1e-30;
+
+//- Minimum pyramid volume. Is absolute volume of cell pyramid.
+//  Set to a sensible fraction of the smallest cell volume expected.
+//  Set to very negative number (e.g. -1E30) to disable.
+minVol              1e-20;
+
+//- Minimum face area. Set to <0 to disable.
+minArea             -1;
+
+//- Minimum face twist. Set to <-1 to disable. dot product of face normal
+//- and face centre triangles normal
+minTwist            0.001;
+
+//- minimum normalised cell determinant
+//- 1 = hex, <= 0 = folded or flattened illegal cell
+minDeterminant      0.001;
+
+//- minFaceWeight (0 -> 0.5)
+minFaceWeight       0.02;
+
+//- minVolRatio (0 -> 1)
+minVolRatio         0.01;
+
+//must be >0 for Fluent compatibility
+minTriangleTwist    -1;
+
+
+// ************************************************************************* //
diff --git a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/DelaunayMesh/DelaunayMesh.C b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/DelaunayMesh/DelaunayMesh.C
new file mode 100644
index 0000000000..a0327ce04f
--- /dev/null
+++ b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/DelaunayMesh/DelaunayMesh.C
@@ -0,0 +1,233 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "DelaunayMesh.H"
+#include "labelPair.H"
+#include "PrintTable.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * Static Member Functions * * * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+template<class Triangulation>
+Foam::DelaunayMesh<Triangulation>::DelaunayMesh()
+:
+    Triangulation(),
+    vertexCount_(0),
+    cellCount_(0)
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+template<class Triangulation>
+Foam::DelaunayMesh<Triangulation>::~DelaunayMesh()
+{}
+
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
+
+template<class Triangulation>
+void Foam::DelaunayMesh<Triangulation>::reset()
+{
+    Info<< "Clearing triangulation" << endl;
+
+    this->clear();
+
+    resetVertexCount();
+    resetCellCount();
+}
+
+
+template<class Triangulation>
+void Foam::DelaunayMesh<Triangulation>::insertPoints(const List<Vb>& vertices)
+{
+    rangeInsertWithInfo
+    (
+        vertices.begin(),
+        vertices.end(),
+        true
+    );
+}
+
+
+template<class Triangulation>
+bool Foam::DelaunayMesh<Triangulation>::Traits_for_spatial_sort::Less_x_3::
+operator()
+(
+    const Point_3& p,
+    const Point_3& q
+) const
+{
+    return typename Gt::Less_x_3()(*(p.first), *(q.first));
+}
+
+template<class Triangulation>
+bool Foam::DelaunayMesh<Triangulation>::Traits_for_spatial_sort::Less_y_3::
+operator()
+(
+    const Point_3& p,
+    const Point_3& q
+) const
+{
+    return typename Gt::Less_y_3()(*(p.first), *(q.first));
+}
+
+template<class Triangulation>
+bool Foam::DelaunayMesh<Triangulation>::Traits_for_spatial_sort::Less_z_3::
+operator()
+(
+    const Point_3& p,
+    const Point_3& q
+) const
+{
+    return typename Gt::Less_z_3()(*(p.first), *(q.first));
+}
+
+template<class Triangulation>
+typename Foam::DelaunayMesh<Triangulation>::Traits_for_spatial_sort::Less_x_3
+Foam::DelaunayMesh<Triangulation>::Traits_for_spatial_sort::less_x_3_object()
+const
+{
+    return Less_x_3();
+}
+
+template<class Triangulation>
+typename Foam::DelaunayMesh<Triangulation>::Traits_for_spatial_sort::Less_y_3
+Foam::DelaunayMesh<Triangulation>::Traits_for_spatial_sort::less_y_3_object()
+const
+{
+    return Less_y_3();
+}
+
+template<class Triangulation>
+typename Foam::DelaunayMesh<Triangulation>::Traits_for_spatial_sort::Less_z_3
+Foam::DelaunayMesh<Triangulation>::Traits_for_spatial_sort::less_z_3_object()
+const
+{
+    return Less_z_3();
+}
+
+
+template<class Triangulation>
+template<class PointIterator>
+void Foam::DelaunayMesh<Triangulation>::rangeInsertWithInfo
+(
+    PointIterator begin,
+    PointIterator end,
+    bool printErrors
+)
+{
+    typedef DynamicList
+    <
+        std::pair
+        <
+            const typename Triangulation::Point*,
+            label
+        >
+    > vectorPairPointIndex;
+
+    vectorPairPointIndex points;
+
+    label count = 0;
+    for (PointIterator it = begin; it != end; ++it)
+    {
+        points.append
+        (
+            std::make_pair(&(it->point()), count++)
+        );
+    }
+
+    std::random_shuffle(points.begin(), points.end());
+
+    spatial_sort
+    (
+        points.begin(),
+        points.end(),
+        Traits_for_spatial_sort()
+    );
+
+    Vertex_handle hint;
+
+    for
+    (
+        typename vectorPairPointIndex::const_iterator p = points.begin();
+        p != points.end();
+        ++p
+    )
+    {
+        const size_t checkInsertion = Triangulation::number_of_vertices();
+
+        hint = this->insert(*(p->first), hint);
+
+        const Vb& vert = *(begin + p->second);
+
+        if (checkInsertion != Triangulation::number_of_vertices() - 1)
+        {
+            if (printErrors)
+            {
+                Vertex_handle nearV =
+                    Triangulation::nearest_vertex(*(p->first));
+
+                Pout<< "Failed insertion : " << vert.info()
+                    << "         nearest : " << nearV->info();
+            }
+        }
+        else
+        {
+            hint->index() = getNewVertexIndex();
+            hint->type() = vert.type();
+            hint->procIndex() = vert.procIndex();
+            hint->targetCellSize() = vert.targetCellSize();
+            hint->alignment() = vert.alignment();
+        }
+    }
+}
+
+
+// * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * Friend Functions  * * * * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * Friend Operators * * * * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#include "DelaunayMeshIO.C"
+
+// ************************************************************************* //
diff --git a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/DelaunayMesh/DelaunayMesh.H b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/DelaunayMesh/DelaunayMesh.H
new file mode 100644
index 0000000000..bdeee880e7
--- /dev/null
+++ b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/DelaunayMesh/DelaunayMesh.H
@@ -0,0 +1,238 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 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::DelaunayMesh
+
+Description
+    The vertex and cell classes must have an index defined
+
+SourceFiles
+    DelaunayMeshI.H
+    DelaunayMesh.C
+    DelaunayMeshIO.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef DelaunayMesh_H
+#define DelaunayMesh_H
+
+#include "Pair.H"
+#include "HashSet.H"
+#include "FixedList.H"
+#include "boundBox.H"
+#include "indexedVertex.H"
+#include "CGALTriangulation3Ddefs.H"
+#include "autoPtr.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+class fvMesh;
+
+/*---------------------------------------------------------------------------*\
+                        Class DelaunayMesh Declaration
+\*---------------------------------------------------------------------------*/
+
+template<class Triangulation>
+class DelaunayMesh
+:
+    public Triangulation
+{
+public:
+
+        typedef typename Triangulation::Cell_handle Cell_handle;
+        typedef typename Triangulation::Vertex_handle Vertex_handle;
+        typedef typename Triangulation::Point Point;
+        typedef typename Triangulation::Facet Facet;
+
+        typedef typename Triangulation::Finite_vertices_iterator
+            Finite_vertices_iterator;
+        typedef typename Triangulation::Finite_cells_iterator
+            Finite_cells_iterator;
+        typedef typename Triangulation::Finite_facets_iterator
+            Finite_facets_iterator;
+
+        typedef HashSet
+        <
+           Pair<label>,
+           FixedList<label, 2>::Hash<>
+        > labelPairHashSet;
+
+
+private:
+
+    // Private data
+
+        //- Keep track of the number of vertices that have been added.
+        //  This allows a unique index to be assigned to each vertex.
+        mutable label vertexCount_;
+
+        //- Keep track of the number of cells that have been added.
+        //  This allows a unique index to be assigned to each cell.
+        mutable label cellCount_;
+
+        //- Spatial sort traits to use with a pair of point pointers and an int.
+        //  Taken from a post on the CGAL lists: 2010-01/msg00004.html by
+        //  Sebastien Loriot (Geometry Factory).
+        struct Traits_for_spatial_sort
+        :
+            public Triangulation::Geom_traits
+        {
+            typedef typename Triangulation::Geom_traits Gt;
+
+            typedef std::pair<const typename Triangulation::Point*, int>
+                Point_3;
+
+            struct Less_x_3
+            {
+                bool operator()(const Point_3& p, const Point_3& q) const;
+            };
+
+            struct Less_y_3
+            {
+                bool operator()(const Point_3& p, const Point_3& q) const;
+            };
+
+            struct Less_z_3
+            {
+                bool operator()(const Point_3& p, const Point_3& q) const;
+            };
+
+            Less_x_3 less_x_3_object() const;
+            Less_y_3 less_y_3_object() const;
+            Less_z_3 less_z_3_object() const;
+        };
+
+
+    // Private Member Functions
+
+        void sortFaces
+        (
+            faceList& faces,
+            labelList& owner,
+            labelList& neighbour
+        ) const;
+
+        void addPatches
+        (
+            const label nInternalFaces,
+            faceList& faces,
+            labelList& owner,
+            labelList& patchSizes,
+            labelList& patchStarts,
+            const List<DynamicList<face> >& patchFaces,
+            const List<DynamicList<label> >& patchOwners
+        ) const;
+
+        //- Disallow default bitwise copy construct
+        DelaunayMesh(const DelaunayMesh<Triangulation>&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const DelaunayMesh<Triangulation>&);
+
+
+public:
+
+    // Constructors
+
+        //- Construct from components
+        DelaunayMesh();
+
+
+    //- Destructor
+    ~DelaunayMesh();
+
+
+    // Member Functions
+
+        inline label getNewVertexIndex() const;
+
+        inline label getNewCellIndex() const;
+
+        inline label cellCount() const;
+
+        inline void resetCellCount();
+
+        inline label vertexCount() const;
+
+        inline void resetVertexCount();
+
+
+        //- Remove the entire triangulation
+        void reset();
+
+        void insertPoints(const List<Vb>& vertices);
+
+        //- Function inserting points into a triangulation and setting the
+        //  index and type data of the point in the correct order. This is
+        //  faster than inserting points individually.
+        //
+        //  Adapted from a post on the CGAL lists: 2010-01/msg00004.html by
+        //  Sebastien Loriot (Geometry Factory).
+        template<class PointIterator>
+        void rangeInsertWithInfo
+        (
+            PointIterator begin,
+            PointIterator end,
+            bool printErrors = true
+        );
+
+
+    // Queries
+
+        void printInfo(Ostream& os) const;
+
+        //- Create an fvMesh from the triangulation.
+        //  The mesh is not parallel consistent - only used for viewing
+        autoPtr<fvMesh> createMesh
+        (
+            const fileName& name,
+            const Time& runTime,
+            labelList& vertexMap,
+            labelList& cellMap
+        ) const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#include "DelaunayMeshI.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+#   include "DelaunayMesh.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/DelaunayMesh/DelaunayMeshI.H b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/DelaunayMesh/DelaunayMeshI.H
new file mode 100644
index 0000000000..841e5c9024
--- /dev/null
+++ b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/DelaunayMesh/DelaunayMeshI.H
@@ -0,0 +1,119 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * * * Destructors * * * * * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+template<class Triangulation>
+inline Foam::label Foam::DelaunayMesh<Triangulation>::getNewVertexIndex() const
+{
+    label id = vertexCount_++;
+
+    if (id == labelMax)
+    {
+        WarningIn
+        (
+            "Foam::DelaunayMesh<Triangulation>::getNewVertexIndex() const"
+        )   << "Vertex counter has overflowed." << endl;
+    }
+
+    return id;
+}
+
+
+template<class Triangulation>
+inline Foam::label Foam::DelaunayMesh<Triangulation>::getNewCellIndex() const
+{
+    label id = cellCount_++;
+
+    if (id == labelMax)
+    {
+        WarningIn
+        (
+            "Foam::DelaunayMesh<Triangulation>::getNewCellIndex() const"
+        )   << "Cell counter has overflowed." << endl;
+    }
+
+    return id;
+}
+
+
+template<class Triangulation>
+Foam::label Foam::DelaunayMesh<Triangulation>::cellCount() const
+{
+    return cellCount_;
+}
+
+
+template<class Triangulation>
+void Foam::DelaunayMesh<Triangulation>::resetCellCount()
+{
+    cellCount_ = 0;
+}
+
+
+template<class Triangulation>
+Foam::label Foam::DelaunayMesh<Triangulation>::vertexCount() const
+{
+    return vertexCount_;
+}
+
+
+template<class Triangulation>
+void Foam::DelaunayMesh<Triangulation>::resetVertexCount()
+{
+    vertexCount_ = 0;
+}
+
+
+// * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * * Friend Functions  * * * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * * Friend Operators  * * * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * IOstream Operators  * * * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * * Ostream Operator  * * * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+
+// ************************************************************************* //
diff --git a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/DelaunayMesh/DelaunayMeshIO.C b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/DelaunayMesh/DelaunayMeshIO.C
new file mode 100644
index 0000000000..63a9889308
--- /dev/null
+++ b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/DelaunayMesh/DelaunayMeshIO.C
@@ -0,0 +1,391 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "DelaunayMesh.H"
+#include "fvMesh.H"
+#include "pointConversion.H"
+#include "wallPolyPatch.H"
+#include "processorPolyPatch.H"
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+template<class Triangulation>
+void Foam::DelaunayMesh<Triangulation>::sortFaces
+(
+    faceList& faces,
+    labelList& owner,
+    labelList& neighbour
+) const
+{
+    // Upper triangular order:
+    // + owner is sorted in ascending cell order
+    // + within each block of equal value for owner, neighbour is sorted in
+    //   ascending cell order.
+    // + faces sorted to correspond
+    // e.g.
+    // owner | neighbour
+    // 0     | 2
+    // 0     | 23
+    // 0     | 71
+    // 1     | 23
+    // 1     | 24
+    // 1     | 91
+
+    List<labelPair> ownerNeighbourPair(owner.size());
+
+    forAll(ownerNeighbourPair, oNI)
+    {
+        ownerNeighbourPair[oNI] = labelPair(owner[oNI], neighbour[oNI]);
+    }
+
+    Info<< nl
+        << "Sorting faces, owner and neighbour into upper triangular order"
+        << endl;
+
+    labelList oldToNew;
+
+    sortedOrder(ownerNeighbourPair, oldToNew);
+
+    oldToNew = invert(oldToNew.size(), oldToNew);
+
+    inplaceReorder(oldToNew, faces);
+    inplaceReorder(oldToNew, owner);
+    inplaceReorder(oldToNew, neighbour);
+}
+
+
+template<class Triangulation>
+void Foam::DelaunayMesh<Triangulation>::addPatches
+(
+    const label nInternalFaces,
+    faceList& faces,
+    labelList& owner,
+    labelList& patchSizes,
+    labelList& patchStarts,
+    const List<DynamicList<face> >& patchFaces,
+    const List<DynamicList<label> >& patchOwners
+) const
+{
+    label nPatches = patchFaces.size();
+
+    patchSizes.setSize(nPatches, -1);
+    patchStarts.setSize(nPatches, -1);
+
+    label nBoundaryFaces = 0;
+
+    forAll(patchFaces, p)
+    {
+        patchSizes[p] = patchFaces[p].size();
+        patchStarts[p] = nInternalFaces + nBoundaryFaces;
+
+        nBoundaryFaces += patchSizes[p];
+    }
+
+    faces.setSize(nInternalFaces + nBoundaryFaces);
+    owner.setSize(nInternalFaces + nBoundaryFaces);
+
+    label faceI = nInternalFaces;
+
+    forAll(patchFaces, p)
+    {
+        forAll(patchFaces[p], f)
+        {
+            faces[faceI] = patchFaces[p][f];
+            owner[faceI] = patchOwners[p][f];
+
+            faceI++;
+        }
+    }
+}
+
+
+// * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * * //
+
+template<class Triangulation>
+void Foam::DelaunayMesh<Triangulation>::printInfo(Ostream& os) const
+{
+    PrintTable<word, label> triInfoTable("Mesh Statistics");
+
+    triInfoTable.add("Points", Triangulation::number_of_vertices());
+    triInfoTable.add("Edges", Triangulation::number_of_finite_edges());
+    triInfoTable.add("Faces", Triangulation::number_of_finite_facets());
+    triInfoTable.add("Cells", Triangulation::number_of_finite_cells());
+
+    scalar minSize = GREAT;
+    scalar maxSize = 0;
+
+    for
+    (
+        Finite_vertices_iterator vit = Triangulation::finite_vertices_begin();
+        vit != Triangulation::finite_vertices_end();
+        ++vit
+    )
+    {
+        if (!vit->farPoint())
+        {
+            minSize = min(vit->targetCellSize(), minSize);
+            maxSize = max(vit->targetCellSize(), maxSize);
+        }
+    }
+
+    Info<< incrIndent;
+    triInfoTable.print(Info, true, true);
+
+    Info<< "Size (Min/Max) = "
+        << returnReduce(minSize, minOp<scalar>()) << " "
+        << returnReduce(maxSize, maxOp<scalar>()) << endl;
+
+    Info<< decrIndent;
+}
+
+
+template<class Triangulation>
+Foam::autoPtr<Foam::fvMesh>
+Foam::DelaunayMesh<Triangulation>::createMesh
+(
+    const fileName& name,
+    const Time& runTime,
+    labelList& vertexMap,
+    labelList& cellMap
+) const
+{
+    pointField points(Triangulation::number_of_vertices());
+    faceList faces(Triangulation::number_of_finite_facets());
+    labelList owner(Triangulation::number_of_finite_facets());
+    labelList neighbour(Triangulation::number_of_finite_facets());
+
+    wordList patchNames(1, "cvMesh_defaultPatch");
+    wordList patchTypes(1, wallPolyPatch::typeName);
+
+    labelList patchSizes(1, 0);
+    labelList patchStarts(1, 0);
+
+    List<DynamicList<face> > patchFaces(1, DynamicList<face>());
+    List<DynamicList<label> > patchOwners(1, DynamicList<label>());
+
+    vertexMap.setSize(Triangulation::number_of_vertices());
+    cellMap.setSize(Triangulation::number_of_finite_cells());
+
+    // Calculate pts and a map of point index to location in pts.
+    label vertI = 0;
+
+    for
+    (
+        Finite_vertices_iterator vit = Triangulation::finite_vertices_begin();
+        vit != Triangulation::finite_vertices_end();
+        ++vit
+    )
+    {
+        if (!vit->farPoint())
+        {
+            vertexMap[vit->index()] = vertI;
+            points[vertI] = topoint(vit->point());
+            vertI++;
+        }
+    }
+
+    points.setSize(vertI);
+
+    // Index the cells
+    label cellI = 0;
+
+    for
+    (
+        Finite_cells_iterator cit = Triangulation::finite_cells_begin();
+        cit != Triangulation::finite_cells_end();
+        ++cit
+    )
+    {
+        if
+        (
+            !cit->hasFarPoint()
+         && !Triangulation::is_infinite(cit)
+        )
+        {
+            cellMap[cit->cellIndex()] = cellI++;
+        }
+    }
+
+    label faceI = 0;
+    labelList verticesOnTriFace(3, -1);
+    face newFace(verticesOnTriFace);
+
+    for
+    (
+        Finite_facets_iterator fit = Triangulation::finite_facets_begin();
+        fit != Triangulation::finite_facets_end();
+        ++fit
+    )
+    {
+        const Cell_handle c1(fit->first);
+        const int oppositeVertex = fit->second;
+        const Cell_handle c2(c1->neighbor(oppositeVertex));
+
+        label c1I = Cb::ctFar;
+        bool c1Real = false;
+        if (!c1->hasFarPoint() && !Triangulation::is_infinite(c1))
+        {
+            c1I = cellMap[c1->cellIndex()];
+            c1Real = true;
+        }
+
+        label c2I = Cb::ctFar;
+        bool c2Real = false;
+        if (!c2->hasFarPoint() && !Triangulation::is_infinite(c2))
+        {
+            c2I = cellMap[c2->cellIndex()];
+            c2Real = true;
+        }
+
+        if (!c1Real && !c2Real)
+        {
+            // Both tets are outside, skip
+            continue;
+        }
+
+        label ownerCell = -1;
+        label neighbourCell = -1;
+
+        for (label i = 0; i < 3; i++)
+        {
+            verticesOnTriFace[i] = vertexMap
+            [
+                c1->vertex
+                (
+                    Triangulation::vertex_triple_index(oppositeVertex, i)
+                )->index()
+            ];
+        }
+
+        newFace = face(verticesOnTriFace);
+
+        if (!c1Real || !c2Real)
+        {
+            // Boundary face...
+            if (!c1Real)
+            {
+                //... with c1 outside
+                ownerCell = c2I;
+            }
+            else
+            {
+                // ... with c2 outside
+                ownerCell = c1I;
+
+                reverse(newFace);
+            }
+
+            patchFaces[0].append(newFace);
+            patchOwners[0].append(ownerCell);
+        }
+        else
+        {
+            // Internal face...
+            if (c1I < c2I)
+            {
+                // ...with c1 as the ownerCell
+                ownerCell = c1I;
+                neighbourCell = c2I;
+
+                reverse(newFace);
+            }
+            else
+            {
+                // ...with c2 as the ownerCell
+                ownerCell = c2I;
+                neighbourCell = c1I;
+            }
+
+            faces[faceI] = newFace;
+            owner[faceI] = ownerCell;
+            neighbour[faceI] = neighbourCell;
+            faceI++;
+        }
+    }
+
+    faces.setSize(faceI);
+    owner.setSize(faceI);
+    neighbour.setSize(faceI);
+
+    sortFaces(faces, owner, neighbour);
+
+    addPatches
+    (
+        faceI,
+        faces,
+        owner,
+        patchSizes,
+        patchStarts,
+        patchFaces,
+        patchOwners
+    );
+
+    autoPtr<fvMesh> meshPtr
+    (
+        new fvMesh
+        (
+            IOobject
+            (
+                name,
+                runTime.timeName(),
+                runTime,
+                IOobject::NO_READ,
+                IOobject::NO_WRITE
+            ),
+            xferMove(points),
+            xferMove(faces),
+            xferMove(owner),
+            xferMove(neighbour)
+        )
+    );
+
+    List<polyPatch*> patches(patchStarts.size());
+
+    label nValidPatches = 0;
+
+    forAll(patches, p)
+    {
+        patches[nValidPatches] = polyPatch::New
+        (
+            patchTypes[p],
+            patchNames[p],
+            patchSizes[p],
+            patchStarts[p],
+            nValidPatches,
+            meshPtr().boundaryMesh()
+        ).ptr();
+
+        nValidPatches++;
+    }
+
+    patches.setSize(nValidPatches);
+
+    meshPtr().addFvPatches(patches);
+
+    return meshPtr;
+}
+
+
+// ************************************************************************* //
diff --git a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/DelaunayMesh/DistributedDelaunayMesh.C b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/DelaunayMesh/DistributedDelaunayMesh.C
new file mode 100644
index 0000000000..b2ed781b8b
--- /dev/null
+++ b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/DelaunayMesh/DistributedDelaunayMesh.C
@@ -0,0 +1,938 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "DistributedDelaunayMesh.H"
+#include "meshSearch.H"
+#include "mapDistribute.H"
+#include "zeroGradientFvPatchFields.H"
+#include "pointConversion.H"
+#include "indexedVertexEnum.H"
+#include "IOmanip.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * Static Member Functions * * * * * * * * * * * * * //
+
+template<class Triangulation>
+Foam::autoPtr<Foam::mapDistribute>
+Foam::DistributedDelaunayMesh<Triangulation>::buildMap
+(
+    const List<label>& toProc
+)
+{
+    // Determine send map
+    // ~~~~~~~~~~~~~~~~~~
+
+    // 1. Count
+    labelList nSend(Pstream::nProcs(), 0);
+
+    forAll(toProc, i)
+    {
+        label procI = toProc[i];
+
+        nSend[procI]++;
+    }
+
+    // Send over how many I need to receive
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    labelListList sendSizes(Pstream::nProcs());
+
+    sendSizes[Pstream::myProcNo()] = nSend;
+
+    combineReduce(sendSizes, UPstream::listEq());
+
+    // 2. Size sendMap
+    labelListList sendMap(Pstream::nProcs());
+
+    forAll(nSend, procI)
+    {
+        sendMap[procI].setSize(nSend[procI]);
+
+        nSend[procI] = 0;
+    }
+
+    // 3. Fill sendMap
+    forAll(toProc, i)
+    {
+        label procI = toProc[i];
+
+        sendMap[procI][nSend[procI]++] = i;
+    }
+
+    // Determine receive map
+    // ~~~~~~~~~~~~~~~~~~~~~
+
+    labelListList constructMap(Pstream::nProcs());
+
+    // Local transfers first
+    constructMap[Pstream::myProcNo()] = identity
+    (
+        sendMap[Pstream::myProcNo()].size()
+    );
+
+    label constructSize = constructMap[Pstream::myProcNo()].size();
+
+    forAll(constructMap, procI)
+    {
+        if (procI != Pstream::myProcNo())
+        {
+            label nRecv = sendSizes[procI][Pstream::myProcNo()];
+
+            constructMap[procI].setSize(nRecv);
+
+            for (label i = 0; i < nRecv; i++)
+            {
+                constructMap[procI][i] = constructSize++;
+            }
+        }
+    }
+
+    return autoPtr<mapDistribute>
+    (
+        new mapDistribute
+        (
+            constructSize,
+            sendMap.xfer(),
+            constructMap.xfer()
+        )
+    );
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+template<class Triangulation>
+Foam::DistributedDelaunayMesh<Triangulation>::DistributedDelaunayMesh()
+:
+    DelaunayMesh<Triangulation>(),
+    allBackgroundMeshBounds_()
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+template<class Triangulation>
+Foam::DistributedDelaunayMesh<Triangulation>::~DistributedDelaunayMesh()
+{}
+
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+template<class Triangulation>
+bool Foam::DistributedDelaunayMesh<Triangulation>::distributeBoundBoxes
+(
+    const boundBox& bb
+)
+{
+    allBackgroundMeshBounds_.reset(new List<boundBox>(Pstream::nProcs()));
+
+    // Give the bounds of every processor to every other processor
+    allBackgroundMeshBounds_()[Pstream::myProcNo()] = bb;
+
+    Pstream::gatherList(allBackgroundMeshBounds_());
+    Pstream::scatterList(allBackgroundMeshBounds_());
+
+    return true;
+}
+
+
+template<class Triangulation>
+bool Foam::DistributedDelaunayMesh<Triangulation>::isLocal
+(
+    const Vertex_handle& v
+) const
+{
+    return isLocal(v->procIndex());
+}
+
+
+template<class Triangulation>
+bool Foam::DistributedDelaunayMesh<Triangulation>::isLocal
+(
+    const label localProcIndex
+) const
+{
+    return localProcIndex == Pstream::myProcNo();
+}
+
+
+template<class Triangulation>
+Foam::labelList Foam::DistributedDelaunayMesh<Triangulation>::overlapProcessors
+(
+    const point& centre,
+    const scalar radiusSqr
+) const
+{
+    DynamicList<label> toProc(Pstream::nProcs());
+
+    forAll(allBackgroundMeshBounds_(), procI)
+    {
+        // Test against the bounding box of the processor
+        if
+        (
+            !isLocal(procI)
+         && allBackgroundMeshBounds_()[procI].overlaps(centre, radiusSqr)
+        )
+        {
+            toProc.append(procI);
+        }
+    }
+
+    return toProc;
+}
+
+
+template<class Triangulation>
+bool Foam::DistributedDelaunayMesh<Triangulation>::checkProcBoundaryCell
+(
+    const Cell_handle& cit,
+    Map<labelList>& circumsphereOverlaps
+) const
+{
+    const Foam::point& cc = cit->dual();
+
+    const scalar crSqr = magSqr
+    (
+        cc - topoint(cit->vertex(0)->point())
+    );
+
+    labelList circumsphereOverlap = overlapProcessors
+    (
+        cc,
+        sqr(1.01)*crSqr
+    );
+
+    cit->cellIndex() = this->getNewCellIndex();
+
+    if (!circumsphereOverlap.empty())
+    {
+        circumsphereOverlaps.insert(cit->cellIndex(), circumsphereOverlap);
+
+        return true;
+    }
+
+    return false;
+}
+
+
+template<class Triangulation>
+void Foam::DistributedDelaunayMesh<Triangulation>::findProcessorBoundaryCells
+(
+    Map<labelList>& circumsphereOverlaps
+) const
+{
+    // Start by assuming that all the cells have no index
+    // If they do, they have already been visited so ignore them
+
+    labelHashSet cellToCheck
+    (
+        Triangulation::number_of_finite_cells()
+       /Pstream::nProcs()
+    );
+
+    for
+    (
+        All_cells_iterator cit = Triangulation::all_cells_begin();
+        cit != Triangulation::all_cells_end();
+        ++cit
+    )
+    {
+        if (Triangulation::is_infinite(cit))
+        {
+            // Index of infinite vertex in this cell.
+            int i = cit->index(Triangulation::infinite_vertex());
+
+            Cell_handle c = cit->neighbor(i);
+
+            if (c->unassigned())
+            {
+                c->cellIndex() = this->getNewCellIndex();
+
+                if (checkProcBoundaryCell(c, circumsphereOverlaps))
+                {
+                    cellToCheck.insert(c->cellIndex());
+                }
+            }
+        }
+        else if (cit->parallelDualVertex())
+        {
+            if (cit->unassigned())
+            {
+                if (checkProcBoundaryCell(cit, circumsphereOverlaps))
+                {
+                    cellToCheck.insert(cit->cellIndex());
+                }
+            }
+        }
+    }
+
+    for
+    (
+        Finite_cells_iterator cit = Triangulation::finite_cells_begin();
+        cit != Triangulation::finite_cells_end();
+        ++cit
+    )
+    {
+        if (cellToCheck.found(cit->cellIndex()))
+        {
+            // Get the neighbours and check them
+            for (label adjCellI = 0; adjCellI < 4; ++adjCellI)
+            {
+                Cell_handle citNeighbor = cit->neighbor(adjCellI);
+
+                // Ignore if has far point or previously visited
+                if
+                (
+                    !citNeighbor->unassigned()
+                 || !citNeighbor->internalOrBoundaryDualVertex()
+                 || Triangulation::is_infinite(citNeighbor)
+                )
+                {
+                    continue;
+                }
+
+                checkProcBoundaryCell
+                (
+                    citNeighbor,
+                    circumsphereOverlaps
+                );
+            }
+        }
+    }
+}
+
+
+template<class Triangulation>
+void Foam::DistributedDelaunayMesh<Triangulation>::markVerticesToRefer
+(
+    const Map<labelList>& circumsphereOverlaps,
+    PtrList<labelPairHashSet>& referralVertices,
+    DynamicList<label>& targetProcessor,
+    DynamicList<Vb>& parallelInfluenceVertices
+)
+{
+    // Relying on the order of iteration of cells being the same as before
+    for
+    (
+        Finite_cells_iterator cit = Triangulation::finite_cells_begin();
+        cit != Triangulation::finite_cells_end();
+        ++cit
+    )
+    {
+        if (Triangulation::is_infinite(cit))
+        {
+             continue;
+        }
+
+        Map<labelList>::const_iterator iter =
+            circumsphereOverlaps.find(cit->cellIndex());
+
+        // Pre-tested circumsphere potential influence
+        if (iter != circumsphereOverlaps.cend())
+        {
+            const labelList& citOverlaps = iter();
+
+            forAll(citOverlaps, cOI)
+            {
+                label procI = citOverlaps[cOI];
+
+                for (int i = 0; i < 4; i++)
+                {
+                    Vertex_handle v = cit->vertex(i);
+
+                    if (v->farPoint())
+                    {
+                        continue;
+                    }
+
+                    label vProcIndex = v->procIndex();
+                    label vIndex = v->index();
+
+                    const labelPair procIndexPair(vProcIndex, vIndex);
+
+                    // Using the hashSet to ensure that each vertex is only
+                    // referred once to each processor.
+                    // Do not refer a vertex to its own processor.
+                    if (vProcIndex != procI)
+                    {
+                        if (referralVertices[procI].insert(procIndexPair))
+                        {
+                            targetProcessor.append(procI);
+
+                            parallelInfluenceVertices.append
+                            (
+                                Vb
+                                (
+                                    v->point(),
+                                    v->index(),
+                                    v->type(),
+                                    v->procIndex()
+                                )
+                            );
+
+                            parallelInfluenceVertices.last().targetCellSize() =
+                                v->targetCellSize();
+                            parallelInfluenceVertices.last().alignment() =
+                                v->alignment();
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+
+template<class Triangulation>
+Foam::label Foam::DistributedDelaunayMesh<Triangulation>::referVertices
+(
+    const DynamicList<label>& targetProcessor,
+    DynamicList<Vb>& parallelVertices,
+    PtrList<labelPairHashSet>& referralVertices,
+    labelPairHashSet& receivedVertices
+)
+{
+    DynamicList<Vb> referredVertices(targetProcessor.size());
+
+    const label preDistributionSize = parallelVertices.size();
+
+    mapDistribute pointMap = buildMap(targetProcessor);
+
+    // Make a copy of the original list.
+    DynamicList<Vb> originalParallelVertices(parallelVertices);
+
+    pointMap.distribute(parallelVertices);
+
+    for (label procI = 0; procI < Pstream::nProcs(); procI++)
+    {
+        const labelList& constructMap = pointMap.constructMap()[procI];
+
+        if (constructMap.size())
+        {
+            forAll(constructMap, i)
+            {
+                const Vb& v = parallelVertices[constructMap[i]];
+
+                if
+                (
+                    v.procIndex() != Pstream::myProcNo()
+                 && !receivedVertices.found(labelPair(v.procIndex(), v.index()))
+                )
+                {
+                    referredVertices.append(v);
+
+                    receivedVertices.insert
+                    (
+                        labelPair(v.procIndex(), v.index())
+                    );
+                }
+            }
+        }
+    }
+
+    label preInsertionSize = Triangulation::number_of_vertices();
+
+    labelPairHashSet pointsNotInserted = rangeInsertReferredWithInfo
+    (
+        referredVertices.begin(),
+        referredVertices.end()
+    );
+
+    if (!pointsNotInserted.empty())
+    {
+        for
+        (
+            typename labelPairHashSet::const_iterator iter
+                = pointsNotInserted.begin();
+            iter != pointsNotInserted.end();
+            ++iter
+        )
+        {
+            if (receivedVertices.found(iter.key()))
+            {
+                receivedVertices.erase(iter.key());
+            }
+        }
+    }
+
+    boolList pointInserted(parallelVertices.size(), true);
+
+    forAll(parallelVertices, vI)
+    {
+        const labelPair procIndexI
+        (
+            parallelVertices[vI].procIndex(),
+            parallelVertices[vI].index()
+        );
+
+        if (pointsNotInserted.found(procIndexI))
+        {
+            pointInserted[vI] = false;
+        }
+    }
+
+    pointMap.reverseDistribute(preDistributionSize, pointInserted);
+
+    forAll(originalParallelVertices, vI)
+    {
+        const label procIndex = targetProcessor[vI];
+
+        if (!pointInserted[vI])
+        {
+            if (referralVertices[procIndex].size())
+            {
+                if
+                (
+                    !referralVertices[procIndex].unset
+                    (
+                        labelPair
+                        (
+                            originalParallelVertices[vI].procIndex(),
+                            originalParallelVertices[vI].index()
+                        )
+                    )
+                )
+                {
+                    Pout<< "*** not found "
+                        << originalParallelVertices[vI].procIndex()
+                        << " " << originalParallelVertices[vI].index() << endl;
+                }
+
+            }
+        }
+    }
+
+    label postInsertionSize = Triangulation::number_of_vertices();
+
+    reduce(preInsertionSize, sumOp<label>());
+    reduce(postInsertionSize, sumOp<label>());
+
+    label nTotalToInsert = referredVertices.size();
+
+    reduce(nTotalToInsert, sumOp<label>());
+
+    if (preInsertionSize + nTotalToInsert != postInsertionSize)
+    {
+        label nNotInserted =
+            returnReduce(pointsNotInserted.size(), sumOp<label>());
+
+        Info<< " Inserted = "
+            << setw(name(label(Triangulation::number_of_finite_cells())).size())
+            << nTotalToInsert - nNotInserted
+            << " / " << nTotalToInsert << endl;
+
+        nTotalToInsert -= nNotInserted;
+    }
+    else
+    {
+        Info<< " Inserted = " << nTotalToInsert << endl;
+    }
+
+    return nTotalToInsert;
+}
+
+
+template<class Triangulation>
+void Foam::DistributedDelaunayMesh<Triangulation>::sync
+(
+    const boundBox& bb,
+    PtrList<labelPairHashSet>& referralVertices,
+    labelPairHashSet& receivedVertices,
+    bool iterateReferral
+)
+{
+    if (!Pstream::parRun())
+    {
+        return;
+    }
+
+    if (allBackgroundMeshBounds_.empty())
+    {
+        distributeBoundBoxes(bb);
+    }
+
+    label nVerts = Triangulation::number_of_vertices();
+    label nCells = Triangulation::number_of_finite_cells();
+
+    DynamicList<Vb> parallelInfluenceVertices(0.1*nVerts);
+    DynamicList<label> targetProcessor(0.1*nVerts);
+
+    // Some of these values will not be used, i.e. for non-real cells
+    DynamicList<Foam::point> circumcentre(0.1*nVerts);
+    DynamicList<scalar> circumradiusSqr(0.1*nVerts);
+
+    Map<labelList> circumsphereOverlaps(nCells);
+
+    findProcessorBoundaryCells(circumsphereOverlaps);
+
+    Info<< "    Influences = "
+        << setw(name(nCells).size())
+        << returnReduce(circumsphereOverlaps.size(), sumOp<label>()) << " / "
+        << returnReduce(nCells, sumOp<label>());
+
+    markVerticesToRefer
+    (
+        circumsphereOverlaps,
+        referralVertices,
+        targetProcessor,
+        parallelInfluenceVertices
+    );
+
+    referVertices
+    (
+        targetProcessor,
+        parallelInfluenceVertices,
+        referralVertices,
+        receivedVertices
+    );
+
+    if (iterateReferral)
+    {
+        label oldNReferred = 0;
+        label nIterations = 1;
+
+        Info<< incrIndent << indent
+            << "Iteratively referring referred vertices..."
+            << endl;
+        do
+        {
+            Info<< indent << "Iteration " << nIterations++ << ":";
+
+            circumsphereOverlaps.clear();
+            targetProcessor.clear();
+            parallelInfluenceVertices.clear();
+
+            findProcessorBoundaryCells(circumsphereOverlaps);
+
+            nCells = Triangulation::number_of_finite_cells();
+
+            Info<< " Influences = "
+                << setw(name(nCells).size())
+                << returnReduce(circumsphereOverlaps.size(), sumOp<label>())
+                << " / "
+                << returnReduce(nCells, sumOp<label>());
+
+            markVerticesToRefer
+            (
+                circumsphereOverlaps,
+                referralVertices,
+                targetProcessor,
+                parallelInfluenceVertices
+            );
+
+            label nReferred = referVertices
+            (
+                targetProcessor,
+                parallelInfluenceVertices,
+                referralVertices,
+                receivedVertices
+            );
+
+            if (nReferred == 0 || nReferred == oldNReferred)
+            {
+                break;
+            }
+
+            oldNReferred = nReferred;
+
+        } while (true);
+
+        Info<< decrIndent;
+    }
+}
+
+
+// * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
+
+template<class Triangulation>
+bool Foam::DistributedDelaunayMesh<Triangulation>::distribute
+(
+    const boundBox& bb
+)
+{
+    notImplemented
+    (
+        "Foam::DistributedDelaunayMesh<Triangulation>::distribute"
+        "("
+        "    const boundBox& bb"
+        ")"
+    );
+
+    if (!Pstream::parRun())
+    {
+        return false;
+    }
+
+    distributeBoundBoxes(bb);
+
+    return true;
+}
+
+
+template<class Triangulation>
+Foam::autoPtr<Foam::mapDistribute>
+Foam::DistributedDelaunayMesh<Triangulation>::distribute
+(
+    const backgroundMeshDecomposition& decomposition
+)
+{
+    if (!Pstream::parRun())
+    {
+        return autoPtr<mapDistribute>();
+    }
+
+    distributeBoundBoxes(decomposition.procBounds());
+
+    DynamicList<point> points(Triangulation::number_of_vertices());
+
+    for
+    (
+        Finite_vertices_iterator vit = Triangulation::finite_vertices_begin();
+        vit != Triangulation::finite_vertices_end();
+        ++vit
+    )
+    {
+        if (vit->real())
+        {
+            points.append(topoint(vit->point()));
+        }
+    }
+
+    autoPtr<mapDistribute> mapDist = decomposition.distributePoints(points);
+
+    return mapDist;
+}
+
+
+template<class Triangulation>
+void Foam::DistributedDelaunayMesh<Triangulation>::sync(const boundBox& bb)
+{
+    if (!Pstream::parRun())
+    {
+        return;
+    }
+
+    if (allBackgroundMeshBounds_.empty())
+    {
+        distributeBoundBoxes(bb);
+    }
+
+    const label nApproxReferred =
+        Triangulation::number_of_vertices()
+       /Pstream::nProcs();
+
+    PtrList<labelPairHashSet> referralVertices(Pstream::nProcs());
+    forAll(referralVertices, procI)
+    {
+        if (!isLocal(procI))
+        {
+            referralVertices.set(procI, new labelPairHashSet(nApproxReferred));
+        }
+    }
+
+    labelPairHashSet receivedVertices(nApproxReferred);
+
+    sync
+    (
+        bb,
+        referralVertices,
+        receivedVertices,
+        true
+    );
+}
+
+
+template<class Triangulation>
+template<class PointIterator>
+typename Foam::DistributedDelaunayMesh<Triangulation>::labelPairHashSet
+Foam::DistributedDelaunayMesh<Triangulation>::rangeInsertReferredWithInfo
+(
+    PointIterator begin,
+    PointIterator end,
+    bool printErrors
+)
+{
+    const boundBox& bb = allBackgroundMeshBounds_()[Pstream::myProcNo()];
+
+    typedef DynamicList
+    <
+        std::pair<scalar, label>
+    > vectorPairPointIndex;
+
+    vectorPairPointIndex pointsBbDistSqr;
+
+    label count = 0;
+    for (PointIterator it = begin; it != end; ++it)
+    {
+        const Foam::point samplePoint(topoint(it->point()));
+
+        scalar distFromBbSqr = 0;
+
+        if (!bb.contains(samplePoint))
+        {
+            const Foam::point nearestPoint = bb.nearest(samplePoint);
+
+            distFromBbSqr = magSqr(nearestPoint - samplePoint);
+        }
+
+        pointsBbDistSqr.append
+        (
+            std::make_pair(distFromBbSqr, count++)
+        );
+    }
+
+    std::random_shuffle(pointsBbDistSqr.begin(), pointsBbDistSqr.end());
+
+    // Sort in ascending order by the distance of the point from the centre
+    // of the processor bounding box
+    sort(pointsBbDistSqr.begin(), pointsBbDistSqr.end());
+
+    typename Triangulation::Vertex_handle hint;
+
+    typename Triangulation::Locate_type lt;
+    int li, lj;
+
+    label nNotInserted = 0;
+
+    labelPairHashSet uninserted
+    (
+        Triangulation::number_of_vertices()
+       /Pstream::nProcs()
+    );
+
+    for
+    (
+        typename vectorPairPointIndex::const_iterator p =
+            pointsBbDistSqr.begin();
+        p != pointsBbDistSqr.end();
+        ++p
+    )
+    {
+        const size_t checkInsertion = Triangulation::number_of_vertices();
+
+        const Vb& vert = *(begin + p->second);
+        const Point& pointToInsert = vert.point();
+
+        // Locate the point
+        Cell_handle c = Triangulation::locate(pointToInsert, lt, li, lj, hint);
+
+        if (lt == Triangulation::VERTEX)
+        {
+            if (printErrors)
+            {
+                Vertex_handle nearV =
+                    Triangulation::nearest_vertex(pointToInsert);
+
+                Pout<< "Failed insertion, point already exists" << nl
+                    << "Failed insertion : " << vert.info()
+                    << "         nearest : " << nearV->info();
+            }
+
+            uninserted.insert(labelPair(vert.procIndex(), vert.index()));
+            nNotInserted++;
+
+            continue;
+        }
+
+        // Get the cells that conflict with p in a vector V,
+        // and a facet on the boundary of this hole in f.
+        std::vector<Cell_handle> V;
+        typename Triangulation::Facet f;
+
+        Triangulation::find_conflicts
+        (
+            pointToInsert,
+            c,
+            CGAL::Oneset_iterator<typename Triangulation::Facet>(f),
+            std::back_inserter(V)
+        );
+
+        bool insert = false;
+        for (size_t i = 0; i < V.size(); ++i)
+        {
+            if (V[i]->real() || V[i]->hasFarPoint())
+            {
+                insert = true;
+                break;
+            }
+        }
+
+        if (insert)
+        {
+            hint = Triangulation::insert_in_hole
+            (
+                pointToInsert,
+                V.begin(),
+                V.end(),
+                f.first,
+                f.second
+            );
+
+            if (checkInsertion != Triangulation::number_of_vertices() - 1)
+            {
+                if (printErrors)
+                {
+                    Vertex_handle nearV =
+                        Triangulation::nearest_vertex(pointToInsert);
+
+                    Pout<< "Failed insertion : " << vert.info()
+                        << "         nearest : " << nearV->info();
+                }
+            }
+            else
+            {
+                hint->index() = vert.index();
+                hint->type() = vert.type();
+                hint->procIndex() = vert.procIndex();
+                hint->targetCellSize() = vert.targetCellSize();
+                hint->alignment() = vert.alignment();
+            }
+        }
+        else
+        {
+            uninserted.insert(labelPair(vert.procIndex(), vert.index()));
+            nNotInserted++;
+        }
+    }
+
+    return uninserted;
+}
+
+
+// * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * Friend Functions  * * * * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * Friend Operators * * * * * * * * * * * * * * //
+
+
+// ************************************************************************* //
diff --git a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/DelaunayMesh/DistributedDelaunayMesh.H b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/DelaunayMesh/DistributedDelaunayMesh.H
new file mode 100644
index 0000000000..124f4b39dc
--- /dev/null
+++ b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/DelaunayMesh/DistributedDelaunayMesh.H
@@ -0,0 +1,207 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 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::DistributedDelaunayMesh
+
+Description
+
+SourceFiles
+    DistributedDelaunayMeshI.H
+    DistributedDelaunayMesh.C
+    DistributedDelaunayMeshIO.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef DistributedDelaunayMesh_H
+#define DistributedDelaunayMesh_H
+
+#include "DelaunayMesh.H"
+#include "backgroundMeshDecomposition.H"
+#include "autoPtr.H"
+#include "boundBox.H"
+#include "indexedVertex.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+class mapDistribute;
+
+/*---------------------------------------------------------------------------*\
+                  Class DistributedDelaunayMesh Declaration
+\*---------------------------------------------------------------------------*/
+
+template<class Triangulation>
+class DistributedDelaunayMesh
+:
+    public DelaunayMesh<Triangulation>
+{
+public:
+
+        typedef typename Triangulation::Vertex_handle Vertex_handle;
+        typedef typename Triangulation::Cell_handle   Cell_handle;
+        typedef typename Triangulation::Point         Point;
+
+        typedef typename Triangulation::Finite_vertices_iterator
+            Finite_vertices_iterator;
+        typedef typename Triangulation::Finite_cells_iterator
+            Finite_cells_iterator;
+        typedef typename Triangulation::All_cells_iterator
+            All_cells_iterator;
+
+        typedef typename DelaunayMesh<Triangulation>::labelPairHashSet
+            labelPairHashSet;
+
+
+private:
+
+        autoPtr<List<boundBox> > allBackgroundMeshBounds_;
+
+
+    // Private Member Functions
+
+        //-
+        bool distributeBoundBoxes(const boundBox& bb);
+
+        //-
+        bool isLocal(const Vertex_handle& v) const;
+
+        bool isLocal(const label localProcIndex) const;
+
+        labelList overlapProcessors
+        (
+            const point& centre,
+            const scalar radiusSqr
+        ) const;
+
+        bool checkProcBoundaryCell
+        (
+            const Cell_handle& cit,
+            Map<labelList>& circumsphereOverlaps
+        ) const;
+
+        void findProcessorBoundaryCells
+        (
+            Map<labelList>& circumsphereOverlaps
+        ) const;
+
+        void markVerticesToRefer
+        (
+            const Map<labelList>& circumsphereOverlaps,
+            PtrList<labelPairHashSet>& referralVertices,
+            DynamicList<label>& targetProcessor,
+            DynamicList<Vb>& parallelInfluenceVertices
+        );
+
+        label referVertices
+        (
+            const DynamicList<label>& targetProcessor,
+            DynamicList<Vb>& parallelVertices,
+            PtrList<labelPairHashSet>& referralVertices,
+            labelPairHashSet& receivedVertices
+        );
+
+        //- Disallow default bitwise copy construct
+        DistributedDelaunayMesh(const DistributedDelaunayMesh<Triangulation>&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const DistributedDelaunayMesh<Triangulation>&);
+
+
+public:
+
+    // Constructors
+
+        //- Construct from components
+        DistributedDelaunayMesh();
+
+
+    //- Destructor
+    ~DistributedDelaunayMesh();
+
+
+    // Member Functions
+
+        //- Build a mapDistribute for the supplied destination processor data
+        static autoPtr<mapDistribute> buildMap(const List<label>& toProc);
+
+        //-
+        bool distribute(const boundBox& bb);
+
+        autoPtr<mapDistribute> distribute
+        (
+            const backgroundMeshDecomposition& decomposition
+        );
+
+        //- Refer vertices so that the processor interfaces are consistent
+        void sync(const boundBox& bb);
+
+        //- Refer vertices so that the processor interfaces are consistent
+        void sync
+        (
+            const boundBox& bb,
+            PtrList<labelPairHashSet>& referralVertices,
+            labelPairHashSet& receivedVertices,
+            bool iterateReferral = true
+        );
+
+        //- Inserts points into the triangulation if the point is within
+        //  the circumsphere of another cell
+        template<class PointIterator>
+        labelPairHashSet rangeInsertReferredWithInfo
+        (
+            PointIterator begin,
+            PointIterator end,
+            bool printErrors = true
+        );
+
+//        distributeField();
+
+
+    // Queries
+
+
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+//#include "DistributedDelaunayMeshI.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+#   include "DistributedDelaunayMesh.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/Make/files b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/Make/files
index 3974c7df75..c6e553f64c 100644
--- a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/Make/files
+++ b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/Make/files
@@ -1,5 +1,8 @@
 #include CGAL_FILES
 
+conformalVoronoiMesh/indexedVertex/indexedVertexEnum.C
+conformalVoronoiMesh/indexedCell/indexedCellEnum.C
+
 conformalVoronoiMesh/conformalVoronoiMesh.C
 conformalVoronoiMesh/conformalVoronoiMeshCalcDualMesh.C
 conformalVoronoiMesh/conformalVoronoiMeshConformToSurface.C
@@ -13,7 +16,20 @@ conformationSurfaces/conformationSurfaces.C
 
 backgroundMeshDecomposition/backgroundMeshDecomposition.C
 
-cellSizeControlSurfaces/cellSizeControlSurfaces.C
+cellShapeControl/cellShapeControl/cellShapeControl.C
+
+cellShapeControl/cellShapeControlMesh/cellShapeControlMesh.C
+
+cellSizeAndAlignmentControl = cellShapeControl/cellSizeAndAlignmentControl
+$(cellSizeAndAlignmentControl)/cellSizeAndAlignmentControls.C
+$(cellSizeAndAlignmentControl)/cellSizeAndAlignmentControl/cellSizeAndAlignmentControl.C
+$(cellSizeAndAlignmentControl)/fileControl/fileControl.C
+$(cellSizeAndAlignmentControl)/searchableSurfaceControl/searchableSurfaceControl.C
+/*cellShapeControl/pQuadCoorControl/pQuadCoorControl.C*/
+
+cellShapeControl/cellAspectRatioControl/cellAspectRatioControl.C
+
+/*cellSizeControlSurfaces/cellSizeControlSurfaces.C*/
 
 cellSizeFunctions = cellSizeControlSurfaces/cellSizeFunction
 $(cellSizeFunctions)/cellSizeFunction/cellSizeFunction.C
diff --git a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/Make/options b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/Make/options
index 2082f88ff0..4a072aa593 100644
--- a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/Make/options
+++ b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/Make/options
@@ -2,7 +2,7 @@ EXE_DEBUG = -DFULLDEBUG -g -O0
 EXE_FROUNDING_MATH = -frounding-math
 EXE_NDEBUG = -DNDEBUG
 
-CGAL_EXACT =
+CGAL_EXACT = /*-DCGAL_DONT_USE_LAZY_KERNEL*/
 CGAL_INEXACT = -DCGAL_INEXACT
 
 include $(GENERAL_RULES)/CGAL
@@ -20,6 +20,8 @@ EXE_INC = \
     -I$(LIB_SRC)/fileFormats/lnInclude \
     -I$(LIB_SRC)/dynamicMesh/lnInclude \
     -I$(LIB_SRC)/triSurface/lnInclude \
+    -I$(LIB_SRC)/sampling/lnInclude \
+    -IPrintTable \
     -I../vectorTools
 
 EXE_LIBS = \
@@ -27,4 +29,5 @@ EXE_LIBS = \
     -ledgeMesh \
     -lfileFormats \
     -ltriSurface \
-    -ldynamicMesh
+    -ldynamicMesh \
+    -lsampling
diff --git a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/PrintTable/PrintTable.C b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/PrintTable/PrintTable.C
new file mode 100644
index 0000000000..ee46bff366
--- /dev/null
+++ b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/PrintTable/PrintTable.C
@@ -0,0 +1,241 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "PrintTable.H"
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+template<class KeyType, class DataType>
+Foam::PrintTable<KeyType, DataType>::PrintTable()
+:
+    table_(),
+    title_(string::null)
+{}
+
+
+template<class KeyType, class DataType>
+Foam::PrintTable<KeyType, DataType>::PrintTable(const string& title)
+:
+    table_(),
+    title_(title)
+{}
+
+
+template<class KeyType, class DataType>
+Foam::PrintTable<KeyType, DataType>::PrintTable
+(
+    const PrintTable<KeyType, DataType>& table
+)
+:
+    table_(table.table_),
+    title_(table.title_)
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+template<class KeyType, class DataType>
+Foam::PrintTable<KeyType, DataType>::~PrintTable()
+{}
+
+
+// * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
+
+template<class KeyType, class DataType>
+void Foam::PrintTable<KeyType, DataType>::print
+(
+    Ostream& os,
+    const bool printSum,
+    const bool printAverage
+) const
+{
+    HashTable<HashTable<DataType, label>, KeyType> combinedTable;
+
+    List<HashTable<DataType, KeyType> > procData
+    (
+        Pstream::nProcs(),
+        HashTable<DataType, KeyType>()
+    );
+
+    procData[Pstream::myProcNo()] = table_;
+
+    Pstream::gatherList(procData);
+
+    if (Pstream::master())
+    {
+        label largestKeyLength = 6;
+        label largestDataLength = 0;
+
+        List<label> largestProcSize(Pstream::nProcs(), 0);
+
+        forAll(procData, procI)
+        {
+            const HashTable<DataType, KeyType>& procIData
+                = procData[procI];
+
+            for
+            (
+                typename HashTable<DataType, KeyType>
+                    ::const_iterator iter = procIData.begin();
+                iter != procIData.end();
+                ++iter
+            )
+            {
+                if (!combinedTable.found(iter.key()))
+                {
+                    combinedTable.insert
+                    (
+                        iter.key(),
+                        HashTable<DataType, label>()
+                    );
+                }
+
+                HashTable<DataType, label>& key
+                    = combinedTable[iter.key()];
+
+                key.insert(procI, iter());
+
+                for
+                (
+                    typename HashTable<DataType, label>
+                        ::const_iterator dataIter = key.begin();
+                    dataIter != key.end();
+                    ++dataIter
+                )
+                {
+                    std::ostringstream buf;
+                    buf << dataIter();
+
+                    largestDataLength = max
+                    (
+                        largestDataLength,
+                        label(buf.str().length())
+                    );
+                }
+
+                std::ostringstream buf;
+                buf << iter.key();
+
+                largestKeyLength = max
+                (
+                    largestKeyLength,
+                    label(buf.str().length())
+                );
+            }
+        }
+
+        os.width(largestKeyLength);
+        os  << nl << indent << tab << title_.c_str() << endl;
+
+        os.width(largestKeyLength);
+        os  << indent << "Proc #";
+        forAll(procData, procI)
+        {
+            os  << tab;
+            os.width(largestDataLength);
+            os  << procI;
+        }
+
+        if (printSum)
+        {
+            os  << tab;
+            os.width(largestDataLength);
+            os  << "Sum";
+        }
+
+        if (printAverage)
+        {
+            os  << tab;
+            os.width(largestDataLength);
+            os  << "Average";
+        }
+
+        os  << endl;
+
+        const List<KeyType>& sortedTable = combinedTable.sortedToc();
+
+        forAll(sortedTable, keyI)
+        {
+            const HashTable<DataType, label>& procDataList
+                = combinedTable[sortedTable[keyI]];
+
+            os.width(largestKeyLength);
+            os  << indent << sortedTable[keyI];
+
+            forAll(procDataList, elemI)
+            {
+                os  << tab;
+                os.width(largestDataLength);
+                os  << procDataList[elemI];
+            }
+
+            if (printSum)
+            {
+                DataType sum = 0;
+                forAll(procDataList, elemI)
+                {
+                    sum += procDataList[elemI];
+                }
+
+                os  << tab;
+                os.width(largestDataLength);
+                os  << sum;
+
+                if (printAverage)
+                {
+                    os  << tab;
+                    os.width(largestDataLength);
+                    os  << sum/Pstream::nProcs();
+                }
+            }
+
+            os  << endl;
+        }
+    }
+}
+
+
+// * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * * //
+
+template<class KeyType, class DataType>
+void Foam::PrintTable<KeyType, DataType>::operator=
+(
+    const PrintTable<KeyType, DataType>& rhs
+)
+{
+    // Check for assignment to self
+    if (this == &rhs)
+    {
+        FatalErrorIn
+        (
+            "Foam::PrintTable<KeyType, DataType>::operator="
+            "(const Foam::PrintTable<KeyType, DataType>&)"
+        )   << "Attempted assignment to self"
+            << abort(FatalError);
+    }
+}
+
+
+// ************************************************************************* //
diff --git a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/PrintTable/PrintTable.H b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/PrintTable/PrintTable.H
new file mode 100644
index 0000000000..7f9ed78871
--- /dev/null
+++ b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/PrintTable/PrintTable.H
@@ -0,0 +1,137 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 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::PrintTable
+
+Description
+    Print a table in parallel, e.g.;
+
+    \verbatim
+                            Vertex Type Information
+                   Proc #        0       1       2       3
+                    Total   145680  145278  145751  145359
+               Unassigned        0       0       0       0
+     nExternalFeatureEdge      883     829     828     960
+    nExternalFeaturePoint        8      10      10      12
+         nExternalSurface     9533    9488    9502    9482
+                     nFar        0       0       0       0
+                nInternal   125494  125198  125642  125174
+     nInternalFeatureEdge      238     241     241     240
+    nInternalFeaturePoint        2       2       2       2
+    nInternalNearBoundary        0       0       0       0
+         nInternalSurface     9522    9510    9526    9489
+                nReferred     7545    7497    7500    7587
+    \endverbatim
+
+SourceFiles
+    PrintTableI.H
+    PrintTable.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef PrintTable_H
+#define PrintTable_H
+
+#include "HashTable.H"
+#include "Ostream.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                         Class PrintTable Declaration
+\*---------------------------------------------------------------------------*/
+
+template<class KeyType, class DataType>
+class PrintTable
+{
+    // Private data
+
+        //- Hash table holding the data
+        HashTable<DataType, KeyType> table_;
+
+        //- Title of the table
+        string title_;
+
+
+    // Private Member Functions
+
+        //- Disallow default bitwise assignment
+        void operator=(const PrintTable<KeyType, DataType>&);
+
+
+public:
+
+    // Constructors
+
+        //- Null constructor
+        PrintTable();
+
+        //- Construct with a title
+        explicit PrintTable(const string& title);
+
+        //- Copy constructor
+        PrintTable(const PrintTable<KeyType, DataType>& table);
+
+
+    //- Destructor
+    ~PrintTable();
+
+
+    // Member Functions
+
+        //- Add an entry (D) to the given key(K)
+        void add(const KeyType& K, const DataType& D);
+
+        //- Print the table
+        void print
+        (
+            Ostream& os,
+            const bool printSum = false,
+            const bool printAverage = false
+        ) const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#include "PrintTableI.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+#   include "PrintTable.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/PrintTable/PrintTableI.H b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/PrintTable/PrintTableI.H
new file mode 100644
index 0000000000..6c093bc13a
--- /dev/null
+++ b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/PrintTable/PrintTableI.H
@@ -0,0 +1,42 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+template<class KeyType, class DataType>
+void Foam::PrintTable<KeyType, DataType>::add
+(
+    const KeyType& K,
+    const DataType& D
+)
+{
+    table_.set(K, D);
+}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+
+// ************************************************************************* //
diff --git a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/backgroundMeshDecomposition/backgroundMeshDecomposition.C b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/backgroundMeshDecomposition/backgroundMeshDecomposition.C
index cf7a1eb902..7f60b96200 100644
--- a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/backgroundMeshDecomposition/backgroundMeshDecomposition.C
+++ b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/backgroundMeshDecomposition/backgroundMeshDecomposition.C
@@ -25,6 +25,10 @@ License
 
 #include "backgroundMeshDecomposition.H"
 #include "meshSearch.H"
+#include "conformationSurfaces.H"
+#include "zeroGradientFvPatchFields.H"
+#include "Time.H"
+#include "Random.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
@@ -377,7 +381,7 @@ void Foam::backgroundMeshDecomposition::initialRefinement()
                         if (oldCellI == -1)
                         {
                             newVolumeStatus[newCellI] =
-                                searchableSurface::UNKNOWN;;
+                                searchableSurface::UNKNOWN;
                         }
                         else
                         {
@@ -413,8 +417,10 @@ void Foam::backgroundMeshDecomposition::initialRefinement()
 
             fvMeshDistribute distributor(mesh_, mergeDist_);
 
-            autoPtr<mapDistributePolyMesh> mapDist =
-                distributor.distribute(newDecomp);
+            autoPtr<mapDistributePolyMesh> mapDist = distributor.distribute
+            (
+                newDecomp
+            );
 
             meshCutter_.distribute(mapDist);
 
@@ -527,87 +533,87 @@ bool Foam::backgroundMeshDecomposition::refineCell
 
     if (volType == searchableSurface::MIXED)
     {
-        // Assess the cell size at the nearest point on the surface for the
-        // MIXED cells, if the cell is large with respect to the cell size,
-        // then refine it.
-
-        pointField samplePoints
-        (
-            volRes_*volRes_*volRes_,
-            vector::zero
-        );
-
-        // scalar sampleVol = cellBb.volume()/samplePoints.size();
-
-        vector delta = cellBb.span()/volRes_;
-
-        label pI = 0;
-
-        for (label i = 0; i < volRes_; i++)
-        {
-            for (label j = 0; j < volRes_; j++)
-            {
-                for (label k = 0; k < volRes_; k++)
-                {
-                    samplePoints[pI++] =
-                        cellBb.min()
-                      + vector
-                        (
-                            delta.x()*(i + 0.5),
-                            delta.y()*(j + 0.5),
-                            delta.z()*(k + 0.5)
-                        );
-                }
-            }
-        }
-
-        List<pointIndexHit> hitInfo;
-        labelList hitSurfaces;
-
-        geometry.findSurfaceNearest
-        (
-            samplePoints,
-            scalarField(samplePoints.size(), sqr(GREAT)),
-            hitInfo,
-            hitSurfaces
-        );
-
-        // weightEstimate = 0.0;
-
-        scalar minCellSize = GREAT;
-
-        forAll(samplePoints, i)
-        {
-            scalar s = cellSizeControl_.cellSize
-            (
-                hitInfo[i].hitPoint()
-            );
-
-            // Info<< "cellBb.midpoint() " << cellBb.midpoint() << nl
-            //     << samplePoints[i] << nl
-            //     << hitInfo[i] << nl
-            //     << "cellBb.span() " << cellBb.span() << nl
-            //     << "cellBb.mag() " << cellBb.mag() << nl
-            //     << s << endl;
-
-            if (s < minCellSize)
-            {
-                minCellSize = max(s, minCellSizeLimit_);
-            }
-
-            // Estimate the number of points in the cell by the surface size,
-            // this is likely to be too small, so reduce.
-            // weightEstimate += sampleVol/pow3(s);
-        }
-
-        if (sqr(spanScale_)*sqr(minCellSize) < magSqr(cellBb.span()))
-        {
-            return true;
-        }
+//        // Assess the cell size at the nearest point on the surface for the
+//        // MIXED cells, if the cell is large with respect to the cell size,
+//        // then refine it.
+//
+//        pointField samplePoints
+//        (
+//            volRes_*volRes_*volRes_,
+//            vector::zero
+//        );
+//
+//        // scalar sampleVol = cellBb.volume()/samplePoints.size();
+//
+//        vector delta = cellBb.span()/volRes_;
+//
+//        label pI = 0;
+//
+//        for (label i = 0; i < volRes_; i++)
+//        {
+//            for (label j = 0; j < volRes_; j++)
+//            {
+//                for (label k = 0; k < volRes_; k++)
+//                {
+//                    samplePoints[pI++] =
+//                        cellBb.min()
+//                      + vector
+//                        (
+//                            delta.x()*(i + 0.5),
+//                            delta.y()*(j + 0.5),
+//                            delta.z()*(k + 0.5)
+//                        );
+//                }
+//            }
+//        }
+//
+//        List<pointIndexHit> hitInfo;
+//        labelList hitSurfaces;
+//
+//        geometry.findSurfaceNearest
+//        (
+//            samplePoints,
+//            scalarField(samplePoints.size(), sqr(GREAT)),
+//            hitInfo,
+//            hitSurfaces
+//        );
+//
+//        // weightEstimate = 0.0;
+//
+//        scalar minCellSize = GREAT;
+//
+//        forAll(samplePoints, i)
+//        {
+//            scalar s = cellShapeControl_.cellSize
+//            (
+//                hitInfo[i].hitPoint()
+//            );
+//
+//            // Info<< "cellBb.midpoint() " << cellBb.midpoint() << nl
+//            //     << samplePoints[i] << nl
+//            //     << hitInfo[i] << nl
+//            //     << "cellBb.span() " << cellBb.span() << nl
+//            //     << "cellBb.mag() " << cellBb.mag() << nl
+//            //     << s << endl;
+//
+//            if (s < minCellSize)
+//            {
+//                minCellSize = max(s, minCellSizeLimit_);
+//            }
+//
+//            // Estimate the number of points in the cell by the surface size,
+//            // this is likely to be too small, so reduce.
+//            // weightEstimate += sampleVol/pow3(s);
+//        }
+//
+//        if (sqr(spanScale_)*sqr(minCellSize) < magSqr(cellBb.span()))
+//        {
+//            return true;
+//        }
     }
     else if (volType == searchableSurface::INSIDE)
     {
-        // scalar s = cvMesh_.cellSizeControl().cellSize(cellBb.midpoint());
+        // scalar s = cvMesh_.cellShapeControl_.cellSize(cellBb.midpoint());
 
         // Estimate the number of points in the cell by the size at the cell
         // midpoint
@@ -724,9 +730,7 @@ void Foam::backgroundMeshDecomposition::buildPatchAndTree()
 
     globalBackgroundBounds_ = treeBoundBox(bbMin, bbMax);
 
-    octreeNearestDistances_ = bFTreePtr_().calcNearestDistance();
-
-    if (cvMeshControls_.objOutput())
+    if (false)
     {
         OFstream fStr
         (
@@ -773,15 +777,15 @@ void Foam::backgroundMeshDecomposition::buildPatchAndTree()
 
 Foam::backgroundMeshDecomposition::backgroundMeshDecomposition
 (
-    const dictionary& coeffsDict,
-    const conformalVoronoiMesh& cvMesh
+    const Time& runTime,
+    Random& rndGen,
+    const conformationSurfaces& geometryToConformTo,
+    const dictionary& coeffsDict
 )
 :
-    runTime_(cvMesh.time()),
-    geometryToConformTo_(cvMesh.geometryToConformTo()),
-    cellSizeControl_(cvMesh.cellSizeControl()),
-    rndGen_(cvMesh.rndGen()),
-    cvMeshControls_(cvMesh.cvMeshControls()),
+    runTime_(runTime),
+    geometryToConformTo_(geometryToConformTo),
+    rndGen_(rndGen),
     mesh_
     (
         IOobject
@@ -800,7 +804,6 @@ Foam::backgroundMeshDecomposition::backgroundMeshDecomposition
     ),
     boundaryFacesPtr_(),
     bFTreePtr_(),
-    octreeNearestDistances_(),
     allBackgroundMeshBounds_(Pstream::nProcs()),
     globalBackgroundBounds_(),
     decomposeDict_
@@ -857,74 +860,6 @@ Foam::backgroundMeshDecomposition::backgroundMeshDecomposition
 }
 
 
-Foam::backgroundMeshDecomposition::backgroundMeshDecomposition
-(
-    const scalar spanScale,
-    const scalar minCellSizeLimit,
-    const label minLevels,
-    const label volRes,
-    const scalar maxCellWeightCoeff,
-
-    const Time& runTime,
-    const conformationSurfaces& geometryToConformTo,
-    const cellSizeControlSurfaces& cellSizeControl,
-    Random& rndGen,
-    const cvControls& cvMeshControls
-)
-:
-    runTime_(runTime),
-    geometryToConformTo_(geometryToConformTo),
-    cellSizeControl_(cellSizeControl),
-    rndGen_(rndGen),
-    cvMeshControls_(cvMeshControls),
-    mesh_
-    (
-        IOobject
-        (
-            fvMesh::defaultRegion,
-            runTime_.timeName(),
-            runTime_,
-            IOobject::MUST_READ
-        )
-    ),
-    meshCutter_
-    (
-        mesh_,
-        labelList(mesh_.nCells(), 0),
-        labelList(mesh_.nPoints(), 0)
-    ),
-    boundaryFacesPtr_(),
-    bFTreePtr_(),
-    octreeNearestDistances_(),
-    allBackgroundMeshBounds_(Pstream::nProcs()),
-    globalBackgroundBounds_(),
-    decomposeDict_
-    (
-        IOobject
-        (
-            "decomposeParDict",
-            runTime_.system(),
-            runTime_,
-            IOobject::MUST_READ_IF_MODIFIED,
-            IOobject::NO_WRITE
-        )
-    ),
-    decomposerPtr_(decompositionMethod::New(decomposeDict_)),
-    mergeDist_(1e-6*mesh_.bounds().mag()),
-    spanScale_(spanScale),
-    minCellSizeLimit_(minCellSizeLimit),
-    minLevels_(minLevels),
-    volRes_(volRes),
-    maxCellWeightCoeff_(maxCellWeightCoeff)
-{
-    // Stand-alone operation
-
-    Info<< nl << "Building initial background mesh decomposition" << endl;
-
-    initialRefinement();
-}
-
-
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
 Foam::backgroundMeshDecomposition::~backgroundMeshDecomposition()
@@ -936,10 +871,7 @@ Foam::backgroundMeshDecomposition::~backgroundMeshDecomposition()
 Foam::autoPtr<Foam::mapDistributePolyMesh>
 Foam::backgroundMeshDecomposition::distribute
 (
-    volScalarField& cellWeights,
-    List<DynamicList<point> >& cellVertices,
-    List<DynamicList<label> >& cellVertexIndices,
-    List<DynamicList<label> >& cellVertexTypes
+    volScalarField& cellWeights
 )
 {
     if (debug)
@@ -982,10 +914,8 @@ Foam::backgroundMeshDecomposition::distribute
         {
             Info<< "    cellWeightLimit " << cellWeightLimit << endl;
 
-            Pout<< "    sum(cellWeights) "
-                << sum(cellWeights.internalField())
-                << " max(cellWeights) "
-                << max(cellWeights.internalField())
+            Pout<< "    sum(cellWeights) " << sum(cellWeights.internalField())
+                << " max(cellWeights) " << max(cellWeights.internalField())
                 << endl;
         }
 
@@ -1049,94 +979,6 @@ Foam::backgroundMeshDecomposition::distribute
         // Update numbering of cells/vertices.
         meshCutter_.updateMesh(map);
 
-        {
-            // Map cellVertices, cellVertexIndices and cellVertexTypes
-
-            meshSearch cellSearch(mesh_, polyMesh::FACEPLANES);
-
-            const labelList& reverseCellMap = map().reverseCellMap();
-
-            List<DynamicList<point> > newCellVertices(mesh_.nCells());
-            List<DynamicList<label> > newCellVertexIndices(mesh_.nCells());
-            List<DynamicList<label> > newCellVertexTypes(mesh_.nCells());
-
-            forAll(cellVertices, oldCellI)
-            {
-                DynamicList<point>& oldCellVertices =
-                    cellVertices[oldCellI];
-
-                DynamicList<label>& oldCellVertexIndices =
-                    cellVertexIndices[oldCellI];
-
-                DynamicList<label>& oldCellVertexTypes =
-                    cellVertexTypes[oldCellI];
-
-                if (findIndex(newCellsToRefine, oldCellI) >= 0)
-                {
-                    // This old cell was refined so the cell for the vertices
-                    // in the new mesh needs to be searched for.
-
-                    forAll(oldCellVertices, oPI)
-                    {
-                        const point& v = oldCellVertices[oPI];
-
-                        label newCellI = cellSearch.findCell(v);
-
-                        if (newCellI == -1)
-                        {
-                            // Pout<< "findCell backgroundMeshDecomposition "
-                            //     << v << " "
-                            //     << oldCellI
-                            //     << newCellI
-                            //     << " find nearest cellI ";
-
-                            newCellI = cellSearch.findNearestCell(v);
-
-                            // Pout<< newCellI << endl;
-                        }
-
-                        newCellVertices[newCellI].append(v);
-
-                        newCellVertexIndices[newCellI].append
-                        (
-                            oldCellVertexIndices[oPI]
-                        );
-
-                        newCellVertexTypes[newCellI].append
-                        (
-                            oldCellVertexTypes[oPI]
-                        );
-                    }
-                }
-                else
-                {
-                    label newCellI = reverseCellMap[oldCellI];
-
-                    forAll(oldCellVertices, oPI)
-                    {
-                        newCellVertices[newCellI].append
-                        (
-                            oldCellVertices[oPI]
-                        );
-
-                        newCellVertexIndices[newCellI].append
-                        (
-                            oldCellVertexIndices[oPI]
-                        );
-
-                        newCellVertexTypes[newCellI].append
-                        (
-                            oldCellVertexTypes[oPI]
-                        );
-                    }
-                }
-            }
-
-            cellVertices.transfer(newCellVertices);
-            cellVertexIndices.transfer(newCellVertexIndices);
-            cellVertexTypes.transfer(newCellVertexTypes);
-        }
-
         Info<< "    Background mesh refined from "
             << returnReduce(map().nOldCells(), sumOp<label>())
             << " to " << mesh_.globalData().nTotalCells()
@@ -1193,10 +1035,6 @@ Foam::backgroundMeshDecomposition::distribute
         cellWeights.write();
     }
 
-    mapDist().distributeCellData(cellVertices);
-    mapDist().distributeCellData(cellVertexIndices);
-    mapDist().distributeCellData(cellVertexTypes);
-
     buildPatchAndTree();
 
     return mapDist;
@@ -1227,8 +1065,10 @@ bool Foam::backgroundMeshDecomposition::positionOnThisProcessor
 //    return bFTreePtr_().findAnyOverlap(pt, 0.0);
 
     return
+    (
         bFTreePtr_().getVolumeType(pt)
-     == indexedOctree<treeDataBPatch>::INSIDE;
+     == indexedOctree<treeDataBPatch>::INSIDE
+    );
 }
 
 
@@ -1247,6 +1087,7 @@ Foam::boolList Foam::backgroundMeshDecomposition::positionOnThisProcessor
     return posProc;
 }
 
+
 bool Foam::backgroundMeshDecomposition::overlapsThisProcessor
 (
     const treeBoundBox& box
@@ -1660,110 +1501,304 @@ Foam::backgroundMeshDecomposition::intersectsProcessors
 }
 
 
-Foam::labelListList Foam::backgroundMeshDecomposition::overlapsProcessors
+bool Foam::backgroundMeshDecomposition::overlapsOtherProcessors
 (
-    const List<point>& centres,
-    const List<scalar>& radiusSqrs,
-    bool includeOwnProcessor
+    const point& centre,
+    const scalar& radiusSqr
 ) const
 {
-    DynamicList<label> toCandidateProc;
-    DynamicList<point> testCentres;
-    DynamicList<scalar> testRadiusSqrs;
-    labelList sphereBlockStart(centres.size(), -1);
-    labelList sphereBlockSize(centres.size(), -1);
-
-    label nTotalCandidates = 0;
-
-    forAll(centres, sI)
+    forAll(allBackgroundMeshBounds_, procI)
     {
-        const point& c = centres[sI];
-        scalar rSqr = radiusSqrs[sI];
-
-        label nCandidates = 0;
-
-        forAll(allBackgroundMeshBounds_, procI)
+        if (bFTreePtr_().findNearest(centre, radiusSqr).hit())
         {
-            // It is assumed that the sphere in question overlaps the source
-            // processor, so don't test it, unless includeOwnProcessor is true
-            if
-            (
-                (includeOwnProcessor || procI != Pstream::myProcNo())
-             && allBackgroundMeshBounds_[procI].overlaps(c, rSqr)
-            )
-            {
-                toCandidateProc.append(procI);
-                testCentres.append(c);
-                testRadiusSqrs.append(rSqr);
-
-                nCandidates++;
-            }
+            return true;
         }
-
-        sphereBlockStart[sI] = nTotalCandidates;
-        sphereBlockSize[sI] = nCandidates;
-
-        nTotalCandidates += nCandidates;
     }
 
-    // Needed for reverseDistribute
-    label preDistributionToCandidateProcSize = toCandidateProc.size();
-
-    autoPtr<mapDistribute> map(buildMap(toCandidateProc));
-
-    map().distribute(testCentres);
-    map().distribute(testRadiusSqrs);
-
-    List<bool> sphereOverlapsCandidate(testCentres.size(), false);
-
-    // Test candidate spheres on candidate processors
-    forAll(testCentres, sI)
-    {
-        const point& c = testCentres[sI];
-        scalar rSqr = testRadiusSqrs[sI];
-
-        // If the sphere finds a nearest element of the patch, then it overlaps
-        sphereOverlapsCandidate[sI] = bFTreePtr_().findNearest(c, rSqr).hit();
-        //sphereOverlapsCandidate[sI] = bFTreePtr_().findAnyOverlap(c, rSqr);
-    }
-
-    map().reverseDistribute
-    (
-        preDistributionToCandidateProcSize,
-        sphereOverlapsCandidate
-    );
-
-    labelListList sphereProcs(centres.size());
-
-    // Working storage for assessing processors
-    DynamicList<label> tmpProcs;
-
-    forAll(centres, sI)
-    {
-        tmpProcs.clear();
-
-        // Extract the sub list of results for this point
-
-        SubList<bool> sphereProcResults
-        (
-            sphereOverlapsCandidate,
-            sphereBlockSize[sI],
-            sphereBlockStart[sI]
-        );
-
-        forAll(sphereProcResults, sPRI)
-        {
-            if (sphereProcResults[sPRI])
-            {
-                tmpProcs.append(toCandidateProc[sphereBlockStart[sI] + sPRI]);
-            }
-        }
-
-        sphereProcs[sI] = tmpProcs;
-    }
-
-    return sphereProcs;
+    return false;
 }
 
 
+Foam::labelList Foam::backgroundMeshDecomposition::overlapProcessors
+(
+    const point& centre,
+    const scalar radiusSqr
+) const
+{
+    DynamicList<label> toProc(Pstream::nProcs());
+
+    forAll(allBackgroundMeshBounds_, procI)
+    {
+        // Test against the bounding box of the processor
+        if
+        (
+            procI != Pstream::myProcNo()
+         && allBackgroundMeshBounds_[procI].overlaps(centre, radiusSqr)
+        )
+        {
+            // Expensive test
+//            if (bFTreePtr_().findNearest(centre, radiusSqr).hit())
+            {
+                toProc.append(procI);
+            }
+        }
+    }
+
+    return toProc;
+}
+
+
+//Foam::labelListList Foam::backgroundMeshDecomposition::overlapsProcessors
+//(
+//    const List<point>& centres,
+//    const List<scalar>& radiusSqrs,
+//    const Delaunay& T,
+//    bool includeOwnProcessor
+//) const
+//{
+//    DynamicList<label> toCandidateProc;
+//    DynamicList<point> testCentres;
+//    DynamicList<scalar> testRadiusSqrs;
+//    labelList sphereBlockStart(centres.size(), -1);
+//    labelList sphereBlockSize(centres.size(), -1);
+//
+//    label nTotalCandidates = 0;
+//
+//    forAll(centres, sI)
+//    {
+//        const point& c = centres[sI];
+//        scalar rSqr = radiusSqrs[sI];
+//
+//        label nCandidates = 0;
+//
+//        forAll(allBackgroundMeshBounds_, procI)
+//        {
+//            // It is assumed that the sphere in question overlaps the source
+//            // processor, so don't test it, unless includeOwnProcessor is true
+//            if
+//            (
+//                (includeOwnProcessor || procI != Pstream::myProcNo())
+//             && allBackgroundMeshBounds_[procI].overlaps(c, rSqr)
+//            )
+//            {
+//                if (bFTreePtr_().findNearest(c, rSqr).hit())
+//                {
+//                    toCandidateProc.append(procI);
+//                    testCentres.append(c);
+//                    testRadiusSqrs.append(rSqr);
+//
+//                    nCandidates++;
+//                }
+//            }
+//        }
+//
+//        sphereBlockStart[sI] = nTotalCandidates;
+//        sphereBlockSize[sI] = nCandidates;
+//
+//        nTotalCandidates += nCandidates;
+//    }
+//
+//    // Needed for reverseDistribute
+////    label preDistributionToCandidateProcSize = toCandidateProc.size();
+////
+////    autoPtr<mapDistribute> map(buildMap(toCandidateProc));
+////
+////    map().distribute(testCentres);
+////    map().distribute(testRadiusSqrs);
+//
+//    // @todo This is faster, but results in more vertices being referred
+//    boolList sphereOverlapsCandidate(testCentres.size(), true);
+////    boolList sphereOverlapsCandidate(testCentres.size(), false);
+////
+////    // Test candidate spheres on candidate processors
+////    forAll(testCentres, sI)
+////    {
+////        const point& c = testCentres[sI];
+////        const scalar rSqr = testRadiusSqrs[sI];
+////
+////        const bool flagOverlap = bFTreePtr_().findNearest(c, rSqr).hit();
+////
+////        if (flagOverlap)
+////        {
+////            //if (vertexOctree.findAnyOverlap(c, rSqr))
+//////            if (vertexOctree.findNearest(c, rSqr*1.001).hit())
+//////            {
+//////                sphereOverlapsCandidate[sI] = true;
+//////            }
+////
+//////            Vertex_handle nearestVertex = T.nearest_vertex
+//////            (
+//////                toPoint<Point>(c)
+//////            );
+//////
+//////            const scalar distSqr = magSqr
+//////            (
+//////                topoint(nearestVertex->point()) - c
+//////            );
+//////
+//////            if (distSqr <= rSqr)
+//////            {
+//////                // If the sphere finds a nearest element of the patch,
+//////                // then it overlaps
+////                sphereOverlapsCandidate[sI] = true;
+//////            }
+////        }
+////    }
+//
+////    map().reverseDistribute
+////    (
+////        preDistributionToCandidateProcSize,
+////        sphereOverlapsCandidate
+////    );
+//
+//    labelListList sphereProcs(centres.size());
+//
+//    // Working storage for assessing processors
+//    DynamicList<label> tmpProcs;
+//
+//    forAll(centres, sI)
+//    {
+//        tmpProcs.clear();
+//
+//        // Extract the sub list of results for this point
+//
+//        SubList<bool> sphereProcResults
+//        (
+//            sphereOverlapsCandidate,
+//            sphereBlockSize[sI],
+//            sphereBlockStart[sI]
+//        );
+//
+//        forAll(sphereProcResults, sPRI)
+//        {
+//            if (sphereProcResults[sPRI])
+//            {
+//                tmpProcs.append(toCandidateProc[sphereBlockStart[sI] + sPRI]);
+//            }
+//        }
+//
+//        sphereProcs[sI] = tmpProcs;
+//    }
+//
+//    return sphereProcs;
+//}
+
+
+//Foam::labelListList Foam::backgroundMeshDecomposition::overlapProcessors
+//(
+//    const point& cc,
+//    const scalar rSqr
+//) const
+//{
+//    DynamicList<label> toCandidateProc;
+//    label sphereBlockStart(-1);
+//    label sphereBlockSize(-1);
+//
+//    label nCandidates = 0;
+//
+//    forAll(allBackgroundMeshBounds_, procI)
+//    {
+//        // It is assumed that the sphere in question overlaps the source
+//        // processor, so don't test it, unless includeOwnProcessor is true
+//        if
+//        (
+//            (includeOwnProcessor || procI != Pstream::myProcNo())
+//         && allBackgroundMeshBounds_[procI].overlaps(cc, rSqr)
+//        )
+//        {
+//            toCandidateProc.append(procI);
+//
+//            nCandidates++;
+//        }
+//    }
+//
+//    sphereBlockSize = nCandidates;
+//    nTotalCandidates += nCandidates;
+//
+//    // Needed for reverseDistribute
+//    label preDistributionToCandidateProcSize = toCandidateProc.size();
+//
+//    autoPtr<mapDistribute> map(buildMap(toCandidateProc));
+//
+//    map().distribute(testCentres);
+//    map().distribute(testRadiusSqrs);
+//
+//    // @todo This is faster, but results in more vertices being referred
+////    boolList sphereOverlapsCandidate(testCentres.size(), true);
+//    boolList sphereOverlapsCandidate(testCentres.size(), false);
+//
+//    // Test candidate spheres on candidate processors
+//    forAll(testCentres, sI)
+//    {
+//        const point& c = testCentres[sI];
+//        const scalar rSqr = testRadiusSqrs[sI];
+//
+//        const bool flagOverlap = bFTreePtr_().findNearest(c, rSqr).hit();
+//
+//        if (flagOverlap)
+//        {
+//            //if (vertexOctree.findAnyOverlap(c, rSqr))
+////            if (vertexOctree.findNearest(c, rSqr*1.001).hit())
+////            {
+////                sphereOverlapsCandidate[sI] = true;
+////            }
+//
+////            Vertex_handle nearestVertex = T.nearest_vertex
+////            (
+////                toPoint<Point>(c)
+////            );
+////
+////            const scalar distSqr = magSqr
+////            (
+////                topoint(nearestVertex->point()) - c
+////            );
+////
+////            if (distSqr <= rSqr)
+////            {
+////                // If the sphere finds a nearest element of the patch, then
+////                // it overlaps
+//                sphereOverlapsCandidate[sI] = true;
+////            }
+//        }
+//    }
+//
+//    map().reverseDistribute
+//    (
+//        preDistributionToCandidateProcSize,
+//        sphereOverlapsCandidate
+//    );
+//
+//    labelListList sphereProcs(centres.size());
+//
+//    // Working storage for assessing processors
+//    DynamicList<label> tmpProcs;
+//
+//    forAll(centres, sI)
+//    {
+//        tmpProcs.clear();
+//
+//        // Extract the sub list of results for this point
+//
+//        SubList<bool> sphereProcResults
+//        (
+//            sphereOverlapsCandidate,
+//            sphereBlockSize[sI],
+//            sphereBlockStart[sI]
+//        );
+//
+//        forAll(sphereProcResults, sPRI)
+//        {
+//            if (sphereProcResults[sPRI])
+//            {
+//                tmpProcs.append(toCandidateProc[sphereBlockStart[sI] + sPRI]);
+//            }
+//        }
+//
+//        sphereProcs[sI] = tmpProcs;
+//    }
+//
+//    return sphereProcs;
+//}
+
+
 // ************************************************************************* //
diff --git a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/backgroundMeshDecomposition/backgroundMeshDecomposition.H b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/backgroundMeshDecomposition/backgroundMeshDecomposition.H
index bcdd163834..73aa2fee74 100644
--- a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/backgroundMeshDecomposition/backgroundMeshDecomposition.H
+++ b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/backgroundMeshDecomposition/backgroundMeshDecomposition.H
@@ -53,7 +53,6 @@ SourceFiles
 #ifndef backgroundMeshDecomposition_H
 #define backgroundMeshDecomposition_H
 
-#include "conformalVoronoiMesh.H"
 #include "fvMesh.H"
 #include "hexRef8.H"
 #include "cellSet.H"
@@ -81,6 +80,10 @@ namespace Foam
 typedef PrimitivePatch<face, List, const pointField, point> bPatch;
 typedef treeDataPrimitivePatch<bPatch> treeDataBPatch;
 
+class Time;
+class Random;
+class conformationSurfaces;
+
 /*---------------------------------------------------------------------------*\
                   Class backgroundMeshDecomposition Declaration
 \*---------------------------------------------------------------------------*/
@@ -98,15 +101,9 @@ class backgroundMeshDecomposition
         //- Reference to surface
         const conformationSurfaces& geometryToConformTo_;
 
-        //- The cell size control object
-        const cellSizeControlSurfaces& cellSizeControl_;
-
         //- Random number generator
         Random& rndGen_;
 
-        //- Controls
-        const cvControls& cvMeshControls_;
-
         //- Mesh stored on for this processor, specifiying the domain that it
         //  is responsible for.
         fvMesh mesh_;
@@ -121,8 +118,6 @@ class backgroundMeshDecomposition
         //- Search tree for the boundaryFaces_ patch
         autoPtr<indexedOctree<treeDataBPatch> > bFTreePtr_;
 
-        List<scalar> octreeNearestDistances_;
-
         //- The bounds of all background meshes on all processors
         treeBoundBoxList allBackgroundMeshBounds_;
 
@@ -204,24 +199,10 @@ public:
         //- Construct from components in cvMesh operation
         backgroundMeshDecomposition
         (
-            const dictionary& coeffsDict,
-            const conformalVoronoiMesh& cvMesh
-        );
-
-        //- Construct from components for standalone operation
-        backgroundMeshDecomposition
-        (
-            const scalar spanScale,
-            const scalar minCellSizeLimit,
-            const label minLevels,
-            const label volRes,
-            const scalar maxCellWeightCoeff,
-
             const Time& runTime,
-            const conformationSurfaces& geometryToConformTo,
-            const cellSizeControlSurfaces& cellSizeControl,
             Random& rndGen,
-            const cvControls& cvMeshControls
+            const conformationSurfaces& geometryToConformTo,
+            const dictionary& coeffsDict
         );
 
 
@@ -238,10 +219,7 @@ public:
         //  returning a map to use to redistribute vertices.
         autoPtr<mapDistributePolyMesh> distribute
         (
-            volScalarField& cellWeights,
-            List<DynamicList<point> >& cellVertices,
-            List<DynamicList<label> >& cellVertexIndices,
-            List<DynamicList<label> >& cellVertexTypes
+            volScalarField& cellWeights
         );
 
         //- Distribute supplied the points to the appropriate processor
@@ -300,18 +278,31 @@ public:
             bool includeOwnProcessor = false
         ) const;
 
-        //- Which processors overlap the given sphere, returns all processors
-        //  whose boundary patch is touched by the sphere or whom the sphere is
-        //  inside.  By default this does not return the processor that the
-        //  query is launched from, it is assumed that the point is on that
-        //  processor.
-        labelListList overlapsProcessors
+        bool overlapsOtherProcessors
         (
-            const List<point>& centres,
-            const List<scalar>& radiusSqrs,
-            bool includeOwnProcessor = false
+            const point& centre,
+            const scalar& radiusSqr
         ) const;
 
+        labelList overlapProcessors
+        (
+            const point& centre,
+            const scalar radiusSqr
+        ) const;
+
+//        //- Which processors overlap the given sphere, returns all processors
+//        //  whose boundary patch is touched by the sphere or whom the sphere
+//        //  is inside.  By default this does not return the processor that the
+//        //  query is launched from, it is assumed that the point is on that
+//        //  processor.
+//        labelListList overlapsProcessors
+//        (
+//            const List<point>& centres,
+//            const List<scalar>& radiusSqrs,
+//            const Delaunay& T,
+//            bool includeOwnProcessor
+//        ) const;
+
         // Access
 
             //- Return access to the underlying mesh
@@ -320,9 +311,6 @@ public:
             //- Return access to the underlying tree
             inline const indexedOctree<treeDataBPatch>& tree() const;
 
-            //- Return access to the nearest distance of the octree nodes
-            inline const List<scalar>& octreeNearestDistances() const;
-
             //- Return the boundBox of this processor
             inline const treeBoundBox& procBounds() const;
 
diff --git a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/backgroundMeshDecomposition/backgroundMeshDecompositionI.H b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/backgroundMeshDecomposition/backgroundMeshDecompositionI.H
index 44a007193d..1f8b7b0a32 100644
--- a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/backgroundMeshDecomposition/backgroundMeshDecompositionI.H
+++ b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/backgroundMeshDecomposition/backgroundMeshDecompositionI.H
@@ -30,18 +30,13 @@ const Foam::fvMesh& Foam::backgroundMeshDecomposition::mesh() const
     return mesh_;
 }
 
+
 const Foam::indexedOctree<Foam::treeDataBPatch>&
 Foam::backgroundMeshDecomposition::tree() const
 {
     return bFTreePtr_();
 }
 
-const Foam::List<Foam::scalar>&
-Foam::backgroundMeshDecomposition::octreeNearestDistances() const
-{
-    return octreeNearestDistances_;
-}
-
 
 const Foam::treeBoundBox&
 Foam::backgroundMeshDecomposition::procBounds() const
diff --git a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellShapeControl/cellAspectRatioControl/cellAspectRatioControl.C b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellShapeControl/cellAspectRatioControl/cellAspectRatioControl.C
new file mode 100644
index 0000000000..dfba259e67
--- /dev/null
+++ b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellShapeControl/cellAspectRatioControl/cellAspectRatioControl.C
@@ -0,0 +1,110 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "cellAspectRatioControl.H"
+#include "vectorTools.H"
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::cellAspectRatioControl::cellAspectRatioControl
+(
+    const dictionary& motionDict
+)
+:
+    aspectRatioDict_(motionDict.subOrEmptyDict("cellAspectRatioControl")),
+    aspectRatio_(aspectRatioDict_.lookupOrDefault<scalar>("aspectRatio", 1.0)),
+    aspectRatioDirection_
+    (
+        aspectRatioDict_.lookupOrDefault<vector>
+        (
+            "aspectRatioDirection",
+            vector(0, 0, 0)
+        )
+    )
+{
+    Info<< nl << "    Cell Aspect Ratio Control" << nl
+        << "        Ratio     : " << aspectRatio_ << nl
+        << "        Direction : " << aspectRatioDirection_ << nl << endl;
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::cellAspectRatioControl::~cellAspectRatioControl()
+{}
+
+
+// * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
+
+void Foam::cellAspectRatioControl::updateCellSizeAndFaceArea
+(
+    vector& alignmentDir,
+    scalar& targetFaceArea,
+    scalar& targetCellSize
+) const
+{
+    const scalar cosAngle = mag
+    (
+        vectorTools::cosPhi(alignmentDir, aspectRatioDirection_)
+    );
+
+    // Change target face area based on aspect ratio
+    targetFaceArea
+        += targetFaceArea
+          *(aspectRatio_ - 1.0)
+          *(1.0 - cosAngle);
+
+    // Change target cell size based on aspect ratio
+    targetCellSize
+        += targetCellSize
+          *(aspectRatio_ - 1.0)
+          *cosAngle;
+
+    alignmentDir *= 0.5*targetCellSize;
+}
+
+
+void Foam::cellAspectRatioControl::updateDeltaVector
+(
+    const vector& alignmentDir,
+    const scalar targetCellSize,
+    const scalar rABMag,
+    vector& delta
+) const
+{
+    const scalar cosAngle = mag
+    (
+        vectorTools::cosPhi(alignmentDir, aspectRatioDirection_)
+    );
+
+    delta += 0.5
+            *delta
+            *cosAngle
+            *(targetCellSize/rABMag)
+            *(aspectRatio_ - 1.0);
+}
+
+
+// ************************************************************************* //
diff --git a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellShapeControl/cellAspectRatioControl/cellAspectRatioControl.H b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellShapeControl/cellAspectRatioControl/cellAspectRatioControl.H
new file mode 100644
index 0000000000..ac47311940
--- /dev/null
+++ b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellShapeControl/cellAspectRatioControl/cellAspectRatioControl.H
@@ -0,0 +1,115 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 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::cellAspectRatioControl
+
+Description
+
+SourceFiles
+    cellAspectRatioControl.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef cellAspectRatioControl_H
+#define cellAspectRatioControl_H
+
+#include "dictionary.H"
+#include "vector.H"
+#include "scalar.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+
+/*---------------------------------------------------------------------------*\
+                     Class cellAspectRatioControl Declaration
+\*---------------------------------------------------------------------------*/
+
+class cellAspectRatioControl
+{
+    // Private data
+
+        const dictionary aspectRatioDict_;
+
+        const scalar aspectRatio_;
+
+        const vector aspectRatioDirection_;
+
+
+    // Private Member Functions
+
+        //- Disallow default bitwise copy construct
+        cellAspectRatioControl(const cellAspectRatioControl&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const cellAspectRatioControl&);
+
+
+public:
+
+    // Constructors
+
+        //- Construct from dictionary
+        cellAspectRatioControl
+        (
+            const dictionary& motionDict
+        );
+
+
+    //- Destructor
+    virtual ~cellAspectRatioControl();
+
+
+    // Member Functions
+
+        // Query
+
+            void updateCellSizeAndFaceArea
+            (
+                vector& alignmentDir,
+                scalar& targetFaceArea,
+                scalar& targetCellSize
+            ) const;
+
+            void updateDeltaVector
+            (
+                const vector& alignmentDir,
+                const scalar targetCellSize,
+                const scalar rABMag,
+                vector& delta
+            ) const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellShapeControl/cellShapeControl/cellShapeControl.C b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellShapeControl/cellShapeControl/cellShapeControl.C
new file mode 100644
index 0000000000..a6b47f4ab0
--- /dev/null
+++ b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellShapeControl/cellShapeControl/cellShapeControl.C
@@ -0,0 +1,922 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "cellShapeControl.H"
+#include "pointField.H"
+#include "scalarField.H"
+#include "cellSizeAndAlignmentControl.H"
+#include "searchableSurfaceControl.H"
+#include "cellSizeFunction.H"
+#include "triad.H"
+
+// * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * * //
+
+template <class Triangulation, class Type>
+Foam::tmp<Foam::Field<Type> > Foam::cellShapeControl::filterFarPoints
+(
+    const Triangulation& mesh,
+    const Field<Type>& field
+)
+{
+    tmp<Field<Type> > tNewField(new Field<Type>(field.size()));
+    Field<Type>& newField = tNewField();
+
+    label added = 0;
+    label count = 0;
+
+    for
+    (
+        typename Triangulation::Finite_vertices_iterator vit =
+            mesh.finite_vertices_begin();
+        vit != mesh.finite_vertices_end();
+        ++vit
+    )
+    {
+        if (vit->real())
+        {
+            newField[added++] = field[count];
+        }
+
+        count++;
+    }
+
+    newField.resize(added);
+
+    return tNewField;
+}
+
+
+template <class Triangulation>
+Foam::autoPtr<Foam::mapDistribute> Foam::cellShapeControl::buildReferredMap
+(
+    const Triangulation& mesh,
+    labelList& indices
+)
+{
+    globalIndex globalIndexing(mesh.vertexCount());
+
+    DynamicList<label> dynIndices(mesh.vertexCount()/10);
+
+    for
+    (
+        typename Triangulation::Finite_vertices_iterator vit =
+            mesh.finite_vertices_begin();
+        vit != mesh.finite_vertices_end();
+        ++vit
+    )
+    {
+        if (vit->referred())
+        {
+            dynIndices.append
+            (
+                globalIndexing.toGlobal(vit->procIndex(), vit->index())
+            );
+        }
+    }
+
+    indices.transfer(dynIndices);
+
+    List<Map<label> > compactMap;
+    return autoPtr<mapDistribute>
+    (
+        new mapDistribute
+        (
+            globalIndexing,
+            indices,
+            compactMap
+        )
+    );
+}
+
+
+template <class Triangulation>
+Foam::autoPtr<Foam::mapDistribute> Foam::cellShapeControl::buildMap
+(
+    const Triangulation& mesh,
+    labelListList& pointPoints
+)
+{
+    pointPoints.setSize(mesh.vertexCount());
+
+    globalIndex globalIndexing(mesh.vertexCount());
+
+    for
+    (
+        typename Triangulation::Finite_vertices_iterator vit =
+            mesh.finite_vertices_begin();
+        vit != mesh.finite_vertices_end();
+        ++vit
+    )
+    {
+        if (!vit->real())
+        {
+            continue;
+        }
+
+        std::list<typename Triangulation::Vertex_handle> adjVerts;
+        mesh.finite_adjacent_vertices(vit, std::back_inserter(adjVerts));
+
+        DynamicList<label> indices(adjVerts.size());
+
+        for
+        (
+            typename std::list<typename Triangulation::Vertex_handle>::
+                const_iterator adjVertI = adjVerts.begin();
+            adjVertI != adjVerts.end();
+            ++adjVertI
+        )
+        {
+            typename Triangulation::Vertex_handle vh = *adjVertI;
+
+            if (!vh->farPoint())
+            {
+                indices.append
+                (
+                    globalIndexing.toGlobal(vh->procIndex(), vh->index())
+                );
+            }
+        }
+
+        pointPoints[vit->index()].transfer(indices);
+    }
+
+    List<Map<label> > compactMap;
+    return autoPtr<mapDistribute>
+    (
+        new mapDistribute
+        (
+            globalIndexing,
+            pointPoints,
+            compactMap
+        )
+    );
+}
+
+
+template <class Triangulation>
+Foam::tmp<Foam::triadField> Foam::cellShapeControl::buildAlignmentField
+(
+    const Triangulation& mesh
+)
+{
+    tmp<triadField> tAlignments
+    (
+        new triadField(mesh.vertexCount(), triad::unset)
+    );
+    triadField& alignments = tAlignments();
+
+    for
+    (
+        typename Triangulation::Finite_vertices_iterator vit =
+            mesh.finite_vertices_begin();
+        vit != mesh.finite_vertices_end();
+        ++vit
+    )
+    {
+        if (!vit->real())
+        {
+            continue;
+        }
+
+        alignments[vit->index()] = triad
+        (
+            vit->alignment().x(),
+            vit->alignment().y(),
+            vit->alignment().z()
+        );
+    }
+
+    return tAlignments;
+}
+
+
+template <class Triangulation>
+Foam::tmp<Foam::pointField> Foam::cellShapeControl::buildPointField
+(
+    const Triangulation& mesh
+)
+{
+    tmp<pointField> tPoints
+    (
+        new pointField(mesh.vertexCount(), point(GREAT, GREAT, GREAT))
+    );
+    pointField& points = tPoints();
+
+    for
+    (
+        typename Triangulation::Finite_vertices_iterator vit =
+            mesh.finite_vertices_begin();
+        vit != mesh.finite_vertices_end();
+        ++vit
+    )
+    {
+        if (!vit->real())
+        {
+            continue;
+        }
+
+        points[vit->index()] = topoint(vit->point());
+    }
+
+    return tPoints;
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::cellShapeControl::cellShapeControl
+(
+    const Time& runTime,
+    const dictionary& motionDict,
+    const searchableSurfaces& allGeometry,
+    const conformationSurfaces& geometryToConformTo
+)
+:
+    dictionary(motionDict),
+    runTime_(runTime),
+    allGeometry_(allGeometry),
+    geometryToConformTo_(geometryToConformTo),
+    defaultCellSize_(readScalar(lookup("defaultCellSize"))),
+    shapeControlMesh_(runTime),
+    aspectRatio_(motionDict),
+    sizeAndAlignment_
+    (
+        runTime,
+        motionDict.subDict("shapeControlFunctions"),
+        geometryToConformTo
+    )
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::cellShapeControl::~cellShapeControl()
+{}
+
+
+// * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
+
+Foam::scalarField Foam::cellShapeControl::cellSize
+(
+    const pointField& pts
+) const
+{
+    scalarField cellSizes(pts.size());
+
+    forAll(pts, i)
+    {
+        cellSizes[i] = cellSize(pts[i]);
+    }
+
+    return cellSizes;
+}
+
+
+Foam::scalar Foam::cellShapeControl::cellSize(const point& pt) const
+{
+    scalarList bary;
+    cellShapeControlMesh::Cell_handle ch;
+
+    shapeControlMesh_.barycentricCoords(pt, bary, ch);
+
+    scalar size = 0;
+
+    label nFarPoints = 0;
+    for (label pI = 0; pI < 4; ++pI)
+    {
+        if (ch->vertex(pI)->farPoint())
+        {
+            nFarPoints++;
+        }
+    }
+
+    if (shapeControlMesh_.is_infinite(ch))
+    {
+//        if (nFarPoints != 0)
+//        {
+//            for (label pI = 0; pI < 4; ++pI)
+//            {
+//                if (!ch->vertex(pI)->farPoint())
+//                {
+//                    size = ch->vertex(pI)->targetCellSize();
+//                    return size;
+//                }
+//            }
+//        }
+
+        // Look up nearest point
+        cellShapeControlMesh::Vertex_handle nearV =
+            shapeControlMesh_.nearest_vertex
+            (
+                toPoint<cellShapeControlMesh::Point>(pt)
+            );
+
+        size = nearV->targetCellSize();
+    }
+    else
+    {
+        if (nFarPoints != 0)
+        {
+            for (label pI = 0; pI < 4; ++pI)
+            {
+                if (!ch->vertex(pI)->farPoint())
+                {
+                    size = ch->vertex(pI)->targetCellSize();
+                    return size;
+                }
+            }
+        }
+        else
+        {
+            forAll(bary, pI)
+            {
+                size += bary[pI]*ch->vertex(pI)->targetCellSize();
+            }
+        }
+    }
+
+    return size;
+}
+
+
+//- Return the cell alignment at the given location
+Foam::tensor Foam::cellShapeControl::cellAlignment(const point& pt) const
+{
+    scalarList bary;
+    cellShapeControlMesh::Cell_handle ch;
+
+    shapeControlMesh_.barycentricCoords(pt, bary, ch);
+
+    tensor alignment = tensor::zero;
+
+    label nFarPoints = 0;
+    for (label pI = 0; pI < 4; ++pI)
+    {
+        if (ch->vertex(pI)->farPoint())
+        {
+            nFarPoints++;
+        }
+    }
+
+    if (shapeControlMesh_.is_infinite(ch) || nFarPoints == 4)
+    {
+        Pout<< "At Infinite vertex" << endl;
+
+        if (nFarPoints != 0)
+        {
+            for (label pI = 0; pI < 4; ++pI)
+            {
+                if (!ch->vertex(pI)->farPoint())
+                {
+                    alignment = ch->vertex(pI)->alignment();
+                    return alignment;
+                }
+            }
+        }
+
+//        cellShapeControlMesh::Vertex_handle nearV =
+//            shapeControlMesh_.nearest_vertex
+//            (
+//                toPoint<cellShapeControlMesh::Point>(pt)
+//            );
+//
+//        alignment = nearV->alignment();
+    }
+    else
+    {
+//        forAll(bary, pI)
+//        {
+//            alignment += bary[pI]*ch->vertex(pI)->alignment();
+//        }
+
+        cellShapeControlMesh::Vertex_handle nearV =
+            shapeControlMesh_.nearest_vertex_in_cell
+            (
+                toPoint<cellShapeControlMesh::Point>(pt),
+                ch
+            );
+
+        alignment = nearV->alignment();
+    }
+
+    return alignment;
+}
+
+
+void Foam::cellShapeControl::cellSizeAndAlignment
+(
+    const point& pt,
+    scalar& size,
+    tensor& alignment
+) const
+{
+    scalarList bary;
+    cellShapeControlMesh::Cell_handle ch;
+
+    shapeControlMesh_.barycentricCoords(pt, bary, ch);
+
+    alignment = tensor::zero;
+    size = 0;
+
+    label nFarPoints = 0;
+    for (label pI = 0; pI < 4; ++pI)
+    {
+        if (ch->vertex(pI)->farPoint())
+        {
+            nFarPoints++;
+        }
+    }
+
+    if (shapeControlMesh_.is_infinite(ch))
+    {
+        if (nFarPoints != 0)
+        {
+            for (label pI = 0; pI < 4; ++pI)
+            {
+                if (!ch->vertex(pI)->farPoint())
+                {
+                    size = ch->vertex(pI)->targetCellSize();
+                    alignment = ch->vertex(pI)->alignment();
+                    return;
+                }
+            }
+        }
+
+//        cellShapeControlMesh::Vertex_handle nearV =
+//            shapeControlMesh_.nearest_vertex
+//            (
+//                toPoint<cellShapeControlMesh::Point>(pt)
+//            );
+//
+//        size = nearV->targetCellSize();
+//        alignment = nearV->alignment();
+    }
+    else
+    {
+        if (nFarPoints != 0)
+        {
+            for (label pI = 0; pI < 4; ++pI)
+            {
+                if (!ch->vertex(pI)->farPoint())
+                {
+                    size = ch->vertex(pI)->targetCellSize();
+                    alignment = ch->vertex(pI)->alignment();
+                    return;
+                }
+            }
+        }
+        else
+        {
+            triad tri;
+
+            forAll(bary, pI)
+            {
+                size += bary[pI]*ch->vertex(pI)->targetCellSize();
+
+                triad triTmp2
+                (
+                    ch->vertex(pI)->alignment().x(),
+                    ch->vertex(pI)->alignment().y(),
+                    ch->vertex(pI)->alignment().z()
+                );
+
+                tri += triTmp2*bary[pI];
+            }
+
+            tri.normalize();
+            tri.orthogonalize();
+            tri = tri.sortxyz();
+
+            alignment = tensor
+            (
+                tri.x(), tri.y(), tri.z()
+            );
+        }
+    }
+}
+
+
+void Foam::cellShapeControl::initialMeshPopulation
+(
+    const autoPtr<backgroundMeshDecomposition>& decomposition
+)
+{
+    // Need to pass in the background mesh decomposition so that can test if
+    // a point to insert is on the processor.
+    if (Pstream::parRun())
+    {
+        shapeControlMesh_.insertBoundingPoints(decomposition().procBounds());
+    }
+    else
+    {
+        shapeControlMesh_.insertBoundingPoints(allGeometry_.bounds());
+    }
+
+    const PtrList<cellSizeAndAlignmentControl>& controlFunctions =
+        sizeAndAlignment_.controlFunctions();
+
+    forAll(controlFunctions, fI)
+    {
+        const cellSizeAndAlignmentControl& controlFunction =
+            controlFunctions[fI];
+
+        Info<< "Inserting points from " << controlFunction.name()
+            << " (" << controlFunction.type() << ")" << endl;
+
+        pointField pts(1);
+        scalarField sizes(1);
+        Field<triad> alignments(1);
+
+        controlFunction.initialVertices(pts, sizes, alignments);
+
+        label nRejected = 0;
+
+        forAll(pts, pI)
+        {
+            if (Pstream::parRun())
+            {
+                if (!decomposition().positionOnThisProcessor(pts[pI]))
+                {
+                    nRejected++;
+                    continue;
+                }
+            }
+
+            shapeControlMesh_.insert
+            (
+                pts[pI],
+                sizes[pI],
+                alignments[pI]
+            );
+        }
+
+        Info<< "    Inserted "
+            << returnReduce(pts.size() - nRejected, sumOp<label>())
+            << "/" << pts.size()
+            << endl;
+    }
+}
+
+
+Foam::label Foam::cellShapeControl::refineMesh
+(
+    const autoPtr<backgroundMeshDecomposition>& decomposition
+)
+{
+    const pointField cellCentres = shapeControlMesh_.cellCentres();
+
+    Info<< "    Created cell centres" << endl;
+
+    const PtrList<cellSizeAndAlignmentControl>& controlFunctions =
+        sizeAndAlignment_.controlFunctions();
+
+    DynamicList<Vb> verts(shapeControlMesh_.number_of_vertices());
+
+    forAll(cellCentres, cellI)
+    {
+        const Foam::point& pt = cellCentres[cellI];
+
+        if (!geometryToConformTo_.inside(pt))
+        {
+            continue;
+        }
+
+        scalarList bary;
+        cellShapeControlMesh::Cell_handle ch;
+
+        shapeControlMesh_.barycentricCoords(pt, bary, ch);
+
+        if (shapeControlMesh_.is_infinite(ch))
+        {
+            continue;
+        }
+
+        scalar interpolatedSize = 0;
+        forAll(bary, pI)
+        {
+            interpolatedSize += bary[pI]*ch->vertex(pI)->targetCellSize();
+        }
+
+        label lastPriority = labelMax;
+        scalar lastCellSize = GREAT;
+        forAll(controlFunctions, fI)
+        {
+            const cellSizeAndAlignmentControl& controlFunction =
+                controlFunctions[fI];
+
+            if (controlFunction.priority() > lastPriority)
+            {
+                continue;
+            }
+
+            if (isA<searchableSurfaceControl>(controlFunction))
+            {
+                const cellSizeFunction& sizeFunction =
+                    dynamicCast<const searchableSurfaceControl>
+                    (
+                        controlFunction
+                    ).sizeFunction();
+
+                scalar cellSize = 0;
+                if (sizeFunction.cellSize(pt, cellSize))
+                {
+                    if (controlFunction.priority() == lastPriority)
+                    {
+                        if (cellSize < lastCellSize)
+                        {
+                            lastCellSize = cellSize;
+                        }
+                    }
+                    else
+                    {
+                        lastCellSize = cellSize;
+                    }
+
+                    lastPriority = controlFunction.priority();
+                }
+            }
+        }
+
+        if
+        (
+            lastCellSize < GREAT
+         && mag(interpolatedSize - lastCellSize)/lastCellSize > 0.2
+        )
+        {
+            if (Pstream::parRun())
+            {
+                if (!decomposition().positionOnThisProcessor(pt))
+                {
+                    continue;
+                }
+            }
+
+            verts.append
+            (
+                Vb
+                (
+                    toPoint<cellShapeControlMesh::Point>(pt),
+                    Vb::vtInternal
+                )
+            );
+            verts.last().targetCellSize() = lastCellSize;
+            verts.last().alignment() = tensor::I;
+        }
+    }
+
+    shapeControlMesh_.insertPoints(verts);
+
+    return verts.size();
+}
+
+
+void Foam::cellShapeControl::smoothMesh()
+{
+    label maxSmoothingIterations = 200;
+    scalar minResidual = 0;
+
+    labelListList pointPoints;
+    autoPtr<mapDistribute> meshDistributor = buildMap
+    (
+        shapeControlMesh_,
+        pointPoints
+    );
+
+    triadField alignments = buildAlignmentField(shapeControlMesh_);
+    pointField points = buildPointField(shapeControlMesh_);
+    // Setup the sizes and alignments on each point
+    triadField fixedAlignments(shapeControlMesh_.vertexCount(), triad::unset);
+
+    for
+    (
+        CellSizeDelaunay::Finite_vertices_iterator vit =
+            shapeControlMesh_.finite_vertices_begin();
+        vit != shapeControlMesh_.finite_vertices_end();
+        ++vit
+    )
+    {
+        if (vit->real())
+        {
+            const tensor& alignment = vit->alignment();
+
+            fixedAlignments[vit->index()] = triad
+            (
+                alignment.x(),
+                alignment.y(),
+                alignment.z()
+            );
+        }
+    }
+
+    Info<< nl << "Smoothing alignments" << endl;
+
+    for (label iter = 0; iter < maxSmoothingIterations; iter++)
+    {
+        Info<< "Iteration " << iter;
+
+        meshDistributor().distribute(points);
+        meshDistributor().distribute(alignments);
+
+        scalar residual = 0;
+
+        triadField triadAv(alignments.size(), triad::unset);
+
+        forAll(pointPoints, pI)
+        {
+            const labelList& pPoints = pointPoints[pI];
+
+            if (pPoints.empty())
+            {
+                continue;
+            }
+
+            triad& newTriad = triadAv[pI];
+
+            forAll(pPoints, adjPointI)
+            {
+                const label adjPointIndex = pPoints[adjPointI];
+
+                scalar dist = mag(points[pI] - points[adjPointIndex]);
+
+                dist = max(dist, SMALL);
+
+                triad tmpTriad = alignments[adjPointIndex];
+
+                for (direction dir = 0; dir < 3; dir++)
+                {
+                    if (tmpTriad.set(dir))
+                    {
+                        tmpTriad[dir] *= (1.0/dist);
+                    }
+                }
+
+                newTriad += tmpTriad;
+            }
+
+            newTriad.normalize();
+            newTriad.orthogonalize();
+            newTriad = newTriad.sortxyz();
+
+            // Enforce the boundary conditions
+            const triad& fixedAlignment = fixedAlignments[pI];
+
+            label nFixed = 0;
+
+            forAll(fixedAlignment, dirI)
+            {
+                if (fixedAlignment[dirI] != triad::unset[dirI])
+                {
+                    nFixed++;
+                }
+            }
+
+            if (nFixed == 1)
+            {
+                forAll(fixedAlignment, dirI)
+                {
+                    if (fixedAlignment.set(dirI))
+                    {
+                        newTriad.align(fixedAlignment[dirI]);
+                    }
+                }
+            }
+            else if (nFixed == 2)
+            {
+                forAll(fixedAlignment, dirI)
+                {
+                    if (fixedAlignment.set(dirI))
+                    {
+                        newTriad[dirI] = fixedAlignment[dirI];
+                    }
+                    else
+                    {
+                        newTriad[dirI] = triad::unset[dirI];
+                    }
+                }
+
+                newTriad.orthogonalize();
+            }
+            else if (nFixed == 3)
+            {
+                forAll(fixedAlignment, dirI)
+                {
+                    if (fixedAlignment.set(dirI))
+                    {
+                        newTriad[dirI] = fixedAlignment[dirI];
+                    }
+                }
+            }
+
+            const triad& oldTriad = alignments[pI];
+
+            if (newTriad.set(vector::X) && oldTriad.set(vector::X))
+            {
+                scalar dotProd = (oldTriad.x() & newTriad.x());
+
+                scalar diff = mag(dotProd) - 1.0;
+                residual += mag(diff);
+            }
+            if (newTriad.set(vector::Y) && oldTriad.set(vector::Y))
+            {
+                scalar dotProd = (oldTriad.y() & newTriad.y());
+
+                scalar diff = mag(dotProd) - 1.0;
+                residual += mag(diff);
+            }
+            if (newTriad.set(vector::Z) && oldTriad.set(vector::Z))
+            {
+                scalar dotProd = (oldTriad.z() & newTriad.z());
+
+                scalar diff = mag(dotProd) - 1.0;
+                residual += mag(diff);
+            }
+        }
+
+        forAll(alignments, pI)
+        {
+            alignments[pI] = triadAv[pI].sortxyz();
+        }
+
+        reduce(residual, sumOp<scalar>());
+
+        Info<< ", Residual = " << residual << endl;
+
+        if (residual <= minResidual)
+        {
+            break;
+        }
+    }
+
+    meshDistributor().distribute(alignments);
+
+    for
+    (
+        CellSizeDelaunay::Finite_vertices_iterator vit =
+            shapeControlMesh_.finite_vertices_begin();
+        vit != shapeControlMesh_.finite_vertices_end();
+        ++vit
+    )
+    {
+        if (vit->real())
+        {
+            vit->alignment() = tensor
+            (
+                alignments[vit->index()].x(),
+                alignments[vit->index()].y(),
+                alignments[vit->index()].z()
+            );
+        }
+    }
+
+    labelList referredPoints;
+    autoPtr<mapDistribute> referredDistributor = buildReferredMap
+    (
+        shapeControlMesh_,
+        referredPoints
+    );
+
+    alignments.setSize(shapeControlMesh_.vertexCount());
+    referredDistributor().distribute(alignments);
+
+    label referredI = 0;
+    for
+    (
+        CellSizeDelaunay::Finite_vertices_iterator vit =
+            shapeControlMesh_.finite_vertices_begin();
+        vit != shapeControlMesh_.finite_vertices_end();
+        ++vit
+    )
+    {
+        if (vit->referred())
+        {
+            const triad& t = alignments[referredPoints[referredI++]];
+
+            vit->alignment() = tensor(t.x(), t.y(), t.z());
+        }
+    }
+}
+
+
+// ************************************************************************* //
diff --git a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellShapeControl/cellShapeControl/cellShapeControl.H b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellShapeControl/cellShapeControl/cellShapeControl.H
new file mode 100644
index 0000000000..3bffe717f7
--- /dev/null
+++ b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellShapeControl/cellShapeControl/cellShapeControl.H
@@ -0,0 +1,212 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 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::cellShapeControl
+
+Description
+
+SourceFiles
+    cellShapeControlI.H
+    cellShapeControl.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef cellShapeControl_H
+#define cellShapeControl_H
+
+#include "dictionary.H"
+#include "autoPtr.H"
+#include "tensor.H"
+#include "point.H"
+#include "primitiveFieldsFwd.H"
+#include "pointFieldFwd.H"
+#include "triadField.H"
+#include "Time.H"
+#include "searchableSurfaces.H"
+#include "conformationSurfaces.H"
+#include "cellAspectRatioControl.H"
+#include "cellSizeAndAlignmentControls.H"
+#include "cellShapeControlMesh.H"
+#include "backgroundMeshDecomposition.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+
+/*---------------------------------------------------------------------------*\
+                     Class cellShapeControl Declaration
+\*---------------------------------------------------------------------------*/
+
+class cellShapeControl
+:
+    public dictionary
+{
+    // Private data
+
+        const Time& runTime_;
+
+        const searchableSurfaces& allGeometry_;
+
+        const conformationSurfaces& geometryToConformTo_;
+
+        const scalar defaultCellSize_;
+
+        cellShapeControlMesh shapeControlMesh_;
+
+        cellAspectRatioControl aspectRatio_;
+
+        cellSizeAndAlignmentControls sizeAndAlignment_;
+
+
+    // Private Member Functions
+
+        template <class Triangulation, class Type>
+        tmp<Field<Type> > filterFarPoints
+        (
+            const Triangulation& mesh,
+            const Field<Type>& field
+        );
+
+        template <class Triangulation>
+        autoPtr<mapDistribute> buildMap
+        (
+            const Triangulation& mesh,
+            labelListList& pointPoints
+        );
+
+        template <class Triangulation>
+        autoPtr<mapDistribute> buildReferredMap
+        (
+            const Triangulation& mesh,
+            labelList& indices
+        );
+
+        template <class Triangulation>
+        tmp<triadField> buildAlignmentField(const Triangulation& mesh);
+
+        template <class Triangulation>
+        tmp<pointField> buildPointField(const Triangulation& mesh);
+
+        //- Disallow default bitwise copy construct
+        cellShapeControl(const cellShapeControl&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const cellShapeControl&);
+
+
+public:
+
+    //- Runtime type information
+    ClassName("cellShapeControl");
+
+
+    // Constructors
+
+        //- Construct from dictionary and references to conformalVoronoiMesh and
+        //  searchableSurfaces
+        cellShapeControl
+        (
+            const Time& runTime,
+            const dictionary& cellShapeControlDict,
+            const searchableSurfaces& allGeometry,
+            const conformationSurfaces& geometryToConformTo
+        );
+
+
+    //- Destructor
+    ~cellShapeControl();
+
+
+    // Member Functions
+
+        // Access
+
+            inline const scalar& defaultCellSize() const;
+
+            inline cellShapeControlMesh& shapeControlMesh();
+
+            inline const cellShapeControlMesh& shapeControlMesh() const;
+
+            inline const cellAspectRatioControl& aspectRatio() const;
+
+            inline const cellSizeAndAlignmentControls& sizeAndAlignment() const;
+
+
+        // Query
+
+            //- Return the cell size at the given location
+            scalar cellSize(const point& pt) const;
+
+            scalarField cellSize(const pointField& pts) const;
+
+            //- Return the cell alignment at the given location
+            tensor cellAlignment(const point& pt) const;
+
+            void cellSizeAndAlignment
+            (
+                const point& pt,
+                scalar& size,
+                tensor& alignment
+            ) const;
+
+
+        // Edit
+
+            void initialMeshPopulation
+            (
+                const autoPtr<backgroundMeshDecomposition>& decomposition
+            );
+
+            label refineMesh
+            (
+                const autoPtr<backgroundMeshDecomposition>& decomposition
+            );
+
+            void smoothMesh();
+
+            //- Add a control point with a specified size and alignment
+//            virtual void addControlPoint
+//            (
+//                const point& pt,
+//                const scalar& size,
+//                const tensor& alignment
+//            );
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#include "cellShapeControlI.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellShapeControl/cellShapeControl/cellShapeControlI.H b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellShapeControl/cellShapeControl/cellShapeControlI.H
new file mode 100644
index 0000000000..f7fdebc931
--- /dev/null
+++ b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellShapeControl/cellShapeControl/cellShapeControlI.H
@@ -0,0 +1,55 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+inline Foam::cellShapeControlMesh&
+Foam::cellShapeControl::shapeControlMesh()
+{
+    return shapeControlMesh_;
+}
+
+
+inline const Foam::cellShapeControlMesh&
+Foam::cellShapeControl::shapeControlMesh() const
+{
+    return shapeControlMesh_;
+}
+
+
+inline const Foam::scalar& Foam::cellShapeControl::defaultCellSize() const
+{
+    return defaultCellSize_;
+}
+
+
+inline const Foam::cellAspectRatioControl&
+Foam::cellShapeControl::aspectRatio() const
+{
+    return aspectRatio_;
+}
+
+
+// ************************************************************************* //
diff --git a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellShapeControl/cellShapeControlMesh/cellShapeControlMesh.C b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellShapeControl/cellShapeControlMesh/cellShapeControlMesh.C
new file mode 100644
index 0000000000..bdcbf5a885
--- /dev/null
+++ b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellShapeControl/cellShapeControlMesh/cellShapeControlMesh.C
@@ -0,0 +1,760 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "cellShapeControlMesh.H"
+#include "pointIOField.H"
+#include "scalarIOField.H"
+#include "tensorIOField.H"
+#include "tetrahedron.H"
+#include "plane.H"
+#include "transform.H"
+#include "meshTools.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+defineTypeNameAndDebug(cellShapeControlMesh, 0);
+
+}
+
+
+// * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * * //
+
+//Foam::tensor Foam::cellShapeControlMesh::requiredAlignment
+//(
+//    const Foam::point& pt,
+//    const searchableSurfaces& allGeometry,
+//    const conformationSurfaces& geometryToConformTo
+//) const
+//{
+//    pointIndexHit surfHit;
+//    label hitSurface;
+//
+//    geometryToConformTo.findSurfaceNearest
+//    (
+//        pt,
+//        sqr(GREAT),
+//        surfHit,
+//        hitSurface
+//    );
+//
+//    if (!surfHit.hit())
+//    {
+//        FatalErrorIn
+//        (
+//            "Foam::tensor Foam::conformalVoronoiMesh::requiredAlignment"
+//        )   << "findSurfaceNearest did not find a hit across the surfaces."
+//            << exit(FatalError) << endl;
+//    }
+//
+//    // Primary alignment
+//
+//    vectorField norm(1);
+//
+//    allGeometry[hitSurface].getNormal
+//    (
+//        List<pointIndexHit>(1, surfHit),
+//        norm
+//    );
+//
+//    const vector np = norm[0];
+//
+//    // Generate equally spaced 'spokes' in a circle normal to the
+//    // direction from the vertex to the closest point on the surface
+//    // and look for a secondary intersection.
+//
+//    const vector d = surfHit.hitPoint() - pt;
+//
+//    const tensor Rp = rotationTensor(vector(0,0,1), np);
+//
+//    const label s = 36;//cvMeshControls().alignmentSearchSpokes();
+//
+//    scalar closestSpokeHitDistance = GREAT;
+//
+//    pointIndexHit closestSpokeHit;
+//
+//    label closestSpokeSurface = -1;
+//
+//    const scalar spanMag = geometryToConformTo.globalBounds().mag();
+//
+//    for (label i = 0; i < s; i++)
+//    {
+//        vector spoke
+//        (
+//            Foam::cos(i*constant::mathematical::twoPi/s),
+//            Foam::sin(i*constant::mathematical::twoPi/s),
+//            0
+//        );
+//
+//        spoke *= spanMag;
+//
+//        spoke = Rp & spoke;
+//
+//        pointIndexHit spokeHit;
+//
+//        label spokeSurface = -1;
+//
+//        // internal spoke
+//
+//        geometryToConformTo.findSurfaceNearestIntersection
+//        (
+//            pt,
+//            pt + spoke,
+//            spokeHit,
+//            spokeSurface
+//        );
+//
+//        if (spokeHit.hit())
+//        {
+//            scalar spokeHitDistance = mag
+//            (
+//                spokeHit.hitPoint() - pt
+//            );
+//
+//            if (spokeHitDistance < closestSpokeHitDistance)
+//            {
+//                closestSpokeHit = spokeHit;
+//                closestSpokeSurface = spokeSurface;
+//                closestSpokeHitDistance = spokeHitDistance;
+//            }
+//        }
+//
+//        //external spoke
+//
+//        Foam::point mirrorPt = pt + 2*d;
+//
+//        geometryToConformTo.findSurfaceNearestIntersection
+//        (
+//            mirrorPt,
+//            mirrorPt + spoke,
+//            spokeHit,
+//            spokeSurface
+//        );
+//
+//        if (spokeHit.hit())
+//        {
+//            scalar spokeHitDistance = mag
+//            (
+//                spokeHit.hitPoint() - mirrorPt
+//            );
+//
+//            if (spokeHitDistance < closestSpokeHitDistance)
+//            {
+//                closestSpokeHit = spokeHit;
+//                closestSpokeSurface = spokeSurface;
+//                closestSpokeHitDistance = spokeHitDistance;
+//            }
+//        }
+//    }
+//
+//    if (closestSpokeSurface == -1)
+//    {
+////        WarningIn
+////        (
+////            "conformalVoronoiMesh::requiredAlignment"
+////            "("
+////                "const Foam::point& pt"
+////            ") const"
+////        )   << "No secondary surface hit found in spoke search "
+////            << "using " << s
+////            << " spokes, try increasing alignmentSearchSpokes."
+////            << endl;
+//
+//        return I;
+//    }
+//
+//    // Auxiliary alignment generated by spoke intersection normal.
+//
+//    allGeometry[closestSpokeSurface].getNormal
+//    (
+//        List<pointIndexHit>(1, closestSpokeHit),
+//        norm
+//    );
+//
+//    const vector& na = norm[0];
+//
+//    // Secondary alignment
+//    vector ns = np ^ na;
+//
+//    if (mag(ns) < SMALL)
+//    {
+//        FatalErrorIn("conformalVoronoiMesh::requiredAlignment")
+//            << "Parallel normals detected in spoke search." << nl
+//            << "point: " << pt << nl
+//            << "closest surface point: " << surfHit.hitPoint() << nl
+//            << "closest spoke hit: " << closestSpokeHit.hitPoint() << nl
+//            << "np: " << surfHit.hitPoint() + np << nl
+//            << "ns: " << closestSpokeHit.hitPoint() + na << nl
+//            << exit(FatalError);
+//    }
+//
+//    ns /= mag(ns);
+//
+//    tensor Rs = rotationTensor((Rp & vector(0,1,0)), ns);
+//
+//    return (Rs & Rp);
+//}
+
+
+Foam::label Foam::cellShapeControlMesh::removePoints()
+{
+    label nRemoved = 0;
+    for
+    (
+        CellSizeDelaunay::Finite_vertices_iterator vit =
+            finite_vertices_begin();
+        vit != finite_vertices_end();
+        ++vit
+    )
+    {
+        std::list<Vertex_handle> verts;
+        adjacent_vertices(vit, std::back_inserter(verts));
+
+        bool removePt = true;
+        for
+        (
+            std::list<Vertex_handle>::iterator aVit = verts.begin();
+            aVit != verts.end();
+            ++aVit
+        )
+        {
+            Vertex_handle avh = *aVit;
+
+            scalar diff =
+                mag(avh->targetCellSize() - vit->targetCellSize())
+               /max(vit->targetCellSize(), 1e-6);
+
+            if (diff > 0.05)
+            {
+                removePt = false;
+            }
+        }
+
+        if (removePt)
+        {
+            remove(vit);
+            nRemoved++;
+        }
+    }
+
+    return nRemoved;
+}
+
+
+Foam::tmp<Foam::pointField> Foam::cellShapeControlMesh::cellCentres() const
+{
+    tmp<pointField> tcellCentres(new pointField(number_of_finite_cells()));
+    pointField& cellCentres = tcellCentres();
+
+    label count = 0;
+    for
+    (
+        CellSizeDelaunay::Finite_cells_iterator c = finite_cells_begin();
+        c != finite_cells_end();
+        ++c
+    )
+    {
+        if (c->hasFarPoint())
+        {
+            continue;
+        }
+
+        scalarList bary;
+        cellShapeControlMesh::Cell_handle ch;
+
+        const Foam::point centre = topoint
+        (
+            CGAL::centroid<baseK>
+            (
+                c->vertex(0)->point(),
+                c->vertex(1)->point(),
+                c->vertex(2)->point(),
+                c->vertex(3)->point()
+            )
+        );
+
+        cellCentres[count++] = centre;
+    }
+
+    cellCentres.resize(count);
+
+    return tcellCentres;
+}
+
+
+void Foam::cellShapeControlMesh::writeTriangulation()
+{
+    OFstream str
+    (
+        "refinementTriangulation_"
+      + name(Pstream::myProcNo())
+      + ".obj"
+    );
+
+    label count = 0;
+
+    Info<< "Write refinementTriangulation" << endl;
+
+    for
+    (
+        CellSizeDelaunay::Finite_edges_iterator e = finite_edges_begin();
+        e != finite_edges_end();
+        ++e
+    )
+    {
+        Cell_handle c = e->first;
+        Vertex_handle vA = c->vertex(e->second);
+        Vertex_handle vB = c->vertex(e->third);
+
+        // Don't write far edges
+        if (vA->farPoint() || vB->farPoint())
+        {
+            continue;
+        }
+
+        // Don't write unowned edges
+        if (vA->referred() && vB->referred())
+        {
+            continue;
+        }
+
+        pointFromPoint p1 = topoint(vA->point());
+        pointFromPoint p2 = topoint(vB->point());
+
+        meshTools::writeOBJ(str, p1, p2, count);
+    }
+
+    if (is_valid())
+    {
+        Info<< "    Triangulation is valid" << endl;
+    }
+    else
+    {
+        FatalErrorIn
+        (
+            "Foam::triangulatedMesh::writeRefinementTriangulation()"
+        )   << "Triangulation is not valid"
+            << abort(FatalError);
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::cellShapeControlMesh::cellShapeControlMesh(const Time& runTime)
+:
+    runTime_(runTime),
+    defaultCellSize_(0.0)
+{}
+
+
+//Foam::triangulatedMesh::triangulatedMesh
+//(
+//    const Time& runTime,
+//    const fileName& pointsFile,
+//    const fileName& sizesFile,
+//    const fileName& alignmentsFile,
+//    const scalar& defaultCellSize
+//)
+//:
+//    defaultCellSize_(defaultCellSize)
+//{
+//    Info<< "    Reading points from file     : " << pointsFile << endl;
+//
+//    pointIOField points
+//    (
+//        IOobject
+//        (
+//            pointsFile,
+//            runTime.constant(),
+//            runTime,
+//            IOobject::MUST_READ,
+//            IOobject::NO_WRITE
+//        )
+//    );
+//
+//    Info<< "    Reading sizes from file      : " << sizesFile << endl;
+//
+//    scalarIOField sizes
+//    (
+//        IOobject
+//        (
+//            sizesFile,
+//            runTime.constant(),
+//            runTime,
+//            IOobject::MUST_READ,
+//            IOobject::NO_WRITE
+//        )
+//    );
+//
+//    Info<< "    Reading alignments from file : " << alignmentsFile << endl;
+//
+//    tensorIOField alignments
+//    (
+//        IOobject
+//        (
+//            alignmentsFile,
+//            runTime.constant(),
+//            runTime,
+//            IOobject::MUST_READ,
+//            IOobject::NO_WRITE
+//        )
+//    );
+//
+//    Info<< "    Number of points : " << points.size() << endl;
+//    Info<< "    Minimum size     : " << min(sizes) << endl;
+//    Info<< "    Average size     : " << average(sizes) << endl;
+//    Info<< "    Maximum size     : " << max(sizes) << endl;
+//
+//    forAll(points, pI)
+//    {
+//        size_t nVert = number_of_vertices();
+//
+//        Vertex_handle v = insert
+//        (
+//            Point(points[pI].x(), points[pI].y(), points[pI].z())
+//        );
+//
+//        if (number_of_vertices() == nVert)
+//        {
+//            Info<< "    Failed to insert point : " << points[pI] << endl;
+//        }
+//
+//        v->targetCellSize() = sizes[pI];
+//
+//        const tensor& alignment = alignments[pI];
+//
+//
+//
+//        v->alignment() = alignment;
+//    }
+//
+////    scalar factor = 1.0;
+////    label maxIteration = 1;
+////
+////    for (label iteration = 0; iteration < maxIteration; ++iteration)
+////    {
+////        Info<< "Iteration : " << iteration << endl;
+////
+////        label nRefined = refineTriangulation(factor);
+////
+////        Info<< "    Number of cells refined in refinement iteration : "
+////            << nRefined << nl << endl;
+////
+////        if (nRefined <= 0 && iteration != 0)
+////        {
+////            break;
+////        }
+////
+////        factor *= 1.5;
+////    }
+//
+//    //writeRefinementTriangulation();
+//}
+
+
+//Foam::triangulatedMesh::triangulatedMesh
+//(
+//    const Time& runTime,
+//    const DynamicList<Foam::point>& points,
+//    const DynamicList<scalar>& sizes,
+//    const DynamicList<tensor>& alignments,
+//    const scalar& defaultCellSize
+//)
+//:
+//    defaultCellSize_(defaultCellSize)
+//{
+//    forAll(points, pI)
+//    {
+//        size_t nVert = number_of_vertices();
+//
+//        Vertex_handle v = insert
+//        (
+//            Point(points[pI].x(), points[pI].y(), points[pI].z())
+//        );
+//
+//        if (number_of_vertices() == nVert)
+//        {
+//            Info<< "Failed to insert point : " << points[pI] << endl;
+//        }
+//
+//        v->targetCellSize() = sizes[pI];
+//
+//        v->alignment() = alignments[pI];
+//    }
+//
+//    //writeRefinementTriangulation();
+//
+//    Info<< nl << "Refinement triangulation information: " << endl;
+//    Info<< "    Number of vertices: " << label(number_of_vertices()) << endl;
+//    Info<< "    Number of cells   : "
+//        << label(number_of_finite_cells()) << endl;
+//    Info<< "    Number of faces   : "
+//        << label(number_of_finite_facets()) << endl;
+//    Info<< "    Number of edges   : "
+//        << label(number_of_finite_edges()) << endl;
+//    Info<< "    Dimensionality    : " << label(dimension()) << nl << endl;
+//}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::cellShapeControlMesh::~cellShapeControlMesh()
+{}
+
+
+// * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
+
+void Foam::cellShapeControlMesh::barycentricCoords
+(
+    const Foam::point& pt,
+    scalarList& bary,
+    Cell_handle& ch
+) const
+{
+    // Use the previous cell handle as a hint on where to start searching
+    ch = locate
+    (
+        Point(pt.x(), pt.y(), pt.z())
+    );
+
+    if (!is_infinite(ch))
+    {
+        oldCellHandle_ = ch;
+
+        tetPointRef tet
+        (
+            topoint(ch->vertex(0)->point()),
+            topoint(ch->vertex(1)->point()),
+            topoint(ch->vertex(2)->point()),
+            topoint(ch->vertex(3)->point())
+        );
+
+        tet.barycentric(pt, bary);
+    }
+}
+
+
+Foam::boundBox Foam::cellShapeControlMesh::bounds() const
+{
+    DynamicList<Foam::point> pts(number_of_vertices());
+
+    for
+    (
+        Finite_vertices_iterator vit = finite_vertices_begin();
+        vit != finite_vertices_end();
+        ++vit
+    )
+    {
+        if (vit->real())
+        {
+            pts.append(topoint(vit->point()));
+        }
+    }
+
+    boundBox bb(pts);
+
+    return bb;
+}
+
+
+void Foam::cellShapeControlMesh::distribute
+(
+    const backgroundMeshDecomposition& decomposition
+)
+{
+    if (!Pstream::parRun())
+    {
+        return;
+    }
+
+    autoPtr<mapDistribute> mapDist =
+        DistributedDelaunayMesh<CellSizeDelaunay>::distribute(decomposition);
+
+    DynamicList<Foam::point> points(number_of_vertices());
+    DynamicList<scalar> sizes(number_of_vertices());
+    DynamicList<tensor> alignments(number_of_vertices());
+
+    for
+    (
+        Finite_vertices_iterator vit = finite_vertices_begin();
+        vit != finite_vertices_end();
+        ++vit
+    )
+    {
+        if (vit->real())
+        {
+            points.append(topoint(vit->point()));
+            sizes.append(vit->targetCellSize());
+            alignments.append(vit->alignment());
+        }
+    }
+
+    mapDist().distribute(points);
+    mapDist().distribute(sizes);
+    mapDist().distribute(alignments);
+
+    // Reset the entire tessellation
+    DelaunayMesh<CellSizeDelaunay>::reset();
+
+    Info<< nl << "    Inserting distributed tessellation" << endl;
+
+    insertBoundingPoints(decomposition.procBounds());
+
+    // Internal points have to be inserted first
+
+    DynamicList<Vb> verticesToInsert(points.size());
+
+    forAll(points, pI)
+    {
+        verticesToInsert.append
+        (
+            Vb
+            (
+                toPoint<Point>(points[pI]),
+                -1,
+                Vb::vtInternal,
+                Pstream::myProcNo()
+            )
+        );
+
+        verticesToInsert.last().targetCellSize() = sizes[pI];
+        verticesToInsert.last().alignment() = alignments[pI];
+    }
+
+    this->rangeInsertWithInfo
+    (
+        verticesToInsert.begin(),
+        verticesToInsert.end(),
+        true
+    );
+
+    sync(decomposition.procBounds());
+
+    Info<< "    Total number of vertices after redistribution "
+        << returnReduce(label(number_of_vertices()), sumOp<label>()) << endl;
+}
+
+
+Foam::tensorField Foam::cellShapeControlMesh::dumpAlignments() const
+{
+    tensorField alignmentsTmp(number_of_vertices(), tensor::zero);
+
+    label count = 0;
+    for
+    (
+        Finite_vertices_iterator vit = finite_vertices_begin();
+        vit != finite_vertices_end();
+        ++vit
+    )
+    {
+        alignmentsTmp[count++] = vit->alignment();
+    }
+
+    return alignmentsTmp;
+}
+
+
+void Foam::cellShapeControlMesh::insertBoundingPoints(const boundBox& bb)
+{
+    boundBox bbInflate = bb;
+    bbInflate.inflate(10);
+
+    pointField pts = bbInflate.points();
+
+    forAll(pts, pI)
+    {
+        insertFar(pts[pI]);
+    }
+}
+
+
+void Foam::cellShapeControlMesh::write() const
+{
+    Info<< "Writing cell size and alignment mesh" << endl;
+
+    const fileName name("cellSizeAndAlignmentMesh");
+
+    // Reindex the cells
+    label cellCount = 0;
+    for
+    (
+        Finite_cells_iterator cit = finite_cells_begin();
+        cit != finite_cells_end();
+        ++cit
+    )
+    {
+        if (!cit->hasFarPoint() && !is_infinite(cit))
+        {
+            cit->cellIndex() = cellCount++;
+        }
+    }
+
+    labelList vertexMap;
+    labelList cellMap;
+
+    autoPtr<fvMesh> meshPtr = DelaunayMesh<CellSizeDelaunay>::createMesh
+    (
+        name,
+        runTime_,
+        vertexMap,
+        cellMap
+    );
+    const fvMesh& mesh = meshPtr();
+
+    pointScalarField sizes
+    (
+        IOobject
+        (
+            "sizes",
+            mesh.time().timeName(),
+            mesh,
+            IOobject::NO_READ,
+            IOobject::AUTO_WRITE
+        ),
+        pointMesh::New(mesh),
+        scalar(0)
+    );
+
+    for
+    (
+        Finite_vertices_iterator vit = finite_vertices_begin();
+        vit != finite_vertices_end();
+        ++vit
+    )
+    {
+        if (!vit->farPoint())
+        {
+            sizes[vertexMap[vit->index()]] = vit->targetCellSize();
+        }
+    }
+
+    mesh.write();
+}
+
+
+// ************************************************************************* //
diff --git a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellShapeControl/cellShapeControlMesh/cellShapeControlMesh.H b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellShapeControl/cellShapeControlMesh/cellShapeControlMesh.H
new file mode 100644
index 0000000000..e6cb37a2c3
--- /dev/null
+++ b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellShapeControl/cellShapeControlMesh/cellShapeControlMesh.H
@@ -0,0 +1,168 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 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::cellShapeControlMesh
+
+Description
+
+SourceFiles
+    cellShapeControlMeshI.H
+    cellShapeControlMesh.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef cellShapeControlMesh_H
+#define cellShapeControlMesh_H
+
+#include "Time.H"
+#include "scalar.H"
+#include "point.H"
+#include "tensor.H"
+#include "triad.H"
+#include "fileName.H"
+#include "searchableSurfaces.H"
+#include "conformationSurfaces.H"
+#include "DistributedDelaunayMesh.H"
+#include "CGALTriangulation3Ddefs.H"
+#include "backgroundMeshDecomposition.H"
+#include "boundBox.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                      Class cellShapeControlMesh Declaration
+\*---------------------------------------------------------------------------*/
+
+class cellShapeControlMesh
+:
+    public DistributedDelaunayMesh<CellSizeDelaunay>
+{
+public:
+
+        typedef CellSizeDelaunay::Cell_handle      Cell_handle;
+        typedef CellSizeDelaunay::Vertex_handle    Vertex_handle;
+        typedef CellSizeDelaunay::Point            Point;
+
+
+private:
+
+        // Private data
+
+        const Time& runTime_;
+
+        mutable Cell_handle oldCellHandle_;
+
+        const scalar defaultCellSize_;
+
+
+    // Private Member Functions
+
+        //- Disallow default bitwise copy construct
+        cellShapeControlMesh(const cellShapeControlMesh&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const cellShapeControlMesh&);
+
+
+public:
+
+    //- Runtime type information
+    ClassName("cellShapeControlMesh");
+
+
+    // Constructors
+
+        explicit cellShapeControlMesh(const Time& runTime);
+
+
+    //- Destructor
+    ~cellShapeControlMesh();
+
+
+    // Member Functions
+
+        // Query
+
+            //- Calculate and return the barycentric coordinates for
+            //  interpolating quantities on the background mesh
+            void barycentricCoords
+            (
+                const Foam::point& pt,
+                scalarList& bary,
+                Cell_handle& ch
+            ) const;
+
+            boundBox bounds() const;
+
+
+        // Edit
+
+            label removePoints();
+
+            //- Get the centres of all the tets
+            tmp<pointField> cellCentres() const;
+
+            inline Vertex_handle insert
+            (
+                const Foam::point& pt,
+                const scalar& size,
+                const triad& alignment,
+                const Foam::indexedVertexEnum::vertexType type = Vb::vtInternal
+            );
+
+            inline Vertex_handle insertFar
+            (
+                const Foam::point& pt
+            );
+
+            void distribute
+            (
+                const backgroundMeshDecomposition& decomposition
+            );
+
+            tensorField dumpAlignments() const;
+
+            void insertBoundingPoints(const boundBox& bb);
+
+            void writeTriangulation();
+
+            void write() const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#include "cellShapeControlMeshI.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+#endif
+
+// ************************************************************************* //
diff --git a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellShapeControl/cellShapeControlMesh/cellShapeControlMeshI.H b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellShapeControl/cellShapeControlMesh/cellShapeControlMeshI.H
new file mode 100644
index 0000000000..305256d4cc
--- /dev/null
+++ b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellShapeControl/cellShapeControlMesh/cellShapeControlMeshI.H
@@ -0,0 +1,68 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+Foam::cellShapeControlMesh::Vertex_handle Foam::cellShapeControlMesh::insert
+(
+    const Foam::point& pt,
+    const scalar& size,
+    const triad& alignment,
+    const Foam::indexedVertexEnum::vertexType type
+)
+{
+    Vertex_handle v = CellSizeDelaunay::insert
+    (
+        Point(pt.x(), pt.y(), pt.z())
+    );
+    v->type() = type;
+    v->index() = getNewVertexIndex();
+    v->procIndex() = Pstream::myProcNo();
+    v->targetCellSize() = size;
+    v->alignment() = tensor(alignment.x(), alignment.y(), alignment.z());
+
+    return v;
+}
+
+
+Foam::cellShapeControlMesh::Vertex_handle Foam::cellShapeControlMesh::insertFar
+(
+    const Foam::point& pt
+)
+{
+    Vertex_handle v = CellSizeDelaunay::insert
+    (
+        Point(pt.x(), pt.y(), pt.z())
+    );
+    v->type() = Vb::vtFar;
+//    v->type() = Vb::vtExternalFeaturePoint;
+    v->index() = getNewVertexIndex();
+    v->procIndex() = Pstream::myProcNo();
+
+    return v;
+}
+
+
+// ************************************************************************* //
diff --git a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellShapeControl/cellSizeAndAlignmentControl/cellSizeAndAlignmentControl/cellSizeAndAlignmentControl.C b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellShapeControl/cellSizeAndAlignmentControl/cellSizeAndAlignmentControl/cellSizeAndAlignmentControl.C
new file mode 100644
index 0000000000..3dce1d518e
--- /dev/null
+++ b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellShapeControl/cellSizeAndAlignmentControl/cellSizeAndAlignmentControl/cellSizeAndAlignmentControl.C
@@ -0,0 +1,121 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "cellSizeAndAlignmentControl.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+defineTypeNameAndDebug(cellSizeAndAlignmentControl, 0);
+defineRunTimeSelectionTable(cellSizeAndAlignmentControl, dictionary);
+
+}
+
+
+// * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * * //
+
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::cellSizeAndAlignmentControl::cellSizeAndAlignmentControl
+(
+    const Time& runTime,
+    const word& name,
+    const dictionary& controlFunctionDict,
+    const conformationSurfaces& allGeometry
+)
+:
+    runTime_(runTime),
+    name_(name),
+    priority_(readLabel(controlFunctionDict.lookup("priority")))
+{}
+
+
+// * * * * * * * * * * * * * * * * * Selectors * * * * * * * * * * * * * * * //
+
+Foam::autoPtr<Foam::cellSizeAndAlignmentControl>
+Foam::cellSizeAndAlignmentControl::New
+(
+    const Time& runTime,
+    const word& name,
+    const dictionary& controlFunctionDict,
+    const conformationSurfaces& allGeometry
+)
+{
+    word cellSizeAndAlignmentControlTypeName
+    (
+        controlFunctionDict.lookup("type")
+    );
+
+    Info<< nl << "Selecting cellSizeAndAlignmentControl "
+        << cellSizeAndAlignmentControlTypeName << endl;
+
+    dictionaryConstructorTable::iterator cstrIter =
+        dictionaryConstructorTablePtr_->find
+        (
+            cellSizeAndAlignmentControlTypeName
+        );
+
+    if (cstrIter == dictionaryConstructorTablePtr_->end())
+    {
+        FatalErrorIn
+        (
+            "cellSizeAndAlignmentControl::New()"
+        )   << "Unknown cellSizeAndAlignmentControl type "
+            << cellSizeAndAlignmentControlTypeName
+            << endl << endl
+            << "Valid cellSizeAndAlignmentControl types are :" << endl
+            << dictionaryConstructorTablePtr_->toc()
+            << exit(FatalError);
+    }
+
+    return autoPtr<cellSizeAndAlignmentControl>
+    (
+        cstrIter()
+        (
+            runTime,
+            name,
+            controlFunctionDict,
+            allGeometry
+        )
+    );
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::cellSizeAndAlignmentControl::~cellSizeAndAlignmentControl()
+{}
+
+
+// * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
+
+
+
+// ************************************************************************* //
diff --git a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellShapeControl/cellSizeAndAlignmentControl/cellSizeAndAlignmentControl/cellSizeAndAlignmentControl.H b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellShapeControl/cellSizeAndAlignmentControl/cellSizeAndAlignmentControl/cellSizeAndAlignmentControl.H
new file mode 100644
index 0000000000..d8589ba6ef
--- /dev/null
+++ b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellShapeControl/cellSizeAndAlignmentControl/cellSizeAndAlignmentControl/cellSizeAndAlignmentControl.H
@@ -0,0 +1,166 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 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::cellSizeAndAlignmentControl
+
+Description
+
+SourceFiles
+    cellSizeAndAlignmentControlI.H
+    cellSizeAndAlignmentControl.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef cellSizeAndAlignmentControl_H
+#define cellSizeAndAlignmentControl_H
+
+#include "dictionary.H"
+#include "conformationSurfaces.H"
+#include "Time.H"
+#include "quaternion.H"
+#include "triad.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+
+/*---------------------------------------------------------------------------*\
+                Class cellSizeAndAlignmentControl Declaration
+\*---------------------------------------------------------------------------*/
+
+class cellSizeAndAlignmentControl
+{
+protected:
+
+        const Time& runTime_;
+
+
+private:
+
+    // Private data
+
+        const word name_;
+
+        //- Priority of this cellSizeFunction
+        label priority_;
+
+
+    // Private Member Functions
+
+        //- Disallow default bitwise copy construct
+        cellSizeAndAlignmentControl(const cellSizeAndAlignmentControl&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const cellSizeAndAlignmentControl&);
+
+
+public:
+
+    //- Runtime type information
+    TypeName("cellSizeAndAlignmentControl");
+
+
+    // Declare run-time constructor selection table
+
+        declareRunTimeSelectionTable
+        (
+            autoPtr,
+            cellSizeAndAlignmentControl,
+            dictionary,
+            (
+                const Time& runTime,
+                const word& name,
+                const dictionary& controlFunctionDict,
+                const conformationSurfaces& allGeometry
+            ),
+            (runTime, name, controlFunctionDict, allGeometry)
+        );
+
+
+    // Constructors
+
+        //- Construct from dictionary and references to conformalVoronoiMesh and
+        //  searchableSurfaces
+        cellSizeAndAlignmentControl
+        (
+            const Time& runTime,
+            const word& name,
+            const dictionary& controlFunctionDict,
+            const conformationSurfaces& allGeometry
+        );
+
+
+    // Selectors
+
+        //- Return a reference to the selected cellShapeControl
+        static autoPtr<cellSizeAndAlignmentControl> New
+        (
+            const Time& runTime,
+            const word& name,
+            const dictionary& controlFunctionDict,
+            const conformationSurfaces& allGeometry
+        );
+
+
+    //- Destructor
+    virtual ~cellSizeAndAlignmentControl();
+
+
+    // Member Functions
+
+        // Access
+
+            const word& name() const
+            {
+                return name_;
+            }
+
+            inline label priority() const
+            {
+                return priority_;
+            }
+
+
+        // Query
+
+            virtual void initialVertices
+            (
+                pointField& pts,
+                scalarField& sizes,
+                Field<triad>& alignments
+            ) const = 0;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellShapeControl/cellSizeAndAlignmentControl/cellSizeAndAlignmentControls.C b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellShapeControl/cellSizeAndAlignmentControl/cellSizeAndAlignmentControls.C
new file mode 100644
index 0000000000..44c8852abf
--- /dev/null
+++ b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellShapeControl/cellSizeAndAlignmentControl/cellSizeAndAlignmentControls.C
@@ -0,0 +1,78 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "cellSizeAndAlignmentControls.H"
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::cellSizeAndAlignmentControls::cellSizeAndAlignmentControls
+(
+    const Time& runTime,
+    const dictionary& shapeControlDict,
+    const conformationSurfaces& allGeometry
+)
+:
+    shapeControlDict_(shapeControlDict),
+    allGeometry_(allGeometry),
+    controlFunctions_(shapeControlDict_.size())
+{
+    label functionI = 0;
+
+    forAllConstIter(dictionary, shapeControlDict_, iter)
+    {
+        word shapeControlEntryName = iter().keyword();
+
+        const dictionary& controlFunctionDict
+        (
+            shapeControlDict_.subDict(shapeControlEntryName)
+        );
+
+        controlFunctions_.set
+        (
+            functionI,
+            cellSizeAndAlignmentControl::New
+            (
+                runTime,
+                shapeControlEntryName,
+                controlFunctionDict,
+                allGeometry
+            )
+        );
+
+        functionI++;
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::cellSizeAndAlignmentControls::~cellSizeAndAlignmentControls()
+{}
+
+
+// * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
+
+
+// ************************************************************************* //
diff --git a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellShapeControl/cellSizeAndAlignmentControl/cellSizeAndAlignmentControls.H b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellShapeControl/cellSizeAndAlignmentControl/cellSizeAndAlignmentControls.H
new file mode 100644
index 0000000000..dac3ffc13c
--- /dev/null
+++ b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellShapeControl/cellSizeAndAlignmentControl/cellSizeAndAlignmentControls.H
@@ -0,0 +1,110 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 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::cellSizeAndAlignmentControls
+
+Description
+
+SourceFiles
+    cellSizeAndAlignmentControls.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef cellSizeAndAlignmentControls_H
+#define cellSizeAndAlignmentControls_H
+
+#include "dictionary.H"
+#include "cellShapeControlMesh.H"
+#include "cellSizeAndAlignmentControl.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+
+/*---------------------------------------------------------------------------*\
+                     Class cellSizeAndAlignmentControls Declaration
+\*---------------------------------------------------------------------------*/
+
+class cellSizeAndAlignmentControls
+{
+    // Private data
+
+        const dictionary& shapeControlDict_;
+
+        const conformationSurfaces& allGeometry_;
+
+        PtrList<cellSizeAndAlignmentControl> controlFunctions_;
+
+
+    // Private Member Functions
+
+        //- Disallow default bitwise copy construct
+        cellSizeAndAlignmentControls(const cellSizeAndAlignmentControls&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const cellSizeAndAlignmentControls&);
+
+
+public:
+
+    // Constructors
+
+        //- Construct from dictionary
+        cellSizeAndAlignmentControls
+        (
+            const Time& runTime,
+            const dictionary& shapeControlDict,
+            const conformationSurfaces& allGeometry
+        );
+
+
+    //- Destructor
+    virtual ~cellSizeAndAlignmentControls();
+
+
+    // Member Functions
+
+        // Access
+
+            const PtrList<cellSizeAndAlignmentControl>& controlFunctions() const
+            {
+                return controlFunctions_;
+            }
+
+
+        // Query
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellShapeControl/cellSizeAndAlignmentControl/fileControl/fileControl.C b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellShapeControl/cellSizeAndAlignmentControl/fileControl/fileControl.C
new file mode 100644
index 0000000000..ce6cb02bbc
--- /dev/null
+++ b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellShapeControl/cellSizeAndAlignmentControl/fileControl/fileControl.C
@@ -0,0 +1,242 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "fileControl.H"
+#include "addToRunTimeSelectionTable.H"
+#include "tetrahedron.H"
+#include "scalarList.H"
+#include "vectorTools.H"
+#include "pointIOField.H"
+#include "scalarIOField.H"
+#include "triadIOField.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+defineTypeNameAndDebug(fileControl, 0);
+addToRunTimeSelectionTable
+(
+    cellSizeAndAlignmentControl,
+    fileControl,
+    dictionary
+);
+
+}
+
+
+// * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::fileControl::fileControl
+(
+    const Time& runTime,
+    const word& name,
+    const dictionary& controlFunctionDict,
+    const conformationSurfaces& allGeometry
+)
+:
+    cellSizeAndAlignmentControl
+    (
+        runTime,
+        name,
+        controlFunctionDict,
+        allGeometry
+    ),
+    pointsFile_(controlFunctionDict.lookup("pointsFile")),
+    sizesFile_(controlFunctionDict.lookup("sizesFile")),
+    alignmentsFile_(controlFunctionDict.lookup("alignmentsFile"))
+{
+    Info<< indent << "Loading from file... " << nl
+        << indent << "    points     : " << pointsFile_ << nl
+        << indent << "    sizes      : " << sizesFile_ << nl
+        << indent << "    alignments : " << alignmentsFile_
+        << endl;
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::fileControl::~fileControl()
+{}
+
+
+// * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
+//
+//Foam::scalar Foam::fileControl::cellSize(const point& pt) const
+//{
+//    scalarList bary;
+//    Cell_handle ch;
+//
+//    triangulatedMesh_.barycentricCoords(pt, bary, ch);
+//
+//    scalar size = 0;
+//    forAll(bary, pI)
+//    {
+//        size += bary[pI]*ch->vertex(pI)->size();
+//    }
+//
+//    return size;
+//}
+//
+//
+////- Return the cell alignment at the given location
+//Foam::tensor Foam::fileControl::cellAlignment(const point& pt) const
+//{
+//    scalarList bary;
+//    Cell_handle ch;
+//
+//    triangulatedMesh_.barycentricCoords(pt, bary, ch);
+//
+//    label nearest = 0;
+//
+//    tensor alignment = Foam::tensor::zero;
+//    forAll(bary, pI)
+//    {
+//        //alignment += bary[pI]*ch->vertex(pI)->alignment();
+//
+//        // Find nearest point
+//        if (bary[pI] > nearest)
+//        {
+//            alignment = ch->vertex(pI)->alignment();
+//            nearest = bary[pI];
+//        }
+//    }
+//
+//    return alignment;
+//}
+//
+//
+////- Return the cell alignment at the given location
+//void Foam::fileControl::cellSizeAndAlignment
+//(
+//    const point& pt,
+//    scalar& size,
+//    tensor& alignment
+//) const
+//{
+//    scalarList bary;
+//    Cell_handle ch;
+//
+//    triangulatedMesh_.barycentricCoords(pt, bary, ch);
+//
+//    size = 0;
+//    forAll(bary, pI)
+//    {
+//        size += bary[pI]*ch->vertex(pI)->size();
+//    }
+//
+////    alignment = Foam::tensor::zero;
+////    forAll(bary, pI)
+////    {
+////        alignment += bary[pI]*ch->vertex(pI)->alignment();
+////    }
+//
+//    alignment = cellAlignment(pt);
+//}
+
+
+void Foam::fileControl::initialVertices
+(
+    pointField& pts,
+    scalarField& sizes,
+    Field<triad>& alignments
+) const
+{
+    Info<< "    Reading points from file     : " << pointsFile_ << endl;
+
+    pointIOField pointsTmp
+    (
+        IOobject
+        (
+            pointsFile_,
+            runTime_.constant(),
+            runTime_,
+            IOobject::MUST_READ,
+            IOobject::NO_WRITE,
+            false
+        )
+    );
+
+    pts.transfer(pointsTmp);
+
+    Info<< "    Reading sizes from file      : " << sizesFile_ << endl;
+
+    scalarIOField sizesTmp
+    (
+        IOobject
+        (
+            sizesFile_,
+            runTime_.constant(),
+            runTime_,
+            IOobject::MUST_READ,
+            IOobject::NO_WRITE,
+            false
+        )
+    );
+
+    sizes.transfer(sizesTmp);
+
+    Info<< "    Reading alignments from file : " << alignmentsFile_ << endl;
+
+    triadIOField alignmentsTmp
+    (
+        IOobject
+        (
+            alignmentsFile_,
+            runTime_.constant(),
+            runTime_,
+            IOobject::MUST_READ,
+            IOobject::NO_WRITE,
+            false
+        )
+    );
+
+    alignments.transfer(alignmentsTmp);
+
+    if ((pts.size() != sizes.size()) || (pts.size() != alignments.size()))
+    {
+        FatalErrorIn
+        (
+            "Foam::fileControl::initialVertices"
+            "("
+            "   pointField&,"
+            "   scalarField&,"
+            "   Field<triad>&"
+            ")"
+        )   << "Size of list of points, sizes and alignments do not match:"
+            << nl
+            << "Points size     = " << pts.size() << nl
+            << "Sizes size      = " << sizes.size() << nl
+            << "Alignments size = " << alignments.size()
+            << abort(FatalError);
+    }
+}
+
+
+// ************************************************************************* //
diff --git a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellShapeControl/cellSizeAndAlignmentControl/fileControl/fileControl.H b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellShapeControl/cellSizeAndAlignmentControl/fileControl/fileControl.H
new file mode 100644
index 0000000000..9c84b516d1
--- /dev/null
+++ b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellShapeControl/cellSizeAndAlignmentControl/fileControl/fileControl.H
@@ -0,0 +1,134 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 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::fileControl
+
+Description
+
+SourceFiles
+    fileControl.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef fileControl_H
+#define fileControl_H
+
+#include "cellSizeAndAlignmentControl.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+
+/*---------------------------------------------------------------------------*\
+                      Class fileControl Declaration
+\*---------------------------------------------------------------------------*/
+
+class fileControl
+:
+    public cellSizeAndAlignmentControl
+{
+    // Private data
+
+        const fileName pointsFile_;
+
+        const fileName sizesFile_;
+
+        const fileName alignmentsFile_;
+
+
+    // Private Member Functions
+
+        //- Disallow default bitwise copy construct
+        fileControl(const fileControl&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const fileControl&);
+
+
+public:
+
+    //- Runtime type information
+    TypeName("fileControl");
+
+
+    // Constructors
+
+        //- Construct from dictionary and references to conformalVoronoiMesh and
+        //  searchableSurfaces
+        fileControl
+        (
+            const Time& runTime,
+            const word& name,
+            const dictionary& controlFunctionDict,
+            const conformationSurfaces& allGeometry
+        );
+
+    //- Destructor
+    ~fileControl();
+
+
+    // Member Functions
+
+        // Access
+
+
+        // Query
+
+//            //- Return the cell size at the given location
+//            virtual scalar cellSize(const point& pt) const;
+//
+//            //- Return the cell alignment at the given location
+//            virtual tensor cellAlignment(const point& pt) const;
+//
+//            virtual void cellSizeAndAlignment
+//            (
+//                const point& pt,
+//                scalar& size,
+//                tensor& alignment
+//            ) const;
+
+
+        // Edit
+
+        virtual void initialVertices
+        (
+            pointField& pts,
+            scalarField& sizes,
+            Field<triad>& alignments
+        ) const;
+
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellShapeControl/cellSizeAndAlignmentControl/searchableSurfaceControl/searchableSurfaceControl.C b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellShapeControl/cellSizeAndAlignmentControl/searchableSurfaceControl/searchableSurfaceControl.C
new file mode 100644
index 0000000000..5350bcdd4a
--- /dev/null
+++ b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellShapeControl/cellSizeAndAlignmentControl/searchableSurfaceControl/searchableSurfaceControl.C
@@ -0,0 +1,667 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "searchableSurfaceControl.H"
+#include "addToRunTimeSelectionTable.H"
+#include "cellSizeFunction.H"
+#include "triSurfaceMesh.H"
+#include "searchableBox.H"
+#include "tetrahedron.H"
+#include "vectorTools.H"
+#include "quaternion.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+defineTypeNameAndDebug(searchableSurfaceControl, 0);
+addToRunTimeSelectionTable
+(
+    cellSizeAndAlignmentControl,
+    searchableSurfaceControl,
+    dictionary
+);
+
+}
+
+
+// * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * * //
+
+//Foam::tensor Foam::surfaceControl::requiredAlignment
+//(
+//    const Foam::point& pt,
+//    const vectorField& ptNormals
+//) const
+//{
+////    pointIndexHit surfHit;
+////    label hitSurface;
+////
+////    geometryToConformTo_.findSurfaceNearest
+////    (
+////        pt,
+////        sqr(GREAT),
+////        surfHit,
+////        hitSurface
+////    );
+////
+////    if (!surfHit.hit())
+////    {
+////        FatalErrorIn
+////        (
+////            "Foam::tensor Foam::conformalVoronoiMesh::requiredAlignment"
+////        )
+////            << "findSurfaceNearest did not find a hit across the surfaces."
+////            << exit(FatalError) << endl;
+////    }
+////
+//////     Primary alignment
+////
+////    vectorField norm(1);
+////
+////    allGeometry_[hitSurface].getNormal
+////    (
+////        List<pointIndexHit>(1, surfHit),
+////        norm
+////    );
+////
+////    const vector np = norm[0];
+////
+////    const tensor Rp = rotationTensor(vector(0,0,1), np);
+////
+////    return (Rp);
+//
+////    Info<< "Point : " << pt << endl;
+////    forAll(ptNormals, pnI)
+////    {
+////        Info<< "    normal " << pnI << " : " << ptNormals[pnI] << endl;
+////    }
+//
+//    vector np = ptNormals[0];
+//
+//    const tensor Rp = rotationTensor(vector(0,0,1), np);
+//
+//    vector na = vector::zero;
+//
+//    scalar smallestAngle = GREAT;
+//
+//    for (label pnI = 1; pnI < ptNormals.size(); ++pnI)
+//    {
+//        const vector& nextNormal = ptNormals[pnI];
+//
+//        const scalar cosPhi = vectorTools::cosPhi(np, nextNormal);
+//
+//        if (mag(cosPhi) < smallestAngle)
+//        {
+//            na = nextNormal;
+//            smallestAngle = cosPhi;
+//        }
+//    }
+//
+//    // Secondary alignment
+//    vector ns = np ^ na;
+//
+//    if (mag(ns) < SMALL)
+//    {
+//        WarningIn("conformalVoronoiMesh::requiredAlignment")
+//            << "Parallel normals detected in spoke search." << nl
+//            << "point: " << pt << nl
+//            << "np   : " << np << nl
+//            << "na   : " << na << nl
+//            << "ns   : " << ns << nl
+//            << endl;
+//
+//        ns = np;
+//    }
+//
+//    ns /= mag(ns);
+//
+//    tensor Rs = rotationTensor((Rp & vector(0,1,0)), ns);
+//
+////    Info<< "Point " << pt << nl
+////        << "      np : " << np << nl
+////        << "      ns : " << ns << nl
+////        << "      Rp : " << Rp << nl
+////        << "      Rs : " << Rs << nl
+////        << "    Rs&Rp: " << (Rs & Rp) << endl;
+//
+//    return (Rs & Rp);
+//}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::searchableSurfaceControl::searchableSurfaceControl
+(
+    const Time& runTime,
+    const word& name,
+    const dictionary& controlFunctionDict,
+    const conformationSurfaces& allGeometry
+)
+:
+    cellSizeAndAlignmentControl
+    (
+        runTime,
+        name,
+        controlFunctionDict,
+        allGeometry
+    ),
+    searchableSurface_(allGeometry.geometry()[name]),
+    allGeometry_(allGeometry),
+    cellSizeFunction_
+    (
+        cellSizeFunction::New(controlFunctionDict, searchableSurface_)
+    )
+//    geometryToConformTo_(geometryToConformTo),
+//    surfaces_(),
+//    cellSizeFunctions_(),
+//    triangulatedMesh_()
+{
+//    const dictionary& surfacesDict = coeffDict();
+//
+//    Info<< nl << "Reading cellSizeControlGeometry" << endl;
+//
+//    surfaces_.setSize(surfacesDict.size());
+//
+//    cellSizeFunctions_.setSize(surfacesDict.size());
+//
+//    label surfI = 0;
+//
+//    DynamicList<point> pointsToInsert;
+//    DynamicList<scalar> sizesToInsert;
+//    DynamicList<tensor> alignmentsToInsert;
+//
+//    forAllConstIter(dictionary, surfacesDict, iter)
+//    {
+//        const dictionary& surfaceSubDict
+//        (
+//            surfacesDict.subDict(iter().keyword())
+//        );
+//
+//        // If the "surface" keyword is not found in the dictionary, assume
+//        // the name of the dictionary is the surface. Distinction required to
+//        // allow the same surface to be used multiple times to supply multiple
+//        // cellSizeFunctions
+//
+//        word surfaceName = surfaceSubDict.lookupOrDefault<word>
+//        (
+//            "surface",
+//            iter().keyword()
+//        );
+//
+//        surfaces_[surfI] = allGeometry_.findSurfaceID(surfaceName);
+//
+//        if (surfaces_[surfI] < 0)
+//        {
+//            FatalErrorIn
+//            (
+//                "Foam::surfaceControl::surfaceControl"
+//            )   << "No surface " << surfaceName << " found. "
+//                << "Valid geometry is " << nl << allGeometry_.names()
+//                << exit(FatalError);
+//        }
+//
+//        const searchableSurface& surface = allGeometry_[surfaces_[surfI]];
+//
+//        Info<< nl << "    " << iter().keyword() << nl
+//            << "    surface: " << surfaceName << nl
+//            << "    size   : " << surface.size() << endl;
+//
+//        cellSizeFunctions_.set
+//        (
+//            surfI,
+//            cellSizeFunction::New
+//            (
+//                surfaceSubDict,
+//                surface
+//            )
+//        );
+//
+//        surfI++;
+//
+//        if (isA<triSurfaceMesh>(surface))
+//        {
+//            const triSurfaceMesh& tsm
+//                = refCast<const triSurfaceMesh>(surface);
+//
+//            const pointField& points = tsm.points();
+//            const vectorField& faceNormals = tsm.faceNormals();
+//            const labelListList& pointFaces = tsm.pointFaces();
+//
+//            Info<< "    Number of points: " << tsm.nPoints() << endl;
+//
+//            forAll(points, pI)
+//            {
+//                const Foam::point& pt = points[pI];
+//                const labelList& ptFaces = pointFaces[pI];
+//
+//                vectorField pointNormals(ptFaces.size());
+//
+//                forAll(pointNormals, pnI)
+//                {
+//                    pointNormals[pnI] = faceNormals[ptFaces[pnI]];
+//                }
+//
+//                pointsToInsert.append(pt);
+//
+//                // Get the value of the point from surfaceCellSizeFunction. If
+//                // adding points internally then will need to interpolate.
+//                scalar newSize = 0;
+//
+//                cellSizeFunctions_[surfI - 1].cellSize(pt, newSize);
+//                sizesToInsert.append(newSize);
+//
+//                tensor newAlignment = requiredAlignment(pt, pointNormals);
+//
+//                alignmentsToInsert.append(newAlignment);
+//            }
+//        }
+//    }
+//
+//    // Add the global bound box to ensure that all internal point queries
+//    // will return sizes and alignments
+////    boundBox bb = allGeometry_.bounds();
+////
+////    pointField bbPoints = bb.points();
+////
+////    forAll(bbPoints, pI)
+////    {
+////        pointsToInsert.append(bbPoints[pI]);
+////        sizesToInsert.append(defaultCellSize());
+////        alignmentsToInsert.append(tensor(1,0,0,0,1,0,0,0,1));
+////    }
+//
+//    triangulatedMesh_.set
+//    (
+//        new triangulatedMesh
+//        (
+//            runTime,
+//            pointsToInsert,
+//            sizesToInsert,
+//            alignmentsToInsert,
+//            defaultCellSize()
+//        )
+//    );
+//
+//    scalar factor = 1.0;
+//    label maxIteration = cellShapeControlDict.lookupOrDefault<label>
+//    (
+//        "maxRefinementIterations", 1
+//    );
+//
+//
+//    for (label iteration = 0; iteration < maxIteration; ++iteration)
+//    {
+//        Info<< "Iteration : " << iteration << endl;
+//
+//        label nRefined = triangulatedMesh_().refineTriangulation
+//        (
+//            factor,
+//            allGeometry_,
+//            geometryToConformTo_
+//        );
+//
+//        Info<< "    Number of cells refined in refinement iteration : "
+//            << nRefined << nl << endl;
+//
+//        if (nRefined <= 0 && iteration != 0)
+//        {
+//            break;
+//        }
+//
+//        factor *= 1.5;
+//    }
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::searchableSurfaceControl::~searchableSurfaceControl()
+{}
+
+
+// * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
+
+//Foam::scalar Foam::surfaceControl::cellSize(const point& pt) const
+//{
+//    scalarList bary;
+//    Cell_handle ch;
+//
+//    triangulatedMesh_().barycentricCoords(pt, bary, ch);
+//
+//    scalar size = 0;
+//    forAll(bary, pI)
+//    {
+//        size += bary[pI]*ch->vertex(pI)->size();
+//    }
+//
+//    return size;
+//}
+//
+//
+////- Return the cell alignment at the given location
+//Foam::tensor Foam::surfaceControl::cellAlignment(const point& pt) const
+//{
+//    scalarList bary;
+//    Cell_handle ch;
+//
+//    triangulatedMesh_().barycentricCoords(pt, bary, ch);
+//
+////    vectorField cartesianDirections(3);
+////
+////    cartesianDirections[0] = vector(0,0,1);
+////    cartesianDirections[1] = vector(0,1,0);
+////    cartesianDirections[2] = vector(1,0,0);
+////
+////    // Rearrange each alignment tensor so that the x/y/z components are
+////    // in order of whichever makes the smallest angle with the global
+////    // coordinate system
+////    FixedList<tensor, 4> alignments;
+////
+////    forAll(alignments, aI)
+////    {
+////        tensor a = ch->vertex(aI)->alignment();
+////
+////        tensor tmpA = a;
+////
+//////        Info<< nl << indent<< a << endl;
+////
+////        scalar minAngle = 0;
+////
+////        scalar axx = vectorTools::cosPhi(a.x(), cartesianDirections[0]);
+////        scalar axy = vectorTools::cosPhi(a.y(), cartesianDirections[0]);
+////        scalar axz = vectorTools::cosPhi(a.z(), cartesianDirections[0]);
+////
+////        scalar ayx = vectorTools::cosPhi(a.x(), cartesianDirections[1]);
+////        scalar ayy = vectorTools::cosPhi(a.y(), cartesianDirections[1]);
+////        scalar ayz = vectorTools::cosPhi(a.z(), cartesianDirections[1]);
+////
+////        scalar azx = vectorTools::cosPhi(a.x(), cartesianDirections[2]);
+////        scalar azy = vectorTools::cosPhi(a.y(), cartesianDirections[2]);
+////        scalar azz = vectorTools::cosPhi(a.z(), cartesianDirections[2]);
+////
+//////        Info<< indent << axx << " " << axy << " " << axz << nl
+//////            << indent << ayx << " " << ayy << " " << ayz << nl
+//////            << indent << azx << " " << azy << " " << azz << endl;
+////
+////        if (mag(axx) >= minAngle)
+////        {
+////            tmpA.xx() = mag(a.xx());
+////            tmpA.xy() = mag(a.xy());
+////            tmpA.xz() = mag(a.xz());
+////            minAngle = mag(axx);
+////        }
+////        if (mag(axy) >= minAngle)
+////        {
+////            tmpA.xx() = mag(a.yx());
+////            tmpA.xy() = mag(a.yy());
+////            tmpA.xz() = mag(a.yz());
+////            minAngle = mag(axy);
+////        }
+////        if (mag(axz) >= minAngle)
+////        {
+////            tmpA.xx() = mag(a.zx());
+////            tmpA.xy() = mag(a.zy());
+////            tmpA.xz() = mag(a.zz());
+////        }
+////
+////        minAngle = 0;
+////
+////        if (mag(ayx) >= minAngle)
+////        {
+////            tmpA.yx() = mag(a.xx());
+////            tmpA.yy() = mag(a.xy());
+////            tmpA.yz() = mag(a.xz());
+////            minAngle = mag(ayx);
+////        }
+////        if (mag(ayy) >= minAngle)
+////        {
+////            tmpA.yx() = mag(a.yx());
+////            tmpA.yy() = mag(a.yy());
+////            tmpA.yz() = mag(a.yz());
+////            minAngle = mag(ayy);
+////        }
+////        if (mag(ayz) >= minAngle)
+////        {
+////            tmpA.yx() = mag(a.zx());
+////            tmpA.yy() = mag(a.zy());
+////            tmpA.yz() = mag(a.zz());
+////        }
+////
+////        minAngle = 0;
+////
+////        if (mag(azx) >= minAngle)
+////        {
+////            tmpA.zx() = mag(a.xx());
+////            tmpA.zy() = mag(a.xy());
+////            tmpA.zz() = mag(a.xz());
+////            minAngle = mag(azx);
+////        }
+////        if (mag(azy) >= minAngle)
+////        {
+////            tmpA.zx() = mag(a.yx());
+////            tmpA.zy() = mag(a.yy());
+////            tmpA.zz() = mag(a.yz());
+////            minAngle = mag(azy);
+////        }
+////        if (mag(azz) >= minAngle)
+////        {
+////            tmpA.zx() = mag(a.zx());
+////            tmpA.zy() = mag(a.zy());
+////            tmpA.zz() = mag(a.zz());
+////        }
+////
+////        alignments[aI] = tmpA;
+////    }
+//
+//    scalar nearest = 0;
+//
+////    Info<< nl << "Point " << pt << endl;
+////
+////    FixedList<quaternion, 4> qAlignments;
+////    forAll(qAlignments, aI)
+////    {
+//////        Info<< "    Direction " << aI << endl;
+//////        Info<< "        Rot tensor" << alignments[aI] << endl;
+////        qAlignments[aI] = quaternion(alignments[aI]);
+////        qAlignments[aI].normalize();
+//////        Info<< "        Quaternion: " << qAlignments[aI] << endl;
+//////        Info<< "        Rot tensor from quat: " << qAlignments[aI].R()
+//////            << endl;
+////    }
+//
+//    tensor alignment = Foam::tensor::zero;
+//    forAll(bary, pI)
+//    {
+////        alignment += bary[pI]*ch->vertex(pI)->alignment();
+//
+////        alignment += bary[pI]*alignments[pI];
+//
+//        // Try slerp with quaternions
+//
+//        // Find nearest point
+//        if (bary[pI] > nearest)
+//        {
+//            alignment = ch->vertex(pI)->alignment();
+//            nearest = bary[pI];
+//        }
+//    }
+//
+////    quaternion alignment;
+//
+////    alignment = qAlignments[0]*bary[0]
+////              + qAlignments[1]*bary[1]
+////              + qAlignments[2]*bary[2]
+////              + qAlignments[3]*bary[3];
+//
+////    alignment =
+////        slerp(qAlignments[0], qAlignments[1], bary[0]+bary[1]+bary[2]);
+////    alignment = slerp(alignment, qAlignments[2], bary[0]+bary[1]+bary[2]);
+////    alignment = slerp(alignment, qAlignments[3], bary[0]+bary[1]+bary[2]);
+////    alignment =
+////        slerp(alignment, qAlignments[0], bary[0]/(bary[0]+bary[1]+bary[2]));
+//
+////    Info<< "    Interp alignment : " << alignment << endl;
+////    Info<< "    Interp rot tensor: " << alignment.R() << endl;
+//
+//    return alignment;
+//}
+//
+//
+//void Foam::surfaceControl::cellSizeAndAlignment
+//(
+//    const point& pt,
+//    scalar& size,
+//    tensor& alignment
+//) const
+//{
+//    scalarList bary;
+//    Cell_handle ch;
+//
+//    triangulatedMesh_().barycentricCoords(pt, bary, ch);
+//
+//    size = 0;
+//    forAll(bary, pI)
+//    {
+//        size += bary[pI]*ch->vertex(pI)->size();
+//    }
+//
+////    alignment = Foam::tensor::zero;
+////    forAll(bary, pI)
+////    {
+////        alignment += bary[pI]*ch->vertex(pI)->alignment();
+////    }
+//
+//    alignment = cellAlignment(pt);
+//}
+
+
+void Foam::searchableSurfaceControl::initialVertices
+(
+    pointField& pts,
+    scalarField& sizes,
+    Field<triad>& alignments
+) const
+{
+    pts = searchableSurface_.points();
+
+    const scalar nearFeatDistSqrCoeff = 1e-8;
+
+    sizes.setSize(pts.size());
+    alignments.setSize(pts.size());
+
+    forAll(pts, pI)
+    {
+        // Is the point in the extendedFeatureEdgeMesh? If so get the
+        // point normal, otherwise get the surface normal from
+        // searchableSurface
+
+        pointIndexHit info;
+        label infoFeature;
+        allGeometry_.findFeaturePointNearest
+        (
+            pts[pI],
+            nearFeatDistSqrCoeff,
+            info,
+            infoFeature
+        );
+
+        autoPtr<triad> pointAlignment;
+
+        if (info.hit())
+        {
+            const extendedFeatureEdgeMesh& features =
+                allGeometry_.features()[infoFeature];
+
+            vectorField norms = features.featurePointNormals(info.index());
+
+            // Create a triad from these norms.
+            pointAlignment.set(new triad());
+            forAll(norms, nI)
+            {
+                pointAlignment() += norms[nI];
+            }
+
+            pointAlignment().normalize();
+            pointAlignment().orthogonalize();
+        }
+        else
+        {
+            allGeometry_.findEdgeNearest
+            (
+                pts[pI],
+                nearFeatDistSqrCoeff,
+                info,
+                infoFeature
+            );
+
+            if (info.hit())
+            {
+                const extendedFeatureEdgeMesh& features =
+                    allGeometry_.features()[infoFeature];
+
+                vectorField norms = features.edgeNormals(info.index());
+
+                // Create a triad from these norms.
+                pointAlignment.set(new triad());
+                forAll(norms, nI)
+                {
+                    pointAlignment() += norms[nI];
+                }
+
+                pointAlignment().normalize();
+                pointAlignment().orthogonalize();
+            }
+            else
+            {
+                pointField ptField(1, pts[pI]);
+                scalarField distField(1, nearFeatDistSqrCoeff);
+                List<pointIndexHit> infoList(1, pointIndexHit());
+
+                searchableSurface_.findNearest(ptField, distField, infoList);
+
+                vectorField normals(1);
+                searchableSurface_.getNormal(infoList, normals);
+
+                pointAlignment.set(new triad(normals[0]));
+            }
+        }
+
+        if (!cellSizeFunction_().cellSize(pts[pI], sizes[pI]))
+        {
+            FatalErrorIn
+            (
+                "Foam::searchableSurfaceControl::initialVertices"
+                "(pointField&, scalarField&, tensorField&)"
+            )   << "Could not calculate cell size"
+                << abort(FatalError);
+        }
+
+        alignments[pI] = pointAlignment();
+    }
+}
+
+
+// ************************************************************************* //
diff --git a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellShapeControl/cellSizeAndAlignmentControl/searchableSurfaceControl/searchableSurfaceControl.H b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellShapeControl/cellSizeAndAlignmentControl/searchableSurfaceControl/searchableSurfaceControl.H
new file mode 100644
index 0000000000..9ecc3a0ac8
--- /dev/null
+++ b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellShapeControl/cellSizeAndAlignmentControl/searchableSurfaceControl/searchableSurfaceControl.H
@@ -0,0 +1,167 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 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::searchableSurfaceControl
+
+Description
+
+SourceFiles
+    searchableSurfaceControl.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef searchableSurfaceControl_H
+#define searchableSurfaceControl_H
+
+#include "cellShapeControl.H"
+#include "cellSizeFunction.H"
+#include "triad.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+
+/*---------------------------------------------------------------------------*\
+                      Class surfaceControl Declaration
+\*---------------------------------------------------------------------------*/
+
+class searchableSurfaceControl
+:
+    public cellSizeAndAlignmentControl
+{
+    // Private data
+
+          //- Reference to the searchableSurface object holding the geometry
+          //  data
+          const searchableSurface& searchableSurface_;
+
+          const conformationSurfaces& allGeometry_;
+
+          autoPtr<cellSizeFunction> cellSizeFunction_;
+
+
+//        const conformationSurfaces& geometryToConformTo_;
+//
+//        //- Indices of surfaces in allGeometry that are to be conformed to
+//        labelList surfaces_;
+//
+//        //- A list of all of the cellSizeFunction objects
+//        PtrList<cellSizeFunction> cellSizeFunctions_;
+//
+//        autoPtr<triangulatedMesh> triangulatedMesh_;
+//
+//
+//    // Private Member Functions
+//
+//        //-
+//        tensor requiredAlignment
+//        (
+//            const point& pt,
+//            const vectorField& ptNormals
+//        ) const;
+
+        //- Disallow default bitwise copy construct
+        searchableSurfaceControl(const searchableSurfaceControl&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const searchableSurfaceControl&);
+
+
+public:
+
+    //- Runtime type information
+    TypeName("searchableSurfaceControl");
+
+
+    // Constructors
+
+        //- Construct from dictionary and references to conformalVoronoiMesh and
+        //  searchableSurfaces
+        searchableSurfaceControl
+        (
+            const Time& runTime,
+            const word& name,
+            const dictionary& controlFunctionDict,
+            const conformationSurfaces& allGeometry
+        );
+
+    //- Destructor
+    ~searchableSurfaceControl();
+
+
+    // Member Functions
+
+        // Access
+
+//            //- Return reference to the searchableSurfaces object containing
+//            //  all of the geometry
+//            inline const searchableSurfaces& geometry() const;
+//
+//            //- Return the surface indices
+//            inline const labelList& surfaces() const;
+//
+//
+//        // Query
+//
+//            //- Return the cell size at the given location
+//            virtual scalar cellSize(const point& pt) const;
+//
+//            //- Return the cell alignment at the given location
+//            virtual tensor cellAlignment(const point& pt) const;
+//
+//            virtual void cellSizeAndAlignment
+//            (
+//                const point& pt,
+//                scalar& size,
+//                tensor& alignment
+//            ) const;
+
+        virtual void initialVertices
+        (
+            pointField& pts,
+            scalarField& sizes,
+            Field<triad>& alignments
+        ) const;
+
+        const cellSizeFunction& sizeFunction() const
+        {
+            return cellSizeFunction_();
+        }
+
+        // Edit
+
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellSizeControlSurfaces/cellSizeControlSurfaces.C b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellSizeControlSurfaces/cellSizeControlSurfaces.C
index 0b6acc5ca0..1cc41dc29c 100644
--- a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellSizeControlSurfaces/cellSizeControlSurfaces.C
+++ b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellSizeControlSurfaces/cellSizeControlSurfaces.C
@@ -26,6 +26,9 @@ License
 #include "cellSizeControlSurfaces.H"
 #include "conformalVoronoiMesh.H"
 #include "cellSizeFunction.H"
+#include "triSurfaceMesh.H"
+#include "tetrahedron.H"
+#include "OFstream.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
@@ -149,15 +152,358 @@ bool Foam::cellSizeControlSurfaces::evalCellSizeFunctions
 }
 
 
+bool Foam::cellSizeControlSurfaces::checkCoplanarTet
+(
+    Cell_handle c,
+    const scalar tol
+) const
+{
+    plane triPlane
+    (
+        topoint(c->vertex(0)->point()),
+        topoint(c->vertex(1)->point()),
+        topoint(c->vertex(2)->point())
+    );
+
+    // Check if the four points are roughly coplanar. If they are then we
+    // cannot calculate the circumcentre. Better test might be the volume
+    // of the tet.
+    if (triPlane.distance(topoint(c->vertex(3)->point())) < tol)
+    {
+        return true;
+    }
+
+    return false;
+}
+
+
+bool Foam::cellSizeControlSurfaces::checkClosePoints
+(
+    Cell_handle c,
+    const scalar tol
+) const
+{
+    for (label v = 0; v < 4; ++v)
+    {
+        for (label vA = v + 1; vA < 4; ++vA)
+        {
+            if
+            (
+                mag
+                (
+                    topoint(c->vertex(v)->point())
+                  - topoint(c->vertex(vA)->point())
+                )
+              < tol
+            )
+            {
+                return true;
+            }
+        }
+    }
+
+    return false;
+}
+
+
+Foam::label Foam::cellSizeControlSurfaces::refineTriangulation
+(
+    const scalar factor
+)
+{
+    // Check the tets and insert new points if necessary
+    List<Foam::point> corners(4);
+    List<scalar> values(4);
+
+    DynamicList<Foam::point> pointsToInsert(T_.number_of_vertices());
+    DynamicList<scalar> valuesToInsert(T_.number_of_vertices());
+
+    for
+    (
+        Delaunay::Finite_cells_iterator c = T_.finite_cells_begin();
+        c != T_.finite_cells_end();
+        ++c
+    )
+    {
+        //const point& newPoint = tet.centre();
+        //Cell_handle ch = c;
+
+//        Info<< count++ << endl;
+//        Info<< "    " << topoint(c->vertex(0)->point()) << nl
+//            << "    " << topoint(c->vertex(1)->point()) << nl
+//            << "    " << topoint(c->vertex(2)->point()) << nl
+//            << "    " << topoint(c->vertex(3)->point()) << endl;
+
+        scalar minDist = 1e-6*defaultCellSize_;
+
+        if (checkClosePoints(c, minDist) || checkCoplanarTet(c, minDist))
+        {
+            continue;
+        }
+
+        const Point circumcenter = CGAL::circumcenter
+        (
+            c->vertex(0)->point(),
+            c->vertex(1)->point(),
+            c->vertex(2)->point(),
+            c->vertex(3)->point()
+        );
+
+        pointFromPoint newPoint = topoint(circumcenter);
+
+        if (geometryToConformTo_.outside(newPoint))
+        {
+            continue;
+        }
+
+        Cell_handle ch = T_.locate
+        (
+            Point(newPoint.x(), newPoint.y(), newPoint.z())
+        );
+
+        forAll(corners, pI)
+        {
+            corners[pI] = topoint(ch->vertex(pI)->point());
+            values[pI] = ch->vertex(pI)->value();
+        }
+
+        tetPointRef tet(corners[0], corners[1], corners[2], corners[3]);
+
+        scalarList bary;
+        tet.barycentric(newPoint, bary);
+
+        scalar interpolatedSize = 0;
+        forAll(bary, pI)
+        {
+            interpolatedSize += bary[pI]*ch->vertex(pI)->value();
+        }
+
+        // Find largest gradient
+        label maxGradCorner = -1;
+        scalar maxGradient = 0.0;
+        forAll(corners, pI)
+        {
+            const scalar distance = mag(newPoint - corners[pI]);
+            const scalar diffSize = interpolatedSize - values[pI];
+
+            const scalar gradient = diffSize/distance;
+
+            if (gradient > maxGradient)
+            {
+                maxGradient = gradient;
+                maxGradCorner = pI;
+            }
+        }
+
+//        if (wallSize < 0.5*defaultCellSize_)
+//        {
+//        Info<< "Centre             : " << centre
+//            << " (Default Size: " << defaultCellSize_ << ")" << nl
+//            << "Interpolated Size  : " << interpolatedSize << nl
+//            << "Distance from wall : " << distanceSize << nl
+//            << "Wall size          : " << wallSize << nl
+//            << "distanceGradient   : " << distanceGradient << nl
+//            << "interpGradient     : " << interpolatedGradient << nl << endl;
+//        }
+
+        scalar minCellSize = 1e-6;
+        scalar initialMaxGradient = 0;//0.2*factor;
+        scalar initialMinGradient = 0;//0.01*(1.0/factor);
+        scalar idealGradient = 0.2;
+
+
+
+        // Reduce strong gradients
+        if (maxGradient > initialMaxGradient)
+        {
+            const scalar distance2 = mag(newPoint - corners[maxGradCorner]);
+
+            scalar newSize
+                = values[maxGradCorner] + idealGradient*distance2;
+
+            pointsToInsert.append(newPoint);
+            valuesToInsert.append
+            (
+                max(min(newSize, defaultCellSize_), minCellSize)
+            );
+        }
+        else if (maxGradient < -initialMaxGradient)
+        {
+            const scalar distance2 = mag(newPoint - corners[maxGradCorner]);
+
+            scalar newSize
+                = values[maxGradCorner] - idealGradient*distance2;
+
+            pointsToInsert.append(newPoint);
+            valuesToInsert.append
+            (
+                max(min(newSize, defaultCellSize_), minCellSize)
+            );
+        }
+
+        // Increase small gradients
+        if
+        (
+            maxGradient < initialMinGradient
+         && maxGradient > 0
+         && interpolatedSize < 0.5*defaultCellSize_
+        )
+        {
+            const scalar distance2 = mag(newPoint - corners[maxGradCorner]);
+
+            scalar newSize
+                = values[maxGradCorner] + idealGradient*distance2;
+
+            pointsToInsert.append(newPoint);
+            valuesToInsert.append
+            (
+                max(min(newSize, defaultCellSize_), minCellSize)
+            );
+        }
+        else if
+        (
+            maxGradient > -initialMinGradient
+         && maxGradient < 0
+         && interpolatedSize > 0.5*defaultCellSize_
+        )
+        {
+            const scalar distance2 = mag(newPoint - corners[maxGradCorner]);
+
+            scalar newSize
+                = values[maxGradCorner] - idealGradient*distance2;
+
+            pointsToInsert.append(newPoint);
+            valuesToInsert.append
+            (
+                max(min(newSize, defaultCellSize_), minCellSize)
+            );
+        }
+    }
+
+    if (!pointsToInsert.empty())
+    {
+        Info<< "    Minimum Cell Size : " << min(valuesToInsert) << nl
+            << "    Average Cell Size : " << average(valuesToInsert) << nl
+            << "    Maximum Cell Size : " << max(valuesToInsert) << endl;
+
+        forAll(pointsToInsert, pI)
+        {
+            Foam::point p = pointsToInsert[pI];
+
+            Vertex_handle v = T_.insert(Point(p.x(), p.y(), p.z()));
+
+            v->value(valuesToInsert[pI]);
+        }
+    }
+
+    return pointsToInsert.size();
+}
+
+
+void Foam::cellSizeControlSurfaces::writeRefinementTriangulation()
+{
+    OFstream str("refinementTriangulation.obj");
+
+    label count = 0;
+
+    Info<< "Write refinementTriangulation" << endl;
+
+    for
+    (
+        Delaunay::Finite_edges_iterator e = T_.finite_edges_begin();
+        e != T_.finite_edges_end();
+        ++e
+    )
+    {
+        Cell_handle c = e->first;
+        Vertex_handle vA = c->vertex(e->second);
+        Vertex_handle vB = c->vertex(e->third);
+
+        pointFromPoint p1 = topoint(vA->point());
+        pointFromPoint p2 = topoint(vB->point());
+
+        meshTools::writeOBJ(str, p1, p2, count);
+    }
+
+
+    OFstream strPoints("refinementObject.obj");
+
+    Info<< "Write refinementObject" << endl;
+
+    for
+    (
+        Delaunay::Finite_vertices_iterator v = T_.finite_vertices_begin();
+        v != T_.finite_vertices_end();
+        ++v
+    )
+    {
+        pointFromPoint p = topoint(v->point());
+
+        meshTools::writeOBJ
+        (
+            strPoints,
+            p,
+            point(p.x() + v->value(), p.y(), p.z())
+        );
+    }
+
+//    OFstream strDual("refinementDualPoints.obj");
+//
+//    Info<< "Write refinementDualPoints" << endl;
+//
+//    for
+//    (
+//        Delaunay::Finite_cells_iterator c = T_.finite_cells_begin();
+//        c != T_.finite_cells_end();
+//        ++c
+//    )
+//    {
+//        Point circumcenter = CGAL::circumcenter
+//        (
+//            c->vertex(0)->point(),
+//            c->vertex(1)->point(),
+//            c->vertex(2)->point(),
+//            c->vertex(3)->point()
+//        );
+//
+//        pointFromPoint p = topoint(circumcenter);
+//
+//        if (geometryToConformTo_.inside(p))
+//        {
+//            meshTools::writeOBJ
+//            (
+//                strDual,
+//                p
+//            );
+//        }
+//    }
+
+    if (T_.is_valid())
+    {
+        Info<< "    Triangulation is valid" << endl;
+    }
+    else
+    {
+        FatalErrorIn
+        (
+            "Foam::cellSizeControlSurfaces::writeRefinementTriangulation()"
+        )   << "Triangulation is not valid"
+            << abort(FatalError);
+    }
+}
+
+
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
 Foam::cellSizeControlSurfaces::cellSizeControlSurfaces
 (
     const searchableSurfaces& allGeometry,
+    const conformationSurfaces& geometryToConformTo,
     const dictionary& motionControlDict
 )
 :
     allGeometry_(allGeometry),
+    geometryToConformTo_(geometryToConformTo),
     surfaces_(),
     cellSizeFunctions_(),
     defaultCellSize_(readScalar(motionControlDict.lookup("defaultCellSize"))),
@@ -214,7 +560,8 @@ Foam::cellSizeControlSurfaces::cellSizeControlSurfaces
         const searchableSurface& surface = allGeometry_[surfaces_[surfI]];
 
         Info<< nl << "    " << iter().keyword() << nl
-            << "    surface: " << surfaceName << endl;
+            << "    surface: " << surfaceName << nl
+            << "    size   : " << surface.size() << endl;
 
         cellSizeFunctions_.set
         (
@@ -229,11 +576,78 @@ Foam::cellSizeControlSurfaces::cellSizeControlSurfaces
         priorities[surfI] = cellSizeFunctions_[surfI].priority();
 
         surfI++;
+
+        if (isA<triSurfaceMesh>(surface))
+        {
+            const triSurfaceMesh& tsm
+                = refCast<const triSurfaceMesh>(surface);
+
+            const pointField& points = tsm.points();
+
+            Info<< "    number of points: " << tsm.nPoints() << endl;
+
+            std::vector<std::pair<Point, scalar> > pointsToInsert;
+
+            forAll(points, pI)
+            {
+                size_t nVert = T_.number_of_vertices();
+
+                Vertex_handle v = T_.insert
+                (
+                    Point(points[pI].x(), points[pI].y(), points[pI].z())
+                );
+
+                if (T_.number_of_vertices() == nVert)
+                {
+                    Info<< "Failed to insert point : " << points[pI] << endl;
+                }
+
+                // Get the value of the point from surfaceCellSizeFunction. If
+                // adding points internally then will need to interpolate.
+                scalar newSize = 0;
+                cellSizeFunctions_[surfI-1].cellSize(points[pI], newSize);
+                v->value(newSize);
+            }
+        }
     }
 
+    scalar factor = 1.0;
+    label maxIteration = 1;
+
+    for (label iteration = 0; iteration < maxIteration; ++iteration)
+    {
+        Info<< "Iteration : " << iteration << endl;
+
+        label nRefined = refineTriangulation(factor);
+
+        Info<< "    Number of cells refined in refinement iteration : "
+            << nRefined << nl << endl;
+
+        if (nRefined <= 0 && iteration != 0)
+        {
+            break;
+        }
+
+        factor *= 1.5;
+    }
+
+    writeRefinementTriangulation();
+
+    Info<< nl << "Refinement triangulation information: " << endl;
+    Info<< "    Number of vertices: " << label(T_.number_of_vertices()) << endl;
+    Info<< "    Number of cells   : "
+        << label(T_.number_of_finite_cells()) << endl;
+    Info<< "    Number of faces   : "
+        << label(T_.number_of_finite_facets()) << endl;
+    Info<< "    Number of edges   : "
+        << label(T_.number_of_finite_edges()) << endl;
+    Info<< "    Dimensionality    : " << label(T_.dimension()) << nl << endl;
+
+
     // Sort cellSizeFunctions_ and surfaces_ by priority.  Cut off any surfaces
     // where priority < defaultPriority_
 
+
     labelList sortedIndices;
 
     sortedOrder(priorities, sortedIndices);
@@ -282,8 +696,40 @@ Foam::scalar Foam::cellSizeControlSurfaces::cellSize
 {
     scalar size = defaultCellSize_;
 
-//  bool anyFunctionFound = evalCellSizeFunctions(pt, size);
-    evalCellSizeFunctions(pt, size);
+    bool refinementTriangulationSwitch = true;
+
+    if (!refinementTriangulationSwitch)
+    {
+        evalCellSizeFunctions(pt, size);
+    }
+    else
+    {
+        Cell_handle ch = T_.locate
+        (
+            Point(pt.x(), pt.y(), pt.z()),
+            oldCellHandle_
+        );
+
+        oldCellHandle_ = ch;
+
+        pointFromPoint pA = topoint(ch->vertex(0)->point());
+        pointFromPoint pB = topoint(ch->vertex(1)->point());
+        pointFromPoint pC = topoint(ch->vertex(2)->point());
+        pointFromPoint pD = topoint(ch->vertex(3)->point());
+
+        tetPointRef tet(pA, pB, pC, pD);
+
+        scalarList bary;
+        tet.barycentric(pt, bary);
+
+        scalar value = 0;
+        forAll(bary, pI)
+        {
+            value += bary[pI]*ch->vertex(pI)->value();
+        }
+
+        size = value;
+    }
 
 //if (!anyFunctionFound)
 //{
diff --git a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellSizeControlSurfaces/cellSizeControlSurfaces.H b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellSizeControlSurfaces/cellSizeControlSurfaces.H
index 9f522f0dfc..de3e9d75c1 100644
--- a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellSizeControlSurfaces/cellSizeControlSurfaces.H
+++ b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellSizeControlSurfaces/cellSizeControlSurfaces.H
@@ -37,9 +37,92 @@ SourceFiles
 
 #include "searchableSurfaces.H"
 #include "searchableSurfacesQueries.H"
+#include "conformationSurfaces.H"
+
+#include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
+#include <CGAL/Delaunay_triangulation_3.h>
+#include <CGAL/Triangulation_vertex_base_with_info_3.h>
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
+template < class GT, class Vb = CGAL::Triangulation_vertex_base_3<GT> >
+class vertexWithInfo
+:
+    public Vb
+{
+public:
+
+    Foam::scalar value_;
+
+    Foam::tensor alignment_;
+
+    typedef typename Vb::Vertex_handle  Vertex_handle;
+    typedef typename Vb::Cell_handle    Cell_handle;
+    typedef typename Vb::Point          Point;
+
+    template < class TDS2 >
+    struct Rebind_TDS
+    {
+        typedef typename Vb::template Rebind_TDS<TDS2>::Other   Vb2;
+        typedef vertexWithInfo<GT, Vb2>                         Other;
+    };
+
+    vertexWithInfo()
+    :
+        Vb(),
+        value_(0.0),
+        alignment_(Foam::tensor::zero)
+    {}
+
+    explicit vertexWithInfo(const Point& p)
+    :
+        Vb(p),
+        value_(0.0),
+        alignment_(Foam::tensor::zero)
+    {}
+
+    vertexWithInfo(const Point& p, const Foam::scalar& value)
+    :
+        Vb(p),
+        value_(value),
+        alignment_(Foam::tensor::zero)
+    {}
+
+    vertexWithInfo
+    (
+        const Point& p,
+        const Foam::scalar& value,
+        const Foam::tensor& alignment
+    )
+    :
+        Vb(p),
+        value_(value),
+        alignment_(alignment)
+    {}
+
+
+    const Foam::scalar& value() const
+    {
+        return value_;
+    }
+
+    void value(const Foam::scalar& value)
+    {
+        value_ = value;
+    }
+
+    const Foam::tensor& alignment() const
+    {
+        return alignment_;
+    }
+
+    void alignment(const Foam::tensor& alignment)
+    {
+        alignment_ = alignment;
+    }
+};
+
+
 namespace Foam
 {
 
@@ -55,11 +138,29 @@ class cellSizeFunction;
 
 class cellSizeControlSurfaces
 {
+    typedef CGAL::Exact_predicates_inexact_constructions_kernel             K;
+    typedef CGAL::Triangulation_data_structure_3<vertexWithInfo<K> >        Tds;
+
+    typedef CGAL::Delaunay_triangulation_3<K, Tds, CGAL::Fast_location>
+        Delaunay;
+
+    typedef Delaunay::Cell_handle    Cell_handle;
+    typedef Delaunay::Vertex_handle  Vertex_handle;
+    typedef Delaunay::Locate_type    Locate_type;
+    typedef Delaunay::Point          Point;
+
+    Delaunay T_;
+
+    mutable Cell_handle oldCellHandle_;
+
+
     // Private data
 
         //- Reference to the searchableSurfaces object holding all geometry data
         const searchableSurfaces& allGeometry_;
 
+        const conformationSurfaces& geometryToConformTo_;
+
         //- Indices of surfaces in allGeometry that are to be conformed to
         labelList surfaces_;
 
@@ -84,6 +185,14 @@ class cellSizeControlSurfaces
             scalar& minSize
         ) const;
 
+        bool checkCoplanarTet(Cell_handle c, const scalar tol) const;
+
+        bool checkClosePoints(Cell_handle c, const scalar tol) const;
+
+        label refineTriangulation(const scalar factor);
+
+        void writeRefinementTriangulation();
+
         //- Disallow default bitwise copy construct
         cellSizeControlSurfaces(const cellSizeControlSurfaces&);
 
@@ -104,6 +213,7 @@ public:
         cellSizeControlSurfaces
         (
             const searchableSurfaces& allGeometry,
+            const conformationSurfaces& geometryToConformTo,
             const dictionary& motionControlDict
         );
 
diff --git a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellSizeControlSurfaces/cellSizeFunction/cellSizeFunction/cellSizeFunction.C b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellSizeControlSurfaces/cellSizeFunction/cellSizeFunction/cellSizeFunction.C
index 1276133623..995d10fdc3 100644
--- a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellSizeControlSurfaces/cellSizeFunction/cellSizeFunction/cellSizeFunction.C
+++ b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellSizeControlSurfaces/cellSizeFunction/cellSizeFunction/cellSizeFunction.C
@@ -56,8 +56,7 @@ Foam::cellSizeFunction::cellSizeFunction
         )
     ),
     coeffsDict_(subDict(type + "Coeffs")),
-    sideMode_(),
-    priority_(readLabel(cellSizeFunctionDict.lookup("priority")))
+    sideMode_()
 {
     word mode = cellSizeFunctionDict.lookup("mode");
 
@@ -77,7 +76,7 @@ Foam::cellSizeFunction::cellSizeFunction
         }
         else
         {
-            FatalErrorIn("cellSizeFunction::cellSizeFunction")
+            FatalErrorIn("searchableSurfaceControl::searchableSurfaceControl")
                 << "Unknown mode, expected: inside, outside or bothSides" << nl
                 << exit(FatalError);
         }
@@ -86,7 +85,7 @@ Foam::cellSizeFunction::cellSizeFunction
     {
         if (mode != "bothSides")
         {
-            WarningIn("cellSizeFunction::cellSizeFunction")
+            WarningIn("searchableSurfaceControl::searchableSurfaceControl")
                 << "surface does not support volumeType, defaulting mode to "
                 << "bothSides."
                 << endl;
diff --git a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellSizeControlSurfaces/cellSizeFunction/cellSizeFunction/cellSizeFunction.H b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellSizeControlSurfaces/cellSizeFunction/cellSizeFunction/cellSizeFunction.H
index 1e6fd4442e..58ee5d5e0f 100644
--- a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellSizeControlSurfaces/cellSizeFunction/cellSizeFunction/cellSizeFunction.H
+++ b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellSizeControlSurfaces/cellSizeFunction/cellSizeFunction/cellSizeFunction.H
@@ -59,9 +59,6 @@ class cellSizeFunction
 
 public:
 
-    //- Runtime type information
-    TypeName("cellSizeFunction");
-
     //- Surface side mode
     enum sideMode
     {
@@ -70,6 +67,9 @@ public:
         rmBothsides       // Control on both sides of a surface
     };
 
+    //- Runtime type information
+    TypeName("cellSizeFunction");
+
 
 protected:
 
@@ -97,9 +97,6 @@ protected:
         //- Mode of size specification, i.e. inside, outside or bothSides
         sideMode sideMode_;
 
-        //- Priority of this cellSizeFunction
-        label priority_;
-
 
 private:
 
@@ -162,11 +159,6 @@ public:
             return coeffsDict_;
         }
 
-        inline label priority() const
-        {
-            return priority_;
-        }
-
         //- Modify scalar argument to the cell size specified by function.
         //  Return a boolean specifying if the function was used, i.e. false if
         //  the point was not in range of the surface for a spatially varying
diff --git a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellSizeControlSurfaces/surfaceCellSizeFunction/cellSizeCalculationType/automatic/automatic.C b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellSizeControlSurfaces/surfaceCellSizeFunction/cellSizeCalculationType/automatic/automatic.C
index d30cc2a5ff..e8f09cf5f1 100644
--- a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellSizeControlSurfaces/surfaceCellSizeFunction/cellSizeCalculationType/automatic/automatic.C
+++ b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellSizeControlSurfaces/surfaceCellSizeFunction/cellSizeCalculationType/automatic/automatic.C
@@ -26,6 +26,7 @@ License
 #include "automatic.H"
 #include "addToRunTimeSelectionTable.H"
 #include "triSurfaceMesh.H"
+#include "vtkSurfaceWriter.H"
 #include "Time.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
@@ -36,6 +37,59 @@ namespace Foam
     addToRunTimeSelectionTable(cellSizeCalculationType, automatic, dictionary);
 }
 
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+void Foam::automatic::smoothField(triSurfaceScalarField& surf)
+{
+    label nSmoothingIterations = 10;
+
+    for (label iter = 0; iter < nSmoothingIterations; ++iter)
+    {
+        const pointField& faceCentres = surface_.faceCentres();
+
+        forAll(surf, sI)
+        {
+            const labelList& faceFaces = surface_.faceFaces()[sI];
+
+            const point& fC = faceCentres[sI];
+            const scalar value = surf[sI];
+
+            scalar newValue = 0;
+            scalar totalDist = 0;
+
+            label nFaces = 0;
+
+            forAll(faceFaces, fI)
+            {
+                const label faceLabel = faceFaces[fI];
+                const point& faceCentre = faceCentres[faceLabel];
+
+                const scalar faceValue = surf[faceLabel];
+                const scalar distance = mag(faceCentre - fC);
+
+                newValue += faceValue/distance;
+
+                totalDist += 1.0/distance;
+
+                if (value < faceValue)
+                {
+                    nFaces++;
+                }
+            }
+
+            // Do not smooth out the peak values
+            if (nFaces == faceFaces.size())
+            {
+                //continue;
+            }
+
+            surf[sI] = newValue/totalDist;
+        }
+    }
+}
+
+
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
 Foam::automatic::automatic
@@ -90,7 +144,8 @@ Foam::triSurfaceScalarField Foam::automatic::load()
 
     if (readCurvature_)
     {
-        Info<< indent << "Reading curvature: " << curvatureFile_ << endl;
+        Info<< indent << "Reading curvature         : "
+            << curvatureFile_ << endl;
 
         triSurfacePointScalarField curvature
         (
@@ -174,7 +229,7 @@ Foam::triSurfaceScalarField Foam::automatic::load()
 
     if (readFeatureProximity_)
     {
-        Info<< indent << "Reading feature proximity: "
+        Info<< indent << "Reading feature proximity : "
             << featureProximityFile_ << endl;
 
         triSurfaceScalarField featureProximity
@@ -204,8 +259,34 @@ Foam::triSurfaceScalarField Foam::automatic::load()
         }
     }
 
+    smoothField(surfaceCellSize);
+
     surfaceCellSize.write();
 
+    debug = 1;
+
+    if (debug)
+    {
+        faceList faces(surface_.size());
+
+        forAll(surface_, fI)
+        {
+            faces[fI] = surface_.triSurface::operator[](fI).triFaceFace();
+        }
+
+        vtkSurfaceWriter().write
+        (
+            surface_.searchableSurface::time().constant()/"triSurface",
+            surfaceName_,
+            surface_.points(),
+            faces,
+            "cellSize",
+            surfaceCellSize,
+            false,
+            true
+        );
+    }
+
     return surfaceCellSize;
 }
 
diff --git a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellSizeControlSurfaces/surfaceCellSizeFunction/cellSizeCalculationType/automatic/automatic.H b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellSizeControlSurfaces/surfaceCellSizeFunction/cellSizeCalculationType/automatic/automatic.H
index 04d8ed7ddb..4288176e8f 100644
--- a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellSizeControlSurfaces/surfaceCellSizeFunction/cellSizeCalculationType/automatic/automatic.H
+++ b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cellSizeControlSurfaces/surfaceCellSizeFunction/cellSizeCalculationType/automatic/automatic.H
@@ -85,6 +85,11 @@ private:
         const scalar maximumCellSize_;
 
 
+    // Private Member Functions
+
+        void smoothField(triSurfaceScalarField& surf);
+
+
 public:
 
     //- Runtime type information
diff --git a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/CGALTriangulation3DKernel.H b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/CGALTriangulation3DKernel.H
new file mode 100644
index 0000000000..e80b3fb8f4
--- /dev/null
+++ b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/CGALTriangulation3DKernel.H
@@ -0,0 +1,62 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 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/>.
+
+Typedefs
+    CGALTriangulation3DKernel
+
+Description
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef CGALTriangulation3DKernel_H
+#define CGALTriangulation3DKernel_H
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#include "CGAL/Delaunay_triangulation_3.h"
+
+#ifdef CGAL_INEXACT
+
+    // Fast kernel using a double as the storage type but the triangulation may
+    // fail. Adding robust circumcentre traits
+    #include "CGAL/Exact_predicates_inexact_constructions_kernel.h"
+    typedef CGAL::Exact_predicates_inexact_constructions_kernel baseK;
+//    #include <CGAL/Robust_circumcenter_traits_3.h>
+    #include <CGAL/Robust_circumcenter_filtered_traits_3.h>
+//    typedef CGAL::Robust_circumcenter_traits_3<baseK>           K;
+    typedef CGAL::Robust_circumcenter_filtered_traits_3<baseK>  K;
+
+#else
+
+    // Very robust but expensive kernel
+    #include "CGAL/Exact_predicates_exact_constructions_kernel.h"
+    typedef CGAL::Exact_predicates_exact_constructions_kernel baseK;
+    typedef CGAL::Exact_predicates_exact_constructions_kernel K;
+
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/CGALTriangulation3Ddefs.H b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/CGALTriangulation3Ddefs.H
index 72d44618a2..4e7dd48c38 100644
--- a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/CGALTriangulation3Ddefs.H
+++ b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/CGALTriangulation3Ddefs.H
@@ -21,11 +21,6 @@ License
     You should have received a copy of the GNU General Public License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
-    As a special exception, you have permission to link this program with the
-    CGAL library and distribute executables, as long as you follow the
-    requirements of the GNU GPL in regard to all of the software in the
-    executable aside from CGAL.
-
 Typedefs
     CGALTriangulation3Ddefs
 
@@ -43,76 +38,20 @@ Description
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-#include "CGAL/Delaunay_triangulation_3.h"
+#include "CGALTriangulation3DKernel.H"
 
 #include "indexedVertex.H"
 #include "indexedCell.H"
 
-#ifdef CGAL_INEXACT
-    // Fast kernel using a double as the storage type but the triangulation may
-    // fail.  Adding robust circumcentre traits
-    #include "CGAL/Exact_predicates_inexact_constructions_kernel.h"
-    #include <CGAL/Robust_circumcenter_traits_3.h>
-    typedef CGAL::Exact_predicates_inexact_constructions_kernel inexactK;
-    typedef CGAL::Robust_circumcenter_traits_3<inexactK>  K;
-#else
-    // Very robust but expensive kernel
-    #include "CGAL/Exact_predicates_exact_constructions_kernel.h"
-    typedef CGAL::Exact_predicates_exact_constructions_kernel K;
-#endif
+typedef CGAL::indexedVertex<K>     Vb;
+typedef CGAL::indexedCell<K>       Cb;
 
-typedef CGAL::indexedVertex<K>          Vb;
-typedef CGAL::indexedCell<K>            Cb;
-
-typedef CGAL::Triangulation_data_structure_3<Vb, Cb>     Tds;
-typedef CGAL::Delaunay_triangulation_3<K, Tds, CGAL::Fast_location> Delaunay;
-
-typedef Delaunay::Vertex_handle    Vertex_handle;
-typedef Delaunay::Cell_handle      Cell_handle;
-typedef Delaunay::Point            Point;
-
-
-//- Spatial sort traits to use with a pair of point pointers and an integer.
-//  Taken from a post on the CGAL lists: 2010-01/msg00004.html by
-//  Sebastien Loriot (Geometry Factory).
-template<class Triangulation>
-struct Traits_for_spatial_sort
-:
-    public Triangulation::Geom_traits
-{
-    typedef typename Triangulation::Geom_traits Gt;
-
-    typedef std::pair<const typename Triangulation::Point*, int> Point_3;
-
-    struct Less_x_3
-    {
-        bool operator()(const Point_3& p, const Point_3& q) const
-        {
-            return typename Gt::Less_x_3()(*(p.first), *(q.first));
-        }
-    };
-
-    struct Less_y_3
-    {
-        bool operator()(const Point_3& p, const Point_3& q) const
-        {
-            return typename Gt::Less_y_3()(*(p.first), *(q.first));
-        }
-    };
-
-    struct Less_z_3
-    {
-        bool operator()(const Point_3& p, const Point_3& q) const
-        {
-            return typename Gt::Less_z_3()(*(p.first), *(q.first));
-        }
-    };
-
-    Less_x_3  less_x_3_object () const {return Less_x_3();}
-    Less_y_3  less_y_3_object () const {return Less_y_3();}
-    Less_z_3  less_z_3_object () const {return Less_z_3();}
-};
+typedef CGAL::Compact_location     CompactLocator;
+typedef CGAL::Fast_location        FastLocator;
 
+typedef CGAL::Triangulation_data_structure_3<Vb, Cb>           Tds;
+typedef CGAL::Delaunay_triangulation_3<K, Tds, CompactLocator> Delaunay;
+typedef CGAL::Delaunay_triangulation_3<K, Tds, FastLocator>    CellSizeDelaunay;
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
diff --git a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/conformalVoronoiMesh.C b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/conformalVoronoiMesh.C
index de23690ea4..5c43329acf 100644
--- a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/conformalVoronoiMesh.C
+++ b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/conformalVoronoiMesh.C
@@ -27,8 +27,11 @@ License
 #include "initialPointsMethod.H"
 #include "relaxationModel.H"
 #include "faceAreaWeightModel.H"
-#include "backgroundMeshDecomposition.H"
 #include "meshSearch.H"
+#include "vectorTools.H"
+#include "IOmanip.H"
+#include "indexedCellChecks.H"
+
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
@@ -44,6 +47,52 @@ const Foam::scalar Foam::conformalVoronoiMesh::tolParallel = 1e-3;
 
 // * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * * //
 
+void Foam::conformalVoronoiMesh::cellSizeMeshOverlapsBackground() const
+{
+    const cellShapeControlMesh& cellSizeMesh =
+        cellShapeControl_.shapeControlMesh();
+
+    DynamicList<Foam::point> pts(number_of_vertices());
+
+    for
+    (
+        Delaunay::Finite_vertices_iterator vit = finite_vertices_begin();
+        vit != finite_vertices_end();
+        ++vit
+    )
+    {
+        if (vit->internalOrBoundaryPoint())
+        {
+            pts.append(topoint(vit->point()));
+        }
+    }
+
+    boundBox bb(pts);
+
+    boundBox cellSizeMeshBb = cellSizeMesh.bounds();
+
+    bool fullyContained = true;
+
+    if (!cellSizeMeshBb.contains(bb))
+    {
+        Pout<< "Triangulation not fully contained in cell size mesh."
+            << endl;
+
+        Pout<< "Cell Size Mesh Bounds = " << cellSizeMesh.bounds() << endl;
+        Pout<< "cvMesh Bounds         = " << bb << endl;
+
+        fullyContained = false;
+    }
+
+    reduce(fullyContained, andOp<unsigned int>());
+
+    Info<< "Triangulation is "
+        << (fullyContained ? "fully" : "not fully")
+        << " contained in the cell size mesh"
+        << endl;
+}
+
+
 Foam::scalar Foam::conformalVoronoiMesh::requiredSize
 (
     const Foam::point& pt
@@ -72,7 +121,7 @@ Foam::scalar Foam::conformalVoronoiMesh::requiredSize
             << exit(FatalError) << endl;
     }
 
-    cellSizeHits.append(cellSizeControl().cellSize(pt));
+    cellSizeHits.append(cellShapeControls().cellSize(pt));
 
     // Primary alignment
 
@@ -135,7 +184,7 @@ Foam::scalar Foam::conformalVoronoiMesh::requiredSize
 
             cellSizeHits.append
             (
-                cellSizeControl().cellSize(hitPt)
+                cellShapeControls().cellSize(hitPt)
             );
 
             totalDist += spokeHitDistance;
@@ -161,7 +210,7 @@ Foam::scalar Foam::conformalVoronoiMesh::requiredSize
 
             cellSizeHits.append
             (
-                cellSizeControl().cellSize(hitPt)
+                cellShapeControls().cellSize(hitPt)
             );
 
             totalDist += spokeHitDistance;
@@ -176,7 +225,7 @@ Foam::scalar Foam::conformalVoronoiMesh::requiredSize
     }
 
     return cellSize/cellSizeHits.size();
-    //return cellSizeControl().cellSize(pt);
+    //return cellShapeControls().cellSize(pt);
 }
 
 
@@ -355,14 +404,12 @@ Foam::tensor Foam::conformalVoronoiMesh::requiredAlignment
 }
 
 
-void Foam::conformalVoronoiMesh::insertPoints
+void Foam::conformalVoronoiMesh::insertInternalPoints
 (
     List<Point>& points,
     bool distribute
 )
 {
-    label preInsertionSize(number_of_vertices());
-
     label nPoints = points.size();
 
     if (Pstream::parRun())
@@ -374,38 +421,13 @@ void Foam::conformalVoronoiMesh::insertPoints
 
     if (Pstream::parRun() && distribute)
     {
-        label preDistributionSize(points.size());
+        List<Foam::point> transferPoints(points.size());
 
-        DynamicList<Foam::point> transferPoints;
-
-        DynamicList<Point> pointsOnProcessor;
-
-        for
-        (
-            List<Point>::iterator pit = points.begin();
-            pit != points.end();
-            ++pit
-        )
+        forAll(points, pI)
         {
-            Foam::point p(topoint(*pit));
-
-            if (!positionOnThisProc(p))
-            {
-                transferPoints.append(p);
-            }
-            else
-            {
-                pointsOnProcessor.append(*pit);
-            }
+            transferPoints[pI] = topoint(points[pI]);
         }
 
-        points.setSize(pointsOnProcessor.size());
-        forAll(pointsOnProcessor, pI)
-        {
-            points[pI] = pointsOnProcessor[pI];
-        }
-        pointsOnProcessor.clear();
-
         // Send the points that are not on this processor to the appropriate
         // place
         Foam::autoPtr<Foam::mapDistribute> map
@@ -413,41 +435,7 @@ void Foam::conformalVoronoiMesh::insertPoints
             decomposition_().distributePoints(transferPoints)
         );
 
-        const label oldSize = points.size();
-
-        points.setSize(oldSize + transferPoints.size());
-
-        forAll(transferPoints, tPI)
-        {
-            points[tPI + oldSize] = toPoint(transferPoints[tPI]);
-        }
-
-        label sizeChange = preDistributionSize - points.size();
-
-        // if (mag(sizeChange) > 0)
-        // {
-        //     Pout<< "    distribution points size change " << sizeChange
-        //         << endl;
-        // }
-
-        label totalMagSizeChange = returnReduce
-        (
-            mag(sizeChange), sumOp<label>()
-        );
-
-        if (totalMagSizeChange > 0)
-        {
-            Info<< "    distribution points size change total "
-                << totalMagSizeChange/2
-                << endl;
-        }
-
-        nPoints = points.size();
-
-        reduce(nPoints, sumOp<label>());
-
-        Info<< "    " << nPoints
-            << " points to insert after distribution..." << endl;
+        map().distribute(points);
     }
 
     label nVert = number_of_vertices();
@@ -455,25 +443,18 @@ void Foam::conformalVoronoiMesh::insertPoints
     // using the range insert (faster than inserting points one by one)
     insert(points.begin(), points.end());
 
-//     Info<< "USING INDIVIDUAL INSERTION TO DETECT FAILURE" << endl;
-//     for
-//     (
-//         List<Point>::iterator pit=points.begin();
-//         pit != points.end();
-//         ++pit
-//     )
-//     {
-//         insertPoint(topoint(*pit), Vb::vtInternal);
-//     }
-
-    label nInserted(number_of_vertices() - preInsertionSize);
+    label nInserted(number_of_vertices() - nVert);
 
     if (Pstream::parRun())
     {
         reduce(nInserted, sumOp<label>());
     }
 
-    Info<< "    " << nInserted << " points inserted" << endl;
+    Info<< "    " << nInserted << " points inserted"
+        << ", failed to insert " << nPoints - nInserted
+        << " ("
+        << 100.0*(nPoints - nInserted)/nInserted
+        << " %)"<< endl;
 
     for
     (
@@ -484,7 +465,8 @@ void Foam::conformalVoronoiMesh::insertPoints
     {
         if (vit->uninitialised())
         {
-            vit->index() = nVert++;
+            vit->index() = getNewVertexIndex();
+            vit->type() = Vb::vtInternal;
         }
     }
 }
@@ -492,30 +474,22 @@ void Foam::conformalVoronoiMesh::insertPoints
 
 void Foam::conformalVoronoiMesh::insertPoints
 (
-    DynamicList<Foam::point>& pts,
-    DynamicList<label>& indices,
-    DynamicList<label>& types,
+    List<Vb>& vertices,
     bool distribute
 )
 {
-    // The pts, indices and types lists must be intact and up-to-date at the
-    // end of this function as they may also be used by other functions
-    // subsequently.
-
     if (Pstream::parRun() && distribute)
     {
-        // The link between vertices that form the boundary via pairs cannot be
-        // strict because both points may end up on different processors.  The
-        // only important thing is that each vertex knows its own role.
-        // Therefore, index and type are set to 0 or 1, then on the destination
-        // processor add back the new index to both.
+        const label preDistributionSize = vertices.size();
 
-        // Each of points generated in this process are pair points, so there
-        // is no risk of underflowing "type".
+        List<Foam::point> pts(preDistributionSize);
 
-        // Pout<< "Points before "
-        //     << pts.size() << " " << indices.size() << " " << types.size()
-        //     << endl;
+        forAll(vertices, vI)
+        {
+            const Foam::point& pt = topoint(vertices[vI].point());
+
+            pts[vI] = pt;
+        }
 
         // Distribute points to their appropriate processor
         autoPtr<mapDistribute> map
@@ -523,97 +497,71 @@ void Foam::conformalVoronoiMesh::insertPoints
             decomposition_().distributePoints(pts)
         );
 
-        map().distribute(indices);
-        map().distribute(types);
+        map().distribute(vertices);
 
-        // Pout<< "Points after "
-        //     << pts.size() << " " << indices.size() << " " << types.size()
-        //     << endl;
-
-        // Info<< returnReduce(pts.size(), sumOp<label>())
-        //     << " points in total" << endl;
+        forAll(vertices, vI)
+        {
+            vertices[vI].procIndex() = Pstream::myProcNo();
+        }
     }
-//
-//    forAll(pts, pI)
-//    {
-//        // creation of points and indices is done assuming that it will be
-//        // relative to the instantaneous number_of_vertices() at insertion.
-//
-//        label type = types[pI];
-//
-//        if (type > Vb::vtFar)
-//        {
-//            // This is a member of a point pair, don't use the type directly
-//            // (note that this routine never gets called for referredPoints
-//            //  so type will never be -procI)
-//            type += number_of_vertices();
-//        }
-//
-//        insertPoint
-//        (
-//            pts[pI],
-//            indices[pI] + number_of_vertices(),
-//            type
-//        );
-//    }
 
     rangeInsertWithInfo
     (
-        pts.begin(),
-        pts.end(),
-        *this,
-        indices,
-        types
+        vertices.begin(),
+        vertices.end(),
+        true
     );
 }
 
 
 void Foam::conformalVoronoiMesh::insertSurfacePointPairs
 (
-    const List<pointIndexHit>& surfaceHits,
-    const List<label>& hitSurfaces,
+    const pointIndexHitAndFeatureList& surfaceHits,
     const fileName fName
 )
 {
-    if (surfaceHits.size() != hitSurfaces.size())
-    {
-        FatalErrorIn("Foam::conformalVoronoiMesh::insertPointPairs")
-            << "surfaceHits and hitSurfaces are not the same size. Sizes "
-            << surfaceHits.size() << ' '
-            << hitSurfaces.size()
-            << exit(FatalError);
-    }
-
-    DynamicList<Foam::point> pts;
-    DynamicList<label> indices;
-    DynamicList<label> types;
+    DynamicList<Vb> pts(2.0*surfaceHits.size());
 
     forAll(surfaceHits, i)
     {
         vectorField norm(1);
 
-        allGeometry_[hitSurfaces[i]].getNormal
+        const pointIndexHit surfaceHit = surfaceHits[i].first();
+        const label featureIndex = surfaceHits[i].second();
+
+        allGeometry_[featureIndex].getNormal
         (
-            List<pointIndexHit>(1, surfaceHits[i]),
+            List<pointIndexHit>(1, surfaceHit),
             norm
         );
 
         const vector& normal = norm[0];
 
-        const Foam::point& surfacePt(surfaceHits[i].hitPoint());
+        const Foam::point& surfacePt(surfaceHit.hitPoint());
 
-        createPointPair
-        (
-            pointPairDistance(surfacePt),
-            surfacePt,
-            normal,
-            pts,
-            indices,
-            types
-        );
+        if (geometryToConformTo_.isBaffle(featureIndex))
+        {
+            createBafflePointPair
+            (
+                pointPairDistance(surfacePt),
+                surfacePt,
+                normal,
+                pts
+            );
+        }
+        else
+        {
+            createPointPair
+            (
+                pointPairDistance(surfacePt),
+                surfacePt,
+                normal,
+                pts
+            );
+        }
     }
 
-    insertPoints(pts, indices, types, true);
+    insertPoints(pts, true);
 
     if (cvMeshControls().objOutput() && fName != fileName::null)
     {
@@ -624,35 +572,25 @@ void Foam::conformalVoronoiMesh::insertSurfacePointPairs
 
 void Foam::conformalVoronoiMesh::insertEdgePointGroups
 (
-    const List<pointIndexHit>& edgeHits,
-    const labelList& featuresHit,
+    const pointIndexHitAndFeatureList& edgeHits,
     const fileName fName
 )
 {
-    if (edgeHits.size() != featuresHit.size())
-    {
-        FatalErrorIn("Foam::conformalVoronoiMesh::insertEdgePointGroups")
-            << "edgeHits and featuresHit are not the same size. Sizes "
-            << edgeHits.size() << ' '
-            << featuresHit.size()
-            << exit(FatalError);
-    }
-
-    DynamicList<Foam::point> pts;
-    DynamicList<label> indices;
-    DynamicList<label> types;
+    DynamicList<Vb> pts(3.0*edgeHits.size());
 
     forAll(edgeHits, i)
     {
         const extendedFeatureEdgeMesh& feMesh
         (
-            geometryToConformTo_.features()[featuresHit[i]]
+            geometryToConformTo_.features()[edgeHits[i].second()]
         );
 
-        createEdgePointGroup(feMesh, edgeHits[i], pts, indices, types);
+        createEdgePointGroup(feMesh, edgeHits[i].first(), pts);
     }
 
-    insertPoints(pts, indices, types, true);
+    pts.shrink();
+
+    insertPoints(pts, true);
 
     if (cvMeshControls().objOutput() && fName != fileName::null)
     {
@@ -680,20 +618,6 @@ bool Foam::conformalVoronoiMesh::nearFeaturePt(const Foam::point& pt) const
 }
 
 
-void Foam::conformalVoronoiMesh::reset(const bool distribute)
-{
-    this->clear();
-
-    reinsertBoundingPoints();
-
-    // Reinsert feature points, distributing them as necessary.
-    reinsertFeaturePoints(distribute);
-    //insertFeaturePoints();
-
-    startOfInternalPoints_ = number_of_vertices();
-}
-
-
 void Foam::conformalVoronoiMesh::insertInitialPoints()
 {
     Info<< nl << "Inserting initial points" << endl;
@@ -706,13 +630,43 @@ void Foam::conformalVoronoiMesh::insertInitialPoints()
 
     // Assume that the initial points method made the correct decision for
     // which processor each point should be on, so give distribute = false
-    insertPoints(initPts, false);
+    insertInternalPoints(initPts);
+}
 
-    if (cvMeshControls().objOutput())
+
+Foam::scalar Foam::conformalVoronoiMesh::calculateLoadUnbalance() const
+{
+    label nRealVertices = 0;
+
+    for
+    (
+        Delaunay::Finite_vertices_iterator vit = finite_vertices_begin();
+        vit != finite_vertices_end();
+        ++vit
+    )
     {
-        writePoints("initialPoints.obj", true);
+        // Only store real vertices that are not feature vertices
+        if (vit->real() && !vit->featurePoint())
+        {
+            nRealVertices++;
+        }
     }
 
+    scalar globalNRealVertices = returnReduce
+    (
+        nRealVertices,
+        sumOp<label>()
+    );
+
+    scalar unbalance = returnReduce
+    (
+        mag(1.0 - nRealVertices/(globalNRealVertices/Pstream::nProcs())),
+        maxOp<scalar>()
+    );
+
+    Info<< "    Processor unbalance " << unbalance << endl;
+
+    return unbalance;
 }
 
 
@@ -729,52 +683,29 @@ bool Foam::conformalVoronoiMesh::distributeBackground()
 
     label iteration = 0;
 
+    scalar previousLoadUnbalance = 0;
+
     while (true)
     {
-        label nRealVertices = 0;
+        scalar maxLoadUnbalance = calculateLoadUnbalance();
 
-        for
+        if
         (
-            Delaunay::Finite_vertices_iterator vit = finite_vertices_begin();
-            vit != finite_vertices_end();
-            vit++
+            maxLoadUnbalance <= cvMeshControls().maxLoadUnbalance()
+         || maxLoadUnbalance <= previousLoadUnbalance
         )
-        {
-            // Only store real vertices that are not feature vertices
-            if (vit->real() && vit->index() >= startOfInternalPoints_)
-            {
-                nRealVertices++;
-            }
-        }
-
-        scalar globalNRealVertices = returnReduce
-        (
-            nRealVertices,
-            sumOp<label>()
-        );
-
-        scalar unbalance = returnReduce
-        (
-            mag(1.0 - nRealVertices/(globalNRealVertices/Pstream::nProcs())),
-            maxOp<scalar>()
-        );
-
-        Info<< "    Processor unbalance " << unbalance << endl;
-
-        if (unbalance <= cvMeshControls().maxLoadUnbalance())
         {
             // If this is the first iteration, return false, if it was a
             // subsequent one, return true;
             return iteration != 0;
         }
 
+        previousLoadUnbalance = maxLoadUnbalance;
+
         Info<< "    Total number of vertices before redistribution "
             << returnReduce(label(number_of_vertices()), sumOp<label>())
             << endl;
 
-        // Pout<< "    Real vertices before distribution "
-        //     << nRealVertices << endl;
-
         const fvMesh& bMesh = decomposition_().mesh();
 
         volScalarField cellWeights
@@ -794,42 +725,36 @@ bool Foam::conformalVoronoiMesh::distributeBackground()
 
         meshSearch cellSearch(bMesh, polyMesh::FACEPLANES);
 
-        List<DynamicList<Foam::point> > cellVertices(bMesh.nCells());
-        List<DynamicList<label> > cellVertexIndices(bMesh.nCells());
-        List<DynamicList<label> > cellVertexTypes(bMesh.nCells());
+        labelList cellVertices(bMesh.nCells(), 0);
 
         for
         (
             Delaunay::Finite_vertices_iterator vit = finite_vertices_begin();
             vit != finite_vertices_end();
-            vit++
+            ++vit
         )
         {
             // Only store real vertices that are not feature vertices
-            if (vit->real() && vit->index() >= startOfInternalPoints_)
+            if (vit->real() && !vit->featurePoint())
             {
-                Foam::point v = topoint(vit->point());
+                pointFromPoint v = topoint(vit->point());
 
                 label cellI = cellSearch.findCell(v);
 
                 if (cellI == -1)
                 {
-                    // Pout<< "findCell conformalVoronoiMesh::distribute "
-                    //     << "findCell "
-                    //     << vit->type() << " "
-                    //     << vit->index() << " "
-                    //     << v << " "
-                    //     << cellI
-                    //     << " find nearest cellI ";
+//                     Pout<< "findCell conformalVoronoiMesh::distribute "
+//                         << "findCell "
+//                         << vit->type() << " "
+//                         << vit->index() << " "
+//                         << v << " "
+//                         << cellI
+//                         << " find nearest cellI ";
 
                     cellI = cellSearch.findNearestCell(v);
-
-                    Pout<< cellI << endl;
                 }
 
-                cellVertices[cellI].append(topoint(vit->point()));
-                cellVertexIndices[cellI].append(vit->index());
-                cellVertexTypes[cellI].append(vit->type());
+                cellVertices[cellI]++;
             }
         }
 
@@ -840,69 +765,19 @@ bool Foam::conformalVoronoiMesh::distributeBackground()
             // the sum of the normalised weight field.
             cellWeights.internalField()[cI] = max
             (
-                cellVertices[cI].size(),
+                cellVertices[cI],
                 1e-2
             );
         }
 
         autoPtr<mapDistributePolyMesh> mapDist = decomposition_().distribute
         (
-            cellWeights,
-            cellVertices,
-            cellVertexIndices,
-            cellVertexTypes
+            cellWeights
         );
 
-        // Reset the entire tessellation
-        reset(true);
+        cellShapeControl_.shapeControlMesh().distribute(decomposition_);
 
-        timeCheck("Distribution performed");
-
-        Info<< nl << "    Inserting distributed tessellation" << endl;
-
-        DynamicList<Foam::point> pointsToInsert;
-        DynamicList<label> indices;
-        DynamicList<label> types;
-
-        forAll(cellVertices, cI)
-        {
-            forAll(cellVertices[cI], cVPI)
-            {
-                pointsToInsert.append(cellVertices[cI][cVPI]);
-
-                // All insertions relative to index of zero
-                indices.append(0);
-
-                label type = cellVertexTypes[cI][cVPI];
-
-                if (type > Vb::vtFar)
-                {
-                    // This is a member of a point pair, don't use the type
-                    // directly, make type relative to the index in preparation
-                    // for insertion.
-
-                    type -= cellVertexIndices[cI][cVPI];
-                }
-
-                types.append(type);
-            }
-        }
-
-        // Assume that the distribution made the correct decision for which
-        // processor each point should be on, so give distribute = false
-        insertPoints(pointsToInsert, indices, types, false);
-
-        Info<< "    Total number of vertices after redistribution "
-            << returnReduce(label(number_of_vertices()), sumOp<label>())
-            << endl;
-
-        // Pout<< "    Real vertices after distribution "
-        //     << label(number_of_vertices() - 8) << endl;
-
-        if (cvMeshControls().objOutput())
-        {
-            writePoints("distributedPoints.obj", true);
-        }
+        distribute();
 
         timeCheck("After distribute");
 
@@ -913,6 +788,128 @@ bool Foam::conformalVoronoiMesh::distributeBackground()
 }
 
 
+void Foam::conformalVoronoiMesh::distribute()
+{
+    if (!Pstream::parRun())
+    {
+        return ;
+    }
+
+    autoPtr<mapDistribute> mapDist =
+        DistributedDelaunayMesh<Delaunay>::distribute(decomposition_());
+
+    DynamicList<Foam::point> points(number_of_vertices());
+    DynamicList<Foam::indexedVertexEnum::vertexType> types
+    (
+        number_of_vertices()
+    );
+    DynamicList<scalar> sizes(number_of_vertices());
+    DynamicList<tensor> alignments(number_of_vertices());
+
+    for
+    (
+        Finite_vertices_iterator vit = finite_vertices_begin();
+        vit != finite_vertices_end();
+        ++vit
+    )
+    {
+        if (vit->real())
+        {
+            points.append(topoint(vit->point()));
+            types.append(vit->type());
+            sizes.append(vit->targetCellSize());
+            alignments.append(vit->alignment());
+        }
+    }
+
+    mapDist().distribute(points);
+    mapDist().distribute(types);
+    mapDist().distribute(sizes);
+    mapDist().distribute(alignments);
+
+    // Reset the entire tessellation
+    DelaunayMesh<Delaunay>::reset();
+
+    Info<< nl << "    Inserting distributed tessellation" << endl;
+
+    // Internal points have to be inserted first
+
+    DynamicList<Vb> verticesToInsert(points.size());
+
+    forAll(points, pI)
+    {
+        verticesToInsert.append
+        (
+            Vb
+            (
+                toPoint<Point>(points[pI]),
+                -1,
+                types[pI],
+                Pstream::myProcNo()
+            )
+        );
+
+        verticesToInsert.last().targetCellSize() = sizes[pI];
+        verticesToInsert.last().alignment() = alignments[pI];
+    }
+
+    this->rangeInsertWithInfo
+    (
+        verticesToInsert.begin(),
+        verticesToInsert.end(),
+        true
+    );
+
+    Info<< "    Total number of vertices after redistribution "
+        << returnReduce
+           (
+               label(number_of_vertices()), sumOp<label>()
+           )
+        << endl;
+}
+
+
+void Foam::conformalVoronoiMesh::buildCellSizeAndAlignmentMesh()
+{
+    cellShapeControl_.initialMeshPopulation(decomposition_);
+
+    cellShapeControlMesh& cellSizeMesh = cellShapeControl_.shapeControlMesh();
+
+    if (Pstream::parRun())
+    {
+        cellSizeMesh.distribute(decomposition_);
+    }
+
+    label nMaxIter = 2;
+
+    for (label i = 0; i < nMaxIter; ++i)
+    {
+        label nAdded = cellShapeControl_.refineMesh(decomposition_);
+        reduce(nAdded, sumOp<label>());
+
+        if (Pstream::parRun())
+        {
+            cellSizeMesh.distribute(decomposition_);
+        }
+
+        if (nAdded == 0)
+        {
+            break;
+        }
+
+        Info<< "    Iteration " << i << ": Added = " << nAdded << " points"
+            << endl;
+    }
+
+    cellShapeControl_.smoothMesh();
+
+    Info<< "Background cell size and alignment mesh:" << endl;
+    cellSizeMesh.printInfo(Info);
+
+//    cellSizeMesh.write();
+}
+
+
 void Foam::conformalVoronoiMesh::storeSizesAndAlignments()
 {
     DynamicList<Point> storePts(number_of_vertices());
@@ -941,41 +938,48 @@ void Foam::conformalVoronoiMesh::storeSizesAndAlignments
     const List<Point>& storePts
 )
 {
-    timeCheck("Start of storeSizesAndAlignments");
-
-    Info << nl << "Store size and alignment" << endl;
-
-    sizeAndAlignmentLocations_.setSize(storePts.size());
-
-    storedSizes_.setSize(sizeAndAlignmentLocations_.size());
-
-    storedAlignments_.setSize(sizeAndAlignmentLocations_.size());
-
-    label i = 0;
-
-    checkCellSizing();
-
-    for
-    (
-        List<Point>::const_iterator pit = storePts.begin();
-        pit != storePts.end();
-        ++pit
-    )
-    {
-        sizeAndAlignmentLocations_[i] = topoint(*pit);
-
-        storedSizes_[i] = requiredSize(sizeAndAlignmentLocations_[i]);
-
-        storedAlignments_[i] = requiredAlignment(sizeAndAlignmentLocations_[i]);
-
-        i++;
-    }
-
-    timeCheck("Sizes and alignments calculated, build tree");
-
-    buildSizeAndAlignmentTree();
-
-    timeCheck("Size and alignment tree built");
+//    timeCheck("Start of storeSizesAndAlignments");
+//
+//    Info << nl << "Store size and alignment" << endl;
+//
+//    sizeAndAlignmentLocations_.setSize(storePts.size());
+//
+//    storedSizes_.setSize(sizeAndAlignmentLocations_.size());
+//
+//    storedAlignments_.setSize(sizeAndAlignmentLocations_.size());
+//
+//    label i = 0;
+//
+//    //checkCellSizing();
+//
+//    for
+//    (
+//        List<Point>::const_iterator pit = storePts.begin();
+//        pit != storePts.end();
+//        ++pit
+//    )
+//    {
+//        pointFromPoint pt = topoint(*pit);
+//
+////        storedAlignments_[i] = requiredAlignment(pt);
+////
+////        storedSizes_[i] = cellShapeControls().cellSize(pt);
+//
+//        cellShapeControls().cellSizeAndAlignment
+//        (
+//            pt,
+//            storedSizes_[i],
+//            storedAlignments_[i]
+//        );
+//
+//        i++;
+//    }
+//
+//    timeCheck("Sizes and alignments calculated, build tree");
+//
+//    buildSizeAndAlignmentTree();
+//
+//    timeCheck("Size and alignment tree built");
 }
 
 
@@ -1016,9 +1020,51 @@ Foam::conformalVoronoiMesh::sizeAndAlignmentTree() const
 
 void Foam::conformalVoronoiMesh::setVertexSizeAndAlignment()
 {
-    Info<< nl << "Looking up target cell alignment and size" << endl;
+//    Info<< nl << "Looking up target cell alignment and size" << endl;
+//
+//    const indexedOctree<treeDataPoint>& tree = sizeAndAlignmentTree();
+//
+//    for
+//    (
+//        Delaunay::Finite_vertices_iterator vit = finite_vertices_begin();
+//        vit != finite_vertices_end();
+//        vit++
+//    )
+//    {
+//        if
+//        (
+//            vit->internalOrBoundaryPoint()
+//         || vit->referredInternalOrBoundaryPoint()
+//        )
+//        {
+//            pointFromPoint pt = topoint(vit->point());
+//
+//            pointIndexHit info = tree.findNearest(pt, sqr(GREAT));
+//
+//            if (info.hit())
+//            {
+//                vit->alignment() = storedAlignments_[info.index()];
+//
+//                vit->targetCellSize() = storedSizes_[info.index()];
+//            }
+//            else
+//            {
+//                WarningIn
+//                (
+//                    "void "
+//                    "Foam::conformalVoronoiMesh::setVertexSizeAndAlignment()"
+//                )
+//                    << "Point " << pt << " did not find a nearest point "
+//                    << " for alignment and size lookup." << endl;
+//
+//                vit->alignment() = cellShapeControls().cellAlignment(pt);
+//
+//                vit->targetCellSize() = cellShapeControls().cellSize(pt);
+//            }
+//        }
+//    }
 
-    const indexedOctree<treeDataPoint>& tree = sizeAndAlignmentTree();
+    Info<< nl << "Calculating target cell alignment and size" << endl;
 
     for
     (
@@ -1027,57 +1073,23 @@ void Foam::conformalVoronoiMesh::setVertexSizeAndAlignment()
         vit++
     )
     {
-        if
-        (
-            vit->internalOrBoundaryPoint()
-         || vit->referredInternalOrBoundaryPoint()
-        )
+        if (vit->internalOrBoundaryPoint())
         {
-            Foam::point pt(topoint(vit->point()));
+            pointFromPoint pt = topoint(vit->point());
 
-            pointIndexHit info = tree.findNearest(pt, sqr(GREAT));
+            cellShapeControls().cellSizeAndAlignment
+            (
+                pt,
+                vit->targetCellSize(),
+                vit->alignment()
+            );
 
-            if (info.hit())
-            {
-                vit->alignment() = storedAlignments_[info.index()];
+            //vit->alignment() = tensor(1,0,0,0,1,0,0,0,1);
+            //vit->alignment() = requiredAlignment(pt);
 
-                vit->targetCellSize() = storedSizes_[info.index()];
-            }
-            else
-            {
-                WarningIn
-                (
-                    "void "
-                    "Foam::conformalVoronoiMesh::setVertexSizeAndAlignment()"
-                )
-                    << "Point " << pt << " did not find a nearest point "
-                    << " for alignment and size lookup." << endl;
-
-                vit->alignment() = requiredAlignment(pt);
-
-                vit->targetCellSize() = cellSizeControl().cellSize(pt);
-            }
+            //vit->targetCellSize() = cellShapeControls().cellSize(pt);
         }
     }
-
-    // Info<< nl << "Calculating target cell alignment and size" << endl;
-
-    // for
-    // (
-    //     Delaunay::Finite_vertices_iterator vit = finite_vertices_begin();
-    //     vit != finite_vertices_end();
-    //     vit++
-    // )
-    // {
-    //     if (vit->internalOrBoundaryPoint())
-    //     {
-    //         point pt(topoint(vit->point()));
-
-    //         vit->alignment() = requiredAlignment(pt);
-
-    //         vit->targetCellSize() = targetCellSize(pt);
-    //     }
-    // }
 }
 
 
@@ -1100,7 +1112,11 @@ Foam::face Foam::conformalVoronoiMesh::buildDualFace
 
     do
     {
-        if (cc1->farCell() || cc2->farCell())
+        if
+        (
+            cc1->hasFarPoint() || cc2->hasFarPoint()
+         || is_infinite(cc1) || is_infinite(cc2)
+        )
         {
             Cell_handle c = eit->first;
             Vertex_handle vA = c->vertex(eit->second);
@@ -1138,6 +1154,8 @@ Foam::face Foam::conformalVoronoiMesh::buildDualFace
 
     } while (cc1 != ccStart);
 
+    verticesOnFace.shrink();
+
     if (verticesOnFace.size() >= 3 && nUniqueVertices < 3)
     {
         // There are not enough unique vertices on this face to
@@ -1172,7 +1190,7 @@ Foam::label Foam::conformalVoronoiMesh::maxFilterCount
 
     do
     {
-        if (cc->farCell())
+        if (cc->hasFarPoint())
         {
             Cell_handle c = eit->first;
             Vertex_handle vA = c->vertex(eit->second);
@@ -1215,14 +1233,14 @@ bool Foam::conformalVoronoiMesh::ownerAndNeighbour
 
     label dualCellIndexA = vA->index();
 
-    if (!vA->internalOrBoundaryPoint())
+    if (!vA->internalOrBoundaryPoint() || vA->referred())
     {
         dualCellIndexA = -1;
     }
 
     label dualCellIndexB = vB->index();
 
-    if (!vB->internalOrBoundaryPoint())
+    if (!vB->internalOrBoundaryPoint() || vB->referred())
     {
         dualCellIndexB = -1;
     }
@@ -1289,7 +1307,7 @@ Foam::conformalVoronoiMesh::conformalVoronoiMesh
     const dictionary& cvMeshDict
 )
 :
-    Delaunay(),
+    DistributedDelaunayMesh<Delaunay>(),
     runTime_(runTime),
     rndGen_(64293*Pstream::myProcNo()),
     cvMeshControls_(cvMeshDict),
@@ -1313,12 +1331,13 @@ Foam::conformalVoronoiMesh::conformalVoronoiMesh
         allGeometry_,
         cvMeshDict.subDict("surfaceConformation")
     ),
-    cellSizeControl_
+    cellShapeControl_
     (
+        runTime_,
+        cvMeshDict.subDict("motionControl"),
         allGeometry_,
-        cvMeshDict.subDict("motionControl")
+        geometryToConformTo_
     ),
-    startOfInternalPoints_(0),
     limitBounds_(),
     featureVertices_(),
     featurePointLocations_(),
@@ -1354,47 +1373,49 @@ Foam::conformalVoronoiMesh::conformalVoronoiMesh
     ),
     decomposition_()
 {
+    if (cvMeshControls().objOutput())
+    {
+        geometryToConformTo_.writeFeatureObj("cvMesh");
+    }
+
     if (Pstream::parRun())
     {
         decomposition_.reset
         (
             new backgroundMeshDecomposition
             (
-                cvMeshDict.subDict("backgroundMeshDecomposition"),
-                *this
+                runTime_,
+                rndGen_,
+                geometryToConformTo_,
+                cvMeshDict.subDict("backgroundMeshDecomposition")
             )
         );
     }
 
-    if (cvMeshControls().objOutput())
-    {
-        geometryToConformTo_.writeFeatureObj("cvMesh");
-    }
+    buildCellSizeAndAlignmentMesh();
 
-    insertBoundingPoints();
+    insertInitialPoints();
 
     insertFeaturePoints();
 
-    startOfInternalPoints_ = number_of_vertices();
+    setVertexSizeAndAlignment();
 
-    insertInitialPoints();
+    cellSizeMeshOverlapsBackground();
 
     // Improve the guess that the backgroundMeshDecomposition makes with the
     // initial positions.  Use before building the surface conformation to
     // better balance the surface conformation load.
     distributeBackground();
 
-//    conformToSurface();
-
-    buildSurfaceConformation(rmCoarse);
+    buildSurfaceConformation();
 
     // The introduction of the surface conformation may have distorted the
     // balance of vertices, distribute if necessary.
-    if (distributeBackground())
+    distributeBackground();
+
+    if (Pstream::parRun())
     {
-        // distributeBackground has destroyed all referred vertices, so the
-        // parallel interface needs to be rebuilt.
-        buildParallelInterface("rebuild");
+        sync(decomposition_().procBounds());
     }
 
     // Do not store the surface conformation until after it has been
@@ -1402,19 +1423,25 @@ Foam::conformalVoronoiMesh::conformalVoronoiMesh
     storeSurfaceConformation();
 
     // Use storeSizesAndAlignments with no feed points because all background
-    // points may have been distributed.  It is a requirement that none of the
-    // preceding functions requires look up of sizes or alignments from the
-    // Delaunay vertices, i.e. setVertexSizeAndAlignment cannot be called
-    // before this point.
+    // points may have been distributed.
     storeSizesAndAlignments();
 
     // Report any Delaunay vertices that do not think that they are in the
     // domain the processor they are on.
     // reportProcessorOccupancy();
 
+    cellSizeMeshOverlapsBackground();
+
+    printVertexInfo();
+
     if (cvMeshControls().objOutput())
     {
-        writePoints("allInitialPoints.obj", false);
+        writePoints
+        (
+            "internalPoints_" + runTime_.timeName() + ".obj",
+            Foam::indexedVertexEnum::vtUnassigned,
+            Foam::indexedVertexEnum::vtExternalFeaturePoint
+        );
     }
 }
 
@@ -1435,9 +1462,9 @@ void Foam::conformalVoronoiMesh::move()
 
     Info<< nl << "Relaxation = " << relaxation << endl;
 
-    pointField dualVertices(number_of_cells());
+    pointField dualVertices(number_of_finite_cells());
 
-    label dualVertI = 0;
+    this->resetCellCount();
 
     // Find the dual point of each tetrahedron and assign it an index.
     for
@@ -1447,19 +1474,22 @@ void Foam::conformalVoronoiMesh::move()
         ++cit
     )
     {
-        cit->cellIndex() = Cb::ctFar;
+        cit->cellIndex() = Cb::ctUnassigned;
 
         if (cit->anyInternalOrBoundaryDualVertex())
         {
-            cit->cellIndex() = dualVertI;
+            cit->cellIndex() = getNewCellIndex();
 
-            dualVertices[dualVertI] = cit->dual();
+            dualVertices[cit->cellIndex()] = cit->dual();
+        }
 
-            dualVertI++;
+        if (cit->hasFarPoint())
+        {
+            cit->cellIndex() = Cb::ctFar;
         }
     }
 
-    dualVertices.setSize(dualVertI);
+    dualVertices.setSize(cellCount());
 
     setVertexSizeAndAlignment();
 
@@ -1469,9 +1499,9 @@ void Foam::conformalVoronoiMesh::move()
 
     vectorField cartesianDirections(3);
 
-    cartesianDirections[0] = vector(0,0,1);
-    cartesianDirections[1] = vector(0,1,0);
-    cartesianDirections[2] = vector(1,0,0);
+    cartesianDirections[0] = vector(1, 0, 0);
+    cartesianDirections[1] = vector(0, 1, 0);
+    cartesianDirections[2] = vector(0, 0, 1);
 
     vectorField displacementAccumulator
     (
@@ -1498,25 +1528,29 @@ void Foam::conformalVoronoiMesh::move()
         Vertex_handle vA = c->vertex(eit->second);
         Vertex_handle vB = c->vertex(eit->third);
 
-        if (!vA->internalOrBoundaryPoint() && !vB->internalOrBoundaryPoint())
-        {
-            // At least one vertex has to be a real internalOrBoundaryPoint
-            continue;
-        }
-
         if
         (
-            vA->anyInternalOrBoundaryPoint()
-         && vB->anyInternalOrBoundaryPoint()
+            (
+                vA->internalPoint() && !vA->referred()
+             && vB->internalOrBoundaryPoint()
+            )
+         || (
+                vB->internalPoint() && !vB->referred()
+             && vA->internalOrBoundaryPoint()
+            )
         )
         {
-            face dualFace = buildDualFace(eit);
+            pointFromPoint dVA = topoint(vA->point());
+            pointFromPoint dVB = topoint(vB->point());
 
-            Foam::point dVA = topoint(vA->point());
-            Foam::point dVB = topoint(vB->point());
-
-            Field<vector> alignmentDirsA(vA->alignment() & cartesianDirections);
-            Field<vector> alignmentDirsB(vB->alignment() & cartesianDirections);
+            Field<vector> alignmentDirsA
+            (
+                vA->alignment().T() & cartesianDirections
+            );
+            Field<vector> alignmentDirsB
+            (
+                vB->alignment().T() & cartesianDirections
+            );
 
             Field<vector> alignmentDirs(3);
 
@@ -1551,7 +1585,11 @@ void Foam::conformalVoronoiMesh::move()
             {
                 // Removal of close points
 
-                if (vA->internalPoint() && vB->internalPoint())
+                if
+                (
+                    vA->internalPoint() && !vA->referred()
+                 && vB->internalPoint() && !vB->referred()
+                )
                 {
                     // Only insert a point at the midpoint of
                     // the short edge if neither attached
@@ -1566,17 +1604,17 @@ void Foam::conformalVoronoiMesh::move()
                     {
                         pointsToInsert.append
                         (
-                            toPoint(0.5*(dVA + dVB))
+                            toPoint<Point>(0.5*(dVA + dVB))
                         );
                     }
                 }
 
-                if (vA->internalPoint())
+                if (vA->internalPoint() && !vA->referred())
                 {
                     pointToBeRetained[vA->index()] = false;
                 }
 
-                if (vB->internalPoint())
+                if (vB->internalPoint() && !vB->referred())
                 {
                     pointToBeRetained[vB->index()] = false;
                 }
@@ -1590,14 +1628,17 @@ void Foam::conformalVoronoiMesh::move()
             {
                 vector& alignmentDir = alignmentDirs[aD];
 
-                if ((rAB & alignmentDir) < 0)
+                scalar dotProd = rAB & alignmentDir;
+
+                if (dotProd < 0)
                 {
                     // swap the direction of the alignment so that has the
                     // same sense as rAB
                     alignmentDir *= -1;
+                    dotProd *= -1;
                 }
 
-                const scalar alignmentDotProd = ((rAB/rABMag) & alignmentDir);
+                const scalar alignmentDotProd = dotProd/rABMag;
 
                 if
                 (
@@ -1605,19 +1646,59 @@ void Foam::conformalVoronoiMesh::move()
                   > cvMeshControls().cosAlignmentAcceptanceAngle()
                 )
                 {
-                    const scalar targetCellSize = averageCellSize(vA, vB);
+                    scalar targetCellSize = averageCellSize(vA, vB);
 
-                    const scalar targetFaceArea = sqr(targetCellSize);
+                    scalar targetFaceArea = sqr(targetCellSize);
 
-                    alignmentDir *= 0.5*targetCellSize;
+                    const vector originalAlignmentDir = alignmentDir;
+
+                    // Update cell size and face area
+                    cellShapeControls().aspectRatio().updateCellSizeAndFaceArea
+                    (
+                        alignmentDir,
+                        targetFaceArea,
+                        targetCellSize
+                    );
 
                     // Vector to move end points around middle of vector
                     // to align edge (i.e. dual face normal) with alignment
                     // directions.
                     vector delta = alignmentDir - 0.5*rAB;
 
+                    face dualFace = buildDualFace(eit);
+
+//                    Pout<< dualFace << endl;
+//                    Pout<< "    " << vA->info() << endl;
+//                    Pout<< "    " << vB->info() << endl;
+
                     const scalar faceArea = dualFace.mag(dualVertices);
 
+                    // Update delta vector
+                    cellShapeControls().aspectRatio().updateDeltaVector
+                    (
+                        originalAlignmentDir,
+                        targetCellSize,
+                        rABMag,
+                        delta
+                    );
+
+                    if (targetFaceArea == 0)
+                    {
+                        Pout<< vA->info() << vB->info();
+
+                        Cell_handle ch = locate(vA->point());
+                        if (is_infinite(ch))
+                        {
+                            Pout<< "vA " << vA->targetCellSize() << endl;
+                        }
+
+                        ch = locate(vB->point());
+                        if (is_infinite(ch))
+                        {
+                            Pout<< "vB " << vB->targetCellSize() << endl;
+                        }
+                    }
+
                     delta *= faceAreaWeightModel_->faceAreaWeight
                     (
                         faceArea/targetFaceArea
@@ -1625,8 +1706,15 @@ void Foam::conformalVoronoiMesh::move()
 
                     if
                     (
-                        vA->internalPoint()
-                     && vB->internalPoint()
+                        (
+                            (vA->internalPoint() && vB->internalPoint())
+                         && (!vA->referred() || !vB->referred())
+//                         ||
+//                            (
+//                                vA->referredInternalPoint()
+//                             && vB->referredInternalPoint()
+//                            )
+                        )
                      && rABMag
                       > cvMeshControls().insertionDistCoeff()*targetCellSize
                      && faceArea
@@ -1636,7 +1724,6 @@ void Foam::conformalVoronoiMesh::move()
                     )
                     {
                         // Point insertion
-
                         if
                         (
                             !geometryToConformTo_.findSurfaceAnyIntersection
@@ -1646,23 +1733,32 @@ void Foam::conformalVoronoiMesh::move()
                             )
                         )
                         {
-                            // Prevent insertions spanning surfaces
-                            pointsToInsert.append
-                            (
-                                toPoint(0.5*(dVA + dVB))
-                            );
+                            const Foam::point& newPt = 0.5*(dVA + dVB);
+
+                            if (positionOnThisProc(newPt))
+                            {
+                                // Prevent insertions spanning surfaces
+                                pointsToInsert.append(toPoint<Point>(newPt));
+                            }
                         }
                     }
                     else if
                     (
-                        (vA->internalPoint() || vB->internalPoint())
+                        (
+                            (vA->internalPoint() && !vA->referred())
+                         || (vB->internalPoint() && !vB->referred())
+                        )
                      && rABMag
-                      < cvMeshControls().removalDistCoeff()*targetCellSize
+                      < cvMeshControls().removalDistCoeff()
+                       *targetCellSize
                     )
                     {
                         // Point removal
-
-                        if (vA->internalPoint() && vB->internalPoint())
+                        if
+                        (
+                            vA->internalPoint() && !vA->referred()
+                         && vB->internalPoint() && !vB->referred()
+                        )
                         {
                             // Only insert a point at the midpoint of
                             // the short edge if neither attached
@@ -1676,31 +1772,31 @@ void Foam::conformalVoronoiMesh::move()
                             {
                                 pointsToInsert.append
                                 (
-                                    toPoint(0.5*(dVA + dVB))
+                                    toPoint<Point>(0.5*(dVA + dVB))
                                 );
                             }
                         }
 
-                        if (vA->internalPoint())
+                        if (vA->internalPoint() && !vA->referred())
                         {
                             pointToBeRetained[vA->index()] = false;
                         }
 
-                        if (vB->internalPoint())
+                        if (vB->internalPoint() && !vB->referred())
                         {
                             pointToBeRetained[vB->index()] = false;
                         }
                     }
                     else
                     {
-                        if (vA->internalPoint())
+                        if (vA->internalPoint() && !vA->referred())
                         {
                             displacementAccumulator[vA->index()] += delta;
                         }
 
-                        if (vB->internalPoint())
+                        if (vB->internalPoint() && !vB->referred())
                         {
-                            displacementAccumulator[vB->index()] += -delta;
+                            displacementAccumulator[vB->index()] -= delta;
                         }
                     }
                 }
@@ -1708,6 +1804,8 @@ void Foam::conformalVoronoiMesh::move()
         }
     }
 
+    Info<< "Limit displacements" << endl;
+
     // Limit displacements that pierce, or get too close to the surface
     for
     (
@@ -1716,22 +1814,26 @@ void Foam::conformalVoronoiMesh::move()
         ++vit
     )
     {
-        if (vit->internalPoint())
+        if (vit->internalPoint() && !vit->referred())
         {
-            limitDisplacement
-            (
-                vit,
-                displacementAccumulator[vit->index()]
-            );
+            if (pointToBeRetained[vit->index()] == true)
+            {
+                limitDisplacement
+                (
+                    vit,
+                    displacementAccumulator[vit->index()]
+                );
+            }
         }
     }
 
     vector totalDisp = gSum(displacementAccumulator);
     scalar totalDist = gSum(mag(displacementAccumulator));
 
-    // Relax the calculated displacement
     displacementAccumulator *= relaxation;
 
+    Info<< "Sum displacements" << endl;
+
     for
     (
         Delaunay::Finite_vertices_iterator vit = finite_vertices_begin();
@@ -1739,7 +1841,7 @@ void Foam::conformalVoronoiMesh::move()
         ++vit
     )
     {
-        if (vit->internalPoint())
+        if (vit->internalPoint() && !vit->referred())
         {
             if (pointToBeRetained[vit->index()] == true)
             {
@@ -1755,7 +1857,7 @@ void Foam::conformalVoronoiMesh::move()
 
                 pointsToInsert.append
                 (
-                    toPoint
+                    toPoint<Point>
                     (
                         topoint(vit->point())
                       + displacementAccumulator[vit->index()]
@@ -1780,7 +1882,7 @@ void Foam::conformalVoronoiMesh::move()
             ++vit
         )
         {
-            if (vit->internalPoint())
+            if (vit->internalPoint() && !vit->referred())
             {
                 if (pointToBeRetained[vit->index()] == true)
                 {
@@ -1797,45 +1899,44 @@ void Foam::conformalVoronoiMesh::move()
     }
 
     // Remove the entire tessellation
-    reset();
-
-    if (cvMeshControls().objOutput() && runTime_.outputTime())
-    {
-        writePoints("featurePoints_" + runTime_.timeName() + ".obj", false);
-    }
+    DelaunayMesh<Delaunay>::reset();
 
     timeCheck("Displacement calculated");
 
     Info<< nl << "Inserting displaced tessellation" << endl;
 
-    insertPoints(pointsToInsert);
+    insertInternalPoints(pointsToInsert, true);
+
+    reinsertFeaturePoints(true);
 
     // Remove internal points that have been inserted outside the surface.
-    label internalPtIsOutside = 0;
-
-    for
-    (
-        Delaunay::Finite_vertices_iterator vit = finite_vertices_begin();
-        vit != finite_vertices_end();
-        ++vit
-    )
-    {
-        if (vit->internalPoint())
-        {
-            bool inside
-                = geometryToConformTo_.inside(topoint(vit->point()));
-
-            if (!inside)
-            {
-                remove(vit);
-                internalPtIsOutside++;
-            }
-        }
-    }
-
-    Info<< "    " << internalPtIsOutside
-        << " internal points were inserted outside the domain. "
-        << "They have been removed." << endl;
+//    label internalPtIsOutside = 0;
+//
+//    for
+//    (
+//        Delaunay::Finite_vertices_iterator vit = finite_vertices_begin();
+//        vit != finite_vertices_end();
+//        ++vit
+//    )
+//    {
+//        if (vit->internalPoint() && !vit->referred())
+//        {
+//            bool inside = geometryToConformTo_.inside
+//            (
+//                topoint(vit->point())
+//            );
+//
+//            if (!inside)
+//            {
+//                remove(vit);
+//                internalPtIsOutside++;
+//            }
+//        }
+//    }
+//
+//    Info<< "    " << internalPtIsOutside
+//        << " internal points were inserted outside the domain. "
+//        << "They have been removed." << endl;
 
     // Fix points that have not been significantly displaced
 //    for
@@ -1858,15 +1959,39 @@ void Foam::conformalVoronoiMesh::move()
 //        }
 //    }
 
-    if (cvMeshControls().objOutput() && runTime_.outputTime())
-    {
-        writePoints("points_" + runTime_.timeName() + ".obj", true);
-    }
-
     timeCheck("Internal points inserted");
 
+    {
+        // Check that no index is shared between any of the local points
+        labelHashSet usedIndices;
+        for
+        (
+            Delaunay::Finite_vertices_iterator vit = finite_vertices_begin();
+            vit != finite_vertices_end();
+            ++vit
+        )
+        {
+            if (!vit->referred() && !usedIndices.insert(vit->index()))
+            {
+                FatalErrorIn("Foam::conformalVoronoiMesh::move()")
+                    << "Index already used! Could not insert: " << nl
+                    << vit->info()
+                    << abort(FatalError);
+            }
+        }
+    }
+
     conformToSurface();
 
+    if (cvMeshControls().objOutput())
+    {
+        writePoints
+        (
+            "internalPoints_" + runTime_.timeName() + ".obj",
+            Foam::indexedVertexEnum::vtInternal
+        );
+    }
+
     if (cvMeshControls().objOutput() && runTime_.outputTime())
     {
         writeBoundaryPoints("boundaryPoints_" + runTime_.timeName() + ".obj");
@@ -1874,10 +1999,12 @@ void Foam::conformalVoronoiMesh::move()
 
     timeCheck("After conformToSurface");
 
+    printVertexInfo();
+
     // Write the intermediate mesh, do not filter the dual faces.
     if (runTime_.outputTime())
     {
-        writeMesh(runTime_.timeName(), false);
+        writeMesh(runTime_.timeName());
     }
 
     updateSizesAndAlignments(pointsToInsert);
@@ -1947,18 +2074,131 @@ Foam::conformalVoronoiMesh::intersectsProc
 }
 
 
-Foam::labelListList Foam::conformalVoronoiMesh::overlapsProc
-(
-    const List<Foam::point>& centres,
-    const List<scalar>& radiusSqrs
-) const
+//Foam::labelListList Foam::conformalVoronoiMesh::overlapsProc
+//(
+//    const List<Foam::point>& centres,
+//    const List<scalar>& radiusSqrs
+//) const
+//{
+//    if (!Pstream::parRun())
+//    {
+//        return labelListList(centres.size(), labelList(0));
+//    }
+//
+////    DynamicList<Foam::point> pts(number_of_vertices());
+//
+////    for
+////    (
+////        Delaunay::Finite_vertices_iterator vit = finite_vertices_begin();
+////        vit != finite_vertices_end();
+////        vit++
+////    )
+////    {
+////        pts.append(topoint(vit->point()));
+////    }
+////
+////    dynamicIndexedOctree<dynamicTreeDataPoint> vertexOctree
+////    (
+////        dynamicTreeDataPoint(pts),
+////        treeBoundBox(min(pts), max(pts)),
+////        10, // maxLevel
+////        10, // leafSize
+////        3.0 // duplicity
+////    );
+//
+//    return decomposition_().overlapsProcessors
+//    (
+//        centres,
+//        radiusSqrs,
+//        *this,
+//        false//,
+////        vertexOctree
+//    );
+//}
+
+
+void Foam::conformalVoronoiMesh::checkCoPlanarCells() const
 {
-    if (!Pstream::parRun())
+    typedef CGAL::Exact_predicates_exact_constructions_kernel   Kexact;
+    typedef CGAL::Point_3<Kexact>                               PointExact;
+
+    if (!is_valid())
     {
-        return labelListList(centres.size(), labelList(0));
+        Pout<< "Triangulation is invalid!" << endl;
     }
 
-    return decomposition_().overlapsProcessors(centres, radiusSqrs, false);
+    OFstream str("badCells.obj");
+
+    label badCells = 0;
+
+    for
+    (
+        Delaunay::Finite_cells_iterator cit = finite_cells_begin();
+        cit != finite_cells_end();
+        ++cit
+    )
+    {
+        const scalar quality = cvMeshChecks::coplanarTet(cit, 1e-16);
+
+        if (quality == 0)
+        {
+            Pout<< "COPLANAR: " << cit->info() << nl
+                << "    quality = " << quality << nl
+                << "    dual    = " << topoint(cit->dual()) << endl;
+
+            drawDelaunayCell(str, cit, badCells++);
+
+            FixedList<PointExact, 4> cellVerticesExact(PointExact(0,0,0));
+            forAll(cellVerticesExact, vI)
+            {
+                cellVerticesExact[vI] = PointExact
+                (
+                    cit->vertex(vI)->point().x(),
+                    cit->vertex(vI)->point().y(),
+                    cit->vertex(vI)->point().z()
+                );
+            }
+
+            PointExact synchronisedDual = CGAL::circumcenter<Kexact>
+            (
+                cellVerticesExact[0],
+                cellVerticesExact[1],
+                cellVerticesExact[2],
+                cellVerticesExact[3]
+            );
+
+            Foam::point exactPt
+            (
+                CGAL::to_double(synchronisedDual.x()),
+                CGAL::to_double(synchronisedDual.y()),
+                CGAL::to_double(synchronisedDual.z())
+            );
+
+            Info<< "inexact = " << cit->dual() << nl
+                << "exact   = " << exactPt << endl;
+        }
+    }
+
+    Pout<< "There are " << badCells << " bad cells out of "
+        << number_of_finite_cells() << endl;
+
+
+    label nNonGabriel = 0;
+    for
+    (
+        Delaunay::Finite_facets_iterator fit = finite_facets_begin();
+        fit != finite_facets_end();
+        ++fit
+    )
+    {
+        if (!is_Gabriel(*fit))
+        {
+            nNonGabriel++;//Pout<< "Non-gabriel face" << endl;
+        }
+    }
+
+    Pout<< "There are " << nNonGabriel << " non-Gabriel faces out of "
+        << number_of_finite_facets() << endl;
 }
 
 
diff --git a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/conformalVoronoiMesh.H b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/conformalVoronoiMesh.H
index 3be6dab81c..bf64f6196c 100644
--- a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/conformalVoronoiMesh.H
+++ b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/conformalVoronoiMesh.H
@@ -21,11 +21,6 @@ License
     You should have received a copy of the GNU General Public License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
-    As a special exception, you have permission to link this program with the
-    CGAL library and distribute executables, as long as you follow the
-    requirements of the GNU GPL in regard to all of the software in the
-    executable aside from CGAL.
-
 Class
     Foam::conformalVoronoiMesh
 
@@ -50,7 +45,7 @@ SourceFiles
 #include "ulong.H"
 #include "searchableSurfaces.H"
 #include "conformationSurfaces.H"
-#include "cellSizeControlSurfaces.H"
+#include "cellShapeControl.H"
 #include "cvControls.H"
 #include "DynamicList.H"
 #include "PackedBoolList.H"
@@ -77,6 +72,11 @@ SourceFiles
 #include "zeroGradientFvPatchFields.H"
 #include "globalIndex.H"
 #include "pointFeatureEdgesTypes.H"
+#include "pointConversion.H"
+#include "Tuple2.H"
+#include "DistributedDelaunayMesh.H"
+#include "tensorIOField.H"
+
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -98,24 +98,25 @@ class backgroundMeshDecomposition;
 
 class conformalVoronoiMesh
 :
-    public Delaunay
+    public DistributedDelaunayMesh<Delaunay>
 {
 public:
 
     enum reconformationMode
     {
-        rmNone,   // Do not rebuild the surface conformation
-        rmCoarse, // Rebuild the conformation with coarse tolerances (faster)
-        rmFine    // Rebuild the conformation with fine tolerances (slower)
+        rmOff,   // Do not rebuild the surface conformation
+        rmOn
     };
 
-    enum faceCollapseMode
-    {
-        fcmNone,             // Do not collapse face
-        fcmEdge,             // Collapse face to a single edge
-        fcmPoint,            // Collapse face to a point
-        fcmDeferredMultiEdge // Collapse face to several edges
-    };
+    typedef Delaunay::Vertex_handle    Vertex_handle;
+    typedef Delaunay::Cell_handle      Cell_handle;
+    typedef Delaunay::Point            Point;
+
+    typedef List<DynamicList<Pair<labelPair> > > labelPairPairDynListList;
+
+    typedef Tuple2<pointIndexHit, label>         pointIndexHitAndFeature;
+    typedef List<pointIndexHitAndFeature>        pointIndexHitAndFeatureList;
+    typedef DynamicList<pointIndexHitAndFeature> pointIndexHitAndFeatureDynList;
 
 
 private:
@@ -147,12 +148,8 @@ private:
         //- The surfaces to conform to
         conformationSurfaces geometryToConformTo_;
 
-        //- The cell size control object
-        cellSizeControlSurfaces cellSizeControl_;
-
-        //- Keep track of the start index of the internal points.  Needs
-        //  careful bookkeeping within several functions.
-        label startOfInternalPoints_;
+        //- The cell shape control object
+        cellShapeControl cellShapeControl_;
 
         //- Limiting bound box before infinity begins
         treeBoundBox limitBounds_;
@@ -167,11 +164,15 @@ private:
 
         //- Search tree for edge point locations
         mutable autoPtr<dynamicIndexedOctree<dynamicTreeDataPoint> >
-        edgeLocationTreePtr_;
+            edgeLocationTreePtr_;
+
+        mutable DynamicList<Foam::point> existingEdgeLocations_;
 
         //- Search tree for surface point locations
         mutable autoPtr<dynamicIndexedOctree<dynamicTreeDataPoint> >
-        surfacePtLocationTreePtr_;
+            surfacePtLocationTreePtr_;
+
+        mutable DynamicList<Foam::point> existingSurfacePtLocations_;
 
         //- Store locations where the cell size and alignments will be
         //  pre-calculated and looked up
@@ -205,6 +206,8 @@ private:
 
     // Private Member Functions
 
+        inline scalar defaultCellSize() const;
+
         //- Return the local target cell size at the given location.  Takes
         //  boolean argument to allow speed-up of queries if the point is going
         //  to be on a surface.
@@ -271,64 +274,55 @@ private:
         //- Return the required alignment directions at the given location
         tensor requiredAlignment(const Foam::point& pt) const;
 
-        //- Insert Foam::point and return its auto-generated index
-        inline label insertPoint
-        (
-            const Foam::point& p,
-            const label type
-        );
-
         //- Insert Point and return its auto-generated index
-        inline label insertPoint
+        inline bool insertPoint
         (
             const Point& P,
-            const label type
+            const indexedVertexEnum::vertexType type
         );
 
         //- Insert Foam::point with specified index and type
-        inline void insertPoint
+        inline bool insertPoint
         (
             const Foam::point& p,
-            const label index,
-            const label type
+            const indexedVertexEnum::vertexType type
         );
 
-        //- Insert Point with specified index and type
-        inline void insertPoint
+        //- Insert Point with specified index, type and original processor
+        inline bool insertReferredPoint
         (
             const Point& P,
             const label index,
-            const label type
+            const indexedVertexEnum::vertexType type,
+            const label processor
+        );
+
+        inline bool insertReferredPoint(const Vb& P);
+
+        //- Insert Foam::point with specified index, type and original processor
+        inline bool insertReferredPoint
+        (
+            const Foam::point& p,
+            const label index,
+            const indexedVertexEnum::vertexType type,
+            const label processor
         );
 
         //- Insert Delaunay vertices using the CGAL range insertion method,
         //  optionally check processor occupancy and distribute to other
         //  processors
-        void insertPoints
+        void insertInternalPoints
         (
             List<Point>& points,
-            bool distribute = true
+            const bool distribute = false
         );
 
-        //- Insert indexed and typed Delaunay vertices, optionally check
-        //  processor occupancy and distribute to other processors
         void insertPoints
         (
-            DynamicList<Foam::point>& pts,
-            DynamicList<label>& indices,
-            DynamicList<label>& types,
+            List<Vb>& vertices,
             bool distribute = true
         );
 
-        //- Insert a point-pair at a ppDist distance either side of
-        //  surface point surfPt, in the direction n
-        inline void insertPointPair
-        (
-            const scalar ppDist,
-            const Foam::point& surfPt,
-            const vector& n
-        );
-
         //- Create a point-pair at a ppDist distance either side of
         //  surface point surfPt, in the direction n
         inline void createPointPair
@@ -336,17 +330,26 @@ private:
             const scalar ppDist,
             const Foam::point& surfPt,
             const vector& n,
-            DynamicList<Foam::point>& pts,
-            DynamicList<label>& indices,
-            DynamicList<label>& types
+            DynamicList<Vb>& pts
+        );
+
+        inline Foam::point perturbPoint(const Foam::point& pt) const;
+
+        //- Create a point-pair at a ppDist distance either side of
+        //  surface point surfPt, in the direction n
+        inline void createBafflePointPair
+        (
+            const scalar ppDist,
+            const Foam::point& surfPt,
+            const vector& n,
+            DynamicList<Vb>& pts
         );
 
         //- Insert pairs of points on the surface with the given normals, at the
         //  specified spacing
         void insertSurfacePointPairs
         (
-            const List<pointIndexHit>& surfaceHits,
-            const List<label>& hitSurfaces,
+            const pointIndexHitAndFeatureList& surfaceHits,
             const fileName fName = fileName::null
         );
 
@@ -355,8 +358,7 @@ private:
         //  to be conformed to on the corresponding entry in featureHit
         void insertEdgePointGroups
         (
-            const List<pointIndexHit>& edgeHits,
-            const labelList& featuresHit,
+            const pointIndexHitAndFeatureList& edgeHits,
             const fileName fName = fileName::null
         );
 
@@ -365,9 +367,7 @@ private:
         (
             const extendedFeatureEdgeMesh& feMesh,
             const pointIndexHit& edHit,
-            DynamicList<Foam::point>& pts,
-            DynamicList<label>& indices,
-            DynamicList<label>& types
+            DynamicList<Vb>& pts
         );
 
         //- Create points to conform to an external edge
@@ -375,9 +375,7 @@ private:
         (
             const extendedFeatureEdgeMesh& feMesh,
             const pointIndexHit& edHit,
-            DynamicList<Foam::point>& pts,
-            DynamicList<label>& indices,
-            DynamicList<label>& types
+            DynamicList<Vb>& pts
         );
 
         //- Create points to conform to an internal edge
@@ -385,9 +383,7 @@ private:
         (
             const extendedFeatureEdgeMesh& feMesh,
             const pointIndexHit& edHit,
-            DynamicList<Foam::point>& pts,
-            DynamicList<label>& indices,
-            DynamicList<label>& types
+            DynamicList<Vb>& pts
         );
 
         //- Create points to conform to a flat edge
@@ -395,9 +391,7 @@ private:
         (
             const extendedFeatureEdgeMesh& feMesh,
             const pointIndexHit& edHit,
-            DynamicList<Foam::point>& pts,
-            DynamicList<label>& indices,
-            DynamicList<label>& types
+            DynamicList<Vb>& pts
         );
 
         //- Create points to conform to an open edge
@@ -405,9 +399,7 @@ private:
         (
             const extendedFeatureEdgeMesh& feMesh,
             const pointIndexHit& edHit,
-            DynamicList<Foam::point>& pts,
-            DynamicList<label>& indices,
-            DynamicList<label>& types
+            DynamicList<Vb>& pts
         );
 
         //- Create points to conform to multiply connected edge
@@ -415,39 +407,54 @@ private:
         (
             const extendedFeatureEdgeMesh& feMesh,
             const pointIndexHit& edHit,
-            DynamicList<Foam::point>& pts,
-            DynamicList<label>& indices,
-            DynamicList<label>& types
+            DynamicList<Vb>& pts
         );
 
         //- Determine and insert point groups at the feature points
         void insertFeaturePoints();
 
-        bool edgesShareNormal(const label e1, const label e2) const;
-
-        //- Create point groups at convex feature points
-        void createConvexFeaturePoints
-        (
-            DynamicList<Foam::point>& pts,
-            DynamicList<label>& indices,
-            DynamicList<label>& types
-        );
-
-        //- Create point groups at concave feature points
-        void createConcaveFeaturePoints
-        (
-            DynamicList<Foam::point>& pts,
-            DynamicList<label>& indices,
-            DynamicList<label>& types
-        );
-
         //- Create point groups at mixed feature points
-        void createMixedFeaturePoints
+        void createMixedFeaturePoints(DynamicList<Vb>& pts);
+
+        void addMasterAndSlavePoints
         (
-            DynamicList<Foam::point>& pts,
-            DynamicList<label>& indices,
-            DynamicList<label>& types
-        );
+            const DynamicList<Foam::point>& masterPoints,
+            const DynamicList<indexedVertexEnum::vertexType>&masterPointsTypes,
+            const Map<DynamicList<autoPtr<plane> > >& masterPointReflections,
+            DynamicList<Vb>& pts,
+            const label ptI
+        ) const;
+
+        label getSign(const extendedFeatureEdgeMesh::edgeStatus eStatus) const;
+
+        void createMasterAndSlavePoints
+        (
+            const extendedFeatureEdgeMesh& feMesh,
+            const label ptI,
+            DynamicList<Vb>& pts
+        ) const;
+
+        void createFeaturePoints(DynamicList<Vb>& pts);
+
+        vector sharedFaceNormal
+        (
+            const extendedFeatureEdgeMesh& feMesh,
+            const label edgeI,
+            const label nextEdgeI
+        ) const;
+
+        List<Foam::point> reflectPointInPlanes
+        (
+            const Foam::point p,
+            const DynamicList<autoPtr<plane> >& planes
+        ) const;
+
+        Foam::point reflectPointInPlane
+        (
+            const Foam::point p,
+            const plane& planeN
+        ) const;
+
 
         //- Fill the pointFeatureEdgesType struct with the types of feature
         //  edges that are attached to the point.
@@ -467,9 +474,7 @@ private:
             const pointFeatureEdgesTypes& pFEdgeTypes,
             const List<extendedFeatureEdgeMesh::edgeStatus>& allEdStat,
             const label ptI,
-            DynamicList<Foam::point>& pts,
-            DynamicList<label>& indices,
-            DynamicList<label>& types
+            DynamicList<Vb>& pts
         );
 
         //- Store the locations of all of the features to be conformed to
@@ -486,28 +491,27 @@ private:
         //- Check if a location is in exclusion range around a feature point
         bool nearFeaturePt(const Foam::point& pt) const;
 
-        //- Clear the entire tesselation
-        //  Reinsert bounding points, feature points and recalculate
-        //  startOfInternalPoints_
-        void reset(const bool distribute = false);
-
-        //- Insert far points in a large bounding box to avoid dual edges
-        //  spanning huge distances
-        void insertBoundingPoints();
-
-        //- Reinsert the bounding points
-        void reinsertBoundingPoints();
-
         //- Insert the initial points into the triangulation, based on the
         //  initialPointsMethod
         void insertInitialPoints();
 
+        //- Calculate the worst load balance
+        scalar calculateLoadUnbalance() const;
+
         //- In parallel redistribute the backgroundMeshDecomposition and
         //  vertices to balance the number of vertices on each processor.
         //  Returns true if the background mesh changes as this removes all
         //  referred vertices, so the parallel interface may need rebuilt.
         bool distributeBackground();
 
+        // Test for full containment
+        void cellSizeMeshOverlapsBackground() const;
+
+        //-
+        void distribute();
+
+        void buildCellSizeAndAlignmentMesh();
+
         //- Store data for sizeAndAlignmentLocations_, storedSizes_ and
         //  storedAlignments_ and initialise the sizeAndAlignmentTreePtr_,
         //  determining the appropriate sizeAndAlignmentLocations_
@@ -568,9 +572,28 @@ private:
         //  conformation
         reconformationMode reconformationControl() const;
 
+        //- Determines geometrically whether a vertex is close to a surface
+        //  This is an optimisation
+        label findVerticesNearBoundaries();
+
         //- Create and insert the necessary point pairs to conform to the
         //  surface, then store the result
-        void buildSurfaceConformation(reconformationMode reconfMode);
+        void buildSurfaceConformation();
+
+        label synchroniseEdgeTrees
+        (
+            pointIndexHitAndFeatureList& featureEdgeHits
+        );
+
+        label synchroniseSurfaceTrees
+        (
+            pointIndexHitAndFeatureList& surfaceHits
+        );
+
+        bool locationConformsToInside
+        (
+            const pointIndexHitAndFeature& info
+        ) const;
 
         //- Check to see if dual cell specified by given vertex iterator
         //  intersects the boundary and hence reqires a point-pair
@@ -583,8 +606,7 @@ private:
         bool dualCellSurfaceAllIntersections
         (
             const Delaunay::Finite_vertices_iterator& vit,
-            DynamicList<pointIndexHit>& info,
-            DynamicList<label>& hitSurface
+            pointIndexHitAndFeatureDynList& info
         ) const;
 
         //- Return false if the line is entirely outside the current processor
@@ -599,64 +621,6 @@ private:
             Foam::point& b
         ) const;
 
-        label removeProcessorBoundarySeeds(bool reinsertBoundPts);
-
-        void seedProcessorBoundarySurfaces(bool seedProcessors);
-
-        label numberOfUnusedReferredPoints() const;
-
-        //- Build the parallelInterfaces of the mesh
-        void buildParallelInterface
-        (
-            const word& outputName
-        );
-
-        //- Build the parallelInterfaces of the mesh, supply hash sets
-        //  externally to allow updates
-        void buildParallelInterface
-        (
-            List<labelHashSet>& referralVertices,
-            List<labelHashSet>& receivedVertices,
-            bool initialEdgeReferral,
-            const word& outputName
-        );
-
-        //- Refer all vertices to all processors
-        void buildParallelInterfaceAll
-        (
-            List<labelHashSet>& referralVertices,
-            List<labelHashSet>& receivedVertices,
-            const word& outputName
-        );
-
-        //- Refer vertices where there dual edge pierces other processors
-        void buildParallelInterfaceIntersection
-        (
-            List<labelHashSet>& referralVertices,
-            List<labelHashSet>& receivedVertices,
-            const word& outputName
-        );
-
-        //- Refer vertices that are attached to Delaunay tets whose
-        //  circumspheres touch other processors
-        void buildParallelInterfaceInfluence
-        (
-            List<labelHashSet>& referralVertices,
-            List<labelHashSet>& receivedVertices,
-            const word& outputName
-        );
-
-        //- Refer vertices to their required processors
-        void referVertices
-        (
-            const DynamicList<label>& targetProcessor,
-            DynamicList<Foam::point>& parallelPoints,
-            DynamicList<label>& parallelIndices,
-            List<labelHashSet>& receivedVertices,
-            const word& stageName,
-            const word& outputName
-        );
-
         //- Find the "worst" protrusion of a dual cell through the surface,
         //  subject to the maxSurfaceProtrusion tolerance
         void dualCellLargestSurfaceProtrusion
@@ -681,7 +645,7 @@ private:
 
         //- Write out debugging information about the surface conformation
         //  quality
-        void reportSurfaceConformationQuality();
+//        void reportSurfaceConformationQuality();
 
         //- Limit the displacement of a point so that it doesn't penetrate the
         //  surface to be meshed or come too close to it
@@ -698,23 +662,19 @@ private:
         //- Check if a surface point is near another.
         bool nearSurfacePoint
         (
-            pointIndexHit& pHit,
-            label& surfaceHit,
-            DynamicList<Foam::point>& existingSurfacePtLocations
+            pointIndexHitAndFeature& pHit
         ) const;
 
         //- Append a point to the surface point tree and the existing list
         bool appendToSurfacePtTree
         (
-            const Foam::point& pt,
-            DynamicList<Foam::point>& existingSurfacePtLocations
+            const Foam::point& pt
         ) const;
 
         //- Append a point to the edge location tree and the existing list
         bool appendToEdgeLocationTree
         (
-            const Foam::point& pt,
-            DynamicList<Foam::point>& existingEdgeLocations
+            const Foam::point& pt
         ) const;
 
         //- Return a list of the nearest feature edge locations
@@ -745,8 +705,7 @@ private:
         //- edge conformation location
         bool nearFeatureEdgeLocation
         (
-            pointIndexHit& pHit,
-            DynamicList<Foam::point>& existingEdgeLocations
+            pointIndexHit& pHit
         ) const;
 
         //- Build or rebuild the edge location tree
@@ -769,18 +728,11 @@ private:
         void addSurfaceAndEdgeHits
         (
             const Delaunay::Finite_vertices_iterator& vit,
-            const Foam::point& vert,
-            const DynamicList<pointIndexHit>& surfHit,
-            const DynamicList<label>& hitSurface,
+            const pointIndexHitAndFeatureDynList& surfaceIntersections,
             scalar surfacePtReplaceDistCoeffSqr,
             scalar edgeSearchDistCoeffSqr,
-            DynamicList<pointIndexHit>& surfaceHits,
-            DynamicList<label>& hitSurfaces,
-            DynamicList<pointIndexHit>& featureEdgeHits,
-            DynamicList<label>& featureEdgeFeaturesHit,
-            DynamicList<Foam::point>& newEdgeLocations,
-            DynamicList<Foam::point>& existingEdgeLocations,
-            DynamicList<Foam::point>& existingSurfacePtLocations
+            pointIndexHitAndFeatureDynList& surfaceHits,
+            pointIndexHitAndFeatureDynList& featureEdgeHits
         ) const;
 
         //- Store the surface conformation with the indices offset to be
@@ -791,10 +743,19 @@ private:
         //  relative to new number of internal vertices
         void reinsertSurfaceConformation();
 
+        void checkCells();
+
+        void checkDuals();
+
+        void checkVertices();
+
+        void checkCoPlanarCells() const;
+
         //- Dual calculation
         void calcDualMesh
         (
             pointField& points,
+            labelList& boundaryPts,
             faceList& faces,
             labelList& owner,
             labelList& neighbour,
@@ -806,7 +767,7 @@ private:
             pointField& cellCentres,
             labelList& cellToDelaunayVertex,
             labelListList& patchToDelaunayVertex,
-            bool filterFaces
+            PackedBoolList& boundaryFacesToRemove
         );
 
         //- Tet mesh calculation
@@ -844,77 +805,27 @@ private:
             const Delaunay::Finite_facets_iterator& fit
         ) const;
 
-        //- Merge adjacent edges that are not attached to other faces
-        label mergeNearlyParallelEdges
+        //- Determines if the dual face constructed by the Delaunay
+        //  edge is a processor boundary face
+        inline bool isProcBoundaryEdge
+        (
+            const Delaunay::Finite_edges_iterator& eit
+        ) const;
+
+        //- Merge vertices that are identical
+        void mergeIdenticalDualVertices
         (
             const pointField& pts,
-            const scalar maxCosAngle
+            const labelList& boundaryPts
         );
 
-        //- Merge vertices that are very close together
-        void mergeCloseDualVertices
+        label mergeIdenticalDualVertices
         (
             const pointField& pts,
-            const PackedBoolList& boundaryPts
-        );
-
-        label mergeCloseDualVertices
-        (
-            const pointField& pts,
-            const PackedBoolList& boundaryPts,
+            const labelList& boundaryPts,
             Map<label>& dualPtIndexMap
         ) const;
 
-        //- Smooth the dual vertices of the dual faces on the boundary
-        //  so that they conform to the surface and remove any
-        //  small, normal oriented faces
-        void smoothSurface
-        (
-            pointField& pts,
-            const PackedBoolList& boundaryPts
-        );
-
-        label smoothSurfaceDualFaces
-        (
-            pointField& pts,
-            const PackedBoolList& boundaryPts,
-            Map<label>& dualPtIndexMap
-        ) const;
-
-        //- Collapse a face to a point or an edge, modifying and
-        //  mapping the points, returns the true if the face was
-        //  collapsed in this operation
-        void collapseFaces
-        (
-            pointField& pts,
-            const PackedBoolList& boundaryPts,
-            HashSet<labelPair, labelPair::Hash<> >& deferredCollapseFaces
-        );
-
-        label collapseFaces
-        (
-            pointField& pts,
-            const PackedBoolList& boundaryPts,
-            Map<label>& dualPtIndexMap,
-            HashSet<labelPair, labelPair::Hash<> >& deferredCollapseFaces
-        ) const;
-
-        //- Collapse a face to an edge, updating the point and point
-        //  map. Returns the collapse mode that was applied.
-        faceCollapseMode collapseFace
-        (
-            const face& f,
-            pointField& pts,
-            const PackedBoolList& boundaryPts,
-            Map<label>& dualPtIndexMap,
-            scalar targetFaceSize,
-            scalar collapseSizeLimitCoeff,
-            label maxFC
-        ) const;
-
-        //- Identify the index of the longest edge on the face
-        label longestEdge(const face& f, const pointField& pts) const;
-
         //- Identify the face labels of the deferred collapse faces
         void deferredCollapseFaceSet
         (
@@ -943,12 +854,19 @@ private:
         void indexDualVertices
         (
             pointField& pts,
-            PackedBoolList& boundaryPts
+            labelList& boundaryPts
         );
 
-        //- Re-index all of the the Delaunay cells
+        //- Re-index all of the Delaunay cells
         void reindexDualVertices(const Map<label>& dualPtIndexMap);
 
+        label createPatchInfo
+        (
+            wordList& patchNames,
+            wordList& patchTypes,
+            labelList& procNeighbours
+        ) const;
+
         //- Create all of the internal and boundary faces
         void createFacesOwnerNeighbourAndPatches
         (
@@ -961,6 +879,7 @@ private:
             labelList& patchStarts,
             labelList& procNeighbours,
             labelListList& patchPointPairSlaves,
+            PackedBoolList& boundaryFacesToRemove,
             bool includeEmptyPatches = false
         ) const;
 
@@ -987,7 +906,7 @@ private:
             List<DynamicList<face> >& patchFaces,
             List<DynamicList<label> >& patchOwners,
             List<DynamicList<label> >& patchPointPairSlaves,
-            List<Pair<DynamicList<label> > >& patchSortingIndices
+            labelPairPairDynListList& patchSortingIndices
         ) const;
 
         //- Add the faces and owner information for the patches
@@ -998,15 +917,18 @@ private:
             labelList& owner,
             labelList& patchSizes,
             labelList& patchStarts,
+            PackedBoolList& boundaryFacesToRemove,
             const List<DynamicList<face> >& patchFaces,
-            const List<DynamicList<label> >& patchOwners
+            const List<DynamicList<label> >& patchOwners,
+            const List<DynamicList<bool> >& indirectPatchFace
         ) const;
 
         //- Remove points that are no longer used by any faces
         void removeUnusedPoints
         (
             faceList& faces,
-            pointField& pts
+            pointField& pts,
+            labelList& boundaryPts
         ) const;
 
         //- Remove dual cells that are not used by any faces. Return compaction
@@ -1031,6 +953,21 @@ private:
         //- Create a polyMesh from points.
         autoPtr<polyMesh> createPolyMeshFromPoints(const pointField& pts) const;
 
+        void checkProcessorPatchesMatch
+        (
+            const wordList& patchTypes,
+            const labelList& patchSizes,
+            const labelList& procNeighbours
+        ) const;
+
+        void reorderPoints
+        (
+            pointField& points,
+            labelList& boundaryPts,
+            faceList& faces,
+            const label nInternalFaces
+        ) const;
+
         //- Rotate the faces on processor patches if necessary
         void reorderProcessorPatches
         (
@@ -1078,6 +1015,8 @@ public:
         //  surface as required
         void move();
 
+        void printVertexInfo() const;
+
         //- Check if the point is in the domain handled by this processor
         bool positionOnThisProc(const Foam::point& pt) const;
 
@@ -1094,30 +1033,18 @@ public:
             const List<Foam::point>& ends
         ) const;
 
-        //- Which other processors does each sphere overlap
-        labelListList overlapsProc
-        (
-            const List<Foam::point>& centres,
-            const List<scalar>& radiusSqrs
-        ) const;
-
-        //- Conversion functions between point (FOAM::) and Point (CGAL)
-
-#       ifdef CGAL_INEXACT
-            typedef const Foam::point& pointFromPoint;
-            typedef const Point& PointFrompoint;
-#       else
-            typedef Foam::point pointFromPoint;
-            typedef Point PointFrompoint;
-#       endif
-
-        inline pointFromPoint topoint(const Point&) const;
-        inline PointFrompoint toPoint(const Foam::point&) const;
+//        //- Which other processors does each sphere overlap
+//        labelListList overlapsProc
+//        (
+//            const List<Foam::point>& centres,
+//            const List<scalar>& radiusSqrs
+//        ) const;
 
         typedef K::Vector_3 CGALVector;
 
         inline CGALVector toCGALVector(const Foam::vector& v) const;
 
+
         // Access
 
             //- Return the Time object
@@ -1135,8 +1062,8 @@ public:
             //- Return the backgroundMeshDecomposition
             inline const backgroundMeshDecomposition& decomposition() const;
 
-            //- Return the cellSizeControlSurfaces object
-            inline const cellSizeControlSurfaces& cellSizeControl() const;
+            //- Return the cellShapeControl object
+            inline const cellShapeControl& cellShapeControls() const;
 
             //- Return the cvMeshControls object
             inline const cvControls& cvMeshControls() const;
@@ -1159,8 +1086,21 @@ public:
                 label offset = 0
             ) const;
 
-            //- Write Delaunay points to .obj file
-            void writePoints(const fileName& fName, bool internalOnly) const;
+            //- Write Delaunay points in the range between (and including)
+            //  type startPointType and endPointType to .obj file
+            void writePoints
+            (
+                const fileName& fName,
+                const Foam::indexedVertexEnum::vertexType startPointType,
+                const Foam::indexedVertexEnum::vertexType endPointType
+            ) const;
+
+            //- Write Delaunay points of type pointType to .obj file
+            void writePoints
+            (
+                const fileName& fName,
+                const Foam::indexedVertexEnum::vertexType pointType
+            ) const;
 
             //- Write the boundary Delaunay points to .obj file
             void writeBoundaryPoints(const fileName& fName) const;
@@ -1172,17 +1112,20 @@ public:
                 const List<Foam::point>& points
             ) const;
 
+            //- Write list of points to file
+            void writePoints
+            (
+                const fileName& fName,
+                const List<Vb>& points
+            ) const;
+
             //- Write the internal Delaunay vertices of the tessellation as a
             //  pointField that may be used to restart the meshing process
             void writeInternalDelaunayVertices(const fileName& instance) const;
 
             //- Prepare data and call writeMesh for polyMesh and
             //  tetDualMesh
-            void writeMesh
-            (
-                const fileName& instance,
-                bool filterFaces = true
-            );
+            void writeMesh(const fileName& instance);
 
             //- Write mesh to disk
             void writeMesh
@@ -1190,6 +1133,7 @@ public:
                 const word& meshName,
                 const fileName& instance,
                 pointField& points,
+                labelList& boundaryPts,
                 faceList& faces,
                 labelList& owner,
                 labelList& neighbour,
@@ -1198,7 +1142,8 @@ public:
                 const labelList& patchSizes,
                 const labelList& patchStarts,
                 const labelList& procNeighbours,
-                const pointField& cellCentres
+                const pointField& cellCentres,
+                const PackedBoolList& boundaryFacesToRemove
             ) const;
 
             //- Write points and faces as .obj file
@@ -1214,6 +1159,8 @@ public:
             //  actual cell size (cbrt(actual cell volume)).
             void writeCellSizes(const fvMesh& mesh) const;
 
+            void writeCellAlignments(const fvMesh& mesh) const;
+
             //- Calculate and write the cell centres.
             void writeCellCentres(const fvMesh& mesh) const;
 
@@ -1226,90 +1173,6 @@ public:
                 const fileName& fName,
                 const faceList& faces
             ) const;
-
-            //- Function inserting points into a triangulation and setting the
-            //  index and type data of the point in the correct order. This is
-            //  faster than inserting points individually.
-            //
-            //  Adapted from a post on the CGAL lists: 2010-01/msg00004.html by
-            //  Sebastien Loriot (Geometry Factory).
-            //
-            //  @todo problems putting declaration in the .C file. Function
-            //        prototype is not recognised.
-            template<class Triangulation, class Point_iterator>
-            void rangeInsertWithInfo
-            (
-                Point_iterator begin,
-                Point_iterator end,
-                Triangulation& T,
-                DynamicList<label>& indices,
-                DynamicList<label>& types
-            )
-            {
-                typedef std::vector
-                <
-                    std::pair<const typename Triangulation::Point*, label>
-                > vectorPairPointIndex;
-
-                vectorPairPointIndex points;
-                label index = 0;
-
-                for (Point_iterator it = begin; it != end; ++it)
-                {
-                    points.push_back
-                    (
-                        std::make_pair(&(toPoint(*it)), index++)
-                    );
-                }
-
-                std::random_shuffle(points.begin(), points.end());
-
-                spatial_sort
-                (
-                    points.begin(),
-                    points.end(),
-                    Traits_for_spatial_sort<Triangulation>()
-                );
-
-                typename Triangulation::Vertex_handle hint;
-
-                for
-                (
-                    typename vectorPairPointIndex::const_iterator
-                    p = points.begin();
-                    p != points.end();
-                    ++p
-                )
-                {
-                    const size_t checkInsertion = T.number_of_vertices();
-
-                    hint = T.insert(*(p->first), hint);
-
-                    if (checkInsertion != T.number_of_vertices() - 1)
-                    {
-                        Pout<< "Failed to insert point "
-                            << topoint(*(p->first)) << endl;
-                    }
-                    else
-                    {
-                        label oldIndex = p->second;
-
-                        label type = types[oldIndex];
-
-                        if (type > Vb::vtFar)
-                        {
-                            // This is a member of a point pair, don't use the
-                            // type directly (note that this routine never gets
-                            // called for referredPoints so type will never be
-                            // -procI
-                            type += checkInsertion;
-                        }
-
-                        hint->index() = indices[oldIndex] + checkInsertion;
-                        hint->type() = type;
-                    }
-                }
-            }
 };
 
 
@@ -1321,10 +1184,6 @@ public:
 
 #include "conformalVoronoiMeshI.H"
 
-//#ifdef NoRepository
-//#   include "conformalVoronoiMeshTemplates.C"
-//#endif
-
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 #endif
diff --git a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/conformalVoronoiMeshCalcDualMesh.C b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/conformalVoronoiMeshCalcDualMesh.C
index ec81b1e944..92ee53c1f2 100644
--- a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/conformalVoronoiMeshCalcDualMesh.C
+++ b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/conformalVoronoiMeshCalcDualMesh.C
@@ -27,12 +27,489 @@ License
 #include "motionSmoother.H"
 #include "backgroundMeshDecomposition.H"
 #include "polyMeshGeometry.H"
+#include "indexedCellChecks.H"
+
+#include "CGAL/Exact_predicates_exact_constructions_kernel.h"
 
 // * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * * //
 
+void Foam::conformalVoronoiMesh::checkCells()
+{
+    List<List<FixedList<Foam::point, 4> > > cellListList(Pstream::nProcs());
+
+    List<FixedList<Foam::point, 4> > cells(number_of_finite_cells());
+
+    globalIndex gIndex(number_of_vertices());
+
+    label count = 0;
+    for
+    (
+        Delaunay::Finite_cells_iterator cit = finite_cells_begin();
+        cit != finite_cells_end();
+        ++cit
+    )
+    {
+        if (tetrahedron(cit).volume() == 0)
+        {
+            Pout<< "ZERO VOLUME TET" << endl;
+            Pout<< cit->info();
+            Pout<< cit->dual();
+        }
+
+        if (cit->hasFarPoint())
+        {
+            continue;
+        }
+
+        List<labelPair> cellVerticesPair(4);
+        List<Foam::point> cellVertices(4);
+
+        for (label vI = 0; vI < 4; ++vI)
+        {
+            cellVerticesPair[vI] = labelPair
+            (
+                cit->vertex(vI)->procIndex(),
+                cit->vertex(vI)->index()
+            );
+            cellVertices[vI] = topoint(cit->vertex(vI)->point());
+        }
+
+        List<Foam::point> cellVerticesOld(cellVertices);
+        labelList oldToNew;
+        sortedOrder(cellVerticesPair, oldToNew);
+        oldToNew = invert(oldToNew.size(), oldToNew);
+        inplaceReorder(oldToNew, cellVerticesPair);
+        inplaceReorder(oldToNew, cellVertices);
+
+//        FixedList<label, 4> globalTetCell
+//        (
+//            cit->globallyOrderedCellVertices(gIndex)
+//        );
+//
+//        FixedList<Point, 4> cellVertices(Point(0,0,0));
+//
+//        forAll(globalTetCell, gvI)
+//        {
+//            label gI = globalTetCell[gvI];
+//
+//            cellVertices[gvI] = cit->vertex(gI)->point();
+//        }
+
+//        if (cit->hasFarPoint())
+//        {
+//            continue;
+//        }
+
+        for (label i = 0; i < 4; ++i)
+        {
+            //cells[count][i] = topoint(cit->vertex(i)->point());
+            cells[count][i] = cellVertices[i];
+        }
+
+        count++;
+    }
+
+    cells.setSize(count);
+
+    cellListList[Pstream::myProcNo()] = cells;
+
+    Pstream::gatherList(cellListList);
+
+    if (Pstream::master())
+    {
+        Info<< "Checking on master processor the cells of each " << nl
+            << "processor point list against the master cell list." << nl
+            << "There are " << cellListList.size() << " processors" << nl
+            << "The size of each processor's cell list is:" << endl;
+
+        forAll(cellListList, cfI)
+        {
+            Info<< "    Proc " << cfI << " has " << cellListList[cfI].size()
+                << " cells" << endl;
+        }
+
+        label nMatches = 0, nMatchFoundDiffOrder = 0;
+
+        forAll(cellListList[0], cmI)
+        {
+            const FixedList<Foam::point, 4>& masterCell = cellListList[0][cmI];
+
+            bool matchFound = false;
+            bool matchFoundDiffOrder = false;
+
+            forAll(cellListList, cpI)
+            {
+                if (cpI == 0)
+                {
+                    continue;
+                }
+
+                forAll(cellListList[cpI], csI)
+                {
+                    const FixedList<Foam::point, 4>& slaveCell
+                        = cellListList[cpI][csI];
+
+                    if (masterCell == slaveCell)
+                    {
+                        matchFound = true;
+                        break;
+                    }
+                    else
+                    {
+                        label samePt = 0;
+
+                        forAll(masterCell, mI)
+                        {
+                            const Foam::point& mPt = masterCell[mI];
+
+                            forAll(slaveCell, sI)
+                            {
+                                const Foam::point& sPt = slaveCell[sI];
+
+                                if (mPt == sPt)
+                                {
+                                    samePt++;
+                                }
+                            }
+                        }
+
+                        if (samePt == 4)
+                        {
+                            matchFoundDiffOrder = true;
+
+                            Pout<< masterCell << nl << slaveCell << endl;
+
+                            break;
+                        }
+                    }
+                }
+            }
+
+            if (matchFound)
+            {
+                nMatches++;
+            }
+
+            if (matchFoundDiffOrder)
+            {
+                nMatchFoundDiffOrder++;
+            }
+        }
+
+        Info<< "Found " << nMatches << " matching cells and "
+            << nMatchFoundDiffOrder << " matching cells with different "
+            << "vertex ordering"<< endl;
+    }
+}
+
+
+void Foam::conformalVoronoiMesh::checkDuals()
+{
+    List<List<Point> > pointFieldList(Pstream::nProcs());
+
+    List<Point> duals(number_of_finite_cells());
+
+    typedef CGAL::Exact_predicates_exact_constructions_kernel       EK2;
+    typedef CGAL::Regular_triangulation_euclidean_traits_3<EK2>     EK;
+    typedef CGAL::Cartesian_converter<typename baseK::Kernel, EK2>  To_exact;
+    typedef CGAL::Cartesian_converter<EK2, typename baseK::Kernel>
+        Back_from_exact;
+
+//    PackedBoolList bPoints(number_of_finite_cells());
+
+//    indexDualVertices(duals, bPoints);
+
+    label count = 0;//duals.size();
+
+    duals.setSize(number_of_finite_cells());
+
+    globalIndex gIndex(number_of_vertices());
+
+    for
+    (
+        Delaunay::Finite_cells_iterator cit = finite_cells_begin();
+        cit != finite_cells_end();
+        ++cit
+    )
+    {
+        if (cit->hasFarPoint())
+        {
+            continue;
+        }
+
+        duals[count++] = cit->circumcenter();
+
+//        List<labelPair> cellVerticesPair(4);
+//        List<Point> cellVertices(4);
+//
+//        for (label vI = 0; vI < 4; ++vI)
+//        {
+//            cellVerticesPair[vI] = labelPair
+//            (
+//                cit->vertex(vI)->procIndex(),
+//                cit->vertex(vI)->index()
+//            );
+//            cellVertices[vI] = cit->vertex(vI)->point();
+//        }
+//
+//        labelList oldToNew;
+//        sortedOrder(cellVerticesPair, oldToNew);
+//        oldToNew = invert(oldToNew.size(), oldToNew);
+//        inplaceReorder(oldToNew, cellVerticesPair);
+//        inplaceReorder(oldToNew, cellVertices);
+//
+//        duals[count++] = CGAL::circumcenter
+//        (
+//            cellVertices[0],
+//            cellVertices[1],
+//            cellVertices[2],
+//            cellVertices[3]
+//        );
+
+//        To_exact to_exact;
+//        Back_from_exact back_from_exact;
+//        EK::Construct_circumcenter_3 exact_circumcenter =
+//            EK().construct_circumcenter_3_object();
+//
+//        duals[count++] = topoint
+//        (
+//            back_from_exact
+//            (
+//                exact_circumcenter
+//                (
+//                    to_exact(cit->vertex(0)->point()),
+//                    to_exact(cit->vertex(1)->point()),
+//                    to_exact(cit->vertex(2)->point()),
+//                    to_exact(cit->vertex(3)->point())
+//                )
+//            )
+//        );
+    }
+
+    Pout<< "Duals Calculated " << count << endl;
+
+    duals.setSize(count);
+
+    pointFieldList[Pstream::myProcNo()] = duals;
+
+    Pstream::gatherList(pointFieldList);
+
+    if (Pstream::master())
+    {
+        Info<< "Checking on master processor the dual locations of each " << nl
+            << "processor point list against the master dual list." << nl
+            << "There are " << pointFieldList.size() << " processors" << nl
+            << "The size of each processor's dual list is:" << endl;
+
+        forAll(pointFieldList, pfI)
+        {
+            Info<< "    Proc " << pfI << " has " << pointFieldList[pfI].size()
+                << " duals" << endl;
+        }
+
+        label nNonMatches = 0;
+        label nNearMatches = 0;
+        label nExactMatches = 0;
+
+        forAll(pointFieldList[0], pI)
+        {
+            const Point& masterPoint = pointFieldList[0][pI];
+
+            bool foundMatch = false;
+            bool foundNearMatch = false;
+
+            scalar minCloseness = GREAT;
+            Point closestPoint(0, 0, 0);
+
+            forAll(pointFieldList, pfI)
+            {
+                if (pfI == 0)
+                {
+                    continue;
+                }
+
+//                label pfI = 1;
+
+                forAll(pointFieldList[pfI], pISlave)
+                {
+                    const Point& slavePoint
+                        = pointFieldList[pfI][pISlave];
+
+                    if (masterPoint == slavePoint)
+                    {
+                        foundMatch = true;
+                        break;
+                    }
+
+                    const scalar closeness = mag
+                    (
+                        topoint(masterPoint) - topoint(slavePoint)
+                    );
+
+                    if (closeness < 1e-12)
+                    {
+                        foundNearMatch = true;
+                    }
+                    else
+                    {
+                        if (closeness < minCloseness)
+                        {
+                            minCloseness = closeness;
+                            closestPoint = slavePoint;
+                        }
+                    }
+                }
+
+                if (!foundMatch)
+                {
+                    if (foundNearMatch)
+                    {
+                        CGAL::Gmpq x(CGAL::to_double(masterPoint.x()));
+                        CGAL::Gmpq y(CGAL::to_double(masterPoint.y()));
+                        CGAL::Gmpq z(CGAL::to_double(masterPoint.z()));
+
+                        std::cout<< "master = " << x << " " << y << " " << z
+                            << std::endl;
+
+                        CGAL::Gmpq xs(CGAL::to_double(closestPoint.x()));
+                        CGAL::Gmpq ys(CGAL::to_double(closestPoint.y()));
+                        CGAL::Gmpq zs(CGAL::to_double(closestPoint.z()));
+                        std::cout<< "slave  = " << xs << " " << ys << " " << zs
+                            << std::endl;
+
+                        nNearMatches++;
+                    }
+                    else
+                    {
+                        nNonMatches++;
+                        Info<< "    Closest point to " << masterPoint << " is "
+                            << closestPoint << nl
+                            << "    Separation is " << minCloseness << endl;
+
+                        CGAL::Gmpq x(CGAL::to_double(masterPoint.x()));
+                        CGAL::Gmpq y(CGAL::to_double(masterPoint.y()));
+                        CGAL::Gmpq z(CGAL::to_double(masterPoint.z()));
+
+                        std::cout<< "master = " << x << " " << y << " " << z
+                                 << endl;
+
+                        CGAL::Gmpq xs(CGAL::to_double(closestPoint.x()));
+                        CGAL::Gmpq ys(CGAL::to_double(closestPoint.y()));
+                        CGAL::Gmpq zs(CGAL::to_double(closestPoint.z()));
+                        std::cout<< "slave  = " << xs << " " << ys << " " << zs
+                                 << endl;
+                    }
+                }
+                else
+                {
+                    nExactMatches++;
+                }
+            }
+        }
+
+        Info<< "Found " << nNonMatches << " non-matching duals" << nl
+            << " and " << nNearMatches << " near matches"
+            << " and " << nExactMatches << " exact matches" << endl;
+    }
+}
+
+
+void Foam::conformalVoronoiMesh::checkVertices()
+{
+    List<pointField> pointFieldList(Pstream::nProcs());
+
+    pointField points(number_of_vertices());
+
+    labelPairHashSet duplicateVertices;
+
+    label count = 0;
+    for
+    (
+        Delaunay::Finite_vertices_iterator vit = finite_vertices_begin();
+        vit != finite_vertices_end();
+        ++vit
+    )
+    {
+        if (duplicateVertices.found(labelPair(vit->procIndex(), vit->index())))
+        {
+            Pout<< "DUPLICATE " << vit->procIndex() << vit->index() << endl;
+        }
+        else
+        {
+            duplicateVertices.insert(labelPair(vit->procIndex(), vit->index()));
+        }
+
+        points[count++] = topoint(vit->point());
+    }
+
+    pointFieldList[Pstream::myProcNo()] = points;
+
+    Pstream::gatherList(pointFieldList);
+
+    OFstream str("missingPoints.obj");
+
+    if (Pstream::master())
+    {
+        Info<< "Checking on master processor the point locations of each " << nl
+            << "processor point list against the master point list." << nl
+            << "There are " << pointFieldList.size() << " processors" << nl
+            << "The size of each processor's point list is:" << endl;
+
+        forAll(pointFieldList, pfI)
+        {
+            Info<< "    Proc " << pfI << " has " << pointFieldList[pfI].size()
+                << " points" << endl;
+        }
+
+        label nNonMatches = 0;
+
+        forAll(pointFieldList[0], pI)
+        {
+            const Foam::point& masterPoint = pointFieldList[0][pI];
+
+            forAll(pointFieldList, pfI)
+            {
+                if (pI == 0)
+                {
+                    continue;
+                }
+
+                bool foundMatch = false;
+
+                forAll(pointFieldList[pfI], pISlave)
+                {
+                    const Foam::point& slavePoint
+                        = pointFieldList[pfI][pISlave];
+
+                    if (masterPoint == slavePoint)
+                    {
+                        foundMatch = true;
+                        break;
+                    }
+                }
+
+                if (!foundMatch)
+                {
+                    Info<< "    Proc " << pfI << " Master != Slave -> "
+                        << masterPoint << endl;
+
+                    meshTools::writeOBJ(str, masterPoint);
+
+                    nNonMatches++;
+                }
+            }
+        }
+
+        Info<< "Found a total of " << nNonMatches << " non-matching points"
+            << endl;
+    }
+}
+
+
 void Foam::conformalVoronoiMesh::calcDualMesh
 (
     pointField& points,
+    labelList& boundaryPts,
     faceList& faces,
     labelList& owner,
     labelList& neighbour,
@@ -44,233 +521,36 @@ void Foam::conformalVoronoiMesh::calcDualMesh
     pointField& cellCentres,
     labelList& cellToDelaunayVertex,
     labelListList& patchToDelaunayVertex,
-    bool filterFaces
+    PackedBoolList& boundaryFacesToRemove
 )
 {
     timeCheck("Start calcDualMesh");
 
+//    if (debug)
+//    {
+//        Pout<< nl << "Perfoming some checks . . ." << nl << nl
+//            << "Total number of vertices = " << number_of_vertices() << nl
+//            << "Total number of cells    = " << number_of_finite_cells()
+//            << endl;
+//
+//        checkVertices();
+//        checkCells();
+//        checkDuals();
+//
+//        Info<< nl << "Finished checks" << nl << endl;
+//    }
+
     setVertexSizeAndAlignment();
 
     timeCheck("After setVertexSizeAndAlignment");
 
-    // Make all filterCount values zero except on cells that are attached
-    // points that are on the parallel interface.  These will not be moved.
-
-    for
-    (
-        Delaunay::Finite_cells_iterator cit = finite_cells_begin();
-        cit != finite_cells_end();
-        ++cit
-    )
-    {
-        if
-        (
-               !cit->vertex(0)->real()
-            || !cit->vertex(1)->real()
-            || !cit->vertex(2)->real()
-            || !cit->vertex(3)->real()
-        )
-        {
-            cit->filterCount() =
-                 cvMeshControls().filterCountSkipThreshold() + 1;
-        }
-        else
-        {
-            cit->filterCount() = 0;
-        }
-    }
-
-    // THIS CODE STOPS ALL FACES NEAR ANY PROCESSOR BOUNDARY BEING FILTERED.
-    for
-    (
-        Delaunay::Finite_vertices_iterator vit = finite_vertices_begin();
-        vit != finite_vertices_end();
-        vit++
-    )
-    {
-        std::list<Cell_handle> cells;
-        incident_cells(vit, std::back_inserter(cells));
-
-        bool hasProcPt = false;
-
-        for
-        (
-            std::list<Cell_handle>::iterator cit = cells.begin();
-            cit != cells.end();
-            ++cit
-        )
-        {
-            // Allow filtering if any vertices are far points. Otherwise faces
-            // with boundary points attached to a cell with a far point will
-            // not be filtered.
-            if
-            (
-                (!(*cit)->vertex(0)->real() && !(*cit)->vertex(0)->farPoint())
-             || (!(*cit)->vertex(1)->real() && !(*cit)->vertex(1)->farPoint())
-             || (!(*cit)->vertex(2)->real() && !(*cit)->vertex(2)->farPoint())
-             || (!(*cit)->vertex(3)->real() && !(*cit)->vertex(3)->farPoint())
-            )
-            {
-                hasProcPt = true;
-
-                break;
-            }
-        }
-
-        if (hasProcPt)
-        {
-            for
-            (
-                std::list<Cell_handle>::iterator cit = cells.begin();
-                cit != cells.end();
-                ++cit
-            )
-            {
-                (*cit)->filterCount() =
-                     cvMeshControls().filterCountSkipThreshold() + 1;
-            }
-        }
-    }
-
-    PackedBoolList boundaryPts(number_of_cells(), false);
-
     indexDualVertices(points, boundaryPts);
 
     {
-        // Ideally requires a no-risk face filtering to get rid of zero area
-        // faces and establish if the mesh can be produced at all to the
-        // specified criteria
-
-        Info<< nl << "Merging close points" << endl;
+        Info<< nl << "Merging identical points" << endl;
 
         // There is no guarantee that a merge of close points is no-risk
-        mergeCloseDualVertices(points, boundaryPts);
-    }
-
-    timeCheck("After initial close point merge");
-
-    if (filterFaces)
-    {
-        label nInitialBadQualityFaces = checkPolyMeshQuality(points).size();
-
-        reduce(nInitialBadQualityFaces, sumOp<label>());
-
-        Info<< nl << "Initial check before face collapse, found "
-            << nInitialBadQualityFaces << " bad quality faces"
-            << endl;
-
-        HashSet<labelPair, labelPair::Hash<> > deferredCollapseFaces;
-
-        if (nInitialBadQualityFaces > 0)
-        {
-            Info<< nl
-                << "A mesh could not be produced to satisfy the specified "
-                << "quality criteria." << nl
-                << "The quality and the surface conformation controls "
-                << "can be altered and the " << nl
-                << "internalDelaunayVertices read in to try again, or more "
-                << "cell size resolution " << nl
-                << "and motion iterations can be applied in areas where "
-                << "problems are occurring."
-                << endl;
-        }
-
-        if
-        (
-            nInitialBadQualityFaces == 0
-         || cvMeshControls().continueFilteringOnBadInitialPolyMesh()
-        )
-        {
-            label nBadQualityFaces = 0;
-
-            labelHashSet lastWrongFaces;
-
-            label nConsecutiveEqualFaceSets = 0;
-
-            do
-            {
-                // Reindexing the Delaunay cells and regenerating the
-                // points resets the mesh to the starting condition.
-
-                indexDualVertices(points, boundaryPts);
-
-                {
-                    Info<< nl << "Merging close points" << endl;
-
-                    mergeCloseDualVertices(points, boundaryPts);
-                }
-
-                {
-                    // Risky and undo-able face filtering to reduce
-                    // the face count as much as possible, staying
-                    // within the specified criteria
-
-                    Info<< nl << "Smoothing surface" << endl;
-
-                    smoothSurface(points, boundaryPts);
-
-                    Info<< nl << "Collapsing unnecessary faces" << endl;
-
-                    collapseFaces(points, boundaryPts, deferredCollapseFaces);
-
-                    const scalar maxCosAngle
-                        = cos(degToRad(cvMeshControls().edgeMergeAngle()));
-
-                    Info<< nl << "Merging adjacent edges which have an angle "
-                        << "of greater than "
-                        << cvMeshControls().edgeMergeAngle() << ": " << endl;
-
-                    label nRemovedEdges =
-                        mergeNearlyParallelEdges(points, maxCosAngle);
-
-                    reduce(nRemovedEdges, sumOp<label>());
-
-                    Info<< "    Merged " << nRemovedEdges << " edges" << endl;
-                }
-
-                labelHashSet wrongFaces = checkPolyMeshQuality(points);
-
-                nBadQualityFaces = wrongFaces.size();
-
-                reduce(nBadQualityFaces, sumOp<label>());
-
-                Info<< nl << "Found " << nBadQualityFaces
-                    << " bad quality faces" << endl;
-
-                bool sameFacesAsLastTime(lastWrongFaces == wrongFaces);
-
-                reduce(sameFacesAsLastTime, andOp<bool>());
-
-                if (sameFacesAsLastTime)
-                {
-                    Info<< nl << "Consecutive iterations found the same set "
-                        << "of bad quality faces." << endl;
-
-                    if
-                    (
-                        ++nConsecutiveEqualFaceSets
-                     >= cvMeshControls().maxConsecutiveEqualFaceSets()
-                    )
-                    {
-                        Info<< nl << nConsecutiveEqualFaceSets
-                            << " consecutive iterations produced the same "
-                            << "bad quality faceSet, stopping filtering"
-                            << endl;
-
-                        break;
-                    }
-                }
-                else
-                {
-                    nConsecutiveEqualFaceSets = 0;
-
-                    lastWrongFaces = wrongFaces;
-                }
-
-                timeCheck("End of filtering iteration");
-
-            } while (nBadQualityFaces > 0); //nInitialBadQualityFaces);
-        }
+        mergeIdenticalDualVertices(points, boundaryPts);
     }
 
     // Final dual face and owner neighbour construction
@@ -288,6 +568,7 @@ void Foam::conformalVoronoiMesh::calcDualMesh
         patchStarts,
         procNeighbours,
         patchToDelaunayVertex,  // from patch face to Delaunay vertex (slavePp)
+        boundaryFacesToRemove,
         false
     );
 
@@ -299,7 +580,7 @@ void Foam::conformalVoronoiMesh::calcDualMesh
 
     cellCentres = pointField(cellCentres, cellToDelaunayVertex);
 
-    removeUnusedPoints(faces, points);
+    removeUnusedPoints(faces, points, boundaryPts);
 
     timeCheck("End of calcDualMesh");
 }
@@ -332,7 +613,7 @@ void Foam::conformalVoronoiMesh::calcTetMesh
         ++vit
     )
     {
-        if (vit->internalPoint() || vit->pairPoint())
+        if (vit->internalPoint() || vit->boundaryPoint())
         {
             vertexMap[vit->index()] = vertI;
             points[vertI] = topoint(vit->point());
@@ -376,11 +657,11 @@ void Foam::conformalVoronoiMesh::calcTetMesh
 
     List<DynamicList<label> > patchOwners(nPatches, DynamicList<label>(0));
 
-    faces.setSize(number_of_facets());
+    faces.setSize(number_of_finite_facets());
 
-    owner.setSize(number_of_facets());
+    owner.setSize(number_of_finite_facets());
 
-    neighbour.setSize(number_of_facets());
+    neighbour.setSize(number_of_finite_facets());
 
     label faceI = 0;
 
@@ -399,7 +680,7 @@ void Foam::conformalVoronoiMesh::calcTetMesh
         const int oppositeVertex = fit->second;
         const Cell_handle c2(c1->neighbor(oppositeVertex));
 
-        if (c1->farCell() && c2->farCell())
+        if (c1->hasFarPoint() && c2->hasFarPoint())
         {
             // Both tets are outside, skip
             continue;
@@ -421,10 +702,10 @@ void Foam::conformalVoronoiMesh::calcTetMesh
 
         newFace = face(verticesOnTriFace);
 
-        if (c1->farCell() || c2->farCell())
+        if (c1->hasFarPoint() || c2->hasFarPoint())
         {
             // Boundary face...
-            if (c1->farCell())
+            if (c1->hasFarPoint())
             {
                 //... with c1 outside
                 ownerCell = c2I;
@@ -490,23 +771,23 @@ void Foam::conformalVoronoiMesh::calcTetMesh
 
     sortFaces(faces, owner, neighbour);
 
-    addPatches
-    (
-        nInternalFaces,
-        faces,
-        owner,
-        patchSizes,
-        patchStarts,
-        patchFaces,
-        patchOwners
-    );
+//    addPatches
+//    (
+//        nInternalFaces,
+//        faces,
+//        owner,
+//        patchSizes,
+//        patchStarts,
+//        patchFaces,
+//        patchOwners
+//    );
 }
 
 
-void Foam::conformalVoronoiMesh::mergeCloseDualVertices
+void Foam::conformalVoronoiMesh::mergeIdenticalDualVertices
 (
     const pointField& pts,
-    const PackedBoolList& boundaryPts
+    const labelList& boundaryPts
 )
 {
     // Assess close points to be merged
@@ -518,18 +799,13 @@ void Foam::conformalVoronoiMesh::mergeCloseDualVertices
     {
         Map<label> dualPtIndexMap;
 
-        nPtsMerged = mergeCloseDualVertices
+        nPtsMerged = mergeIdenticalDualVertices
         (
             pts,
             boundaryPts,
             dualPtIndexMap
         );
 
-        // if (nPtsMerged > 0)
-        // {
-        //     Pout<< "    Merged " << nPtsMerged << " points " << endl;
-        // }
-
         reindexDualVertices(dualPtIndexMap);
 
         reduce(nPtsMerged, sumOp<label>());
@@ -545,30 +821,15 @@ void Foam::conformalVoronoiMesh::mergeCloseDualVertices
 }
 
 
-Foam::label Foam::conformalVoronoiMesh::mergeCloseDualVertices
+Foam::label Foam::conformalVoronoiMesh::mergeIdenticalDualVertices
 (
     const pointField& pts,
-    const PackedBoolList& boundaryPts,
+    const labelList& boundaryPts,
     Map<label>& dualPtIndexMap
 ) const
 {
     label nPtsMerged = 0;
 
-    label nIdentical = 0;
-    label nProcEdge = 0;
-
-    // Relative distance for points to be merged
-    scalar closenessTolerance = cvMeshControls().mergeClosenessCoeff();
-
-    // Absolute distance for points to be considered coincident. Bit adhoc
-    // but points were seen with distSqr ~ 1e-30 which is SMALL^2. Add a few
-    // digits to account for truncation errors.
-    scalar coincidentDistanceSqr = sqr
-    (
-        SMALL*1E2*geometryToConformTo_.globalBounds().mag()
-    );
-
-
     for
     (
         Delaunay::Finite_facets_iterator fit = finite_facets_begin();
@@ -580,84 +841,41 @@ Foam::label Foam::conformalVoronoiMesh::mergeCloseDualVertices
         const int oppositeVertex = fit->second;
         const Cell_handle c2(c1->neighbor(oppositeVertex));
 
-        label& c1I = c1->cellIndex();
-        label& c2I = c2->cellIndex();
-
-        if (dualPtIndexMap.found(c1I) || dualPtIndexMap.found(c2I))
+        if (is_infinite(c1) || is_infinite(c2))
         {
-            // One of the points of this edge has already been
-            // merged this sweep, leave for next sweep
-
             continue;
         }
 
-        if ((c1I != c2I) && !c1->farCell() && !c2->farCell())
+        label& c1I = c1->cellIndex();
+        label& c2I = c2->cellIndex();
+
+        if ((c1I != c2I) && !c1->hasFarPoint() && !c2->hasFarPoint())
         {
-            scalar distSqr = magSqr(pts[c1I] - pts[c2I]);
+            const Foam::point& p1 = pts[c1I];
+            const Foam::point& p2 = pts[c2I];
 
-            if (pts[c1I] == pts[c2I] || distSqr < coincidentDistanceSqr)
+            if (p1 == p2)
             {
-                nIdentical++;
-
-                if (boundaryPts[c2I] == true)
-                {
-                    // If c2I is a boundary point, then it is kept.
-                    // If both are boundary points then c2I is chosen
-                    // arbitrarily to be kept.
-
-                    dualPtIndexMap.insert(c1I, c2I);
-                    dualPtIndexMap.insert(c2I, c2I);
-                    nPtsMerged++;
-                }
-                else
+                if (c1I < c2I)
                 {
                     dualPtIndexMap.insert(c1I, c1I);
                     dualPtIndexMap.insert(c2I, c1I);
-                    nPtsMerged++;
-                }
-
-            }
-            else if (distSqr < sqr(averageAnyCellSize(fit)*closenessTolerance))
-            {
-                if (c1->parallelDualVertex() || c2->parallelDualVertex())
-                //if (isParallelDualEdge(fit))
-                {
-                    // Skip if face uses any edge that becomes a processor
-                    // dual face.
-                    // Note: the real test should be whether the Delaunay edge
-                    //  will form a processor patch.
-                    nProcEdge++;
-                }
-                else if (boundaryPts[c2I] == true)
-                {
-                    // If c2I is a boundary point, then it is kept.
-                    // If both are boundary points then c2I is chosen
-                    // arbitrarily to be kept.
-
-                    dualPtIndexMap.insert(c1I, c2I);
-                    dualPtIndexMap.insert(c2I, c2I);
-                    nPtsMerged++;
                 }
                 else
                 {
-                    dualPtIndexMap.insert(c1I, c1I);
-                    dualPtIndexMap.insert(c2I, c1I);
-                    nPtsMerged++;
+                    dualPtIndexMap.insert(c1I, c2I);
+                    dualPtIndexMap.insert(c2I, c2I);
                 }
+
+                nPtsMerged++;
             }
         }
     }
 
     if (debug)
     {
-        Info<< "mergeCloseDualVertices:"
-            << " coincident distance:" << coincidentDistanceSqr
-            << " closenessTolerance:" << closenessTolerance << endl
-            << "    zero-length edges         : "
-            << returnReduce(nIdentical, sumOp<label>()) << endl
-            << "    protected processor edges : "
-            << returnReduce(nProcEdge, sumOp<label>()) << endl
-            << "    collapsed edges           : "
+        Info<< "mergeIdenticalDualVertices:" << endl
+            << "    zero-length edges     : "
             << returnReduce(nPtsMerged, sumOp<label>()) << endl
             << endl;
     }
@@ -666,1172 +884,267 @@ Foam::label Foam::conformalVoronoiMesh::mergeCloseDualVertices
 }
 
 
-Foam::label Foam::conformalVoronoiMesh::mergeNearlyParallelEdges
-(
-    const pointField& pts,
-    const scalar maxCosAngle
-)
-{
-    List<HashSet<label> > pointFaceCount(number_of_cells());
-    labelList pointNeighbour(number_of_cells(), -1);
-
-    Map<label> dualPtIndexMap;
-
-    for
-    (
-        Delaunay::Finite_edges_iterator eit = finite_edges_begin();
-        eit != finite_edges_end();
-        ++eit
-    )
-    {
-        Cell_handle c = eit->first;
-        Vertex_handle vA = c->vertex(eit->second);
-        Vertex_handle vB = c->vertex(eit->third);
-
-        if (isBoundaryDualFace(eit))
-        {
-            const face f = buildDualFace(eit);
-
-            forAll(f, pI)
-            {
-                const label pIndex = f[pI];
-
-                const label prevPointI = f.prevLabel(pI);
-                const label nextPointI = f.nextLabel(pI);
-
-                pointFaceCount[pIndex].insert(prevPointI);
-                pointFaceCount[pIndex].insert(nextPointI);
-                pointNeighbour[pIndex] = nextPointI;
-            }
-        }
-        else if
-        (
-            vA->internalOrBoundaryPoint()
-         || vB->internalOrBoundaryPoint()
-        )
-        {
-            const face f = buildDualFace(eit);
-            const boolList faceBoundaryPoints = dualFaceBoundaryPoints(eit);
-
-            forAll(f, pI)
-            {
-                const label pIndex = f[pI];
-
-                const label prevPointI = f.prevLabel(pI);
-                const label nextPointI = f.nextLabel(pI);
-
-                pointFaceCount[pIndex].insert(prevPointI);
-                pointFaceCount[pIndex].insert(nextPointI);
-
-                if (faceBoundaryPoints[pI] == false)
-                {
-                    pointNeighbour[pIndex] = nextPointI;
-                }
-                else
-                {
-                    if (faceBoundaryPoints[prevPointI] == true)
-                    {
-                        pointNeighbour[pIndex] = prevPointI;
-                    }
-                    else if (faceBoundaryPoints[nextPointI] == true)
-                    {
-                        pointNeighbour[pIndex] = nextPointI;
-                    }
-                    else
-                    {
-                        pointNeighbour[pIndex] = pIndex;
-                    }
-                }
-            }
-        }
-    }
-
-    forAll(pointFaceCount, pI)
-    {
-        if (pointFaceCount[pI].size() == 2)
-        {
-            List<vector> edges(2, vector(0, 0, 0));
-
-            label count = 0;
-            forAllConstIter(HashSet<label>, pointFaceCount[pI], iter)
-            {
-                edges[count] = pts[pI] - pts[iter.key()];
-                edges[count] /= mag(edges[count]) + VSMALL;
-                count++;
-            }
-
-            if (mag(edges[0] & edges[1]) > maxCosAngle)
-            {
-                dualPtIndexMap.insert(pI, pointNeighbour[pI]);
-            }
-        }
-    }
-
-    reindexDualVertices(dualPtIndexMap);
-
-    return dualPtIndexMap.size();
-}
-
-
-void Foam::conformalVoronoiMesh::smoothSurface
-(
-    pointField& pts,
-    const PackedBoolList& boundaryPts
-)
-{
-    label nCollapsedFaces = 0;
-
-    label iterI = 0;
-
-    do
-    {
-        Map<label> dualPtIndexMap;
-
-        nCollapsedFaces = smoothSurfaceDualFaces
-        (
-            pts,
-            boundaryPts,
-            dualPtIndexMap
-        );
-
-        reduce(nCollapsedFaces, sumOp<label>());
-
-        reindexDualVertices(dualPtIndexMap);
-
-        mergeCloseDualVertices(pts, boundaryPts);
-
-        if (nCollapsedFaces > 0)
-        {
-            Info<< "    Collapsed " << nCollapsedFaces << " boundary faces"
-                << endl;
-        }
-
-        if (++iterI > cvMeshControls().maxCollapseIterations())
-        {
-            Info<< "    maxCollapseIterations reached, stopping collapse"
-                << endl;
-
-            break;
-        }
-
-    } while (nCollapsedFaces > 0);
-
-    // Force all points of boundary faces to be on the surface
-    for
-    (
-        Delaunay::Finite_cells_iterator cit = finite_cells_begin();
-        cit != finite_cells_end();
-        ++cit
-    )
-    {
-        label ptI = cit->cellIndex();
-
-        label fC = cit->filterCount();
-
-        if (fC > cvMeshControls().filterCountSkipThreshold())
-        {
-            // This vertex has been limited too many times, skip
-            continue;
-        }
-
-        // Only cells with indices > -1 are valid
-        if (ptI > -1)
-        {
-            if (boundaryPts[ptI] == true)
-            {
-                Foam::point& pt = pts[ptI];
-
-                pointIndexHit surfHit;
-                label hitSurface;
-
-                geometryToConformTo_.findSurfaceNearest
-                (
-                    pt,
-                    sqr(GREAT),
-                    surfHit,
-                    hitSurface
-                );
-
-                if (surfHit.hit())
-                {
-                    pt +=
-                        (surfHit.hitPoint() - pt)
-                       *pow(cvMeshControls().filterErrorReductionCoeff(), fC);
-                }
-            }
-        }
-    }
-
-    mergeCloseDualVertices(pts, boundaryPts);
-}
-
-
-Foam::label Foam::conformalVoronoiMesh::smoothSurfaceDualFaces
-(
-    pointField& pts,
-    const PackedBoolList& boundaryPts,
-    Map<label>& dualPtIndexMap
-) const
-{
-    label nCollapsedFaces = 0;
-
-    const scalar cosPerpendicularToleranceAngle = cos
-    (
-        degToRad(cvMeshControls().surfaceStepFaceAngle())
-    );
-
-    for
-    (
-        Delaunay::Finite_edges_iterator eit = finite_edges_begin();
-        eit != finite_edges_end();
-        ++eit
-    )
-    {
-        Cell_circulator ccStart = incident_cells(*eit);
-        Cell_circulator cc = ccStart;
-
-        bool skipFace = false;
-
-        do
-        {
-            if (dualPtIndexMap.found(cc->cellIndex()))
-            {
-                // One of the points of this face has already been
-                // collapsed this sweep, leave for next sweep
-
-                skipFace = true;
-
-                break;
-            }
-
-        } while (++cc != ccStart);
-
-        if (skipFace)
-        {
-            continue;
-        }
-
-        if (isBoundaryDualFace(eit))
-        {
-            face dualFace = buildDualFace(eit);
-
-            if (dualFace.size() < 3)
-            {
-                // This face has been collapsed already
-                continue;
-            }
-
-            label maxFC = maxFilterCount(eit);
-
-            if (maxFC > cvMeshControls().filterCountSkipThreshold())
-            {
-                // A vertex on this face has been limited too many
-                // times, skip
-                continue;
-            }
-
-            pointIndexHit surfHit;
-            label hitSurface;
-
-            geometryToConformTo_.findSurfaceNearest
-            (
-                dualFace.centre(pts),
-                sqr(GREAT),
-                surfHit,
-                hitSurface
-            );
-
-            vectorField norm(1);
-
-            allGeometry_[hitSurface].getNormal
-            (
-                List<pointIndexHit>(1, surfHit),
-                norm
-            );
-
-            const vector& surfaceNormal = norm[0];
-
-            // Orient the face correctly before calculating the normal
-
-            Cell_handle c = eit->first;
-            Vertex_handle vA = c->vertex(eit->second);
-            Vertex_handle vB = c->vertex(eit->third);
-
-            if (!vA->internalOrBoundaryPoint())
-            {
-                reverse(dualFace);
-            }
-
-            vector faceNormal = dualFace.normal(pts);
-
-            if (mag(faceNormal) < VSMALL)
-            {
-                // If the face is essentially zero area, then force it
-                // to be collapsed by making the dot product result -1
-                faceNormal = -surfaceNormal;
-            }
-            else
-            {
-                faceNormal /= mag(faceNormal);
-            }
-
-            if ((faceNormal & surfaceNormal) < cosPerpendicularToleranceAngle)
-            {
-                scalar targetFaceSize = averageAnyCellSize(vA, vB);
-
-                // Selecting faces to collapse based on angle to
-                // surface, so set collapseSizeLimitCoeff to GREAT to
-                // allow collapse of all faces
-
-                faceCollapseMode mode = collapseFace
-                (
-                    dualFace,
-                    pts,
-                    boundaryPts,
-                    dualPtIndexMap,
-                    targetFaceSize,
-                    GREAT,
-                    maxFC
-                );
-
-                if (mode == fcmPoint || mode == fcmEdge)
-                {
-                    nCollapsedFaces++;
-                }
-            }
-        }
-    }
-
-    return nCollapsedFaces;
-}
-
-
-void Foam::conformalVoronoiMesh::collapseFaces
-(
-    pointField& pts,
-    const PackedBoolList& boundaryPts,
-    HashSet<labelPair, labelPair::Hash<> >& deferredCollapseFaces
-)
-{
-    label nCollapsedFaces = 0;
-
-    label iterI = 0;
-
-    do
-    {
-        Map<label> dualPtIndexMap;
-
-        deferredCollapseFaces.clear();
-
-        nCollapsedFaces = collapseFaces
-        (
-            pts,
-            boundaryPts,
-            dualPtIndexMap,
-            deferredCollapseFaces
-        );
-
-        reduce(nCollapsedFaces, sumOp<label>());
-
-        reindexDualVertices(dualPtIndexMap);
-
-        mergeCloseDualVertices(pts, boundaryPts);
-
-
-        if (nCollapsedFaces > 0)
-        {
-            Info<< "    Collapsed " << nCollapsedFaces << " faces" << endl;
-            // Info<< "dualPtIndexMap" << nl << dualPtIndexMap << endl;
-        }
-
-        if (++iterI > cvMeshControls().maxCollapseIterations())
-        {
-            Info<< nl << "maxCollapseIterations reached, stopping collapse"
-                << endl;
-
-            break;
-        }
-
-    } while (nCollapsedFaces > 0);
-
-}
-
-
-Foam::label Foam::conformalVoronoiMesh::collapseFaces
-(
-    pointField& pts,
-    const PackedBoolList& boundaryPts,
-    Map<label>& dualPtIndexMap,
-    HashSet<labelPair, labelPair::Hash<> >& deferredCollapseFaces
-) const
-{
-    label nCollapsedFaces = 0;
-
-    scalar collapseSizeLimitCoeff = cvMeshControls().filterSizeCoeff();
-
-    for
-    (
-        Delaunay::Finite_edges_iterator eit = finite_edges_begin();
-        eit != finite_edges_end();
-        ++eit
-    )
-    {
-        Cell_circulator ccStart = incident_cells(*eit);
-        Cell_circulator cc = ccStart;
-
-        bool skipFace = false;
-
-        do
-        {
-            if (dualPtIndexMap.found(cc->cellIndex()))
-            {
-                // One of the points of this face has already been
-                // collapsed this sweep, leave for next sweep
-
-                skipFace = true;
-
-                break;
-            }
-
-        } while (++cc != ccStart);
-
-        if (skipFace)
-        {
-            continue;
-        }
-
-        Cell_handle c = eit->first;
-        Vertex_handle vA = c->vertex(eit->second);
-        Vertex_handle vB = c->vertex(eit->third);
-
-        if
-        (
-            vA->internalOrBoundaryPoint()
-         || vB->internalOrBoundaryPoint()
-        )
-        {
-            face dualFace = buildDualFace(eit);
-
-            if (dualFace.size() < 3)
-            {
-                continue;
-            }
-
-            label maxFC = maxFilterCount(eit);
-
-            if (maxFC > cvMeshControls().filterCountSkipThreshold())
-            {
-                continue;
-            }
-
-            scalar targetFaceSize = averageAnyCellSize(vA, vB);
-
-            faceCollapseMode mode = collapseFace
-            (
-                dualFace,
-                pts,
-                boundaryPts,
-                dualPtIndexMap,
-                targetFaceSize,
-                collapseSizeLimitCoeff,
-                maxFC
-            );
-
-            if (mode != fcmNone)
-            {
-                if (mode == fcmDeferredMultiEdge)
-                {
-                    // Determine the owner and neighbour labels
-
-                    Pair<label> ownAndNei(-1, -1);
-
-                    ownerAndNeighbour
-                    (
-                        vA,
-                        vB,
-                        ownAndNei.first(),
-                        ownAndNei.second()
-                    );
-
-                    // Record the owner and neighbour of this face for a
-                    // deferredMultiEdge collapse
-
-                    deferredCollapseFaces.insert(ownAndNei);
-                }
-                else
-                {
-                    nCollapsedFaces++;
-                }
-            }
-        }
-    }
-
-    return nCollapsedFaces;
-}
-
-
-Foam::conformalVoronoiMesh::faceCollapseMode
-Foam::conformalVoronoiMesh::collapseFace
-(
-    const face& f,
-    pointField& pts,
-    const PackedBoolList& boundaryPts,
-    Map<label>& dualPtIndexMap,
-    scalar targetFaceSize,
-    scalar collapseSizeLimitCoeff,
-    label maxFC
-) const
-{
-    bool limitToQuadsOrTris = false;
-
-    bool allowEarlyCollapseToPoint = true;
-
-
-//    // Quick exit
-//    label smallEdges = 0;
-//    const edgeList& fEdges = f.edges();
-//    forAll(fEdges, eI)
-//    {
-//        const edge& e = fEdges[eI];
+//void Foam::conformalVoronoiMesh::smoothSurface
+//(
+//    pointField& pts,
+//    const labelList& boundaryPts
+//)
+//{
+//    label nCollapsedFaces = 0;
 //
-//        if (e.mag(pts) < 0.2*targetFaceSize)
+//    label iterI = 0;
+//
+//    do
+//    {
+//        Map<label> dualPtIndexMap;
+//
+//        nCollapsedFaces = smoothSurfaceDualFaces
+//        (
+//            pts,
+//            boundaryPts,
+//            dualPtIndexMap
+//        );
+//
+//        reduce(nCollapsedFaces, sumOp<label>());
+//
+//        reindexDualVertices(dualPtIndexMap);
+//
+//        mergeIdenticalDualVertices(pts, boundaryPts);
+//
+//        if (nCollapsedFaces > 0)
 //        {
-//            smallEdges++;
+//            Info<< "    Collapsed " << nCollapsedFaces << " boundary faces"
+//                << endl;
 //        }
-//    }
-//    if (smallEdges == 0)
-//    {
-//        return fcmNone;
-//    }
-
-
-    // if (maxFC > cvMeshControls().filterCountSkipThreshold() - 3)
-    // {
-    //     limitToQuadsOrTris = true;
-
-    //     allowEarlyCollapseToPoint = false;
-    // }
-
-
-    collapseSizeLimitCoeff *= pow
-    (
-        cvMeshControls().filterErrorReductionCoeff(),
-        maxFC
-    );
-
-    labelList facePts(f);
-
-    const Foam::point fC = f.centre(pts);
-
-    vector fN = f.normal(pts);
-
-    const scalar fA = mag(fN);
-
-    tensor J = f.inertia(pts, fC);
-
-    // Find the dominant collapse direction by finding the eigenvector
-    // that corresponds to the normal direction, discarding it.  The
-    // eigenvector corresponding to the smaller of the two remaining
-    // eigenvalues is the dominant axis in a high aspect ratio face.
-
-    scalar magJ = mag(J);
-
-    scalar detJ = SMALL;
-
-    if (magJ > VSMALL)
-    {
-        // Normalise inertia tensor to remove problems with small values
-
-        J /= mag(J);
-        // J /= cmptMax(J);
-        // J /= max(eigenValues(J).x(), SMALL);
-
-        // Calculating determinant, including stabilisation for zero or
-        // small negative values
-
-        detJ = max(det(J), SMALL);
-    }
-
-    vector collapseAxis = vector::zero;
-
-    scalar aspectRatio = 1.0;
-
-    if (detJ < 1e-5)
-    {
-        collapseAxis = f.edges()[longestEdge(f, pts)].vec(pts);
-
-        collapseAxis /= mag(collapseAxis);
-
-        // Empirical correlation for high aspect ratio faces
-
-        aspectRatio = sqrt(0.35/detJ);
-    }
-    else
-    {
-        vector eVals = eigenValues(J);
-
-        if (mag(eVals.y() - eVals.x()) < 100*SMALL)
-        {
-            // First two eigenvalues are the same: i.e. a square face
-
-            // Cannot necessarily determine linearly independent
-            // eigenvectors, or any at all, use longest edge direction.
-
-            collapseAxis = f.edges()[longestEdge(f, pts)].vec(pts);
-
-            collapseAxis /= mag(collapseAxis);
-
-            aspectRatio = 1.0;
-        }
-        else
-        {
-            // The maximum eigenvalue (z()) must be the direction of the
-            // normal, as it has the greatest value.  The minimum eigenvalue
-            // is the dominant collapse axis for high aspect ratio faces.
-
-            collapseAxis = eigenVector(J, eVals.x());
-
-            // The inertia calculation describes the mass distribution as a
-            // function of distance squared to the axis, so the square root of
-            // the ratio of face-plane moments gives a good indication of the
-            // aspect ratio.
-
-            aspectRatio = sqrt(eVals.y()/max(eVals.x(), SMALL));
-        }
-    }
-
-
-    scalar maxDist = 0;
-    scalar minDist = GREAT;
 //
-//    if (f.size() <= 3)
-//    {
-//        const edgeList& fEdges = f.edges();
-//
-//        forAll(fEdges, eI)
+//        if (++iterI > cvMeshControls().maxCollapseIterations())
 //        {
-//            const edge& e = fEdges[eI];
-//            const scalar d = e.mag(pts);
+//            Info<< "    maxCollapseIterations reached, stopping collapse"
+//                << endl;
 //
-//            if (d > maxDist)
-//            {
-//                maxDist = d;
-//                collapseAxis = e.vec(pts);
-//            }
-//            else if (d < minDist && d != 0)
-//            {
-//                minDist = d;
-//            }
+//            break;
 //        }
-//    }
-//    else
+//
+//    } while (nCollapsedFaces > 0);
+//
+//    // Force all points of boundary faces to be on the surface
+////    for
+////    (
+////        Delaunay::Finite_cells_iterator cit = finite_cells_begin();
+////        cit != finite_cells_end();
+////        ++cit
+////    )
+////    {
+////        label ptI = cit->cellIndex();
+////
+////        label fC = cit->filterCount();
+////
+////        if (fC > cvMeshControls().filterCountSkipThreshold())
+////        {
+////            // This vertex has been limited too many times, skip
+////            continue;
+////        }
+////
+////        // Only cells with indices > -1 are valid
+////        if (ptI > -1)
+////        {
+////            if (boundaryPts[ptI] != -1)
+////            {
+////                Foam::point& pt = pts[ptI];
+////
+////                pointIndexHit surfHit;
+////                label hitSurface;
+////
+////                geometryToConformTo_.findSurfaceNearest
+////                (
+////                    pt,
+////                    sqr(GREAT),
+////                    surfHit,
+////                    hitSurface
+////                );
+////
+////                if (surfHit.hit())
+////                {
+////                    pt += (surfHit.hitPoint() - pt)
+////                         *pow
+////                          (
+////                              cvMeshControls().filterErrorReductionCoeff(),
+////                              fC
+////                          );
+////                }
+////            }
+////        }
+////    }
+////
+////    mergeCloseDualVertices(pts, boundaryPts);
+//}
+//
+//
+//Foam::label Foam::conformalVoronoiMesh::smoothSurfaceDualFaces
+//(
+//    pointField& pts,
+//    const labelList& boundaryPts,
+//    Map<label>& dualPtIndexMap
+//) const
+//{
+//    label nCollapsedFaces = 0;
+//
+//    const scalar cosPerpendicularToleranceAngle = cos
+//    (
+//        degToRad(cvMeshControls().surfaceStepFaceAngle())
+//    );
+//
+//    for
+//    (
+//        Delaunay::Finite_edges_iterator eit = finite_edges_begin();
+//        eit != finite_edges_end();
+//        ++eit
+//    )
 //    {
-//        forAll(f, pI)
+//        Cell_circulator ccStart = incident_cells(*eit);
+//        Cell_circulator cc = ccStart;
+//
+//        bool skipFace = false;
+//
+//        do
 //        {
-//            for (label i = pI + 1; i < f.size(); ++i)
+//            if (dualPtIndexMap.found(cc->cellIndex()))
 //            {
-//                if
+//                // One of the points of this face has already been
+//                // collapsed this sweep, leave for next sweep
+//
+//                skipFace = true;
+//
+//                break;
+//            }
+//
+//        } while (++cc != ccStart);
+//
+//        if (skipFace)
+//        {
+//            continue;
+//        }
+//
+//        if (isBoundaryDualFace(eit))
+//        {
+//            face dualFace = buildDualFace(eit);
+//
+//            if (dualFace.size() < 3)
+//            {
+//                // This face has been collapsed already
+//                continue;
+//            }
+//
+//            label maxFC = maxFilterCount(eit);
+//
+//            if (maxFC > cvMeshControls().filterCountSkipThreshold())
+//            {
+//                // A vertex on this face has been limited too many
+//                // times, skip
+//                continue;
+//            }
+//
+//            Cell_handle c = eit->first;
+//            Vertex_handle vA = c->vertex(eit->second);
+//            Vertex_handle vB = c->vertex(eit->third);
+//
+//            if
+//            (
+//                vA->internalBoundaryPoint() && vA->surfacePoint()
+//             && vB->externalBoundaryPoint() && vB->surfacePoint()
+//            )
+//            {
+//                if (vA->index() == vB->index() - 1)
+//                {
+//                    continue;
+//                }
+//            }
+//            else if
+//            (
+//                vA->externalBoundaryPoint() && vA->surfacePoint()
+//             && vB->internalBoundaryPoint() && vB->surfacePoint()
+//            )
+//            {
+//                if (vA->index() == vB->index() + 1)
+//                {
+//                    continue;
+//                }
+//            }
+////            else if
+////            (
+////                vA->internalBoundaryPoint() && vA->featureEdgePoint()
+////             && vB->externalBoundaryPoint() && vB->featureEdgePoint()
+////            )
+////            {
+////                if (vA->index() == vB->index() - 1)
+////                {
+////                    continue;
+////                }
+////            }
+////            else if
+////            (
+////                vA->externalBoundaryPoint() && vA->featureEdgePoint()
+////             && vB->internalBoundaryPoint() && vB->featureEdgePoint()
+////            )
+////            {
+////                if (vA->index() == vB->index() + 1)
+////                {
+////                    continue;
+////                }
+////            }
+////            else if
+////            (
+////                vA->internalBoundaryPoint() && vA->featurePoint()
+////             && vB->externalBoundaryPoint() && vB->featurePoint()
+////            )
+////            {
+////                if (vA->index() == vB->index() - 1)
+////                {
+////                    continue;
+////                }
+////            }
+////            else if
+////            (
+////                vA->externalBoundaryPoint() && vA->featurePoint()
+////             && vB->internalBoundaryPoint() && vB->featurePoint()
+////            )
+////            {
+////                if (vA->index() == vB->index() + 1)
+////                {
+////                    continue;
+////                }
+////            }
+//
+//
+//            if ((faceNormal & surfaceNormal) < cosPerpendicularToleranceAngle)
+//            {
+//                scalar targetFaceSize = averageAnyCellSize(vA, vB);
+//
+//                // Selecting faces to collapse based on angle to
+//                // surface, so set collapseSizeLimitCoeff to GREAT to
+//                // allow collapse of all faces
+//
+//                faceCollapseMode mode = collapseFace
 //                (
-//                    f[i] != f.nextLabel(pI)
-//                 && f[i] != f.prevLabel(pI)
-//                )
-//                {
-//                    scalar d = mag(pts[f[pI]] - pts[f[i]]);
+//                    dualFace,
+//                    pts,
+//                    boundaryPts,
+//                    dualPtIndexMap,
+//                    targetFaceSize,
+//                    GREAT,
+//                    maxFC
+//                );
 //
-//                    if (d > maxDist)
-//                    {
-//                        maxDist = d;
-//                        collapseAxis = pts[f[pI]] - pts[f[i]];
-//                    }
-//                    else if (d < minDist && d != 0)
-//                    {
-//                        minDist = d;
-//                    }
+//                if (mode == fcmPoint || mode == fcmEdge)
+//                {
+//                    nCollapsedFaces++;
 //                }
 //            }
 //        }
 //    }
 //
-//    const edgeList& fEdges = f.edges();
-//
-//    scalar perimeter = 0;
-//
-//    forAll(fEdges, eI)
-//    {
-//        const edge& e = fEdges[eI];
-//        const scalar d = e.mag(pts);
-//
-//        perimeter += d;
-//
-////        collapseAxis += e.vec(pts);
-//
-//        if (d > maxDist)
-//        {
-//            collapseAxis = e.vec(pts);
-//            maxDist = d;
-//        }
-//        else if (d < minDist && d != 0)
-//        {
-//            minDist = d;
-//        }
-//    }
-//
-//    collapseAxis /= mag(collapseAxis);
-//
-////    Info<< f.size() << " " << minDist << " " << maxDist << " | "
-////        << collapseAxis << endl;
-//
-//    aspectRatio = maxDist/minDist;
-//
-//    aspectRatio = min(aspectRatio, sqr(perimeter)/(16.0*fA));
-
-    if (magSqr(collapseAxis) < VSMALL)
-    {
-        WarningIn
-        (
-            "Foam::conformalVoronoiMesh::collapseFace"
-        )
-            << "No collapse axis found for face, not collapsing."
-            << endl;
-
-        // Output face and collapse axis for visualisation
-
-        Pout<< "# Aspect ratio = " << aspectRatio << nl
-//            << "# inertia = " << J << nl
-//            << "# determinant = " << detJ << nl
-//            << "# eigenvalues = " << eigenValues(J) << nl
-            << "# collapseAxis = " << collapseAxis << nl
-            << "# facePts = " << facePts << nl
-            << endl;
-
-        forAll(f, fPtI)
-        {
-            meshTools::writeOBJ(Pout, pts[f[fPtI]]);
-        }
-
-        Pout<< "f";
-
-        forAll(f, fPtI)
-        {
-            Pout << " " << fPtI + 1;
-        }
-
-        Pout<< endl;
-
-        return fcmNone;
-    }
-
-    // The signed distance along the collapse axis passing through the
-    // face centre that each vertex projects to.
-
-    Field<scalar> d(f.size());
-
-    forAll(f, fPtI)
-    {
-        const Foam::point& pt = pts[f[fPtI]];
-
-        d[fPtI] = (collapseAxis & (pt - fC));
-    }
-
-    // Sort the projected distances and the corresponding vertex
-    // indices along the collapse axis
-
-    labelList oldToNew;
-
-    sortedOrder(d, oldToNew);
-
-    oldToNew = invert(oldToNew.size(), oldToNew);
-
-    inplaceReorder(oldToNew, d);
-
-    inplaceReorder(oldToNew, facePts);
-
-    // Shift the points so that they are relative to the centre of the
-    // collapse line.
-
-    scalar dShift = -0.5*(d.first() + d.last());
-
-    d += dShift;
-
-    // Form two lists, one for each half of the set of points
-    // projected along the collapse axis.
-
-    // Middle value, index of first entry in the second half
-    label middle = -1;
-
-    forAll(d, dI)
-    {
-        if (d[dI] > 0)
-        {
-            middle = dI;
-
-            break;
-        }
-    }
-
-    // Negative half
-    SubList<scalar> dNeg(d, middle, 0);
-    SubList<label> facePtsNeg(facePts, middle, 0);
-
-    // Positive half
-    SubList<scalar> dPos(d, d.size() - middle, middle);
-    SubList<label> facePtsPos(facePts, d.size() - middle, middle);
-
-    // Defining how close to the midpoint (M) of the projected
-    // vertices line a projected vertex (X) can be before making this
-    // an invalid edge collapse
-    //
-    // X---X-g----------------M----X-----------g----X--X
-    //
-    // Only allow a collapse if all projected vertices are outwith
-    // guardFraction (g) of the distance form the face centre to the
-    // furthest vertex in the considered direction
-
-    if (dNeg.size() == 0 || dPos.size() == 0)
-    {
-        WarningIn
-        (
-            "Foam::conformalVoronoiMesh::collapseFace"
-        )
-            << "All points on one side of face centre, not collapsing."
-            << endl;
-    }
-
-    faceCollapseMode mode = fcmNone;
-
-    if
-    (
-        (fA < aspectRatio*sqr(targetFaceSize*collapseSizeLimitCoeff))
-     && (!limitToQuadsOrTris || f.size() <= 4)
-    )
-    {
-        scalar guardFraction = cvMeshControls().edgeCollapseGuardFraction();
-
-        if
-        (
-            allowEarlyCollapseToPoint
-         && (d.last() - d.first())
-          < targetFaceSize
-           *0.2*cvMeshControls().maxCollapseFaceToPointSideLengthCoeff()
-        )
-        {
-            mode = fcmPoint;
-        }
-        else if
-        (
-            (dNeg.last() < guardFraction*dNeg.first())
-         && (dPos.first() > guardFraction*dPos.last())
-        )
-        {
-            mode = fcmEdge;
-        }
-        else if
-        (
-            (d.last() - d.first())
-          < targetFaceSize
-           *cvMeshControls().maxCollapseFaceToPointSideLengthCoeff()
-        )
-        {
-            // If the face can't be collapsed to an edge, and it has a
-            // small enough span, collapse it to a point.
-
-            mode = fcmPoint;
-        }
-        else
-        {
-            // Alternatively, do not topologically collapse face here,
-            // but push all points onto a line, so that the face area
-            // is zero and then collapse to a string of edges later.
-            // The fcmDeferredMultiEdge collapse must be performed at
-            // the polyMesh stage as this type of collapse can't be
-            // performed and still maintain topological dual
-            // consistency with the Delaunay structure
-
-            mode = fcmDeferredMultiEdge;
-        }
-    }
-
-    switch (mode)
-    {
-        case fcmEdge:
-        {
-            // Negative half
-
-            label collapseToPtI = facePtsNeg.first();
-
-            Foam::point collapseToPt =
-                collapseAxis*(sum(dNeg)/dNeg.size() - dShift) + fC;
-
-//            DynamicList<label> faceBoundaryPts(f.size());
-
-            forAll(facePtsNeg, fPtI)
-            {
-                if (boundaryPts[facePtsNeg[fPtI]] == true)
-                {
-                    // If there is a point which is on the boundary,
-                    // use it as the point to collapse others to, will
-                    // use the first boundary point encountered if
-                    // there are multiple boundary points.
-
-                    collapseToPtI = facePtsNeg[fPtI];
-
-                    collapseToPt = pts[collapseToPtI];
-
-                    break;
-
-//                    faceBoundaryPts.append(facePtsNeg[fPtI]);
-                }
-            }
-
-//            if (!faceBoundaryPts.empty())
-//            {
-//                if (faceBoundaryPts.size() == 2)
-//                {
-//                    collapseToPtI = faceBoundaryPts[0];
-//
-//                    collapseToPt =
-//                        0.5
-//                       *(
-//                            pts[faceBoundaryPts[0]]
-//                          + pts[faceBoundaryPts[1]]
-//                        );
-//                }
-//                else if (faceBoundaryPts.size() < f.size())
-//                {
-//                    face bFace(faceBoundaryPts);
-//
-//                    collapseToPtI = faceBoundaryPts.first();
-//
-//                    collapseToPt = bFace.centre(pts);
-//                }
-//            }
-//
-//            faceBoundaryPts.clear();
-
-            // ...otherwise arbitrarily choosing the most distant
-            // point as the index to collapse to.
-
-            forAll(facePtsNeg, fPtI)
-            {
-                dualPtIndexMap.insert(facePtsNeg[fPtI], collapseToPtI);
-            }
-
-            pts[collapseToPtI] = collapseToPt;
-
-            // Positive half
-
-            collapseToPtI = facePtsPos.last();
-
-            collapseToPt = collapseAxis*(sum(dPos)/dPos.size() - dShift) + fC;
-
-            forAll(facePtsPos, fPtI)
-            {
-                if (boundaryPts[facePtsPos[fPtI]] == true)
-                {
-                    // If there is a point which is on the boundary,
-                    // use it as the point to collapse others to, will
-                    // use the first boundary point encountered if
-                    // there are multiple boundary points.
-
-                    collapseToPtI = facePtsPos[fPtI];
-
-                    collapseToPt = pts[collapseToPtI];
-
-                    break;
-
-//                    faceBoundaryPts.append(facePtsNeg[fPtI]);
-                }
-            }
-
-//            if (!faceBoundaryPts.empty())
-//            {
-//                if (faceBoundaryPts.size() == 2)
-//                {
-//                    collapseToPtI = faceBoundaryPts[0];
-//
-//                    collapseToPt =
-//                        0.5
-//                       *(
-//                            pts[faceBoundaryPts[0]]
-//                          + pts[faceBoundaryPts[1]]
-//                        );
-//                }
-//                else if (faceBoundaryPts.size() < f.size())
-//                {
-//                    face bFace(faceBoundaryPts);
-//
-//                    collapseToPtI = faceBoundaryPts.first();
-//
-//                    collapseToPt = bFace.centre(pts);
-//                }
-//            }
-
-            // ...otherwise arbitrarily choosing the most distant
-            // point as the index to collapse to.
-
-            forAll(facePtsPos, fPtI)
-            {
-                dualPtIndexMap.insert(facePtsPos[fPtI], collapseToPtI);
-            }
-
-            pts[collapseToPtI] = collapseToPt;
-
-            break;
-        }
-
-        case fcmPoint:
-        {
-            label collapseToPtI = facePts.first();
-
-            Foam::point collapseToPt = fC;
-
-            DynamicList<label> faceBoundaryPts(f.size());
-
-            forAll(facePts, fPtI)
-            {
-                if (boundaryPts[facePts[fPtI]] == true)
-                {
-                    // If there is a point which is on the boundary,
-                    // use it as the point to collapse others to, will
-                    // use the first boundary point encountered if
-                    // there are multiple boundary points.
-
-//                    collapseToPtI = facePts[fPtI];
-//
-//                    collapseToPt = pts[collapseToPtI];
-//
-//                    break;
-
-                    faceBoundaryPts.append(facePts[fPtI]);
-                }
-            }
-
-            if (!faceBoundaryPts.empty())
-            {
-                if (faceBoundaryPts.size() == 2)
-                {
-                    collapseToPtI = faceBoundaryPts[0];
-
-                    collapseToPt =
-                        0.5*(pts[faceBoundaryPts[0]] + pts[faceBoundaryPts[1]]);
-                }
-                else if (faceBoundaryPts.size() < f.size())
-                {
-                    face bFace(faceBoundaryPts);
-
-                    collapseToPtI = faceBoundaryPts.first();
-
-                    collapseToPt = bFace.centre(pts);
-                }
-            }
-
-            // ...otherwise arbitrarily choosing the first point as
-            // the index to collapse to.  Collapse to the face centre.
-
-            forAll(facePts, fPtI)
-            {
-                dualPtIndexMap.insert(facePts[fPtI], collapseToPtI);
-            }
-
-            pts[collapseToPtI] = collapseToPt;
-
-            break;
-        }
-
-        case fcmDeferredMultiEdge:
-        {
-            // forAll(facePts, fPtI)
-            // {
-            //     label ptI = facePts[fPtI];
-
-            //     pts[ptI] = collapseAxis*(d[fPtI] - dShift) + fC;
-
-            //     dualPtIndexMap.insert(ptI, ptI);
-            // }
-
-            break;
-        }
-
-        case fcmNone:
-        {
-            break;
-        }
-    }
-
-    // if (mode == fcmDeferredMultiEdge)
-    // if (mode != fcmNone)
-    // {
-    //     // Output face and collapse axis for visualisation
-
-    //     Pout<< "# Aspect ratio = " << aspectRatio << nl
-    //         << "# determinant = " << detJ << nl
-    //         << "# collapseAxis = " << collapseAxis << nl
-    //         << "# mode = " << mode << nl
-    //         << "# facePts = " << facePts << nl
-    //     //        << "# eigenvalues = " << eVals
-    //         << endl;
-
-    //     scalar scale = 2.0*mag(fC - pts[f[0]]);
-
-    //     meshTools::writeOBJ(Pout, fC);
-    //     meshTools::writeOBJ(Pout, fC + scale*collapseAxis);
-
-    //     Pout<< "f 1 2" << endl;
-
-    //     forAll(f, fPtI)
-    //     {
-    //         meshTools::writeOBJ(Pout, pts[f[fPtI]]);
-    //     }
-
-    //     Pout<< "f";
-
-    //     forAll(f, fPtI)
-    //     {
-    //         Pout << " " << fPtI + 3;
-    //     }
-
-    //     Pout<< nl << "# " << d << endl;
-
-    //     Pout<< "# " << d.first() << " " << d.last() << endl;
-
-    //     forAll(d, dI)
-    //     {
-    //         meshTools::writeOBJ(Pout, fC + (d[dI] - dShift)*collapseAxis);
-    //     }
-
-    //     Pout<< endl;
-    // }
-
-    return mode;
-}
-
-
-Foam::label Foam::conformalVoronoiMesh::longestEdge
-(
-    const face& f,
-    const pointField& pts
-) const
-{
-    const edgeList& eds = f.edges();
-
-    label longestEdgeI = -1;
-
-    scalar longestEdgeLength = -SMALL;
-
-    forAll(eds, edI)
-    {
-        scalar edgeLength = eds[edI].mag(pts);
-
-        if (edgeLength > longestEdgeLength)
-        {
-            longestEdgeI = edI;
-
-            longestEdgeLength = edgeLength;
-        }
-    }
-
-    return longestEdgeI;
-}
+//    return nCollapsedFaces;
+//}
 
 
 void Foam::conformalVoronoiMesh::deferredCollapseFaceSet
@@ -1871,6 +1184,7 @@ Foam::conformalVoronoiMesh::createPolyMeshFromPoints
     labelList procNeighbours;
     pointField cellCentres;
     labelListList patchToDelaunayVertex;
+    PackedBoolList boundaryFacesToRemove;
 
     timeCheck("Start of checkPolyMeshQuality");
 
@@ -1887,6 +1201,7 @@ Foam::conformalVoronoiMesh::createPolyMeshFromPoints
         patchStarts,
         procNeighbours,
         patchToDelaunayVertex,
+        boundaryFacesToRemove,
         false
     );
 
@@ -1926,7 +1241,6 @@ Foam::conformalVoronoiMesh::createPolyMeshFromPoints
        if (patchTypes[p] == processorPolyPatch::typeName)
        {
            // Do not create empty processor patches
-
            if (patchSizes[p] > 0)
            {
                patches[nValidPatches] = new processorPolyPatch
@@ -1937,7 +1251,8 @@ Foam::conformalVoronoiMesh::createPolyMeshFromPoints
                    nValidPatches,
                    pMesh.boundaryMesh(),
                    Pstream::myProcNo(),
-                   procNeighbours[p]
+                   procNeighbours[p],
+                   coupledPolyPatch::COINCIDENTFULLMATCH
                );
 
                nValidPatches++;
@@ -1991,13 +1306,13 @@ void Foam::conformalVoronoiMesh::checkCellSizing()
 
     timeCheck("Start of Cell Sizing");
 
-    PackedBoolList boundaryPts(number_of_cells(), false);
+    labelList boundaryPts(number_of_finite_cells(), -1);
     pointField ptsField;
 
     indexDualVertices(ptsField, boundaryPts);
 
     // Merge close dual vertices.
-    mergeCloseDualVertices(ptsField, boundaryPts);
+    mergeIdenticalDualVertices(ptsField, boundaryPts);
 
     autoPtr<polyMesh> meshPtr = createPolyMeshFromPoints(ptsField);
     const polyMesh& pMesh = meshPtr();
@@ -2092,10 +1407,10 @@ void Foam::conformalVoronoiMesh::checkCellSizing()
             }
         }
 
-        Info<< "    Automatically re-sizing " << cellsToResize.size()
+        Info<< "    DISABLED: Automatically re-sizing " << cellsToResize.size()
             << " cells that are attached to the bad faces: " << endl;
 
-        cellSizeControl_.setCellSizes(cellsToResize);
+        //cellSizeControl_.setCellSizes(cellsToResize);
     }
 
     timeCheck("End of Cell Sizing");
@@ -2181,8 +1496,6 @@ Foam::labelHashSet Foam::conformalVoronoiMesh::checkPolyMeshQuality
 
     labelHashSet wrongFaces(pMesh.nFaces()/100);
 
-    Info << endl;
-
     DynamicList<label> checkFaces(pMesh.nFaces());
 
     const vectorField& fAreas = pMesh.faceAreas();
@@ -2197,7 +1510,7 @@ Foam::labelHashSet Foam::conformalVoronoiMesh::checkPolyMeshQuality
         }
     }
 
-    Info<< "Excluding "
+    Info<< nl << "Excluding "
         << returnReduce(fAreas.size() - checkFaces.size(), sumOp<label>())
         << " faces from check, < " << faceAreaLimit << " area" << endl;
 
@@ -2371,18 +1684,16 @@ Foam::labelHashSet Foam::conformalVoronoiMesh::checkPolyMeshQuality
 void Foam::conformalVoronoiMesh::indexDualVertices
 (
     pointField& pts,
-    PackedBoolList& boundaryPts
+    labelList& boundaryPts
 )
 {
     // Indexing Delaunay cells, which are the dual vertices
 
-    label dualVertI = 0;
+    this->resetCellCount();
 
-    pts.setSize(number_of_cells());
+    pts.setSize(number_of_finite_cells());
 
-    boundaryPts.setSize(number_of_cells(), false);
-
-    boundaryPts = false;
+    boundaryPts.setSize(number_of_finite_cells(), -1);
 
     for
     (
@@ -2391,19 +1702,83 @@ void Foam::conformalVoronoiMesh::indexDualVertices
         ++cit
     )
     {
-        if (cit->internalOrBoundaryDualVertex())
-        {
-            cit->cellIndex() = dualVertI;
+//        if (tetrahedron(cit).volume() == 0)
+//        {
+//            Pout<< "ZERO VOLUME TET" << endl;
+//            Pout<< cit->info();
+//            Pout<< "Dual = " << cit->dual();
+//        }
 
-            pts[dualVertI] = cit->dual();
+        if (!cit->hasFarPoint())
+        {
+            cit->cellIndex() = getNewCellIndex();
+
+            // For nearly coplanar Delaunay cells that are present on different
+            // processors the result of the circumcentre calculation depends on
+            // the ordering of the vertices, so synchronise it across processors
+
+            if (Pstream::parRun() && cit->parallelDualVertex())
+            {
+                typedef CGAL::Exact_predicates_exact_constructions_kernel Exact;
+                typedef CGAL::Point_3<Exact> ExactPoint;
+
+                List<labelPair> cellVerticesPair(4);
+                List<ExactPoint> cellVertices(4);
+
+                for (label vI = 0; vI < 4; ++vI)
+                {
+                    cellVerticesPair[vI] = labelPair
+                    (
+                        cit->vertex(vI)->procIndex(),
+                        cit->vertex(vI)->index()
+                    );
+
+                    cellVertices[vI] = ExactPoint
+                    (
+                        cit->vertex(vI)->point().x(),
+                        cit->vertex(vI)->point().y(),
+                        cit->vertex(vI)->point().z()
+                    );
+                }
+
+                // Sort the vertices so that they will be in the same order on
+                // each processor
+                labelList oldToNew;
+                sortedOrder(cellVerticesPair, oldToNew);
+                oldToNew = invert(oldToNew.size(), oldToNew);
+                inplaceReorder(oldToNew, cellVertices);
+
+                ExactPoint synchronisedDual = CGAL::circumcenter
+                (
+                    cellVertices[0],
+                    cellVertices[1],
+                    cellVertices[2],
+                    cellVertices[3]
+                );
+
+                pts[cit->cellIndex()] = Foam::point
+                (
+                    CGAL::to_double(synchronisedDual.x()),
+                    CGAL::to_double(synchronisedDual.y()),
+                    CGAL::to_double(synchronisedDual.z())
+                );
+            }
+            else
+            {
+                pts[cit->cellIndex()] = cit->dual();
+            }
 
             if (cit->boundaryDualVertex())
             {
-                // This is a boundary dual vertex
-                boundaryPts[dualVertI] = true;
+                if (cit->featureEdgeDualVertex())
+                {
+                    boundaryPts[cit->cellIndex()] = 1;
+                }
+                else
+                {
+                    boundaryPts[cit->cellIndex()] = 0;
+                }
             }
-
-            dualVertI++;
         }
         else
         {
@@ -2411,9 +1786,9 @@ void Foam::conformalVoronoiMesh::indexDualVertices
         }
     }
 
-    pts.setSize(dualVertI);
+    pts.setSize(this->cellCount());
 
-    boundaryPts.setSize(dualVertI);
+    boundaryPts.setSize(this->cellCount());
 }
 
 
@@ -2437,18 +1812,11 @@ void Foam::conformalVoronoiMesh::reindexDualVertices
 }
 
 
-void Foam::conformalVoronoiMesh::createFacesOwnerNeighbourAndPatches
+Foam::label Foam::conformalVoronoiMesh::createPatchInfo
 (
-    faceList& faces,
-    labelList& owner,
-    labelList& neighbour,
-    wordList& patchTypes,
     wordList& patchNames,
-    labelList& patchSizes,
-    labelList& patchStarts,
-    labelList& procNeighbours,
-    labelListList& patchPointPairSlaves,
-    bool includeEmptyPatches
+    wordList& patchTypes,
+    labelList& procNeighbours
 ) const
 {
     patchNames = geometryToConformTo_.patchNames();
@@ -2467,7 +1835,13 @@ void Foam::conformalVoronoiMesh::createFacesOwnerNeighbourAndPatches
 
     if (Pstream::parRun())
     {
-        boolList procUsed(Pstream::nProcs(), false);
+        List<boolList> procUsedList
+        (
+            Pstream::nProcs(),
+            boolList(Pstream::nProcs(), false)
+        );
+
+        boolList& procUsed = procUsedList[Pstream::myProcNo()];
 
         // Determine which processor patches are required
         for
@@ -2477,12 +1851,30 @@ void Foam::conformalVoronoiMesh::createFacesOwnerNeighbourAndPatches
             vit++
         )
         {
+            // This test is not sufficient if one of the processors does
+            // not receive a referred vertex from another processor, but does
+            // send one to the other processor.
             if (vit->referred())
             {
                 procUsed[vit->procIndex()] = true;
             }
         }
 
+        // Because the previous test was insufficient, combine the lists.
+        Pstream::gatherList(procUsedList);
+        Pstream::scatterList(procUsedList);
+
+        forAll(procUsedList, procI)
+        {
+            if (procI != Pstream::myProcNo())
+            {
+                if (procUsedList[procI][Pstream::myProcNo()])
+                {
+                    procUsed[procI] = true;
+                }
+            }
+        }
+
         forAll(procUsed, pUI)
         {
             if (procUsed[pUI])
@@ -2493,9 +1885,9 @@ void Foam::conformalVoronoiMesh::createFacesOwnerNeighbourAndPatches
 
         label nNonProcPatches = patchNames.size();
 
+        patchNames.setSize(nNonProcPatches + nProcPatches);
         patchTypes.setSize(nNonProcPatches + nProcPatches);
         procNeighbours.setSize(nNonProcPatches + nProcPatches, -1);
-        patchNames.setSize(nNonProcPatches + nProcPatches);
 
         label procAddI = 0;
 
@@ -2519,25 +1911,46 @@ void Foam::conformalVoronoiMesh::createFacesOwnerNeighbourAndPatches
         }
     }
 
-    // Pout<< patchTypes << " " << patchNames << endl;
+    return defaultPatchIndex;
+}
 
-    label nPatches = patchNames.size();
+
+void Foam::conformalVoronoiMesh::createFacesOwnerNeighbourAndPatches
+(
+    faceList& faces,
+    labelList& owner,
+    labelList& neighbour,
+    wordList& patchTypes,
+    wordList& patchNames,
+    labelList& patchSizes,
+    labelList& patchStarts,
+    labelList& procNeighbours,
+    labelListList& patchPointPairSlaves,
+    PackedBoolList& boundaryFacesToRemove,
+    bool includeEmptyPatches
+) const
+{
+    const label defaultPatchIndex = createPatchInfo
+    (
+        patchNames,
+        patchTypes,
+        procNeighbours
+    );
+
+    const label nPatches = patchNames.size();
 
     List<DynamicList<face> > patchFaces(nPatches, DynamicList<face>(0));
-
     List<DynamicList<label> > patchOwners(nPatches, DynamicList<label>(0));
-
     // Per patch face the index of the slave node of the point pair
     List<DynamicList<label> > patchPPSlaves(nPatches, DynamicList<label>(0));
 
+    List<DynamicList<bool> > indirectPatchFace(nPatches, DynamicList<bool>(0));
 
-    faces.setSize(number_of_edges());
+    faces.setSize(number_of_finite_edges());
+    owner.setSize(number_of_finite_edges());
+    neighbour.setSize(number_of_finite_edges());
 
-    owner.setSize(number_of_edges());
-
-    neighbour.setSize(number_of_edges());
-
-    List<Pair<DynamicList<label> > > procPatchSortingIndex(nPatches);
+    labelPairPairDynListList procPatchSortingIndex(nPatches);
 
     label dualFaceI = 0;
 
@@ -2554,8 +1967,8 @@ void Foam::conformalVoronoiMesh::createFacesOwnerNeighbourAndPatches
 
         if
         (
-            vA->internalOrBoundaryPoint()
-         || vB->internalOrBoundaryPoint()
+            (vA->internalOrBoundaryPoint() && !vA->referred())
+         || (vB->internalOrBoundaryPoint() && !vB->referred())
         )
         {
             face newDualFace = buildDualFace(eit);
@@ -2574,44 +1987,56 @@ void Foam::conformalVoronoiMesh::createFacesOwnerNeighbourAndPatches
                 {
                     // boundary face
 
-                    Foam::point ptA = topoint(vA->point());
-                    Foam::point ptB = topoint(vB->point());
+                    pointFromPoint ptA = topoint(vA->point());
+                    pointFromPoint ptB = topoint(vB->point());
 
                     label patchIndex = -1;
 
-                    if
-                    (
-                        vA->referredInternalOrBoundaryPoint()
-                     || vB->referredInternalOrBoundaryPoint()
-                    )
+                    if (isProcBoundaryEdge(eit))
                     {
                         // One (and only one) of the points is an internal
                         // point from another processor
 
                         label procIndex = max(vA->procIndex(), vB->procIndex());
 
-                        patchIndex = findIndex(procNeighbours, procIndex);
+                        patchIndex = max
+                        (
+                            findIndex(procNeighbours, vA->procIndex()),
+                            findIndex(procNeighbours, vB->procIndex())
+                        );
 
                         // The lower processor index is the owner of the
-                        // two for the purposed of sorting the patch faces.
+                        // two for the purpose of sorting the patch faces.
 
                         if (Pstream::myProcNo() < procIndex)
                         {
                             // Use this processor's vertex index as the master
                             // for sorting
 
-                           Pair<DynamicList<label> >& sortingIndex =
-                               procPatchSortingIndex[patchIndex];
+                            DynamicList<Pair<labelPair> >& sortingIndex =
+                                procPatchSortingIndex[patchIndex];
 
-                            if (vB->referredInternalOrBoundaryPoint())
+                            if (vB->internalOrBoundaryPoint() && vB->referred())
                             {
-                                sortingIndex.first().append(vA->index());
-                                sortingIndex.second().append(vB->index());
+                                sortingIndex.append
+                                (
+                                    Pair<labelPair>
+                                    (
+                                        labelPair(vA->index(), vA->procIndex()),
+                                        labelPair(vB->index(), vB->procIndex())
+                                    )
+                                );
                             }
                             else
                             {
-                                sortingIndex.first().append(vB->index());
-                                sortingIndex.second().append(vA->index());
+                                sortingIndex.append
+                                (
+                                    Pair<labelPair>
+                                    (
+                                        labelPair(vB->index(), vB->procIndex()),
+                                        labelPair(vA->index(), vA->procIndex())
+                                    )
+                                );
                             }
                         }
                         else
@@ -2619,30 +2044,42 @@ void Foam::conformalVoronoiMesh::createFacesOwnerNeighbourAndPatches
                             // Use the other processor's vertex index as the
                             // master for sorting
 
-                            Pair<DynamicList<label> >& sortingIndex =
+                            DynamicList<Pair<labelPair> >& sortingIndex =
                                 procPatchSortingIndex[patchIndex];
 
-                            if (vA->referredInternalOrBoundaryPoint())
+                            if (vA->internalOrBoundaryPoint() && vA->referred())
                             {
-                                sortingIndex.first().append(vA->index());
-                                sortingIndex.second().append(vB->index());
+                                sortingIndex.append
+                                (
+                                    Pair<labelPair>
+                                    (
+                                        labelPair(vA->index(), vA->procIndex()),
+                                        labelPair(vB->index(), vB->procIndex())
+                                    )
+                                );
                             }
                             else
                             {
-                                sortingIndex.first().append(vB->index());
-                                sortingIndex.second().append(vA->index());
+                                sortingIndex.append
+                                (
+                                    Pair<labelPair>
+                                    (
+                                        labelPair(vB->index(), vB->procIndex()),
+                                        labelPair(vA->index(), vA->procIndex())
+                                    )
+                                );
                             }
                         }
 
-                        // Pout<< ptA << " " << ptB
-                        //     << " proc indices "
-                        //     << vA->procIndex() << " " << vB->procIndex()
-                        //     << " indices " << vA->index()
-                        //     << " " << vB->index()
-                        //     << " my proc " << Pstream::myProcNo()
-                        //     << " addedIndex "
-                        //     << procPatchSortingIndex[patchIndex].last()
-                        //     << endl;
+//                        Pout<< ptA << " " << ptB
+//                            << " proc indices "
+//                            << vA->procIndex() << " " << vB->procIndex()
+//                            << " indices " << vA->index()
+//                            << " " << vB->index()
+//                            << " my proc " << Pstream::myProcNo()
+//                            << " addedIndex "
+//                            << procPatchSortingIndex[patchIndex].last()
+//                            << endl;
                     }
                     else
                     {
@@ -2667,6 +2104,17 @@ void Foam::conformalVoronoiMesh::createFacesOwnerNeighbourAndPatches
                     patchFaces[patchIndex].append(newDualFace);
                     patchOwners[patchIndex].append(own);
 
+                    // If the two vertices are a pair, then the patch face is
+                    // a desired one.
+                    if (vA->type() == vB->index())
+                    {
+                        indirectPatchFace[patchIndex].append(true);
+                    }
+                    else
+                    {
+                        indirectPatchFace[patchIndex].append(false);
+                    }
+
                     // Store the non-internal or boundary point
                     if (vA->internalOrBoundaryPoint())
                     {
@@ -2680,7 +2128,6 @@ void Foam::conformalVoronoiMesh::createFacesOwnerNeighbourAndPatches
                 else
                 {
                     // internal face
-
                     faces[dualFaceI] = newDualFace;
                     owner[dualFaceI] = own;
                     neighbour[dualFaceI] = nei;
@@ -2727,8 +2174,10 @@ void Foam::conformalVoronoiMesh::createFacesOwnerNeighbourAndPatches
         owner,
         patchSizes,
         patchStarts,
+        boundaryFacesToRemove,
         patchFaces,
-        patchOwners
+        patchOwners,
+        indirectPatchFace
     );
 
     // Return     patchPointPairSlaves.setSize(nPatches);
@@ -2738,14 +2187,28 @@ void Foam::conformalVoronoiMesh::createFacesOwnerNeighbourAndPatches
         patchPointPairSlaves[patchI].transfer(patchPPSlaves[patchI]);
     }
 
-    if (cvMeshControls().objOutput())
+//    if (cvMeshControls().objOutput())
     {
+        Info<< "Writing processor interfaces" << endl;
+
         forAll(procNeighbours, nbI)
         {
             if (patchFaces[nbI].size() > 0)
             {
                 const label neighbour = procNeighbours[nbI];
 
+                faceList procPatchFaces = patchFaces[nbI];
+
+                // Reverse faces as it makes it easier to analyse the output
+                // using a diff
+                if (neighbour < Pstream::myProcNo())
+                {
+                    forAll(procPatchFaces, fI)
+                    {
+                        procPatchFaces[fI] = procPatchFaces[fI].reverseFace();
+                    }
+                }
+
                 if (neighbour != -1)
                 {
                     word fName =
@@ -2755,11 +2218,7 @@ void Foam::conformalVoronoiMesh::createFacesOwnerNeighbourAndPatches
                       + name(neighbour)
                       + "_interface.obj";
 
-                    writeProcessorInterface
-                    (
-                        fName,
-                        patchFaces[nbI]
-                    );
+                    writeProcessorInterface(fName, procPatchFaces);
                 }
             }
         }
@@ -2785,9 +2244,7 @@ void Foam::conformalVoronoiMesh::createCellCentres
     {
         if (vit->internalOrBoundaryPoint())
         {
-            cellCentres[vit->index()] = topoint(vit->point());
-
-            vertI++;
+            cellCentres[vertI++] = topoint(vit->point());
         }
     }
 
@@ -2800,6 +2257,8 @@ Foam::tmp<Foam::pointField> Foam::conformalVoronoiMesh::allPoints() const
     tmp<pointField> tpts(new pointField(number_of_vertices(), point::max));
     pointField& pts = tpts();
 
+    label nVert = 0;
+
     for
     (
         Delaunay::Finite_vertices_iterator vit = finite_vertices_begin();
@@ -2809,7 +2268,7 @@ Foam::tmp<Foam::pointField> Foam::conformalVoronoiMesh::allPoints() const
     {
         if (vit->internalOrBoundaryPoint())
         {
-            pts[vit->index()] = topoint(vit->point());
+            pts[nVert++] = topoint(vit->point());
         }
     }
 
@@ -2838,8 +2297,12 @@ void Foam::conformalVoronoiMesh::sortFaces
     // 1     | 24
     // 1     | 91
 
-    // Two stage sort:
-    // 1) sort by owner
+    List<labelPair> ownerNeighbourPair(owner.size());
+
+    forAll(ownerNeighbourPair, oNI)
+    {
+        ownerNeighbourPair[oNI] = labelPair(owner[oNI], neighbour[oNI]);
+    }
 
     Info<< nl
         << "Sorting faces, owner and neighbour into upper triangular order"
@@ -2847,71 +2310,13 @@ void Foam::conformalVoronoiMesh::sortFaces
 
     labelList oldToNew;
 
-    sortedOrder(owner, oldToNew);
+    sortedOrder(ownerNeighbourPair, oldToNew);
 
     oldToNew = invert(oldToNew.size(), oldToNew);
 
     inplaceReorder(oldToNew, faces);
     inplaceReorder(oldToNew, owner);
     inplaceReorder(oldToNew, neighbour);
-
-    // 2) in each block of owners sort by neighbour
-
-    // Reset map.  Elements that are not sorted will retain their -1
-    // value, which will mean that they are ignored by inplaceReorder
-
-    oldToNew = -1;
-
-    label blockStart = 0;
-
-    for (label i = 1; i < owner.size(); i++)
-    {
-        label blockLength = -1;
-
-        if (owner[i] > owner[i - 1])
-        {
-            blockLength = i - blockStart;
-        }
-        else if (i == owner.size() - 1)
-        {
-            // If the last element is not a jump in owner, then it
-            // needs to trigger a sort of the last block, but with a
-            // block length that is one element longer so that it
-            // sorts itself.
-
-            // If it is a jump in owner, then it will form a block of
-            // length one, and so will not need sorted.
-
-            blockLength = i - blockStart + 1;
-        }
-
-        if (blockLength >= 1)
-        {
-            labelList blockIndices = identity(blockLength) + blockStart;
-
-            SubList<label> neighbourBlock
-            (
-                neighbour,
-                blockLength,
-                blockStart
-            );
-
-            sortedOrder(neighbourBlock, blockIndices);
-
-            blockIndices = invert(blockIndices.size(), blockIndices);
-
-            forAll(blockIndices, b)
-            {
-                oldToNew[blockStart + b] = blockIndices[b] + blockStart;
-            }
-
-            blockStart = i;
-        }
-    }
-
-    // owner does not need re-sorted
-    inplaceReorder(oldToNew, faces);
-    inplaceReorder(oldToNew, neighbour);
 }
 
 
@@ -2920,7 +2325,7 @@ void Foam::conformalVoronoiMesh::sortProcPatches
     List<DynamicList<face> >& patchFaces,
     List<DynamicList<label> >& patchOwners,
     List<DynamicList<label> >& patchPointPairSlaves,
-    List<Pair<DynamicList<label> > >& patchSortingIndices
+    labelPairPairDynListList& patchSortingIndices
 ) const
 {
     if (!Pstream::parRun())
@@ -2934,18 +2339,16 @@ void Foam::conformalVoronoiMesh::sortProcPatches
         labelList& owner = patchOwners[patchI];
         DynamicList<label>& slaves = patchPointPairSlaves[patchI];
 
-        Pair<DynamicList<label> >& sortingIndices = patchSortingIndices[patchI];
+        DynamicList<Pair<labelPair> >& sortingIndices
+            = patchSortingIndices[patchI];
 
-        List<label>& primary = sortingIndices.first();
-        List<label>& secondary = sortingIndices.second();
-
-        if (!primary.empty())
+        if (!sortingIndices.empty())
         {
             if
             (
-                faces.size() != primary.size()
-             || owner.size() != primary.size()
-             || slaves.size() != primary.size()
+                faces.size() != sortingIndices.size()
+             || owner.size() != sortingIndices.size()
+             || slaves.size() != sortingIndices.size()
             )
             {
                 FatalErrorIn
@@ -2962,80 +2365,18 @@ void Foam::conformalVoronoiMesh::sortProcPatches
                     << " faces.size() " << faces.size() << nl
                     << " owner.size() " << owner.size() << nl
                     << " slaves.size() " << slaves.size() << nl
-                    << " sortingIndices.first().size() "
-                    << sortingIndices.first().size()
+                    << " sortingIndices.size() "
+                    << sortingIndices.size()
                     << exit(FatalError) << endl;
             }
 
-            // Two stage sort:
-            // 1) sort by primary
-
             labelList oldToNew;
 
-            sortedOrder(primary, oldToNew);
+            sortedOrder(sortingIndices, oldToNew);
 
             oldToNew = invert(oldToNew.size(), oldToNew);
 
-            inplaceReorder(oldToNew, primary);
-            inplaceReorder(oldToNew, secondary);
-            inplaceReorder(oldToNew, faces);
-            inplaceReorder(oldToNew, owner);
-            inplaceReorder(oldToNew, slaves);
-
-            // 2) in each block of primary sort by secondary
-
-            // Reset map.  Elements that are not sorted will retain their -1
-            // value, which will mean that they are ignored by inplaceReorder
-
-            oldToNew = -1;
-
-            label blockStart = 0;
-
-            for (label i = 1; i < primary.size(); i++)
-            {
-                label blockLength = -1;
-
-                if (primary[i] > primary[i - 1])
-                {
-                    blockLength = i - blockStart;
-                }
-                else if (i == primary.size() - 1)
-                {
-                    // If the last element is not a jump in index, then it
-                    // needs to trigger a sort of the last block, but with a
-                    // block length that is one element longer so that it
-                    // sorts itself.
-
-                    // If it is a jump in index, then it will form a block of
-                    // length one, and so will not need sorted.
-
-                    blockLength = i - blockStart + 1;
-                }
-
-                if (blockLength >= 1)
-                {
-                    labelList blockIndices = identity(blockLength) + blockStart;
-
-                    SubList<label> secondaryBlock
-                    (
-                        secondary,
-                        blockLength,
-                        blockStart
-                    );
-
-                    sortedOrder(secondaryBlock, blockIndices);
-
-                    blockIndices = invert(blockIndices.size(), blockIndices);
-
-                    forAll(blockIndices, b)
-                    {
-                        oldToNew[blockStart + b] = blockIndices[b] + blockStart;
-                    }
-
-                    blockStart = i;
-                }
-            }
-
+            inplaceReorder(oldToNew, sortingIndices);
             inplaceReorder(oldToNew, faces);
             inplaceReorder(oldToNew, owner);
             inplaceReorder(oldToNew, slaves);
@@ -3051,8 +2392,10 @@ void Foam::conformalVoronoiMesh::addPatches
     labelList& owner,
     labelList& patchSizes,
     labelList& patchStarts,
+    PackedBoolList& boundaryFacesToRemove,
     const List<DynamicList<face> >& patchFaces,
-    const List<DynamicList<label> >& patchOwners
+    const List<DynamicList<label> >& patchOwners,
+    const List<DynamicList<bool> >& indirectPatchFace
 ) const
 {
     label nPatches = patchFaces.size();
@@ -3081,6 +2424,7 @@ void Foam::conformalVoronoiMesh::addPatches
         {
             faces[faceI] = patchFaces[p][f];
             owner[faceI] = patchOwners[p][f];
+            boundaryFacesToRemove[faceI] = indirectPatchFace[p][f];
 
             faceI++;
         }
@@ -3091,7 +2435,8 @@ void Foam::conformalVoronoiMesh::addPatches
 void Foam::conformalVoronoiMesh::removeUnusedPoints
 (
     faceList& faces,
-    pointField& pts
+    pointField& pts,
+    labelList& boundaryPts
 ) const
 {
     Info<< nl << "Removing unused points" << endl;
@@ -3126,6 +2471,7 @@ void Foam::conformalVoronoiMesh::removeUnusedPoints
     }
 
     inplaceReorder(oldToNew, pts);
+    inplaceReorder(oldToNew, boundaryPts);
 
     Info<< "    Removing "
         << returnReduce(pts.size() - pointI, sumOp<label>())
@@ -3133,6 +2479,7 @@ void Foam::conformalVoronoiMesh::removeUnusedPoints
         << endl;
 
     pts.setSize(pointI);
+    boundaryPts.setSize(pointI);
 
     // Renumber the faces to use the new point numbers
 
@@ -3198,8 +2545,9 @@ Foam::labelList Foam::conformalVoronoiMesh::removeUnusedCells
 
     if (unusedCells.size() > 0)
     {
-        // Pout<< "Removing " << unusedCells.size() <<  " unused cell labels"
-        //     << endl;
+        Info<< "    Removing "
+            << returnReduce(unusedCells.size(), sumOp<label>())
+            <<  " unused cell labels" << endl;
 
         forAll(owner, oI)
         {
diff --git a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/conformalVoronoiMeshConformToSurface.C b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/conformalVoronoiMeshConformToSurface.C
index 2d850aff09..14c5428c81 100644
--- a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/conformalVoronoiMeshConformToSurface.C
+++ b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/conformalVoronoiMeshConformToSurface.C
@@ -26,6 +26,8 @@ License
 #include "conformalVoronoiMesh.H"
 #include "backgroundMeshDecomposition.H"
 #include "vectorTools.H"
+#include "indexedCellChecks.H"
+#include "IOmanip.H"
 
 using namespace Foam::vectorTools;
 
@@ -35,34 +37,44 @@ const Foam::scalar Foam::conformalVoronoiMesh::searchConeAngle
 const Foam::scalar Foam::conformalVoronoiMesh::searchAngleOppositeSurface
     = Foam::cos(degToRad(150));
 
+
 // * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * * //
 
 void Foam::conformalVoronoiMesh::conformToSurface()
 {
-    reconformationMode reconfMode = reconformationControl();
+    this->resetCellCount();
+    // Index the cells
+    for
+    (
+        Delaunay::Finite_cells_iterator cit = finite_cells_begin();
+        cit != finite_cells_end();
+        ++cit
+    )
+    {
+        cit->cellIndex() = Cb::ctUnassigned;
+    }
 
-//    if (Pstream::parRun())
-//    {
-//        seedProcessorBoundarySurfaces(true);
-//    }
-
-    if (reconfMode == rmNone)
+    if (reconformationControl() == rmOff)
     {
         // Reinsert stored surface conformation
         reinsertSurfaceConformation();
 
-        buildParallelInterface("move_" + runTime_.timeName());
+        if (Pstream::parRun())
+        {
+            sync(decomposition_().procBounds());
+        }
     }
     else
     {
         // Rebuild, insert and store new surface conformation
-        buildSurfaceConformation(reconfMode);
+        buildSurfaceConformation();
 
         if (distributeBackground())
         {
-            // distributeBackground has destroyed all referred vertices, so the
-            // parallel interface needs to be rebuilt.
-            buildParallelInterface("rebuild");
+            if (Pstream::parRun())
+            {
+                sync(decomposition_().procBounds());
+            }
 
             // Use storeSizesAndAlignments with no feed points because all
             // background points may have been distributed.
@@ -74,16 +86,6 @@ void Foam::conformalVoronoiMesh::conformToSurface()
         storeSurfaceConformation();
     }
 
-//    if (Pstream::parRun())
-//    {
-//        label nFarPoints = removeProcessorBoundarySeeds(true);
-//
-//        reduce(nFarPoints, sumOp<label>());
-//
-//        Info<< "    Removed " << nFarPoints
-//            << " far points from the mesh." << endl;
-//    }
-
     // reportSurfaceConformationQuality();
 }
 
@@ -91,47 +93,143 @@ void Foam::conformalVoronoiMesh::conformToSurface()
 Foam::conformalVoronoiMesh::reconformationMode
 Foam::conformalVoronoiMesh::reconformationControl() const
 {
-    if (!runTime_.run())
-    {
-        Info<< nl << "Rebuilding surface conformation for final output"
-            << endl;
-
-        return rmFine;
-    }
-    else if
+    if
     (
         runTime_.timeIndex()
       % cvMeshControls().surfaceConformationRebuildFrequency() == 0
     )
     {
-        Info<< nl << "Rebuilding surface conformation for more iterations"
-            << endl;
-
-        return rmCoarse;
+        return rmOn;
     }
 
-    return rmNone;
+    return rmOff;
 }
 
 
-void Foam::conformalVoronoiMesh::buildSurfaceConformation
-(
-    reconformationMode reconfMode
-)
+// @todo Investigate topological tests
+Foam::label Foam::conformalVoronoiMesh::findVerticesNearBoundaries()
+{
+    label countNearBoundaryVertices = 0;
+
+    for
+    (
+        Delaunay::Finite_facets_iterator fit = finite_facets_begin();
+        fit != finite_facets_end();
+        ++fit
+    )
+    {
+        if
+        (
+            is_infinite(fit->first)
+         || is_infinite(fit->first->neighbor(fit->second))
+        )
+        {
+            continue;
+        }
+
+        Cell_handle c1 = fit->first;
+        Cell_handle c2 = fit->first->neighbor(fit->second);
+
+        pointFromPoint dE0 = c1->dual();
+        pointFromPoint dE1 = c2->dual();
+
+        if (!geometryToConformTo_.findSurfaceAnyIntersection(dE0, dE1))
+        {
+            continue;
+        }
+
+        for (label cellI = 0; cellI < 4; ++cellI)
+        {
+            Vertex_handle v = c1->vertex(cellI);
+
+            if
+            (
+                !is_infinite(v)
+             && v->internalPoint()
+             && fit->second != cellI
+            )
+            {
+                v->setNearBoundary();
+            }
+        }
+
+        for (label cellI = 0; cellI < 4; ++cellI)
+        {
+            Vertex_handle v = c2->vertex(cellI);
+
+            if
+            (
+                !is_infinite(v)
+             && v->internalPoint()
+             && fit->second != cellI
+            )
+            {
+                v->setNearBoundary();
+            }
+        }
+    }
+
+    for
+    (
+        Delaunay::Finite_vertices_iterator vit = finite_vertices_begin();
+        vit != finite_vertices_end();
+        ++vit
+    )
+    {
+        if (vit->nearBoundary())
+        {
+            countNearBoundaryVertices++;
+        }
+    }
+
+    // Geometric test.
+//    for
+//    (
+//        Delaunay::Finite_vertices_iterator vit = finite_vertices_begin();
+//        vit != finite_vertices_end();
+//        ++vit
+//    )
+//    {
+//        if (vit->internalPoint() && !vit->nearBoundary())
+//        {
+//            pointFromPoint pt = topoint(vit->point());
+//
+//            const scalar range = sqr
+//            (
+//                cvMeshControls().nearBoundaryDistanceCoeff()
+//               *targetCellSize(pt)
+//            );
+//
+//            pointIndexHit pHit;
+//            label hitSurface;
+//
+//            geometryToConformTo_.findSurfaceNearest
+//            (
+//                pt,
+//                range,
+//                pHit,
+//                hitSurface
+//            );
+//
+//            if (pHit.hit())
+//            {
+//                vit->setNearBoundary();
+//                countNearBoundaryVertices++;
+//            }
+//        }
+//    }
+
+    return countNearBoundaryVertices;
+}
+
+
+void Foam::conformalVoronoiMesh::buildSurfaceConformation()
 {
     timeCheck("Start buildSurfaceConformation");
 
-    if (reconfMode == rmCoarse)
+    if (reconformationControl() == rmOff)
     {
-        Info<< nl << "Build coarse surface conformation" << endl;
-    }
-    else if (reconfMode == rmFine)
-    {
-        Info<< nl << "Build fine surface conformation" << endl;
-    }
-    else if (reconfMode == rmNone)
-    {
-        WarningIn("buildSurfaceConformation(reconformationMode reconfMode)")
+        WarningIn("buildSurfaceConformation()")
             << "reconformationMode rmNone specified, not building conformation"
             << endl;
 
@@ -139,21 +237,15 @@ void Foam::conformalVoronoiMesh::buildSurfaceConformation
     }
     else
     {
-        WarningIn("buildSurfaceConformation(reconformationMode reconfMode)")
-            << "Unknown reconformationMode " << reconfMode
-            << " not building conformation" << endl;
-
-        return;
+        Info<< nl << "Rebuilding surface conformation for more iterations"
+            << endl;
     }
 
-    // Initialise containers to store the edge conformation locations
-    DynamicList<Foam::point> newEdgeLocations;
+    existingEdgeLocations_.clearStorage();
+    existingSurfacePtLocations_.clearStorage();
 
-    DynamicList<Foam::point> existingEdgeLocations;
-    DynamicList<Foam::point> existingSurfacePtLocations;
-
-    buildEdgeLocationTree(existingEdgeLocations);
-    buildSurfacePtLocationTree(existingSurfacePtLocations);
+    buildEdgeLocationTree(existingEdgeLocations_);
+    buildSurfacePtLocationTree(existingSurfacePtLocations_);
 
     label initialTotalHits = 0;
 
@@ -177,7 +269,7 @@ void Foam::conformalVoronoiMesh::buildSurfaceConformation
     //     --------
     //
     // Shoot ray and find intersection with outside segment (x) and
-    // introduce pointpair (..)
+    // introduce point pair (..)
     //
     //        |
     // \      .      /
@@ -185,57 +277,27 @@ void Foam::conformalVoronoiMesh::buildSurfaceConformation
     //   \    .    /
     //     ---x----
 
-    label countNearBoundaryVertices = 0;
-
-    for
-    (
-        Delaunay::Finite_vertices_iterator vit = finite_vertices_begin();
-        vit != finite_vertices_end();
-        vit++
-    )
-    {
-        if (vit->internalPoint() && !vit->nearBoundary())
-        {
-            pointFromPoint pt = topoint(vit->point());
-            const scalar range = sqr(2.0*targetCellSize(pt));
-
-            pointIndexHit pHit;
-            label hitSurface;
-
-            geometryToConformTo_.findSurfaceNearest
-            (
-                pt,
-                range,
-                pHit,
-                hitSurface
-            );
-
-            if (pHit.hit())
-            {
-                vit->setNearBoundary();
-                countNearBoundaryVertices++;
-            }
-        }
-    }
+    // Find vertices near boundaries to speed up subsequent checks.
+    label countNearBoundaryVertices = findVerticesNearBoundaries();
 
     Info<< "    Vertices marked as being near a boundary: "
-        << countNearBoundaryVertices << " (estimated)" << endl;
+        << returnReduce(countNearBoundaryVertices, sumOp<label>())
+        << " (estimated)" << endl;
 
     timeCheck("After set near boundary");
 
+    const scalar edgeSearchDistCoeffSqr =
+        cvMeshControls().edgeSearchDistCoeffSqr();
+
+    const scalar surfacePtReplaceDistCoeffSqr =
+        cvMeshControls().surfacePtReplaceDistCoeffSqr();
+
+    const label AtoV = label(6/Foam::pow(scalar(number_of_vertices()), 3));
+
     // Initial surface protrusion conformation - nearest surface point
     {
-        const scalar edgeSearchDistCoeffSqr =
-            cvMeshControls().edgeSearchDistCoeffSqrInitial(reconfMode);
-
-        const scalar surfacePtReplaceDistCoeffSqr =
-            cvMeshControls().surfacePtReplaceDistCoeffSqrInitial(reconfMode);
-
-        DynamicList<pointIndexHit> surfaceHits;
-        DynamicList<label> hitSurfaces;
-
-        DynamicList<pointIndexHit> featureEdgeHits;
-        DynamicList<label> featureEdgeFeaturesHit;
+        pointIndexHitAndFeatureDynList featureEdgeHits(AtoV/4);
+        pointIndexHitAndFeatureDynList surfaceHits(AtoV);
 
         for
         (
@@ -244,25 +306,16 @@ void Foam::conformalVoronoiMesh::buildSurfaceConformation
             vit++
         )
         {
-            if (vit->internalPoint() && vit->nearBoundary())
+            if (vit->nearBoundary())
             {
-                const Foam::point vert = topoint(vit->point());
-
-                if (!positionOnThisProc(vert))
-                {
-                    continue;
-                }
-
-                DynamicList<pointIndexHit> surfHitList;
-                DynamicList<label> hitSurfaceList;
+                pointIndexHitAndFeatureDynList surfaceIntersections(AtoV);
 
                 if
                 (
                     dualCellSurfaceAllIntersections
                     (
                         vit,
-                        surfHitList,
-                        hitSurfaceList
+                        surfaceIntersections
                     )
                 )
                 {
@@ -273,18 +326,11 @@ void Foam::conformalVoronoiMesh::buildSurfaceConformation
                     addSurfaceAndEdgeHits
                     (
                         vit,
-                        vert,
-                        surfHitList,
-                        hitSurfaceList,
+                        surfaceIntersections,
                         surfacePtReplaceDistCoeffSqr,
                         edgeSearchDistCoeffSqr,
                         surfaceHits,
-                        hitSurfaces,
-                        featureEdgeHits,
-                        featureEdgeFeaturesHit,
-                        newEdgeLocations,
-                        existingEdgeLocations,
-                        existingSurfacePtLocations
+                        featureEdgeHits
                     );
                 }
                 else
@@ -296,7 +342,7 @@ void Foam::conformalVoronoiMesh::buildSurfaceConformation
         }
 
         Info<< "    Vertices marked as being near a boundary: "
-            << countNearBoundaryVertices
+            << returnReduce(countNearBoundaryVertices, sumOp<label>())
             << " (after dual surface intersection)" << endl;
 
         label nVerts = number_of_vertices();
@@ -316,17 +362,27 @@ void Foam::conformalVoronoiMesh::buildSurfaceConformation
             << "    Number of edge hits " << nFeatEdHits
             << endl;
 
+        // In parallel, synchronise the surface trees
+        if (Pstream::parRun())
+        {
+            synchroniseSurfaceTrees(surfaceHits);
+        }
+
         insertSurfacePointPairs
         (
             surfaceHits,
-            hitSurfaces,
             "surfaceConformationLocations_initial.obj"
         );
 
+        // In parallel, synchronise the edge trees
+        if (Pstream::parRun())
+        {
+            synchroniseEdgeTrees(featureEdgeHits);
+        }
+
         insertEdgePointGroups
         (
             featureEdgeHits,
-            featureEdgeFeaturesHit,
             "edgeConformationLocations_initial.obj"
         );
 
@@ -337,32 +393,56 @@ void Foam::conformalVoronoiMesh::buildSurfaceConformation
 
     // Remember which vertices were referred to each processor so only updates
     // are sent.
-    List<labelHashSet> referralVertices(Pstream::nProcs());
+    PtrList<labelPairHashSet> referralVertices(Pstream::nProcs());
 
     // Store the vertices that have been received and added from each processor
     // already so that there is no attempt to add them more than once.
-    List<labelHashSet> receivedVertices(Pstream::nProcs());
+    autoPtr<labelPairHashSet> receivedVertices;
 
-    // Build the parallel interface the initial surface conformation
-    buildParallelInterface(referralVertices, receivedVertices, true, "initial");
+    if (Pstream::parRun())
+    {
+        forAll(referralVertices, procI)
+        {
+            if (procI != Pstream::myProcNo())
+            {
+                referralVertices.set
+                (
+                    procI,
+                    new labelPairHashSet(number_of_vertices()/Pstream::nProcs())
+                );
+            }
+        }
+
+        receivedVertices.set
+        (
+            new labelPairHashSet(number_of_vertices()/Pstream::nProcs())
+        );
+
+        // Build the parallel interface the initial surface conformation
+        sync
+        (
+            decomposition_().procBounds(),
+            referralVertices,
+            receivedVertices()
+        );
+    }
 
     label iterationNo = 0;
 
-    label maxIterations =
-        cvMeshControls().maxConformationIterations(reconfMode);
+    label maxIterations = cvMeshControls().maxConformationIterations();
 
     scalar iterationToInitialHitRatioLimit =
-        cvMeshControls().iterationToInitialHitRatioLimit(reconfMode);
+        cvMeshControls().iterationToInitialHitRatioLimit();
 
     label hitLimit = label(iterationToInitialHitRatioLimit*initialTotalHits);
 
     Info<< nl << "Stopping iterations when: " << nl
-        <<"    total number of hits drops below "
-        << iterationToInitialHitRatioLimit << " of initial hits ("
-        << hitLimit << ")" << nl
+        << "    total number of hits drops below "
+        << iterationToInitialHitRatioLimit
+        << " of initial hits (" << hitLimit << ")" << nl
         << " or " << nl
-        << "    maximum number of iterations ("
-        << maxIterations << ") is reached"
+        << "    maximum number of iterations (" << maxIterations
+        << ") is reached"
         << endl;
 
     // Set totalHits to a large enough positive value to enter the while loop on
@@ -376,17 +456,8 @@ void Foam::conformalVoronoiMesh::buildSurfaceConformation
      && iterationNo < maxIterations
     )
     {
-        scalar edgeSearchDistCoeffSqr =
-            cvMeshControls().edgeSearchDistCoeffSqrIteration(reconfMode);
-
-        scalar surfacePtReplaceDistCoeffSqr =
-            cvMeshControls().surfacePtReplaceDistCoeffSqrIteration(reconfMode);
-
-        DynamicList<pointIndexHit> surfaceHits;
-        DynamicList<label> hitSurfaces;
-
-        DynamicList<pointIndexHit> featureEdgeHits;
-        DynamicList<label> featureEdgeFeaturesHit;
+        pointIndexHitAndFeatureDynList surfaceHits(0.5*AtoV);
+        pointIndexHitAndFeatureDynList featureEdgeHits(0.25*AtoV);
 
         for
         (
@@ -402,11 +473,11 @@ void Foam::conformalVoronoiMesh::buildSurfaceConformation
             if
             (
                 vit->nearBoundary()
-             || vit->ppMaster()
-             || vit->referredInternalOrBoundaryPoint()
+             || vit->internalBoundaryPoint()
+             || (vit->internalOrBoundaryPoint() && vit->referred())
             )
             {
-                const Foam::point vert = topoint(vit->point());
+                pointIndexHitAndFeatureDynList surfaceIntersections(0.5*AtoV);
 
                 pointIndexHit surfHit;
                 label hitSurface;
@@ -417,37 +488,34 @@ void Foam::conformalVoronoiMesh::buildSurfaceConformation
 
                 if (surfHit.hit())
                 {
-                    DynamicList<pointIndexHit> tmpPIH;
-                    tmpPIH.append(surfHit);
-
-                    DynamicList<label> tmpHS;
-                    tmpHS.append(hitSurface);
+                    surfaceIntersections.append
+                    (
+                        pointIndexHitAndFeature(surfHit, hitSurface)
+                    );
 
                     addSurfaceAndEdgeHits
                     (
                         vit,
-                        vert,
-                        tmpPIH,
-                        tmpHS,
+                        surfaceIntersections,
                         surfacePtReplaceDistCoeffSqr,
                         edgeSearchDistCoeffSqr,
                         surfaceHits,
-                        hitSurfaces,
-                        featureEdgeHits,
-                        featureEdgeFeaturesHit,
-                        newEdgeLocations,
-                        existingEdgeLocations,
-                        existingSurfacePtLocations
+                        featureEdgeHits
                     );
                 }
-//                else
-//                {
-//                    vit->setInternal();
-//                }
+                else
+                {
+                    // No surface hit detected so if internal then don't check
+                    // again
+                    if (vit->nearBoundary())
+                    {
+                        vit->setInternal();
+                    }
+                }
             }
-            else if (vit->ppSlave() || vit->referredExternal())
+            else if (vit->externalBoundaryPoint())
             {
-                const Foam::point vert = topoint(vit->point());
+                pointIndexHitAndFeatureDynList surfaceIntersections(0.5*AtoV);
 
                 pointIndexHit surfHit;
                 label hitSurface;
@@ -458,33 +526,21 @@ void Foam::conformalVoronoiMesh::buildSurfaceConformation
 
                 if (surfHit.hit())
                 {
-                    DynamicList<pointIndexHit> tmpPIH;
-                    tmpPIH.append(surfHit);
-
-                    DynamicList<label> tmpHS;
-                    tmpHS.append(hitSurface);
+                    surfaceIntersections.append
+                    (
+                        pointIndexHitAndFeature(surfHit, hitSurface)
+                    );
 
                     addSurfaceAndEdgeHits
                     (
                         vit,
-                        vert,
-                        tmpPIH,
-                        tmpHS,
+                        surfaceIntersections,
                         surfacePtReplaceDistCoeffSqr,
                         edgeSearchDistCoeffSqr,
                         surfaceHits,
-                        hitSurfaces,
-                        featureEdgeHits,
-                        featureEdgeFeaturesHit,
-                        newEdgeLocations,
-                        existingEdgeLocations,
-                        existingSurfacePtLocations
+                        featureEdgeHits
                     );
                 }
-//                else
-//                {
-//                    vit->setInternal();
-//                }
             }
         }
 
@@ -507,41 +563,47 @@ void Foam::conformalVoronoiMesh::buildSurfaceConformation
 
         totalHits = nSurfHits + nFeatEdHits;
 
+        label nNotInserted = 0;
+
         if (totalHits > 0)
         {
+            // In parallel, synchronise the surface trees
+            if (Pstream::parRun())
+            {
+                nNotInserted += synchroniseSurfaceTrees(surfaceHits);
+            }
+
             insertSurfacePointPairs
             (
                 surfaceHits,
-                hitSurfaces,
-                fileName
-                (
-                    "surfaceConformationLocations_" + name(iterationNo) + ".obj"
-                )
+                "surfaceConformationLocations_" + name(iterationNo) + ".obj"
             );
 
+            // In parallel, synchronise the edge trees
+            if (Pstream::parRun())
+            {
+                nNotInserted += synchroniseEdgeTrees(featureEdgeHits);
+            }
+
             insertEdgePointGroups
             (
                 featureEdgeHits,
-                featureEdgeFeaturesHit,
                 "edgeConformationLocations_" + name(iterationNo) + ".obj"
             );
+
+            if (Pstream::parRun())
+            {
+                sync
+                (
+                    decomposition_().procBounds(),
+                    referralVertices,
+                    receivedVertices()
+                );
+            }
         }
 
         timeCheck("Conformation iteration " + name(iterationNo));
 
-        // Only need to update the interface if there are surface/edge hits
-        if (totalHits > 0)
-        {
-            // Update the parallel interface
-            buildParallelInterface
-            (
-                referralVertices,
-                receivedVertices,
-                false,
-                name(iterationNo)
-            );
-        }
-
         iterationNo++;
 
         if (iterationNo == maxIterations)
@@ -551,6 +613,14 @@ void Foam::conformalVoronoiMesh::buildSurfaceConformation
                 << maxIterations <<  ") reached." << endl;
         }
 
+        if (totalHits <= nNotInserted)
+        {
+            Info<< nl << "Total hits (" << totalHits
+                << ") less than number of failed insertions (" << nNotInserted
+                << "), stopping iterations" << endl;
+            break;
+        }
+
         if (totalHits < hitLimit)
         {
             Info<< nl << "Total hits (" << totalHits
@@ -558,6 +628,220 @@ void Foam::conformalVoronoiMesh::buildSurfaceConformation
                 << "), stopping iterations" << endl;
         }
     }
+
+    edgeLocationTreePtr_.clear();
+    surfacePtLocationTreePtr_.clear();
+}
+
+
+Foam::label Foam::conformalVoronoiMesh::synchroniseSurfaceTrees
+(
+    pointIndexHitAndFeatureList& surfaceHits
+)
+{
+    Info<< "    Surface tree synchronisation" << endl;
+
+    pointIndexHitAndFeatureDynList synchronisedSurfLocations
+    (
+        surfaceHits.size()
+    );
+
+    List<pointIndexHitAndFeatureDynList> procSurfLocations(Pstream::nProcs());
+
+    procSurfLocations[Pstream::myProcNo()] = surfaceHits;
+
+    Pstream::gatherList(procSurfLocations);
+    Pstream::scatterList(procSurfLocations);
+
+    List<labelHashSet> hits(Pstream::nProcs());
+
+    label nStoppedInsertion = 0;
+
+    // Do the nearness tests here
+    for (label procI = 0; procI < Pstream::nProcs(); ++procI)
+    {
+        // Skip own points
+        if (procI >= Pstream::myProcNo())
+        {
+            continue;
+        }
+
+        const pointIndexHitAndFeatureList& otherSurfEdges =
+            procSurfLocations[procI];
+
+        forAll(otherSurfEdges, peI)
+        {
+            const Foam::point& pt = otherSurfEdges[peI].first().hitPoint();
+
+            pointIndexHit nearest;
+            pointIsNearSurfaceLocation(pt, nearest);
+
+            pointIndexHit nearestEdge;
+            pointIsNearFeatureEdgeLocation(pt, nearestEdge);
+
+            bool isNearFeaturePt = nearFeaturePt(pt);
+
+            if (nearest.hit() || nearestEdge.hit() || isNearFeaturePt)
+            {
+                nStoppedInsertion++;
+
+                if (!hits[procI].found(peI))
+                {
+                    hits[procI].insert(peI);
+                }
+            }
+        }
+    }
+
+    Pstream::listCombineGather(hits, plusEqOp<labelHashSet>());
+    Pstream::listCombineScatter(hits);
+
+    forAll(surfaceHits, eI)
+    {
+        if (!hits[Pstream::myProcNo()].found(eI))
+        {
+            synchronisedSurfLocations.append(surfaceHits[eI]);
+        }
+    }
+
+    forAll(synchronisedSurfLocations, pI)
+    {
+        appendToSurfacePtTree
+        (
+            synchronisedSurfLocations[pI].first().hitPoint()
+        );
+    }
+
+    const label nNotInserted = returnReduce(nStoppedInsertion, sumOp<label>());
+
+    Info<< "        Not inserting total of " << nNotInserted << " locations"
+        << endl;
+
+    surfaceHits = synchronisedSurfLocations;
+
+    return nNotInserted;
+}
+
+
+Foam::label Foam::conformalVoronoiMesh::synchroniseEdgeTrees
+(
+    pointIndexHitAndFeatureList& featureEdgeHits
+)
+{
+    Info<< "    Edge tree synchronisation" << endl;
+
+    pointIndexHitAndFeatureDynList synchronisedEdgeLocations
+    (
+        featureEdgeHits.size()
+    );
+
+    List<pointIndexHitAndFeatureDynList> procEdgeLocations(Pstream::nProcs());
+
+    procEdgeLocations[Pstream::myProcNo()] = featureEdgeHits;
+
+    Pstream::gatherList(procEdgeLocations);
+    Pstream::scatterList(procEdgeLocations);
+
+    List<labelHashSet> hits(Pstream::nProcs());
+
+    label nStoppedInsertion = 0;
+
+    // Do the nearness tests here
+    for (label procI = 0; procI < Pstream::nProcs(); ++procI)
+    {
+        // Skip own points
+        if (procI >= Pstream::myProcNo())
+        {
+            continue;
+        }
+
+        pointIndexHitAndFeatureList& otherProcEdges = procEdgeLocations[procI];
+
+        forAll(otherProcEdges, peI)
+        {
+            const Foam::point& pt = otherProcEdges[peI].first().hitPoint();
+
+            pointIndexHit nearest;
+            pointIsNearFeatureEdgeLocation(pt, nearest);
+
+            bool isNearFeaturePt = nearFeaturePt(pt);
+
+            if (nearest.hit() || isNearFeaturePt)
+            {
+                nStoppedInsertion++;
+
+                if (!hits[procI].found(peI))
+                {
+                    hits[procI].insert(peI);
+                }
+            }
+        }
+    }
+
+    Pstream::listCombineGather(hits, plusEqOp<labelHashSet>());
+    Pstream::listCombineScatter(hits);
+
+    forAll(featureEdgeHits, eI)
+    {
+        if (!hits[Pstream::myProcNo()].found(eI))
+        {
+            synchronisedEdgeLocations.append(featureEdgeHits[eI]);
+        }
+    }
+
+    forAll(synchronisedEdgeLocations, pI)
+    {
+        appendToEdgeLocationTree
+        (
+            synchronisedEdgeLocations[pI].first().hitPoint()
+        );
+    }
+
+    const label nNotInserted = returnReduce(nStoppedInsertion, sumOp<label>());
+
+    Info<< "        Not inserting total of " << nNotInserted << " locations"
+        << endl;
+
+    featureEdgeHits = synchronisedEdgeLocations;
+
+    return nNotInserted;
+}
+
+
+bool Foam::conformalVoronoiMesh::locationConformsToInside
+(
+    const pointIndexHitAndFeature& info
+) const
+{
+    bool keepLocation = true;
+
+    if (info.first().hit())
+    {
+        vectorField norm(1);
+
+        allGeometry_[info.second()].getNormal
+        (
+            List<pointIndexHit>(1, info.first()),
+            norm
+        );
+
+        const vector& n = norm[0];
+
+        const scalar ppDist = pointPairDistance(info.first().hitPoint());
+
+        const Foam::point innerPoint = info.first().hitPoint() - ppDist*n;
+
+        if (!geometryToConformTo_.inside(innerPoint))
+        {
+            keepLocation = false;
+        }
+    }
+    else
+    {
+        keepLocation = false;
+    }
+
+    return keepLocation;
 }
 
 
@@ -580,6 +864,8 @@ bool Foam::conformalVoronoiMesh::dualCellSurfaceAnyIntersection
         (
             is_infinite(fit->first)
          || is_infinite(fit->first->neighbor(fit->second))
+         || !fit->first->hasInternalPoint()
+         || !fit->first->neighbor(fit->second)->hasInternalPoint()
         )
         {
             continue;
@@ -602,11 +888,6 @@ bool Foam::conformalVoronoiMesh::dualCellSurfaceAnyIntersection
              && geometryToConformTo_.findSurfaceAnyIntersection(a, b)
             )
             {
-                // Pout<< "# findSurfaceAnyIntersection" << endl;
-                // meshTools::writeOBJ(Pout, a);
-                // meshTools::writeOBJ(Pout, b);
-                // Pout<< "l cr0 cr1" << endl;
-
                 return true;
             }
         }
@@ -626,8 +907,7 @@ bool Foam::conformalVoronoiMesh::dualCellSurfaceAnyIntersection
 bool Foam::conformalVoronoiMesh::dualCellSurfaceAllIntersections
 (
     const Delaunay::Finite_vertices_iterator& vit,
-    DynamicList<pointIndexHit>& infoList,
-    DynamicList<label>& hitSurfaceList
+    pointIndexHitAndFeatureDynList& infoList
 ) const
 {
     bool flagIntersection = false;
@@ -646,6 +926,10 @@ bool Foam::conformalVoronoiMesh::dualCellSurfaceAllIntersections
         (
             is_infinite(fit->first)
          || is_infinite(fit->first->neighbor(fit->second))
+         || !fit->first->hasInternalPoint()
+         || !fit->first->neighbor(fit->second)->hasInternalPoint()
+//         || fit->first->hasFarPoint()
+//         || fit->first->neighbor(fit->second)->hasFarPoint()
         )
         {
             continue;
@@ -689,7 +973,7 @@ bool Foam::conformalVoronoiMesh::dualCellSurfaceAllIntersections
 
             const vector& n = norm[0];
 
-            const Foam::point vertex = topoint(vit->point());
+            pointFromPoint vertex = topoint(vit->point());
 
             const plane p(infoIntersection.hitPoint(), n);
 
@@ -699,36 +983,45 @@ bool Foam::conformalVoronoiMesh::dualCellSurfaceAllIntersections
 
             const Foam::point newPoint = vertex + d*n;
 
-            pointIndexHit info;
-            label hitSurface = -1;
+            pointIndexHitAndFeature info;
 
             geometryToConformTo_.findSurfaceNearest
             (
                 newPoint,
                 surfaceSearchDistanceSqr(newPoint),
-                info,
-                hitSurface
+                info.first(),
+                info.second()
             );
 
             bool rejectPoint = false;
 
-            if (info.hit())
+            if (!locationConformsToInside(info))
+            {
+                rejectPoint = true;
+            }
+
+            if (!rejectPoint && info.first().hit())
             {
                 if (!infoList.empty())
                 {
                     forAll(infoList, hitI)
                     {
                         // Reject point if the point is already added
-                        if (infoList[hitI].index() == info.index())
+                        if
+                        (
+                            infoList[hitI].first().index()
+                         == info.first().index()
+                        )
                         {
                             rejectPoint = true;
                             break;
                         }
 
-                        const Foam::point& p = infoList[hitI].hitPoint();
+                        const Foam::point& p
+                            = infoList[hitI].first().hitPoint();
 
                         const scalar separationDistance =
-                            mag(p - info.hitPoint());
+                            mag(p - info.first().hitPoint());
 
                         const scalar minSepDist =
                             sqr
@@ -751,11 +1044,10 @@ bool Foam::conformalVoronoiMesh::dualCellSurfaceAllIntersections
 
             // The normal ray from the vertex will not always result in a hit
             // because another surface may be in the way.
-            if (!rejectPoint && info.hit())
+            if (!rejectPoint && info.first().hit())
             {
                 flagIntersection = true;
                 infoList.append(info);
-                hitSurfaceList.append(hitSurface);
             }
         }
     }
@@ -808,1005 +1100,6 @@ bool Foam::conformalVoronoiMesh::clipLineToProc
 }
 
 
-void Foam::conformalVoronoiMesh::buildParallelInterface
-(
-    const word& outputName
-)
-{
-    List<labelHashSet> referralVertices(Pstream::nProcs());
-    List<labelHashSet> receivedVertices(Pstream::nProcs());
-
-    buildParallelInterface
-    (
-        referralVertices,
-        receivedVertices,
-        true,
-        outputName
-    );
-}
-
-
-Foam::label Foam::conformalVoronoiMesh::removeProcessorBoundarySeeds
-(
-    bool reinsertBoundPts
-)
-{
-    label nFarPoints = 0;
-
-
-
-    std::list<Vertex_handle> toRemove;
-
-    for
-    (
-        Delaunay::Finite_vertices_iterator vit = finite_vertices_begin();
-        vit != finite_vertices_end();
-        ++vit
-    )
-    {
-        if (vit->farPoint())
-        {
-            //remove(vit);
-            toRemove.push_back(vit);
-            nFarPoints++;
-        }
-    }
-
-    // This function removes the points in the iterator range and then
-    // retriangulates.
-    timeCheck("Start Removing Seeded Points " + name(toRemove.size()));
-
-    remove_cluster(toRemove.begin(), toRemove.end());
-
-
-    // Need to do this to make sure the triangulation is well-behaved
-    if (reinsertBoundPts)
-    {
-        reinsertBoundingPoints();
-    }
-
-
-
-//    DynamicList<Foam::point> toAdd;
-//    DynamicList<label> indices;
-//    DynamicList<label> types;
-//
-//    for
-//    (
-//        Delaunay::Finite_vertices_iterator vit = finite_vertices_begin();
-//        vit != finite_vertices_end();
-//        ++vit
-//    )
-//    {
-//        if (!vit->farPoint())
-//        {
-//            toAdd.append(topoint(vit->point()));
-//            indices.append(vit->index());
-//            types.append(vit->type());
-//
-//            nFarPoints++;
-//        }
-//    }
-//
-//    this->clear();
-//
-//    // Need to do this to make sure the triangulation is well-behaved
-//    if (reinsertBoundPts)
-//    {
-//        reinsertBoundingPoints();
-//    }
-//
-//    forAll(toAdd, pI)
-//    {
-//        insertPoint(toAdd[pI], indices[pI], types[pI]);
-//    }
-
-
-    timeCheck("End Removing Seeded Points");
-
-    return nFarPoints;
-}
-
-
-void Foam::conformalVoronoiMesh::seedProcessorBoundarySurfaces
-(
-    bool seedProcessors
-)
-{
-    //removeProcessorBoundarySeeds(false);
-
-    // Loop over processor patch faces and insert a point in the centre of the
-    // face
-    const fvMesh& mesh = decomposition_().mesh();
-    const polyBoundaryMesh& bMesh = mesh.boundaryMesh();
-
-    DynamicList<Foam::point> pts;
-    DynamicList<label> indices;
-    DynamicList<label> types;
-
-    label nFarPoints = 0;
-
-    const scalar normalDistance = 2.0;
-    const scalar pert = 0.1*(rndGen_.scalar01() - 0.5);
-
-    forAll(bMesh, patchI)
-    {
-        const polyPatch& patch = bMesh[patchI];
-
-        if (!seedProcessors && isA<processorPolyPatch>(patch))
-        {
-            continue;
-        }
-
-        forAll(patch, faceI)
-        {
-            if (faceI % 1 == 0)
-            {
-                const face& f = patch[faceI];
-
-                pts.append
-                (
-                    f.centre(mesh.points())
-                  + pert*normalDistance*f.normal(mesh.points())
-                );
-                indices.append(nFarPoints++);
-                types.append(Vb::vtFar);
-            }
-        }
-    }
-
-    insertPoints(pts, indices, types, false);
-
-    reduce(nFarPoints, sumOp<label>());
-
-    Info<< "    Inserted " << nFarPoints
-        << " far points into the mesh." << endl;
-}
-
-
-void Foam::conformalVoronoiMesh::buildParallelInterface
-(
-    List<labelHashSet>& referralVertices,
-    List<labelHashSet>& receivedVertices,
-    bool initialEdgeReferral,
-    const word& outputName
-)
-{
-    if (!Pstream::parRun())
-    {
-        return;
-    }
-
-    Info<< nl << "Parallel interface construction" << endl;
-
-    timeCheck("Before buildParallelInterface");
-
-    // Hard coded switch, can be turned on for testing and debugging purposes -
-    // all vertices will be referred to all processors, use with caution for
-    // big cases.
-    bool allPointReferral = false;
-
-    if (allPointReferral)
-    {
-        buildParallelInterfaceAll
-        (
-            referralVertices,
-            receivedVertices,
-            outputName
-        );
-
-        timeCheck("After buildParallelInterfaceAll");
-    }
-
-
-    // Reject points that are not near the boundary from the subsequent
-    // searches
-
-//    label nearProcCount = 0;
-//    label notNearProcCount = 0;
-//    boundBox quickRejectionBox(decomposition_().procBounds());
-//
-////    Pout<< "Processor boundBox: " << quickRejectionBox << endl;
-//
-//    quickRejectionBox.inflate(-0.1);
-//
-//    OFstream str("rejectionBox_" + name(Pstream::myProcNo()) + ".obj");
-//
-//    meshTools::writeOBJ
-//    (
-//        str,
-//        boundBox::faces(),
-//        quickRejectionBox.points()
-//    );
-//
-//    Pout<< "Inflated rejection boundBox: " << quickRejectionBox << endl;
-
-//    for
-//    (
-//        Delaunay::Finite_vertices_iterator vit = finite_vertices_begin();
-//        vit != finite_vertices_end();
-//        vit++
-//    )
-//    {
-//        if (vit->real() && !vit->nearProcBoundary())
-//        {
-//            const Foam::point& pt = topoint(vit->point());
-//            const scalar range = targetCellSize(pt);
-//
-////            if
-////            (
-////                decomposition_().overlapsThisProcessor
-////                (
-////                    pt,
-////                    range
-////                )
-////            )
-//            if (!quickRejectionBox.contains(pt))
-//            {
-//                vit->setNearProcBoundary();
-//                nearProcCount++;
-//            }
-//            else
-//            {
-//                //vit->setNearProcBoundary();
-//                notNearProcCount++;
-//            }
-//        }
-//    }
-//
-//    reduce(nearProcCount, sumOp<label>());
-//    reduce(notNearProcCount, sumOp<label>());
-//
-//    timeCheck
-//    (
-//        "End of potential intersection search. "
-//      + name(nearProcCount) + " are near a processor boundary. "
-//      + name(notNearProcCount) + " are not."
-//    );
-
-//    if (initialEdgeReferral)
-//    {
-//        // Used as an initial pass to localise the vertex referring - find
-//        // vertices whose dual edges pierce nearby processor volumes and refer
-//        // them to establish a sensible boundary interface region before
-//        // running a circumsphere assessment.
-//
-//        buildParallelInterfaceIntersection
-//        (
-//            referralVertices,
-//            receivedVertices,
-//            outputName
-//        );
-//
-//        timeCheck("After buildParallelInterfaceIntersection");
-//    }
-
-    buildParallelInterfaceInfluence
-    (
-        referralVertices,
-        receivedVertices,
-        outputName
-    );
-
-    timeCheck("After buildParallelInterface");
-
-    // Check all referred vertices are actually used on the processor.
-    label nUnusedReferred = numberOfUnusedReferredPoints();
-
-    reduce(nUnusedReferred, sumOp<label>());
-
-    Info<< "    Number of referred points that are not used : "
-        << nUnusedReferred << " (approximate)" << endl;
-}
-
-
-Foam::label Foam::conformalVoronoiMesh::numberOfUnusedReferredPoints() const
-{
-    label nUnusedPoints = 0;
-
-    for
-    (
-        Delaunay::Finite_vertices_iterator vit = finite_vertices_begin();
-        vit != finite_vertices_end();
-        ++vit
-    )
-    {
-        if (vit->referred())
-        {
-            std::list<Vertex_handle> adjVertices;
-            finite_adjacent_vertices(vit, std::back_inserter(adjVertices));
-
-            bool isUsed = false;
-
-            for
-            (
-                std::list<Vertex_handle>::iterator adjVit = adjVertices.begin();
-                adjVit != adjVertices.end();
-                ++adjVit
-            )
-            {
-                if ((*adjVit)->real())
-                {
-                    isUsed = true;
-                }
-            }
-
-            if (!isUsed)
-            {
-                nUnusedPoints++;
-            }
-        }
-    }
-
-    return nUnusedPoints;
-}
-
-
-void Foam::conformalVoronoiMesh::buildParallelInterfaceAll
-(
-    List<labelHashSet>& referralVertices,
-    List<labelHashSet>& receivedVertices,
-    const word& outputName
-)
-{
-    // Refer all points to all processors
-
-    DynamicList<Foam::point> parallelAllPoints;
-    DynamicList<label> targetProcessor;
-    DynamicList<label> parallelAllIndices;
-
-    for
-    (
-        Delaunay::Finite_vertices_iterator vit = finite_vertices_begin();
-        vit != finite_vertices_end();
-        ++vit
-    )
-    {
-        if (!vit->farPoint())
-        {
-            for (label procI = 0; procI < Pstream::nProcs(); procI++)
-            {
-                if (procI == Pstream::myProcNo())
-                {
-                    continue;
-                }
-
-                label vIndex = vit->index();
-
-                // Using the hashSet to ensure that each vertex is
-                // only referred once to each processor
-                if (!referralVertices[procI].found(vIndex))
-                {
-                    referralVertices[procI].insert(vIndex);
-
-                    parallelAllPoints.append
-                    (
-                        topoint(vit->point())
-                    );
-
-                    targetProcessor.append(procI);
-
-                    if (vit->internalOrBoundaryPoint())
-                    {
-                        parallelAllIndices.append(vIndex);
-                    }
-                    else
-                    {
-                        parallelAllIndices.append(-vIndex);
-                    }
-                }
-            }
-        }
-    }
-
-    referVertices
-    (
-        targetProcessor,
-        parallelAllPoints,
-        parallelAllIndices,
-        receivedVertices,
-        "all",
-        outputName
-    );
-}
-
-void Foam::conformalVoronoiMesh::buildParallelInterfaceIntersection
-(
-    List<labelHashSet>& referralVertices,
-    List<labelHashSet>& receivedVertices,
-    const word& outputName
-)
-{
-    DynamicList<Foam::point> parallelIntersectionPoints;
-    DynamicList<label> targetProcessor;
-    DynamicList<label> parallelIntersectionIndices;
-
-    // End points of dual edges.  Some of these values will not be used,
-    // i.e. for edges with non-real vertices.
-    DynamicList<Foam::point> dE0;
-    DynamicList<Foam::point> dE1;
-
-    PackedBoolList testFacetIntersection(number_of_facets(), false);
-
-    // Index outer (all) Delaunauy facets for whether they are potential
-    // intersections, index (inner) the list of tests an results.
-    label fIInner = 0;
-    label fIOuter = 0;
-
-    for
-    (
-        Delaunay::Finite_facets_iterator fit = finite_facets_begin();
-        fit != finite_facets_end();
-        ++fit
-    )
-    {
-        const Cell_handle c1(fit->first);
-        const Cell_handle c2(c1->neighbor(fit->second));
-
-        // If either Delaunay cell at the end of the Dual edge is infinite,
-        // skip.
-        if
-        (
-            !is_infinite(c1) && !is_infinite(c2)
-        )
-        {
-            // The Delaunauy cells at either end of the dual edge need to be
-            // real, i.e. all vertices form part of the internal or boundary
-            // definition
-            if
-            (
-                c1->internalOrBoundaryDualVertex()
-             && c2->internalOrBoundaryDualVertex()
-            )
-            {
-                const Foam::point& a = c1->dual();
-                const Foam::point& b = c2->dual();
-
-                // Only if the dual edge cuts the boundary of this processor is
-                // it going to be counted.
-                pointIndexHit info = decomposition_().findLineAny(a, b);
-
-                if (info.hit())
-                {
-                    dE0.append(a);
-                    dE1.append(b);
-
-                    testFacetIntersection[fIOuter] = true;
-                }
-            }
-        }
-
-        fIOuter++;
-    }
-
-    reduce(fIOuter, sumOp<label>());
-
-    timeCheck
-    (
-        "End of actual intersection search over "
-      + name(fIOuter)
-      + " faces."
-    );
-
-    // Preform intersections in both directions, as there is no sense
-    // associated with the Dual edge
-    List<List<pointIndexHit> > intersectionForward(intersectsProc(dE0, dE1));
-    List<List<pointIndexHit> > intersectionReverse(intersectsProc(dE1, dE0));
-
-    timeCheck("End of find processor intersection");
-
-    // Reset counter
-    fIOuter = 0;
-
-    // Relying on the order of iteration of facets being the same as before
-    for
-    (
-        Delaunay::Finite_facets_iterator fit = finite_facets_begin();
-        fit != finite_facets_end();
-        ++fit
-    )
-    {
-        const Cell_handle c1(fit->first);
-        const Cell_handle c2(c1->neighbor(fit->second));
-
-        // Pre-tested facet intersection potential
-        if (testFacetIntersection[fIOuter])
-        {
-            const Foam::point a = dE0[fIInner];
-            const Foam::point b = dE1[fIInner];
-
-            scalar hitDistSqr = GREAT;
-            label closestHitProc = -1;
-            scalar closestHitDistSqr = GREAT;
-
-            // Find the closest intersection with the other background meshes
-            // of the other processors in each direction, finding the closest.
-            forAll(intersectionForward[fIInner], iFI)
-            {
-                const pointIndexHit& info = intersectionForward[fIInner][iFI];
-
-                if (info.hit())
-                {
-                    // Line was a -> hit
-                    hitDistSqr = magSqr(a - info.hitPoint());
-                }
-
-                if (hitDistSqr < closestHitDistSqr)
-                {
-                    closestHitProc = info.index();
-                    closestHitDistSqr = hitDistSqr;
-                }
-            }
-
-            forAll(intersectionReverse[fIInner], iRI)
-            {
-                const pointIndexHit& info = intersectionReverse[fIInner][iRI];
-
-                if (info.hit())
-                {
-                    // Line was b -> hit
-                    hitDistSqr = magSqr(b - info.hitPoint());
-                }
-
-                if (hitDistSqr < closestHitDistSqr)
-                {
-                    closestHitProc = info.index();
-                    closestHitDistSqr = hitDistSqr;
-                }
-            }
-
-            if (closestHitProc >= 0)
-            {
-                // This dual edge pierces a processor, refer all vertices from
-                // both Delaunauy cells to it.
-
-                for (int i = 0; i < 4; i++)
-                {
-                    Vertex_handle v = c1->vertex(i);
-
-                    label vIndex = v->index();
-
-                    if (v->farPoint() || v->referred())
-                    {
-                        continue;
-                    }
-
-                    // Using the hashSet to ensure that each vertex is only
-                    // referred once to each processor
-                    if (!referralVertices[closestHitProc].found(vIndex))
-                    {
-                        referralVertices[closestHitProc].insert(vIndex);
-
-                        parallelIntersectionPoints.append(topoint(v->point()));
-
-                        targetProcessor.append(closestHitProc);
-
-                        if (v->internalOrBoundaryPoint())
-                        {
-                            parallelIntersectionIndices.append(vIndex);
-                        }
-                        else
-                        {
-                            parallelIntersectionIndices.append(-vIndex);
-                        }
-
-                        // Pout<< "Refer "
-                        //     << parallelIntersectionPoints.last()
-                        //     << " " << parallelIntersectionIndices.last()
-                        //     << " " << closestHitProc
-                        //     << endl;
-                    }
-                }
-
-                for (int i = 0; i < 4; i++)
-                {
-                    Vertex_handle v = c2->vertex(i);
-
-                    label vIndex = v->index();
-
-                    if (v->farPoint() || v->referred())
-                    {
-                        continue;
-                    }
-
-                    // Using the hashSet to ensure that each vertex is only
-                    // referred once to each processor
-                    if (!referralVertices[closestHitProc].found(vIndex))
-                    {
-                        referralVertices[closestHitProc].insert(vIndex);
-
-                        parallelIntersectionPoints.append(topoint(v->point()));
-
-                        targetProcessor.append(closestHitProc);
-
-                        if (v->internalOrBoundaryPoint())
-                        {
-                            parallelIntersectionIndices.append(vIndex);
-                        }
-                        else
-                        {
-                            parallelIntersectionIndices.append(-vIndex);
-                        }
-
-                        // Pout<< "Refer "
-                        //     << parallelIntersectionPoints.last()
-                        //     << " " << parallelIntersectionIndices.last()
-                        //     << " " << closestHitProc
-                        //     << endl;
-                    }
-                }
-            }
-
-            fIInner++;
-        }
-
-        fIOuter++;
-    }
-
-    referVertices
-    (
-        targetProcessor,
-        parallelIntersectionPoints,
-        parallelIntersectionIndices,
-        receivedVertices,
-        "intersection",
-        outputName
-    );
-}
-
-
-void Foam::conformalVoronoiMesh::buildParallelInterfaceInfluence
-(
-    List<labelHashSet>& referralVertices,
-    List<labelHashSet>& receivedVertices,
-    const word& outputName
-)
-{
-    DynamicList<Foam::point> parallelInfluencePoints;
-    DynamicList<label> targetProcessor;
-    DynamicList<label> parallelInfluenceIndices;
-
-    // Some of these values will not be used, i.e. for non-real cells
-    DynamicList<Foam::point> circumcentre;
-    DynamicList<scalar> circumradiusSqr;
-
-
-    // Index outer (all) Delaunauy cells for whether they are potential
-    // overlaps, index (inner) the list of tests an results.
-    label cIInner = 0;
-    label cIOuter = 0;
-
-    seedProcessorBoundarySurfaces(true);
-
-    label cellIndexCount = 0;
-    for
-    (
-        Delaunay::Finite_cells_iterator cit = finite_cells_begin();
-        cit != finite_cells_end();
-        ++cit
-    )
-    {
-        cit->cellIndex() = cellIndexCount++;
-    }
-
-
-    timeCheck("End of cell Indexing");
-
-    labelList testCellInfluence(number_of_cells(), 0);
-
-    label nQuickRejections = 0;
-
-    for
-    (
-        Delaunay::Finite_cells_iterator cit = finite_cells_begin();
-        cit != finite_cells_end();
-        ++cit
-    )
-    {
-        const Foam::point& cc = cit->dual();
-
-        const scalar crSqr = magSqr(cc - topoint(cit->vertex(0)->point()));
-
-        if
-        (
-            decomposition_().tree().quickCircumsphereRejection
-            (
-                cc,
-                crSqr,
-                decomposition_().octreeNearestDistances()
-            )
-        )
-        {
-            nQuickRejections++;
-            //testCellInfluence[cit->cellIndex()] = -1;
-        }
-    }
-
-    timeCheck("End of octreeNearestDistances calculation");
-
-    for
-    (
-        Delaunay::Finite_cells_iterator cit = finite_cells_begin();
-        cit != finite_cells_end();
-        ++cit
-    )
-    {
-        // Assess the influence of the circumsphere of each Delaunay cell with
-        // the defining volumes for all processors.  Any processor touched by
-        // the circumsphere requires all points of the cell to be referred to
-        // it.
-
-        // The Delaunay cells to assess have to be real, i.e. all vertices form
-        // part of the internal or any part of the boundary definition
-        if
-        (
-            (testCellInfluence[cit->cellIndex()] == 0)
-         && (cit->real() || cit->hasFarPoint())
-        )
-        {
-            const Foam::point& cc = cit->dual();
-
-            const scalar crSqr = magSqr(cc - topoint(cit->vertex(0)->point()));
-
-            // Only if the circumsphere overlaps the boundary of this processor
-            // is there a chance of it overlapping others
-            if (decomposition_().overlapsThisProcessor(cc, sqr(1.01)*crSqr))
-            {
-                circumcentre.append(cc);
-                circumradiusSqr.append(crSqr);
-
-                testCellInfluence[cit->cellIndex()] = 1;
-            }
-        }
-
-        cIOuter++;
-    }
-
-    timeCheck("End of testing cell influence");
-
-//    Pout<< "Number of quick rejections = " << nQuickRejections << endl;
-    Pout<< "Number of influences = " << circumcentre.size() << endl;
-
-    // Increasing the circumspheres to increase the overlaps and compensate for
-    // floating point errors missing some referrals
-    labelListList circumsphereOverlaps
-        = decomposition_().overlapsProcessors
-          (
-              circumcentre,
-              sqr(1.01)*circumradiusSqr,
-              false
-          );
-
-    timeCheck("End of increasing overlaps");
-
-    // Reset counters
-    cIOuter = 0;
-
-    // Relying on the order of iteration of cells being the same as before
-    for
-    (
-        Delaunay::Finite_cells_iterator cit = finite_cells_begin();
-        cit != finite_cells_end();
-        ++cit
-    )
-    {
-        // Pre-tested circumsphere potential influence
-        if (testCellInfluence[cit->cellIndex()] == 1)
-        {
-            const labelList& citOverlaps = circumsphereOverlaps[cIInner];
-
-            forAll(citOverlaps, cOI)
-            {
-                label procI = citOverlaps[cOI];
-
-                for (int i = 0; i < 4; i++)
-                {
-                    Vertex_handle v = cit->vertex(i);
-
-                    label vIndex = v->index();
-
-                    if (v->farPoint() || v->referred())
-                    {
-                        continue;
-                    }
-
-                    // Using the hashSet to ensure that each vertex is only
-                    // referred once to each processor
-                    if (!referralVertices[procI].found(vIndex))
-                    {
-                        referralVertices[procI].insert(vIndex);
-
-                        parallelInfluencePoints.append(topoint(v->point()));
-
-                        targetProcessor.append(procI);
-
-                        if (v->internalOrBoundaryPoint())
-                        {
-                            parallelInfluenceIndices.append(vIndex);
-                        }
-                        else
-                        {
-                            parallelInfluenceIndices.append(-vIndex);
-                        }
-                    }
-                }
-            }
-
-            cIInner++;
-        }
-
-        cIOuter++;
-    }
-
-    label nFarPoints = removeProcessorBoundarySeeds(true);
-
-    reduce(nFarPoints, sumOp<label>());
-
-    Info<< "    Removed " << nFarPoints
-        << " far points from the mesh." << endl;
-
-
-//    seedProcessorBoundarySurfaces(false);
-
-//    cIInner = 0;
-//    cIOuter = 0;
-
-
-    // Relying on the order of iteration of cells being the same as before
-//    for
-//    (
-//        Delaunay::Finite_cells_iterator cit = finite_cells_begin();
-//        cit != finite_cells_end();
-//        ++cit
-//    )
-//    {
-//        // Pre-tested circumsphere potential influence
-//        if (testCellInfluence[cIOuter])
-//        {
-//            const labelList& citOverlaps = circumsphereOverlaps[cIInner];
-//
-//            forAll(citOverlaps, cOI)
-//            {
-//                label procI = citOverlaps[cOI];
-//
-//                recursiveCircumsphereSearch
-//                (
-//                    cit,
-//                    procI,
-//                    referralVertices,
-//                    checkedCells,
-//                    parallelInfluencePoints,
-//                    parallelInfluenceIndices,
-//                    targetProcessor
-//                );
-//            }
-//
-//            cIInner++;
-//        }
-//
-//        cIOuter++;
-//    }
-
-//    for
-//    (
-//        Delaunay::Finite_vertices_iterator vit = finite_vertices_begin();
-//        vit != finite_vertices_end();
-//        ++vit
-//    )
-//    {
-//        if (vit->referred())
-//        {
-//            //Pout << "REMOVE: " << topoint(vit->point()) << endl;
-//            remove(vit);
-//        }
-//    }
-
-    referVertices
-    (
-        targetProcessor,
-        parallelInfluencePoints,
-        parallelInfluenceIndices,
-        receivedVertices,
-        "influence",
-        outputName
-    );
-}
-
-
-void Foam::conformalVoronoiMesh::referVertices
-(
-    const DynamicList<label>& targetProcessor,
-    DynamicList<Foam::point>& parallelPoints,
-    DynamicList<label>& parallelIndices,
-    List<labelHashSet>& receivedVertices,
-    const word& stageName,
-    const word& outputName
-)
-{
-    timeCheck("Start of referVertices " + stageName);
-
-    if (cvMeshControls().objOutput())
-    {
-        writePoints
-        (
-            "parallel_" + stageName +"_pointsToSend_" + outputName + ".obj",
-            parallelPoints
-        );
-    }
-
-    mapDistribute pointMap = backgroundMeshDecomposition::buildMap
-    (
-        targetProcessor
-    );
-
-    label totalVertices = parallelPoints.size();
-
-    reduce(totalVertices, sumOp<label>());
-
-    pointMap.distribute(parallelPoints);
-
-    pointMap.distribute(parallelIndices);
-
-    if (cvMeshControls().objOutput())
-    {
-        writePoints
-        (
-            "parallel_" + stageName +"_pointsReceived_" + outputName + ".obj",
-            parallelPoints
-        );
-    }
-
-    timeCheck("Start of referVertices " + stageName + " insertion.");
-
-    label inserted = 0;
-
-    for (label procI = 0; procI < Pstream::nProcs(); procI++)
-    {
-        const labelList& constructMap = pointMap.constructMap()[procI];
-
-        if (constructMap.size())
-        {
-            forAll(constructMap, i)
-            {
-                label origIndex = parallelIndices[constructMap[i]];
-
-                if (!receivedVertices[procI].found(origIndex))
-                {
-                    // For the initial referred vertices, the original
-                    // processor is the one that is sending it.
-                    label encodedProcI = Vb::encodeProcIndex(procI);
-
-                    // Pout<< "Insert "
-                    //     << parallelPoints[constructMap[i]]
-                    //     << " " << origIndex
-                    //     << " " << procI
-                    //     << endl;
-
-                    insertPoint
-                    (
-                        parallelPoints[constructMap[i]],
-                        origIndex,
-                        encodedProcI
-                    );
-
-                    inserted++;
-
-                    receivedVertices[procI].insert(origIndex);
-                }
-            }
-        }
-    }
-
-    reduce(inserted, sumOp<label>());
-
-    Info<< "    Inserted " << stageName << " vertices " << inserted << endl;
-
-    Info<< "    Total " << stageName << " vertices " << totalVertices << endl;
-
-    timeCheck("End of referVertices " + stageName);
-}
-
-
 void Foam::conformalVoronoiMesh::dualCellLargestSurfaceProtrusion
 (
     const Delaunay::Finite_vertices_iterator& vit,
@@ -1821,7 +1114,7 @@ void Foam::conformalVoronoiMesh::dualCellLargestSurfaceProtrusion
     std::list<Facet> facets;
     finite_incident_facets(vit, std::back_inserter(facets));
 
-    const Foam::point vert = topoint(vit->point());
+    pointFromPoint vert = topoint(vit->point());
 
     scalar maxProtrusionDistance = maxSurfaceProtrusion(vert);
 
@@ -1832,12 +1125,20 @@ void Foam::conformalVoronoiMesh::dualCellLargestSurfaceProtrusion
         ++fit
     )
     {
-        const Foam::point edgeMid =
-            0.5
-           *(
-                fit->first->dual()
-              + fit->first->neighbor(fit->second)->dual()
-            );
+        Cell_handle c1 = fit->first;
+        Cell_handle c2 = fit->first->neighbor(fit->second);
+
+        if
+        (
+            is_infinite(c1) || is_infinite(c2)
+         || !c1->hasInternalPoint() || !c2->hasInternalPoint()
+         || !c1->real() || !c2->real()
+        )
+        {
+            continue;
+        }
+
+        Foam::point edgeMid = 0.5*(c1->dual() + c2->dual());
 
         pointIndexHit surfHit;
         label hitSurface;
@@ -1906,7 +1207,7 @@ void Foam::conformalVoronoiMesh::dualCellLargestSurfaceIncursion
     std::list<Facet> facets;
     finite_incident_facets(vit, std::back_inserter(facets));
 
-    const Foam::point vert = topoint(vit->point());
+    pointFromPoint vert = topoint(vit->point());
 
     scalar minIncursionDistance = -maxSurfaceProtrusion(vert);
 
@@ -1917,12 +1218,20 @@ void Foam::conformalVoronoiMesh::dualCellLargestSurfaceIncursion
         ++fit
     )
     {
-        const Foam::point edgeMid =
-            0.5
-           *(
-                fit->first->dual()
-              + fit->first->neighbor(fit->second)->dual()
-            );
+        Cell_handle c1 = fit->first;
+        Cell_handle c2 = fit->first->neighbor(fit->second);
+
+        if
+        (
+            is_infinite(c1) || is_infinite(c2)
+         || !c1->hasInternalPoint() || !c2->hasInternalPoint()
+         || !c1->real() || !c2->real()
+        )
+        {
+            continue;
+        }
+
+        Foam::point edgeMid = 0.5*(c1->dual() + c2->dual());
 
         pointIndexHit surfHit;
         label hitSurface;
@@ -2003,111 +1312,110 @@ void Foam::conformalVoronoiMesh::reportProcessorOccupancy()
 }
 
 
-void Foam::conformalVoronoiMesh::reportSurfaceConformationQuality()
-{
-    Info<< nl << "Check surface conformation quality" << endl;
-
-    for
-    (
-        Delaunay::Finite_vertices_iterator vit = finite_vertices_begin();
-        vit != finite_vertices_end();
-        vit++
-    )
-    {
-        if (vit->internalOrBoundaryPoint())
-        {
-            Foam::point vert(topoint(vit->point()));
-            pointIndexHit surfHit;
-            label hitSurface;
-
-            dualCellLargestSurfaceProtrusion(vit, surfHit, hitSurface);
-
-            if (surfHit.hit())
-            {
-                Pout<< nl << "Residual penetration: " << nl
-                    << vit->index() << nl
-                    << vit->type() << nl
-                    << vit->ppMaster() << nl
-                    << "nearFeaturePt "
-                    << nearFeaturePt(surfHit.hitPoint()) << nl
-                    << vert << nl
-                    << surfHit.hitPoint()
-                    << endl;
-            }
-        }
-    }
-
-    {
-        // Assess close surface points
-
-        setVertexSizeAndAlignment();
-
-        for
-        (
-            Delaunay::Finite_vertices_iterator vit = finite_vertices_begin();
-            vit != finite_vertices_end();
-            vit++
-        )
-        {
-            if (vit->ppMaster())
-            {
-                std::list<Vertex_handle> adjacentVertices;
-
-                adjacent_vertices(vit, std::back_inserter(adjacentVertices));
-
-                Foam::point pt = topoint(vit->point());
-
-                // Pout<< nl << "vit: " << vit->index() << " "
-                //     << topoint(vit->point())
-                //     << endl;
-
-                // Pout<< adjacentVertices.size() << endl;
-
-                for
-                (
-                    std::list<Vertex_handle>::iterator
-                    avit = adjacentVertices.begin();
-                    avit != adjacentVertices.end();
-                    ++avit
-                )
-                {
-                    Vertex_handle avh = *avit;
-
-                    // The lower indexed vertex will perform the assessment
-                    if
-                    (
-                        avh->ppMaster()
-                     && vit->index() < avh->index()
-                     && vit->type() != avh->type()
-                    )
-                    {
-                        scalar targetSize = 0.2*averageAnyCellSize(vit, avh);
-
-                        // Pout<< "diff " << mag(pt - topoint(avh->point()))
-                        //     << " " << targetSize << endl;
-
-                        if
-                        (
-                            magSqr(pt - topoint(avh->point()))
-                          < sqr(targetSize)
-                        )
-                        {
-                            Pout<< nl << "vit: " << vit->index() << " "
-                                << topoint(vit->point())
-                                << endl;
-
-                            Pout<< "    adjacent too close: "
-                                << avh->index() << " "
-                                << topoint(avh->point())
-                                << endl;
-                        }
-                    }
-                }
-            }
-        }
-    }
-}
-
+//void Foam::conformalVoronoiMesh::reportSurfaceConformationQuality()
+//{
+//    Info<< nl << "Check surface conformation quality" << endl;
+//
+//    for
+//    (
+//        Delaunay::Finite_vertices_iterator vit = finite_vertices_begin();
+//        vit != finite_vertices_end();
+//        vit++
+//    )
+//    {
+//        if (vit->internalOrBoundaryPoint())
+//        {
+//            Foam::point vert(topoint(vit->point()));
+//            pointIndexHit surfHit;
+//            label hitSurface;
+//
+//            dualCellLargestSurfaceProtrusion(vit, surfHit, hitSurface);
+//
+//            if (surfHit.hit())
+//            {
+//                Pout<< nl << "Residual penetration: " << nl
+//                    << vit->index() << nl
+//                    << vit->type() << nl
+//                    << vit->ppMaster() << nl
+//                    << "nearFeaturePt "
+//                    << nearFeaturePt(surfHit.hitPoint()) << nl
+//                    << vert << nl
+//                    << surfHit.hitPoint()
+//                    << endl;
+//            }
+//        }
+//    }
+//
+//    {
+//        // Assess close surface points
+//
+//        setVertexSizeAndAlignment();
+//
+//        for
+//        (
+//            Delaunay::Finite_vertices_iterator vit = finite_vertices_begin();
+//            vit != finite_vertices_end();
+//            vit++
+//        )
+//        {
+//            if (vit->ppMaster())
+//            {
+//                std::list<Vertex_handle> adjacentVertices;
+//
+//                adjacent_vertices(vit, std::back_inserter(adjacentVertices));
+//
+//                Foam::point pt = topoint(vit->point());
+//
+//                // Pout<< nl << "vit: " << vit->index() << " "
+//                //     << topoint(vit->point())
+//                //     << endl;
+//
+//                // Pout<< adjacentVertices.size() << endl;
+//
+//                for
+//                (
+//                    std::list<Vertex_handle>::iterator
+//                    avit = adjacentVertices.begin();
+//                    avit != adjacentVertices.end();
+//                    ++avit
+//                )
+//                {
+//                    Vertex_handle avh = *avit;
+//
+//                    // The lower indexed vertex will perform the assessment
+//                    if
+//                    (
+//                        avh->ppMaster()
+//                     && vit->index() < avh->index()
+//                     && vit->type() != avh->type()
+//                    )
+//                    {
+//                        scalar targetSize = 0.2*averageAnyCellSize(vit, avh);
+//
+//                        // Pout<< "diff " << mag(pt - topoint(avh->point()))
+//                        //     << " " << targetSize << endl;
+//
+//                        if
+//                        (
+//                            magSqr(pt - topoint(avh->point()))
+//                          < sqr(targetSize)
+//                        )
+//                        {
+//                            Pout<< nl << "vit: " << vit->index() << " "
+//                                << topoint(vit->point())
+//                                << endl;
+//
+//                            Pout<< "    adjacent too close: "
+//                                << avh->index() << " "
+//                                << topoint(avh->point())
+//                                << endl;
+//                        }
+//                    }
+//                }
+//            }
+//        }
+//    }
+//}
 
 void Foam::conformalVoronoiMesh::limitDisplacement
 (
@@ -2124,7 +1432,7 @@ void Foam::conformalVoronoiMesh::limitDisplacement
         return;
     }
 
-    Foam::point pt = topoint(vit->point());
+    pointFromPoint pt = topoint(vit->point());
     Foam::point dispPt = pt + displacement;
 
     bool limit = false;
@@ -2205,6 +1513,11 @@ Foam::scalar Foam::conformalVoronoiMesh::angleBetweenSurfacePoints
         pAsurfaceHit
     );
 
+    if (!pAhit.hit())
+    {
+        return constant::mathematical::pi;
+    }
+
     vectorField norm(1);
 
     allGeometry_[pAsurfaceHit].getNormal
@@ -2226,6 +1539,11 @@ Foam::scalar Foam::conformalVoronoiMesh::angleBetweenSurfacePoints
         pBsurfaceHit
     );
 
+    if (!pBhit.hit())
+    {
+        return constant::mathematical::pi;
+    }
+
     allGeometry_[pBsurfaceHit].getNormal
     (
         List<pointIndexHit>(1, pBhit),
@@ -2240,84 +1558,81 @@ Foam::scalar Foam::conformalVoronoiMesh::angleBetweenSurfacePoints
 
 bool Foam::conformalVoronoiMesh::nearSurfacePoint
 (
-    pointIndexHit& pHit,
-    label& surfaceHit,
-    DynamicList<Foam::point>& existingSurfacePtLocations
+    pointIndexHitAndFeature& pHit
 ) const
 {
-    const Foam::point& pt = pHit.hitPoint();
+    const Foam::point& pt = pHit.first().hitPoint();
 
     pointIndexHit closePoint;
 
     const bool closeToSurfacePt = pointIsNearSurfaceLocation(pt, closePoint);
 
-    if (closeToSurfacePt)
+//    if
+//    (
+//        closeToSurfacePt
+//     && mag(pt - closePoint.hitPoint()) > pointPairDistance(pt)
+//    )
+//    {
+//        const scalar cosAngle
+//            = angleBetweenSurfacePoints(pt, closePoint.hitPoint());
+//
+//        // @todo make this tolerance run-time selectable?
+//        if (cosAngle < searchAngleOppositeSurface)
+//        {
+//            pointIndexHit pCloseHit;
+//            label pCloseSurfaceHit = -1;
+//
+//            const scalar searchDist = targetCellSize(closePoint.hitPoint());
+//
+//            if (searchDist < SMALL)
+//            {
+//                Pout<< "WARNING: SMALL CELL SIZE" << endl;
+//            }
+//
+//            geometryToConformTo_.findSurfaceNearest
+//            (
+//                closePoint.hitPoint(),
+//                searchDist,
+//                pCloseHit,
+//                pCloseSurfaceHit
+//            );
+//
+//            vectorField norm(1);
+//
+//            allGeometry_[pCloseSurfaceHit].getNormal
+//            (
+//                List<pointIndexHit>(1, pCloseHit),
+//                norm
+//            );
+//
+//            const vector nA = norm[0];
+//
+//            pointIndexHit oppositeHit;
+//            label oppositeSurfaceHit = -1;
+//
+//            geometryToConformTo_.findSurfaceNearestIntersection
+//            (
+//                closePoint.hitPoint() + SMALL*nA,
+//                closePoint.hitPoint() + mag(pt - closePoint.hitPoint())*nA,
+//                oppositeHit,
+//                oppositeSurfaceHit
+//            );
+//
+//            if (oppositeHit.hit())
+//            {
+//                // Replace point
+//                pHit.first() = oppositeHit;
+//                pHit.second() = oppositeSurfaceHit;
+//
+//                appendToSurfacePtTree(pHit.first().hitPoint());
+//
+//                return !closeToSurfacePt;
+//            }
+//        }
+//    }
+//    else
     {
-        const scalar cosAngle
-            = angleBetweenSurfacePoints(pt, closePoint.hitPoint());
-
-        // @todo make this tolerance run-time selectable?
-        if (cosAngle < searchAngleOppositeSurface)
-        {
-            pointIndexHit pCloseHit;
-            label pCloseSurfaceHit = -1;
-
-            const scalar searchDist = targetCellSize(closePoint.hitPoint());
-
-            geometryToConformTo_.findSurfaceNearest
-            (
-                closePoint.hitPoint(),
-                searchDist,
-                pCloseHit,
-                pCloseSurfaceHit
-            );
-
-            vectorField norm(1);
-
-            allGeometry_[pCloseSurfaceHit].getNormal
-            (
-                List<pointIndexHit>(1, pCloseHit),
-                norm
-            );
-
-            const vector nA = norm[0];
-
-            pointIndexHit oppositeHit;
-            label oppositeSurfaceHit = -1;
-
-            geometryToConformTo_.findSurfaceNearestIntersection
-            (
-                closePoint.hitPoint() + SMALL*nA,
-                closePoint.hitPoint() + mag(pt - closePoint.hitPoint())*nA,
-                oppositeHit,
-                oppositeSurfaceHit
-            );
-
-            if (oppositeHit.hit())
-            {
-                // Replace point
-                pHit = oppositeHit;
-                surfaceHit = oppositeSurfaceHit;
-
-                Foam::point newPt = oppositeHit.hitPoint();
-
-                appendToSurfacePtTree(newPt, existingSurfacePtLocations);
-
-                return !closeToSurfacePt;
-
-                if (debug)
-                {
-                    Info<< "Point " << pt
-                        << " is close to " << closePoint.hitPoint()
-                        << " so will be moved to " << oppositeHit.hitPoint()
-                        << endl;
-                }
-            }
-        }
-    }
-    else
-    {
-        appendToSurfacePtTree(pt, existingSurfacePtLocations);
+        appendToSurfacePtTree(pt);
     }
 
     return closeToSurfacePt;
@@ -2326,15 +1641,14 @@ bool Foam::conformalVoronoiMesh::nearSurfacePoint
 
 bool Foam::conformalVoronoiMesh::appendToSurfacePtTree
 (
-    const Foam::point& pt,
-    DynamicList<Foam::point>& existingSurfacePtLocations
+    const Foam::point& pt
 ) const
 {
-   label startIndex = existingSurfacePtLocations.size();
+   label startIndex = existingSurfacePtLocations_.size();
 
-   existingSurfacePtLocations.append(pt);
+   existingSurfacePtLocations_.append(pt);
 
-   label endIndex = existingSurfacePtLocations.size();
+   label endIndex = existingSurfacePtLocations_.size();
 
    return surfacePtLocationTreePtr_().insert(startIndex, endIndex);
 }
@@ -2342,15 +1656,14 @@ bool Foam::conformalVoronoiMesh::appendToSurfacePtTree
 
 bool Foam::conformalVoronoiMesh::appendToEdgeLocationTree
 (
-    const Foam::point& pt,
-    DynamicList<Foam::point>& existingEdgeLocations
+    const Foam::point& pt
 ) const
 {
-   label startIndex = existingEdgeLocations.size();
+   label startIndex = existingEdgeLocations_.size();
 
-   existingEdgeLocations.append(pt);
+   existingEdgeLocations_.append(pt);
 
-   label endIndex = existingEdgeLocations.size();
+   label endIndex = existingEdgeLocations_.size();
 
    return edgeLocationTreePtr_().insert(startIndex, endIndex);
 }
@@ -2442,8 +1755,7 @@ bool Foam::conformalVoronoiMesh::pointIsNearSurfaceLocation
 
 bool Foam::conformalVoronoiMesh::nearFeatureEdgeLocation
 (
-    pointIndexHit& pHit,
-    DynamicList<Foam::point>& existingEdgeLocations
+    pointIndexHit& pHit
 ) const
 {
     Foam::point pt = pHit.hitPoint();
@@ -2513,7 +1825,7 @@ bool Foam::conformalVoronoiMesh::nearFeatureEdgeLocation
 
     if (!closeToFeatureEdge)
     {
-        appendToEdgeLocationTree(pt, existingEdgeLocations);
+        appendToEdgeLocationTree(pt);
     }
 
     return closeToFeatureEdge;
@@ -2609,57 +1921,34 @@ void Foam::conformalVoronoiMesh::buildSizeAndAlignmentTree() const
 void Foam::conformalVoronoiMesh::addSurfaceAndEdgeHits
 (
     const Delaunay::Finite_vertices_iterator& vit,
-    const Foam::point& vert,
-    const DynamicList<pointIndexHit>& surfHit,
-    const DynamicList<label>& hitSurface,
+    const pointIndexHitAndFeatureDynList& surfaceIntersections,
     scalar surfacePtReplaceDistCoeffSqr,
     scalar edgeSearchDistCoeffSqr,
-    DynamicList<pointIndexHit>& surfaceHits,
-    DynamicList<label>& hitSurfaces,
-    DynamicList<pointIndexHit>& featureEdgeHits,
-    DynamicList<label>& featureEdgeFeaturesHit,
-    DynamicList<Foam::point>& newEdgeLocations,
-    DynamicList<Foam::point>& existingEdgeLocations,
-    DynamicList<Foam::point>& existingSurfacePtLocations
+    pointIndexHitAndFeatureDynList& surfaceHits,
+    pointIndexHitAndFeatureDynList& featureEdgeHits
 ) const
 {
-    const scalar cellSize = targetCellSize(vert);
+    const scalar cellSize = targetCellSize(topoint(vit->point()));
     const scalar cellSizeSqr = sqr(cellSize);
 
-    forAll(surfHit, sI)
+    forAll(surfaceIntersections, sI)
     {
+        pointIndexHitAndFeature surfHitI = surfaceIntersections[sI];
+
         bool keepSurfacePoint = true;
 
-        pointIndexHit surfHitI = surfHit[sI];
-        label hitSurfaceI = hitSurface[sI];
-
-        if (!surfHitI.hit())
+        if (!surfHitI.first().hit())
         {
             continue;
         }
 
-        bool isNearFeaturePt = nearFeaturePt(surfHitI.hitPoint());
+        bool isNearFeaturePt = nearFeaturePt(surfHitI.first().hitPoint());
 
-        bool isNearSurfacePt = nearSurfacePoint
-        (
-            surfHitI,
-            hitSurfaceI,
-            existingSurfacePtLocations
-        );
+        bool isNearSurfacePt = nearSurfacePoint(surfHitI);
 
         if (isNearFeaturePt || isNearSurfacePt)
         {
             keepSurfacePoint = false;
-
-            // If the triggering Vertex is part of a feature point, allow it to
-            // conform to the surface.
-            // @todo Is this needed?! Shouldn't be any feature points here...
-            if (vit->index() < startOfInternalPoints_)
-            {
-                surfaceHits.append(surfHitI);
-
-                hitSurfaces.append(hitSurfaceI);
-            }
         }
 
         List<List<pointIndexHit> > edHitsByFeature;
@@ -2670,7 +1959,7 @@ void Foam::conformalVoronoiMesh::addSurfaceAndEdgeHits
 
         geometryToConformTo_.findAllNearestEdges
         (
-            surfHitI.hitPoint(),
+            surfHitI.first().hitPoint(),
             searchRadiusSqr,
             edHitsByFeature,
             featuresHit
@@ -2688,11 +1977,13 @@ void Foam::conformalVoronoiMesh::addSurfaceAndEdgeHits
 
                 if (edHit.hit())
                 {
-                    if (!nearFeaturePt(edHit.hitPoint()))
+                    const Foam::point& edPt = edHit.hitPoint();
+
+                    if (!nearFeaturePt(edPt))
                     {
                         if
                         (
-                            magSqr(edHit.hitPoint() - surfHitI.hitPoint())
+                            magSqr(edPt - surfHitI.first().hitPoint())
                           < surfacePtReplaceDistCoeffSqr*cellSizeSqr
                         )
                         {
@@ -2703,25 +1994,26 @@ void Foam::conformalVoronoiMesh::addSurfaceAndEdgeHits
                             keepSurfacePoint = false;
 
                             // NEED TO REMOVE FROM THE SURFACE TREE...
-                            surfacePtLocationTreePtr_().remove
-                            (
-                                existingSurfacePtLocations.size() - 1
-                            );
+//                            surfacePtLocationTreePtr_().remove
+//                            (
+//                                existingSurfacePtLocations_.size() - 1
+//                            );
                         }
 
                         if
                         (
                             !nearFeatureEdgeLocation
                             (
-                                edHit,
-                                existingEdgeLocations
+                                edHit
                             )
                         )
                         {
                             // Do not place edge control points too close to a
                             // feature point or existing edge control points
-                            featureEdgeHits.append(edHit);
-                            featureEdgeFeaturesHit.append(featureHit);
+                            featureEdgeHits.append
+                            (
+                                pointIndexHitAndFeature(edHit, featureHit)
+                            );
                         }
                     }
                 }
@@ -2731,7 +2023,6 @@ void Foam::conformalVoronoiMesh::addSurfaceAndEdgeHits
         if (keepSurfacePoint)
         {
             surfaceHits.append(surfHitI);
-            hitSurfaces.append(hitSurfaceI);
         }
     }
 }
@@ -2758,8 +2049,8 @@ void Foam::conformalVoronoiMesh::storeSurfaceConformation()
         if
         (
             !vit->referred()
-         && vit->pairPoint()
-         && vit->index() >= startOfInternalPoints_
+         && vit->boundaryPoint()
+         && !vit->featurePoint()
         )
         {
             tempSurfaceVertices.append
@@ -2767,8 +2058,7 @@ void Foam::conformalVoronoiMesh::storeSurfaceConformation()
                 Vb
                 (
                     vit->point(),
-                    0,                          // index, reset to zero
-                    vit->type() - vit->index()  // type, relative to index
+                    vit->type()
                 )
             );
         }
@@ -2784,7 +2074,7 @@ void Foam::conformalVoronoiMesh::storeSurfaceConformation()
             label(surfaceConformationVertices_.size()),
             sumOp<label>()
         )
-        << " vertices" << endl;
+        << " vertices" << nl << endl;
 }
 
 
@@ -2792,35 +2082,24 @@ void Foam::conformalVoronoiMesh::reinsertSurfaceConformation()
 {
     Info<< nl << "Reinserting stored surface conformation" << endl;
 
-    label preReinsertionSize(number_of_vertices());
+    const label preReinsertionSize(number_of_vertices());
 
     // It is assumed that the stored surface conformation is on the correct
     // processor and does not need distributed
-
-    for
+    rangeInsertWithInfo
     (
-        List<Vb>::iterator vit=surfaceConformationVertices_.begin();
-        vit != surfaceConformationVertices_.end();
-        ++vit
-    )
-    {
-        // Assuming that all of the reinsertions are pair points, and that the
-        // index and type are relative, i.e. index 0 and type relative to it.
-        insertPoint
-        (
-            vit->point(),
-            vit->index() + number_of_vertices(),
-            vit->type() + number_of_vertices()
-        );
-    }
+        surfaceConformationVertices_.begin(),
+        surfaceConformationVertices_.end(),
+        true
+    );
 
-    Info<< "    Reinserted "
-        << returnReduce
-        (
-            label(number_of_vertices()) - preReinsertionSize,
-            sumOp<label>()
-        )
-        << " vertices" << endl;
+    const label nInserted = label(number_of_vertices()) - preReinsertionSize;
+    const label nFailed = surfaceConformationVertices_.size() - nInserted;
+
+    Info<< "    " << returnReduce(nInserted, sumOp<label>())
+        << " points reinserted, failed to insert "
+        << returnReduce(nFailed, sumOp<label>())
+        << endl;
 }
 
 
diff --git a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/conformalVoronoiMeshFeaturePointSpecialisations.C b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/conformalVoronoiMeshFeaturePointSpecialisations.C
index 2882be0c6f..2f7579cbbf 100644
--- a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/conformalVoronoiMeshFeaturePointSpecialisations.C
+++ b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/conformalVoronoiMeshFeaturePointSpecialisations.C
@@ -48,39 +48,7 @@ Foam::conformalVoronoiMesh::calcPointFeatureEdgesTypes
 
         eS = feMesh.getEdgeStatus(edgeI);
 
-        switch (eS)
-        {
-            case extendedFeatureEdgeMesh::EXTERNAL:
-            {
-                pFEdgeTypes.nExternal++;
-                break;
-            }
-            case extendedFeatureEdgeMesh::INTERNAL:
-            {
-                pFEdgeTypes.nInternal++;
-                break;
-            }
-            case extendedFeatureEdgeMesh::FLAT:
-            {
-                pFEdgeTypes.nFlat++;
-                break;
-            }
-            case extendedFeatureEdgeMesh::OPEN:
-            {
-                pFEdgeTypes.nOpen++;
-                break;
-            }
-            case extendedFeatureEdgeMesh::MULTIPLE:
-            {
-                pFEdgeTypes.nMultiple++;
-                break;
-            }
-            case extendedFeatureEdgeMesh::NONE:
-            {
-                pFEdgeTypes.nNonFeature++;
-                break;
-            }
-        }
+        pFEdgeTypes(eS)++;
     }
 
     if (debug)
@@ -99,15 +67,22 @@ bool Foam::conformalVoronoiMesh::createSpecialisedFeaturePoint
     const pointFeatureEdgesTypes& pFEdgesTypes,
     const List<extendedFeatureEdgeMesh::edgeStatus>& allEdStat,
     const label ptI,
-    DynamicList<Foam::point>& pts,
-    DynamicList<label>& indices,
-    DynamicList<label>& types
+    DynamicList<Vb>& pts
 )
 {
     if
     (
-        pFEdgesTypes.nExternal == 2
-     && pFEdgesTypes.nInternal == 1
+        !pFEdgesTypes.found(extendedFeatureEdgeMesh::EXTERNAL)
+     || !pFEdgesTypes.found(extendedFeatureEdgeMesh::INTERNAL)
+    )
+    {
+        return false;
+    }
+
+    if
+    (
+        pFEdgesTypes[extendedFeatureEdgeMesh::EXTERNAL] == 2
+     && pFEdgesTypes[extendedFeatureEdgeMesh::INTERNAL] == 1
      && pEds.size() == 3
     )
     {
@@ -120,6 +95,8 @@ bool Foam::conformalVoronoiMesh::createSpecialisedFeaturePoint
             return false;
         }
 
+        label nVert = number_of_vertices();
+
         const label initialNumOfPoints = pts.size();
 
         const scalar ppDist = pointPairDistance(featPt);
@@ -212,18 +189,20 @@ bool Foam::conformalVoronoiMesh::createSpecialisedFeaturePoint
           - 2.0*planeA.distance(concaveEdgeExternalPt)
             *concaveEdgePlaneANormal;
 
-        pts.append(internalPtA);
-        indices.append(0);
-        types.append(4);
+        pts.append
+        (
+            Vb(internalPtA, Vb::vtInternalFeaturePoint)
+        );
 
         const Foam::point internalPtB =
             concaveEdgeExternalPt
           - 2.0*planeB.distance(concaveEdgeExternalPt)
             *concaveEdgePlaneBNormal;
 
-        pts.append(internalPtB);
-        indices.append(0);
-        types.append(3);
+        pts.append
+        (
+            Vb(internalPtB, Vb::vtInternalFeaturePoint)
+        );
 
         // Add the external points
 
@@ -295,8 +274,7 @@ bool Foam::conformalVoronoiMesh::createSpecialisedFeaturePoint
                 for (label i = 0; i < 2; ++i)
                 {
                     pts.remove();
-                    indices.remove();
-                    types.remove();
+                    nVert--;
                 }
 
                 return false;
@@ -325,9 +303,10 @@ bool Foam::conformalVoronoiMesh::createSpecialisedFeaturePoint
                           + 2.0*planeC.distance(internalPtA)
                            *convexEdgePlaneCNormal;
 
-                        pts.append(externalPtD);
-                        indices.append(0);
-                        types.append(-2);
+                        pts.append
+                        (
+                            Vb(externalPtD, Vb::vtExternalFeaturePoint)
+                        );
                     }
                 }
             }
@@ -355,17 +334,19 @@ bool Foam::conformalVoronoiMesh::createSpecialisedFeaturePoint
                           + 2.0*planeD.distance(internalPtB)
                            *convexEdgePlaneDNormal;
 
-                        pts.append(externalPtE);
-                        indices.append(0);
-                        types.append(-2);
+                        pts.append
+                        (
+                            Vb(externalPtE, Vb::vtExternalFeaturePoint)
+                        );
                     }
                 }
             }
         }
 
-        pts.append(concaveEdgeExternalPt);
-        indices.append(0);
-        types.append(-4);
+        pts.append
+        (
+            Vb(concaveEdgeExternalPt, Vb::vtExternalFeaturePoint)
+        );
 
         const scalar totalAngle = radToDeg
         (
@@ -375,12 +356,13 @@ bool Foam::conformalVoronoiMesh::createSpecialisedFeaturePoint
 
         if (totalAngle > cvMeshControls().maxQuadAngle())
         {
-            // Add additional mitering points
+            // Add additional mitreing points
             //scalar angleSign = 1.0;
 
 
             vector convexEdgesPlaneNormal =
                 0.5*(convexEdgePlaneCNormal + convexEdgePlaneDNormal);
+
             plane planeM(featPt, convexEdgesPlaneNormal);
 
 //            if
@@ -410,17 +392,19 @@ bool Foam::conformalVoronoiMesh::createSpecialisedFeaturePoint
             //+ (2.0 + guard)*(concaveEdgeLocalFeatPt - concaveEdgeExternalPt);
               + 2.0*(concaveEdgeLocalFeatPt - concaveEdgeExternalPt);
 
-            pts.append(internalPtF);
-            indices.append(0);
-            types.append(1);
+            pts.append
+            (
+                Vb(internalPtF, Vb::vtInternalFeaturePoint)
+            );
 
             const Foam::point externalPtG =
                 internalPtF
               + 2.0*planeM.distance(internalPtF)*convexEdgesPlaneNormal;
 
-            pts.append(externalPtG);
-            indices.append(0);
-            types.append(-1);
+            pts.append
+            (
+                Vb(externalPtG, Vb::vtExternalFeaturePoint)
+            );
         }
 
         if (debug)
@@ -428,13 +412,17 @@ bool Foam::conformalVoronoiMesh::createSpecialisedFeaturePoint
             for (label ptI = initialNumOfPoints; ptI < pts.size(); ++ptI)
             {
                 Info<< "Point " << ptI << " : ";
-                meshTools::writeOBJ(Info, pts[ptI]);
+                meshTools::writeOBJ(Info, topoint(pts[ptI].point()));
             }
         }
 
         return true;
     }
-    else if (pFEdgesTypes.nExternal == 1 && pFEdgesTypes.nInternal == 2)
+    else if
+    (
+        pFEdgesTypes[extendedFeatureEdgeMesh::EXTERNAL] == 1
+     && pFEdgesTypes[extendedFeatureEdgeMesh::INTERNAL] == 2
+    )
     {
         // Info<< "nExternal == 1 && nInternal == 2" << endl;
 
diff --git a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/conformalVoronoiMeshFeaturePoints.C b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/conformalVoronoiMeshFeaturePoints.C
index 407de61b39..028dd5a0df 100644
--- a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/conformalVoronoiMeshFeaturePoints.C
+++ b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/conformalVoronoiMeshFeaturePoints.C
@@ -25,40 +25,19 @@ License
 
 #include "conformalVoronoiMesh.H"
 #include "vectorTools.H"
+#include "triangle.H"
+#include "tetrahedron.H"
+#include "const_circulator.H"
 
 using namespace Foam::vectorTools;
 
 // * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * * //
 
-void Foam::conformalVoronoiMesh::insertBoundingPoints()
-{
-    pointField farPts(geometryToConformTo_.globalBounds().points());
-
-    // Shift corners of bounds relative to origin
-    farPts -= geometryToConformTo_.globalBounds().midpoint();
-
-    // Scale the box up
-    farPts *= 10.0;
-
-    // Shift corners of bounds back to be relative to midpoint
-    farPts += geometryToConformTo_.globalBounds().midpoint();
-
-    limitBounds_ = treeBoundBox(farPts);
-
-    forAll(farPts, fPI)
-    {
-        insertPoint(farPts[fPI], Vb::vtFar);
-    }
-}
-
-
 void Foam::conformalVoronoiMesh::createEdgePointGroup
 (
     const extendedFeatureEdgeMesh& feMesh,
     const pointIndexHit& edHit,
-    DynamicList<Foam::point>& pts,
-    DynamicList<label>& indices,
-    DynamicList<label>& types
+    DynamicList<Vb>& pts
 )
 {
     label edgeI = edHit.index();
@@ -69,27 +48,27 @@ void Foam::conformalVoronoiMesh::createEdgePointGroup
     {
         case extendedFeatureEdgeMesh::EXTERNAL:
         {
-            createExternalEdgePointGroup(feMesh, edHit, pts, indices, types);
+            createExternalEdgePointGroup(feMesh, edHit, pts);
             break;
         }
         case extendedFeatureEdgeMesh::INTERNAL:
         {
-            createInternalEdgePointGroup(feMesh, edHit, pts, indices, types);
+            createInternalEdgePointGroup(feMesh, edHit, pts);
             break;
         }
         case extendedFeatureEdgeMesh::FLAT:
         {
-            createFlatEdgePointGroup(feMesh, edHit, pts, indices, types);
+            createFlatEdgePointGroup(feMesh, edHit, pts);
             break;
         }
         case extendedFeatureEdgeMesh::OPEN:
         {
-            //createOpenEdgePointGroup(feMesh, edHit, pts, indices, types);
+            createOpenEdgePointGroup(feMesh, edHit, pts);
             break;
         }
         case extendedFeatureEdgeMesh::MULTIPLE:
         {
-            //createMultipleEdgePointGroup(feMesh, edHit, pts, indices, types);
+            createMultipleEdgePointGroup(feMesh, edHit, pts);
             break;
         }
         case extendedFeatureEdgeMesh::NONE:
@@ -104,9 +83,7 @@ void Foam::conformalVoronoiMesh::createExternalEdgePointGroup
 (
     const extendedFeatureEdgeMesh& feMesh,
     const pointIndexHit& edHit,
-    DynamicList<Foam::point>& pts,
-    DynamicList<label>& indices,
-    DynamicList<label>& types
+    DynamicList<Vb>& pts
 )
 {
     const Foam::point& edgePt = edHit.hitPoint();
@@ -158,22 +135,30 @@ void Foam::conformalVoronoiMesh::createExternalEdgePointGroup
 
     // Insert the master point pairing the the first slave
 
-    pts.append(refPt);
-    indices.append(0);
-    types.append(1);
+    if (!geometryToConformTo_.inside(refPt))
+    {
+        return;
+    }
+
+    pts.append
+    (
+        Vb(refPt, Vb::vtInternalFeatureEdge)
+    );
 
     // Insert the slave points by reflecting refPt in both faces.
     // with each slave refering to the master
 
     Foam::point reflectedA = refPt + 2*ppDist*nA;
-    pts.append(reflectedA);
-    indices.append(0);
-    types.append(-1);
+    pts.append
+    (
+        Vb(reflectedA, Vb::vtExternalFeatureEdge)
+    );
 
     Foam::point reflectedB = refPt + 2*ppDist*nB;
-    pts.append(reflectedB);
-    indices.append(0);
-    types.append(-2);
+    pts.append
+    (
+        Vb(reflectedB, Vb::vtExternalFeatureEdge)
+    );
 }
 
 
@@ -181,9 +166,7 @@ void Foam::conformalVoronoiMesh::createInternalEdgePointGroup
 (
     const extendedFeatureEdgeMesh& feMesh,
     const pointIndexHit& edHit,
-    DynamicList<Foam::point>& pts,
-    DynamicList<label>& indices,
-    DynamicList<label>& types
+    DynamicList<Vb>& pts
 )
 {
     const Foam::point& edgePt = edHit.hitPoint();
@@ -245,9 +228,6 @@ void Foam::conformalVoronoiMesh::createInternalEdgePointGroup
     // required number of quadrants.
     int nAddPoints = min(max(nQuads - 2, 0), 2);
 
-    // index of reflMaster
-    label reflectedMaster = 2 + nAddPoints;
-
     // Add number_of_vertices() at insertion of first vertex to all numbers:
     // Result for nAddPoints 1 when the points are eventually inserted
     // pt           index type
@@ -270,41 +250,56 @@ void Foam::conformalVoronoiMesh::createInternalEdgePointGroup
     // reflectedBb  3     4
     // reflMasterPt 4     0
 
+    if
+    (
+        !geometryToConformTo_.inside(reflectedA)
+     || !geometryToConformTo_.inside(reflectedB)
+    )
+    {
+        return;
+    }
+
     // Master A is inside.
-    pts.append(reflectedA);
-    indices.append(0);
-    types.append(reflectedMaster--);
+    pts.append
+    (
+        Vb(reflectedA, Vb::vtInternalFeatureEdge)
+    );
 
     // Master B is inside.
-    pts.append(reflectedB);
-    indices.append(0);
-    types.append(reflectedMaster--);
+    pts.append
+    (
+        Vb(reflectedB, Vb::vtInternalFeatureEdge)
+    );
 
     if (nAddPoints == 1)
     {
         // One additinal point is the reflection of the slave point,
         // i.e. the original reference point
-        pts.append(refPt);
-        indices.append(0);
-        types.append(reflectedMaster--);
+        pts.append
+        (
+            Vb(refPt, Vb::vtInternalFeatureEdge)
+        );
     }
     else if (nAddPoints == 2)
     {
         Foam::point reflectedAa = refPt + ppDist*nB;
-        pts.append(reflectedAa);
-        indices.append(0);
-        types.append(reflectedMaster--);
+        pts.append
+        (
+            Vb(reflectedAa, Vb::vtInternalFeatureEdge)
+        );
 
         Foam::point reflectedBb = refPt + ppDist*nA;
-        pts.append(reflectedBb);
-        indices.append(0);
-        types.append(reflectedMaster--);
+        pts.append
+        (
+            Vb(reflectedBb, Vb::vtInternalFeatureEdge)
+        );
     }
 
     // Slave is outside.
-    pts.append(reflMasterPt);
-    indices.append(0);
-    types.append(-(nAddPoints + 2));
+    pts.append
+    (
+        Vb(reflMasterPt, Vb::vtExternalFeatureEdge)
+    );
 }
 
 
@@ -312,9 +307,7 @@ void Foam::conformalVoronoiMesh::createFlatEdgePointGroup
 (
     const extendedFeatureEdgeMesh& feMesh,
     const pointIndexHit& edHit,
-    DynamicList<Foam::point>& pts,
-    DynamicList<label>& indices,
-    DynamicList<label>& types
+    DynamicList<Vb>& pts
 )
 {
     const Foam::point& edgePt = edHit.hitPoint();
@@ -337,8 +330,8 @@ void Foam::conformalVoronoiMesh::createFlatEdgePointGroup
     // is a flat edge
     vector s = ppDist*(feMesh.edgeDirections()[edHit.index()] ^ n);
 
-    createPointPair(ppDist, edgePt + s, n, pts, indices, types);
-    createPointPair(ppDist, edgePt - s, n, pts, indices, types);
+    createPointPair(ppDist, edgePt + s, n, pts);
+    createPointPair(ppDist, edgePt - s, n, pts);
 }
 
 
@@ -346,11 +339,33 @@ void Foam::conformalVoronoiMesh::createOpenEdgePointGroup
 (
     const extendedFeatureEdgeMesh& feMesh,
     const pointIndexHit& edHit,
-    DynamicList<Foam::point>& pts,
-    DynamicList<label>& indices,
-    DynamicList<label>& types
+    DynamicList<Vb>& pts
 )
 {
+//    // Assume it is a baffle and insert flat edge point pairs
+//    const Foam::point& edgePt = edHit.hitPoint();
+//
+//    const scalar ppDist = pointPairDistance(edgePt);
+//
+//    const vectorField& feNormals = feMesh.normals();
+//    const labelList& edNormalIs = feMesh.edgeNormals()[edHit.index()];
+//
+//    // As this is a flat edge, there are two normals by definition
+//    const vector& nA = feNormals[edNormalIs[0]];
+//    const vector& nB = feNormals[edNormalIs[1]];
+//
+//    // Average normal to remove any bias to one side, although as this
+//    // is a flat edge, the normals should be essentially the same
+//    const vector n = 0.5*(nA + nB);
+//
+//    // Direction along the surface to the control point, sense of edge
+//    // direction not important, as +s and -s can be used because this
+//    // is a flat edge
+//    vector s = ppDist*(feMesh.edgeDirections()[edHit.index()] ^ n);
+//
+//    createBafflePointPair(ppDist, edgePt + s, n, pts);
+//    createBafflePointPair(ppDist, edgePt - s, n, pts);
+
     Info<< "NOT INSERTING OPEN EDGE POINT GROUP, NOT IMPLEMENTED" << endl;
 }
 
@@ -359,279 +374,34 @@ void Foam::conformalVoronoiMesh::createMultipleEdgePointGroup
 (
     const extendedFeatureEdgeMesh& feMesh,
     const pointIndexHit& edHit,
-    DynamicList<Foam::point>& pts,
-    DynamicList<label>& indices,
-    DynamicList<label>& types
+    DynamicList<Vb>& pts
 )
 {
     Info<< "NOT INSERTING MULTIPLE EDGE POINT GROUP, NOT IMPLEMENTED" << endl;
 }
 
 
-void Foam::conformalVoronoiMesh::reinsertBoundingPoints()
-{
-    tmp<pointField> farPts = limitBounds_.points();
-
-    forAll(farPts(), fPI)
-    {
-        insertPoint(farPts()[fPI], Vb::vtFar);
-    }
-}
-
-
 void Foam::conformalVoronoiMesh::reinsertFeaturePoints(bool distribute)
 {
     Info<< nl << "Reinserting stored feature points" << endl;
 
     label preReinsertionSize(number_of_vertices());
 
-    if (distribute)
-    {
-        DynamicList<Foam::point> pointsToInsert;
-        DynamicList<label> indices;
-        DynamicList<label> types;
+    insertPoints(featureVertices_, distribute);
 
-        for
-        (
-            List<Vb>::iterator vit=featureVertices_.begin();
-            vit != featureVertices_.end();
-            ++vit
-        )
-        {
-            pointsToInsert.append(topoint(vit->point()));
-            indices.append(vit->index());
-            types.append(vit->type());
-        }
-
-        // Insert distributed points
-        insertPoints(pointsToInsert, indices, types, true);
-
-        // Save points in new distribution
-        featureVertices_.clear();
-        featureVertices_.setSize(pointsToInsert.size());
-
-        forAll(pointsToInsert, pI)
-        {
-            featureVertices_[pI] =
-                Vb(toPoint(pointsToInsert[pI]), indices[pI], types[pI]);
-        }
-    }
-    else
-    {
-        for
-        (
-            List<Vb>::iterator vit=featureVertices_.begin();
-            vit != featureVertices_.end();
-            ++vit
-        )
-        {
-            // Assuming that all of the reinsertions are pair points, and that
-            // the index and type are relative, i.e. index 0 and type relative
-            // to it.
-            insertPoint
-            (
-                vit->point(),
-                vit->index() + number_of_vertices(),
-                vit->type() + number_of_vertices()
-            );
-        }
-    }
-
-    Info<< "    Reinserted "
-        << returnReduce
-        (
-            label(number_of_vertices()) - preReinsertionSize,
-            sumOp<label>()
-        )
-        << " vertices" << endl;
-}
-
-
-bool Foam::conformalVoronoiMesh::edgesShareNormal
-(
-    const label e1,
-    const label e2
-) const
-{
-    const PtrList<extendedFeatureEdgeMesh>& feMeshes
+    const label nReinserted = returnReduce
     (
-        geometryToConformTo_.features()
+        label(number_of_vertices()) - preReinsertionSize,
+        sumOp<label>()
     );
 
-    forAll(feMeshes, i)
-    {
-        const extendedFeatureEdgeMesh& feMesh(feMeshes[i]);
-
-        const vectorField& e1normals = feMesh.edgeNormals(e1);
-        const vectorField& e2normals = feMesh.edgeNormals(e2);
-
-        forAll(e1normals, nI1)
-        {
-            forAll(e2normals, nI2)
-            {
-                if (degAngleBetween(e1normals[nI1], e2normals[nI2]) < 1)
-                {
-                    return true;
-                }
-            }
-        }
-    }
-
-    return false;
-}
-
-
-void Foam::conformalVoronoiMesh::createConvexFeaturePoints
-(
-    DynamicList<Foam::point>& pts,
-    DynamicList<label>& indices,
-    DynamicList<label>& types
-)
-{
-    const PtrList<extendedFeatureEdgeMesh>& feMeshes
-    (
-        geometryToConformTo_.features()
-    );
-
-    forAll(feMeshes, i)
-    {
-        const extendedFeatureEdgeMesh& feMesh(feMeshes[i]);
-
-        for
-        (
-            label ptI = feMesh.convexStart();
-            ptI < feMesh.concaveStart();
-            ptI++
-        )
-        {
-            const Foam::point& featPt = feMesh.points()[ptI];
-
-            if (!positionOnThisProc(featPt))
-            {
-                continue;
-            }
-
-            const vectorField& featPtNormals = feMesh.featurePointNormals(ptI);
-
-            const scalar ppDist = - pointPairDistance(featPt);
-
-            vector cornerNormal = sum(featPtNormals);
-            cornerNormal /= mag(cornerNormal);
-
-            Foam::point internalPt = featPt + ppDist*cornerNormal;
-
-            // Result when the points are eventually inserted (example n = 4)
-            // Add number_of_vertices() at insertion of first vertex to all
-            // numbers:
-            // pt           index type
-            // internalPt   0     1
-            // externalPt0  1     0
-            // externalPt1  2     0
-            // externalPt2  3     0
-            // externalPt3  4     0
-
-            pts.append(internalPt);
-            indices.append(0);
-            types.append(1);
-
-            label internalPtIndex = -1;
-
-            forAll(featPtNormals, nI)
-            {
-                const vector& n = featPtNormals[nI];
-
-                plane planeN = plane(featPt, n);
-
-                Foam::point externalPt =
-                    internalPt + 2.0 * planeN.distance(internalPt) * n;
-
-                pts.append(externalPt);
-                indices.append(0);
-                types.append(internalPtIndex--);
-            }
-        }
-    }
-}
-
-
-void Foam::conformalVoronoiMesh::createConcaveFeaturePoints
-(
-    DynamicList<Foam::point>& pts,
-    DynamicList<label>& indices,
-    DynamicList<label>& types
-)
-{
-    const PtrList<extendedFeatureEdgeMesh>& feMeshes
-    (
-        geometryToConformTo_.features()
-    );
-
-    forAll(feMeshes, i)
-    {
-        const extendedFeatureEdgeMesh& feMesh(feMeshes[i]);
-
-        for
-        (
-            label ptI = feMesh.concaveStart();
-            ptI < feMesh.mixedStart();
-            ptI++
-        )
-        {
-            const Foam::point& featPt = feMesh.points()[ptI];
-
-            if (!positionOnThisProc(featPt))
-            {
-                continue;
-            }
-
-            const vectorField& featPtNormals = feMesh.featurePointNormals(ptI);
-            const scalar ppDist = pointPairDistance(featPt);
-
-            vector cornerNormal = sum(featPtNormals);
-            cornerNormal /= mag(cornerNormal);
-
-            Foam::point externalPt = featPt + ppDist*cornerNormal;
-
-            label externalPtIndex = featPtNormals.size();
-
-            // Result when the points are eventually inserted (example n = 5)
-            // Add number_of_vertices() at insertion of first vertex to all
-            // numbers:
-            // pt           index type
-            // internalPt0  0     5
-            // internalPt1  1     5
-            // internalPt2  2     5
-            // internalPt3  3     5
-            // internalPt4  4     5
-            // externalPt   5     4
-
-            forAll(featPtNormals, nI)
-            {
-                const vector& n = featPtNormals[nI];
-
-                const plane planeN = plane(featPt, n);
-
-                const Foam::point internalPt =
-                    externalPt - 2.0 * planeN.distance(externalPt) * n;
-
-                pts.append(internalPt);
-                indices.append(0);
-                types.append(externalPtIndex--);
-            }
-
-            pts.append(externalPt);
-            indices.append(0);
-            types.append(-1);
-        }
-    }
+    Info<< "    Reinserted " << nReinserted << " vertices" << endl;
 }
 
 
 void Foam::conformalVoronoiMesh::createMixedFeaturePoints
 (
-    DynamicList<Foam::point>& pts,
-    DynamicList<label>& indices,
-    DynamicList<label>& types
+    DynamicList<Vb>& pts
 )
 {
     if (cvMeshControls().mixedFeaturePointPPDistanceCoeff() < 0)
@@ -659,6 +429,13 @@ void Foam::conformalVoronoiMesh::createMixedFeaturePoints
             ptI++
         )
         {
+            const Foam::point& featPt = points[ptI];
+
+            if (!positionOnThisProc(featPt))
+            {
+                continue;
+            }
+
             const labelList& pEds = pointsEdges[ptI];
 
             pointFeatureEdgesTypes pFEdgeTypes(ptI);
@@ -672,8 +449,7 @@ void Foam::conformalVoronoiMesh::createMixedFeaturePoints
             {
                 specialisedSuccess = createSpecialisedFeaturePoint
                 (
-                    feMesh, pEds, pFEdgeTypes, allEdStat, ptI,
-                    pts, indices, types
+                    feMesh, pEds, pFEdgeTypes, allEdStat, ptI, pts
                 );
             }
 
@@ -715,12 +491,9 @@ void Foam::conformalVoronoiMesh::createMixedFeaturePoints
                     continue;
                 }
 
-                const Foam::point& pt = points[ptI];
+//                createFeaturePoints(feMesh, ptI, pts, types);
 
-                if (!positionOnThisProc(pt))
-                {
-                    continue;
-                }
+                const Foam::point pt = points[ptI];
 
                 const scalar edgeGroupDistance = mixedFeaturePointDistance(pt);
 
@@ -733,13 +506,13 @@ void Foam::conformalVoronoiMesh::createMixedFeaturePoints
 
                     const pointIndexHit edgeHit(true, edgePt, edgeI);
 
-                    createEdgePointGroup(feMesh, edgeHit, pts, indices, types);
+                    createEdgePointGroup(feMesh, edgeHit, pts);
                 }
             }
         }
     }
 }
-
+//
 //
 //void Foam::conformalVoronoiMesh::createFeaturePoints
 //(
@@ -787,7 +560,7 @@ void Foam::conformalVoronoiMesh::createMixedFeaturePoints
 //                    surfaceConformationVertices_[indices[pI]];
 //            }
 //
-//            forAll()
+//            forAll(feMesh.)
 //
 //            // Now find the nearest points within the edge cones.
 //
@@ -803,22 +576,36 @@ void Foam::conformalVoronoiMesh::insertFeaturePoints()
 {
     Info<< nl << "Conforming to feature points" << endl;
 
-    DynamicList<Foam::point> pts;
-    DynamicList<label> indices;
-    DynamicList<label> types;
+    DynamicList<Vb> pts;
 
     const label preFeaturePointSize = number_of_vertices();
 
-    createConvexFeaturePoints(pts, indices, types);
+    createFeaturePoints(pts);
 
-    createConcaveFeaturePoints(pts, indices, types);
+    createMixedFeaturePoints(pts);
 
-//    createFeaturePoints(pts, indices, types);
+    // Points added using the createEdgePointGroup function will be labelled as
+    // internal/external feature edges. Relabel them as feature points,
+    // otherwise they are inserted as both feature points and surface points.
+    forAll(pts, pI)
+    {
+        Vb& pt = pts[pI];
 
-    createMixedFeaturePoints(pts, indices, types);
+        if (pt.featureEdgePoint())
+        {
+            if (pt.internalBoundaryPoint())
+            {
+                pt.type() = Vb::vtInternalFeaturePoint;
+            }
+            else if (pt.externalBoundaryPoint())
+            {
+                pt.type() = Vb::vtExternalFeaturePoint;
+            }
+        }
+    }
 
     // Insert the created points, distributing to the appropriate processor
-    insertPoints(pts, indices, types, true);
+    insertPoints(pts, true);
 
     if (cvMeshControls().objOutput())
     {
@@ -843,7 +630,7 @@ void Foam::conformalVoronoiMesh::insertFeaturePoints()
 
     forAll(pts, pI)
     {
-        featureVertices_[pI] = Vb(toPoint(pts[pI]), indices[pI], types[pI]);
+        featureVertices_[pI] = pts[pI];
     }
 
     constructFeaturePointLocations();
@@ -924,3 +711,525 @@ Foam::conformalVoronoiMesh::findSurfacePtLocationsNearFeaturePoint
 
     return dynPointList.shrink();
 }
+
+
+void Foam::conformalVoronoiMesh::addMasterAndSlavePoints
+(
+    const DynamicList<Foam::point>& masterPoints,
+    const DynamicList<Foam::indexedVertexEnum::vertexType>& masterPointsTypes,
+    const Map<DynamicList<autoPtr<plane> > >& masterPointReflections,
+    DynamicList<Vb>& pts,
+    const label ptI
+) const
+{
+    typedef DynamicList<autoPtr<plane> >        planeDynList;
+    typedef Foam::indexedVertexEnum::vertexType vertexType;
+
+    forAll(masterPoints, pI)
+    {
+        // Append master to the list of points
+
+//        OFstream strMasters("fpm_" + name(ptI) + ".obj");
+//        OFstream strSlaves("fps_" + name(ptI) + ".obj");
+
+        const Foam::point& masterPt = masterPoints[pI];
+        const vertexType masterType = masterPointsTypes[pI];
+
+        pts.append
+        (
+            Vb
+            (
+                masterPt,
+                masterType
+            )
+        );
+
+//        meshTools::writeOBJ(strMasters, masterPt);
+
+        const planeDynList& masterPointPlanes = masterPointReflections[pI];
+
+        forAll(masterPointPlanes, planeI)
+        {
+            // Reflect master points in the planes and insert the slave points
+
+            const plane& reflPlane = masterPointPlanes[planeI]();
+
+            const Foam::point slavePt =
+                reflectPointInPlane(masterPt, reflPlane);
+
+            const vertexType slaveType =
+            (
+                masterType == Vb::vtInternalFeaturePoint
+              ? Vb::vtExternalFeaturePoint // true
+              : Vb::vtInternalFeaturePoint // false
+            );
+
+            pts.append
+            (
+                Vb
+                (
+                    slavePt,
+                    slaveType
+                )
+            );
+
+//            meshTools::writeOBJ(strSlaves, slavePt);
+        }
+    }
+}
+
+
+Foam::label Foam::conformalVoronoiMesh::getSign
+(
+    const extendedFeatureEdgeMesh::edgeStatus eStatus
+) const
+{
+    if (eStatus == extendedFeatureEdgeMesh::EXTERNAL)
+    {
+        return -1;
+    }
+    else if (eStatus == extendedFeatureEdgeMesh::INTERNAL)
+    {
+        return 1;
+    }
+
+    return 0;
+}
+
+
+void Foam::conformalVoronoiMesh::createMasterAndSlavePoints
+(
+    const extendedFeatureEdgeMesh& feMesh,
+    const label ptI,
+    DynamicList<Vb>& pts
+) const
+{
+    typedef DynamicList<autoPtr<plane> >                planeDynList;
+    typedef Foam::indexedVertexEnum::vertexType         vertexType;
+    typedef Foam::extendedFeatureEdgeMesh::edgeStatus   edgeStatus;
+
+    const Foam::point& featPt = feMesh.points()[ptI];
+
+    if (!positionOnThisProc(featPt))
+    {
+        return;
+    }
+
+    const scalar ppDist = pointPairDistance(featPt);
+
+    // Maintain a list of master points and the planes to relect them in
+    DynamicList<Foam::point> masterPoints;
+    DynamicList<vertexType> masterPointsTypes;
+    Map<planeDynList> masterPointReflections;
+
+    const labelList& featPtEdges = feMesh.featurePointEdges()[ptI];
+
+    const_circulator<labelList> circ(featPtEdges);
+
+//    Info<< "Point = " << ptI << endl;
+
+    // Loop around the edges of the feature point
+    if (circ.size()) do
+    {
+//        const edgeStatus eStatusPrev = feMesh.getEdgeStatus(circ.prev());
+        const edgeStatus eStatusCurr = feMesh.getEdgeStatus(circ());
+//        const edgeStatus eStatusNext = feMesh.getEdgeStatus(circ.next());
+
+//        Info<< "Prev = "
+//            << extendedFeatureEdgeMesh::edgeStatusNames_[eStatusPrev]
+//            << " Curr = "
+//            << extendedFeatureEdgeMesh::edgeStatusNames_[eStatusCurr]
+////            << " Next = "
+////            << extendedFeatureEdgeMesh::edgeStatusNames_[eStatusNext]
+//            << endl;
+
+        // Get the direction in which to move the point in relation to the
+        // feature point
+        label sign = getSign(eStatusCurr);
+
+        const vector n = sharedFaceNormal(feMesh, circ(), circ.next());
+
+        const vector pointMotionDirection = sign*0.5*ppDist*n;
+
+        if (masterPoints.empty())
+        {
+            // Initialise with the first master point
+
+            Foam::point pt = featPt + pointMotionDirection;
+
+            planeDynList firstPlane;
+            firstPlane.append(autoPtr<plane>(new plane(featPt, n)));
+
+            masterPoints.append(pt);
+
+            masterPointsTypes.append
+            (
+                sign == 1
+              ? Vb::vtExternalFeaturePoint // true
+              : Vb::vtInternalFeaturePoint // false
+            );
+
+            if
+            (
+                masterPointsTypes.last() == Vb::vtInternalFeaturePoint
+             && !geometryToConformTo_.inside(masterPoints.last())
+            )
+            {
+                return;
+            }
+
+            const Foam::point reflectedPoint = reflectPointInPlane
+            (
+                masterPoints.last(),
+                firstPlane.last()()
+            );
+
+            if
+            (
+                masterPointsTypes.last() == Vb::vtExternalFeaturePoint
+             && !geometryToConformTo_.inside(reflectedPoint)
+            )
+            {
+                return;
+            }
+
+            masterPointReflections.insert
+            (
+                masterPoints.size() - 1,
+                firstPlane
+            );
+        }
+//        else if
+//        (
+//            eStatusPrev == extendedFeatureEdgeMesh::INTERNAL
+//         && eStatusCurr == extendedFeatureEdgeMesh::EXTERNAL
+//        )
+//        {
+//            // Insert a new master point.
+//            Foam::point pt = featPt + pointMotionDirection;
+//
+//            planeDynList firstPlane;
+//            firstPlane.append(autoPtr<plane>(new plane(featPt, n)));
+//
+//            masterPoints.append(pt);
+//
+//            masterPointsTypes.append
+//            (
+//                sign == 1
+//              ? Vb::vtExternalFeaturePoint // true
+//              : Vb::vtInternalFeaturePoint // false
+//            );
+//
+//            masterPointReflections.insert
+//            (
+//                masterPoints.size() - 1,
+//                firstPlane
+//            );
+//        }
+//        else if
+//        (
+//            eStatusPrev == extendedFeatureEdgeMesh::EXTERNAL
+//         && eStatusCurr == extendedFeatureEdgeMesh::INTERNAL
+//        )
+//        {
+//
+//        }
+        else
+        {
+            // Just add this face contribution to the latest master point
+
+            masterPoints.last() += pointMotionDirection;
+
+            masterPointReflections[masterPoints.size() - 1].append
+            (
+                autoPtr<plane>(new plane(featPt, n))
+            );
+        }
+
+    } while (circ.circulate(CirculatorBase::CLOCKWISE));
+
+    addMasterAndSlavePoints
+    (
+        masterPoints,
+        masterPointsTypes,
+        masterPointReflections,
+        pts,
+        ptI
+    );
+}
+
+
+void Foam::conformalVoronoiMesh::createFeaturePoints(DynamicList<Vb>& pts)
+{
+    const PtrList<extendedFeatureEdgeMesh>& feMeshes
+    (
+        geometryToConformTo_.features()
+    );
+
+    forAll(feMeshes, i)
+    {
+        Info<< indent << "Edge mesh = " << feMeshes[i].name() << nl << endl;
+
+        const extendedFeatureEdgeMesh& feMesh(feMeshes[i]);
+
+        for
+        (
+            label ptI = feMesh.convexStart();
+            ptI < feMesh.mixedStart();
+            ptI++
+        )
+        {
+            createMasterAndSlavePoints(feMesh, ptI, pts);
+        }
+    }
+}
+
+
+//Foam::scalar Foam::conformalVoronoiMesh::pyramidVolume
+//(
+//    const Foam::point& apex,
+//    const Foam::point& a,
+//    const Foam::point& b,
+//    const Foam::point& c,
+//    const bool printInfo
+//) const
+//{
+//    triPointRef tri(a, b, c);
+//
+//    tetPointRef tet(tri.a(), tri.b(), tri.c(), apex);
+//
+//    scalar volume = tet.mag();
+//
+////    scalar volume = (1.0/3.0)*constant::mathematical::pi;
+////
+////    K::Circle_3 circle(toPoint(a), toPoint(b), toPoint(c));
+////
+////    scalar height = mag(topoint(circle.center()) - apex);
+////
+////    volume *= circle.squared_radius()*height;
+//
+//    if (printInfo)
+//    {
+//        Info<< "Calculating volume of pyramid..." << nl
+//            << "    Apex      : " << apex << nl
+//            << "    Point a   : " << a << nl
+//            << "    Point b   : " << b << nl
+//            << "    Point c   : " << c << nl
+//            << "        Center  : " << tri.centre() << nl
+//            << "        Volume  : " << volume << endl;
+//    }
+//
+//    return volume;
+//}
+
+
+//void Foam::conformalVoronoiMesh::createPyramidMasterPoint
+//(
+//    const Foam::point& apex,
+//    const vectorField& edgeDirections,
+//    Foam::point& masterPoint,
+//    vectorField& norms
+//) const
+//{
+//    pointField basePoints(edgeDirections.size() + 1);
+//
+//    forAll(edgeDirections, eI)
+//    {
+//        basePoints[eI] = edgeDirections[eI] + apex;
+//    }
+//
+//    basePoints[edgeDirections.size() + 1] = apex;
+//
+//    face f(identity(edgeDirections.size()));
+//
+//    pyramidPointFaceRef p(f, apex);
+//
+//    const scalar ppDist = pointPairDistance(apex);
+//
+//
+//    vector unitDir = f.centre();
+//    unitDir /= mag(unitDir);
+//
+//    masterPoint = apex + ppDist*unitDir;
+//
+//    norms.setSize(edgeDirections.size());
+//
+//    forAll(norms, nI)
+//    {
+//        norms[nI] =
+//    }
+//}
+
+
+//void Foam::conformalVoronoiMesh::createConvexConcaveFeaturePoints
+//(
+//    DynamicList<Foam::point>& pts,
+//    DynamicList<label>& indices,
+//    DynamicList<label>& types
+//)
+//{
+//    const PtrList<extendedFeatureEdgeMesh>& feMeshes
+//    (
+//        geometryToConformTo_.features()
+//    );
+//
+//    forAll(feMeshes, i)
+//    {
+//        const extendedFeatureEdgeMesh& feMesh(feMeshes[i]);
+//
+//        for
+//        (
+//            label ptI = feMesh.convexStart();
+//            ptI < feMesh.mixedStart();
+//            ptI++
+//        )
+//        {
+//            const Foam::point& apex = feMesh.points()[ptI];
+//
+//            if (!positionOnThisProc(apex))
+//            {
+//                continue;
+//            }
+//
+//            const vectorField& featPtEdgeDirections
+//                = feMesh.featurePointEdgeDirections(ptI);
+//
+//            Foam::point masterPoint;
+//            vectorField tetNorms;
+//
+//            createPyramidMasterPoint
+//            (
+//                apex,
+//                featPtEdgeDirections,
+//                masterPoint,
+//                tetNorms
+//            );
+//
+//
+//
+//            // Result when the points are eventually inserted (example n = 4)
+//            // Add number_of_vertices() at insertion of first vertex to all
+//            // numbers:
+//            // pt           index type
+//            // internalPt   0     1
+//            // externalPt0  1     0
+//            // externalPt1  2     0
+//            // externalPt2  3     0
+//            // externalPt3  4     0
+//
+//            // Result when the points are eventually inserted (example n = 5)
+//            // Add number_of_vertices() at insertion of first vertex to all
+//            // numbers:
+//            // pt           index type
+//            // internalPt0  0     5
+//            // internalPt1  1     5
+//            // internalPt2  2     5
+//            // internalPt3  3     5
+//            // internalPt4  4     5
+//            // externalPt   5     4
+//
+//            if (geometryToConformTo_.inside(masterPoint))
+//            {
+//
+//            }
+//            else
+//            {
+//
+//            }
+//
+//            pts.append(masterPoint);
+//            indices.append(0);
+//            types.append(1);
+//
+//            label internalPtIndex = -1;
+//
+//            forAll(tetNorms, nI)
+//            {
+//                const vector& n = tetNorms[nI];
+//
+//                Foam::point reflectedPoint
+//                    = reflectPoint(featPt, masterPoint, n);
+//
+//                pts.append(reflectedPoint);
+//                indices.append(0);
+//                types.append(internalPtIndex--);
+//            }
+//        }
+//    }
+//}
+
+
+Foam::vector Foam::conformalVoronoiMesh::sharedFaceNormal
+(
+    const extendedFeatureEdgeMesh& feMesh,
+    const label edgeI,
+    const label nextEdgeI
+) const
+{
+    const labelList& edgeInormals = feMesh.edgeNormals()[edgeI];
+    const labelList& nextEdgeInormals = feMesh.edgeNormals()[nextEdgeI];
+
+    const vector& A1 = feMesh.normals()[edgeInormals[0]];
+    const vector& A2 = feMesh.normals()[edgeInormals[1]];
+
+    const vector& B1 = feMesh.normals()[nextEdgeInormals[0]];
+    const vector& B2 = feMesh.normals()[nextEdgeInormals[1]];
+
+    const scalar A1B1 = mag(A1 ^ B1);
+    const scalar A1B2 = mag(A1 ^ B2);
+    const scalar A2B1 = mag(A2 ^ B1);
+    const scalar A2B2 = mag(A2 ^ B2);
+
+    if (A1B1 < A1B2 && A1B1 < A2B1 && A1B1 < A2B2)
+    {
+        return 0.5*(A1 + B1);
+    }
+    else if (A1B2 < A1B1 && A1B2 < A2B1 && A1B2 < A2B2)
+    {
+        return 0.5*(A1 + B2);
+    }
+    else if (A2B1 < A1B1 && A2B1 < A1B2 && A2B1 < A2B2)
+    {
+        return 0.5*(A2 + B1);
+    }
+    else
+    {
+        return 0.5*(A2 + B2);
+    }
+}
+
+
+Foam::List<Foam::point> Foam::conformalVoronoiMesh::reflectPointInPlanes
+(
+    const Foam::point p,
+    const DynamicList<autoPtr<plane> >& planes
+) const
+{
+    List<Foam::point> reflectedPoints(planes.size());
+
+    forAll(planes, planeI)
+    {
+        reflectedPoints[planeI] = reflectPointInPlane(p, planes[planeI]());
+    }
+
+    return reflectedPoints;
+}
+
+
+Foam::point Foam::conformalVoronoiMesh::reflectPointInPlane
+(
+    const Foam::point p,
+    const plane& planeN
+) const
+{
+    const vector reflectedPtDir = p - planeN.nearestPoint(p);
+
+    if ((planeN.normal() & reflectedPtDir) > 0)
+    {
+        return p - 2.0*planeN.distance(p)*planeN.normal();
+    }
+    else
+    {
+        return p + 2.0*planeN.distance(p)*planeN.normal();
+    }
+}
diff --git a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/conformalVoronoiMeshI.H b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/conformalVoronoiMeshI.H
index 43d8c077fc..7d664407dc 100644
--- a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/conformalVoronoiMeshI.H
+++ b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/conformalVoronoiMeshI.H
@@ -21,21 +21,28 @@ License
     You should have received a copy of the GNU General Public License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
-    As a special exception, you have permission to link this program with the
-    CGAL library and distribute executables, as long as you follow the
-    requirements of the GNU GPL in regard to all of the software in the
-    executable aside from CGAL.
-
 \*---------------------------------------------------------------------------*/
 
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 
+inline Foam::scalar Foam::conformalVoronoiMesh::defaultCellSize() const
+{
+    return readScalar
+    (
+        cvMeshControls().cvMeshDict().subDict("motionControl").lookup
+        (
+            "defaultCellSize"
+        )
+    );
+}
+
+
 inline Foam::scalar Foam::conformalVoronoiMesh::targetCellSize
 (
     const Foam::point& pt
 ) const
 {
-    return cellSizeControl().cellSize(pt);
+    return cellShapeControls().cellSize(pt);
 }
 
 
@@ -66,8 +73,8 @@ inline Foam::scalar Foam::conformalVoronoiMesh::averageAnyCellSize
 {
     if
     (
-        !vA->internalOrBoundaryPoint()
-     && !vB->internalOrBoundaryPoint()
+        (!vA->internalOrBoundaryPoint() || vA->referred())
+     && (!vB->internalOrBoundaryPoint() || vB->referred())
     )
     {
         // There are no internalOrBoundaryPoints available, determine
@@ -80,11 +87,11 @@ inline Foam::scalar Foam::conformalVoronoiMesh::averageAnyCellSize
            *targetCellSize(topoint(vB->point()))
         );
     }
-    else if (!vB->internalOrBoundaryPoint())
+    else if (!vB->internalOrBoundaryPoint() || vB->referred())
     {
         return vA->targetCellSize();
     }
-    else if (!vA->internalOrBoundaryPoint())
+    else if (!vA->internalOrBoundaryPoint() || vA->referred())
     {
         return vB->targetCellSize();
     }
@@ -98,9 +105,10 @@ inline Foam::scalar Foam::conformalVoronoiMesh::averageAnyCellSize
     const Delaunay::Finite_facets_iterator& fit
 ) const
 {
-    // Geometric mean
+    // Arithmetic mean
+
+    scalar sizeSum = 0;
 
-    scalar sizeProduct = 1;
     label nProducts = 0;
 
     const Cell_handle c(fit->first);
@@ -110,10 +118,10 @@ inline Foam::scalar Foam::conformalVoronoiMesh::averageAnyCellSize
     {
         Vertex_handle v = c->vertex(vertex_triple_index(oppositeVertex, i));
 
-        if (v->internalOrBoundaryPoint())
+        if (v->internalOrBoundaryPoint() && !v->referred())
         {
 
-            sizeProduct *= v->targetCellSize();
+            sizeSum += v->targetCellSize();
 
             nProducts++;
         }
@@ -128,13 +136,22 @@ inline Foam::scalar Foam::conformalVoronoiMesh::averageAnyCellSize
         {
             Vertex_handle v = c->vertex(vertex_triple_index(oppositeVertex, i));
 
-            sizeProduct *= targetCellSize(topoint(v->point()));
+            sizeSum += targetCellSize(topoint(v->point()));
         }
 
         nProducts = 3;
     }
 
-    return pow(sizeProduct, (1.0/nProducts));
+    if (sizeSum < 0)
+    {
+        WarningIn("averageAnyCellSize(const Delaunay::Finite_facets_iterator&)")
+            << "sizeSum = " << sizeSum
+            << endl;
+
+        return 0;
+    }
+
+    return pow(sizeSum, (1.0/nProducts));
 }
 
 
@@ -219,93 +236,91 @@ inline Foam::scalar Foam::conformalVoronoiMesh::maxSurfaceProtrusion
 }
 
 
-inline Foam::label Foam::conformalVoronoiMesh::insertPoint
+inline bool Foam::conformalVoronoiMesh::insertPoint
 (
     const Foam::point& p,
-    const label type
+    const indexedVertexEnum::vertexType type
 )
 {
-    return insertPoint(toPoint(p), type);
+    return insertPoint(toPoint<Point>(p), type);
 }
 
 
-inline Foam::label Foam::conformalVoronoiMesh::insertPoint
+inline bool Foam::conformalVoronoiMesh::insertPoint
 (
     const Point& P,
-    const label type
+    const indexedVertexEnum::vertexType type
 )
 {
     uint nVert = number_of_vertices();
 
     Vertex_handle vh = insert(P);
 
+    bool pointInserted = true;
+
     if (nVert == number_of_vertices())
     {
-        Pout << "Failed to insert point " << topoint(P) << endl;
+        Pout<< "Failed to insert point : " << topoint(P)
+            << " of type " << type << endl;
+        pointInserted = false;
     }
     else
     {
-        vh->index() = nVert;
+        vh->index() = getNewVertexIndex();
         vh->type() = type;
     }
 
-    return vh->index();
+    return pointInserted;
 }
 
 
-inline void Foam::conformalVoronoiMesh::insertPoint
+inline bool Foam::conformalVoronoiMesh::insertReferredPoint(const Vb& P)
+{
+    return insertReferredPoint(P.point(), P.index(), P.type(), P.procIndex());
+}
+
+
+inline bool Foam::conformalVoronoiMesh::insertReferredPoint
 (
     const Foam::point& p,
     const label index,
-    const label type
+    const indexedVertexEnum::vertexType type,
+    const label processor
 )
 {
-    insertPoint(toPoint(p), index, type);
+    return insertReferredPoint(toPoint<Point>(p), index, type, processor);
 }
 
 
-inline void Foam::conformalVoronoiMesh::insertPoint
+inline bool Foam::conformalVoronoiMesh::insertReferredPoint
 (
     const Point& P,
     const label index,
-    const label type
+    const indexedVertexEnum::vertexType type,
+    const label processor
 )
 {
     uint nVert = number_of_vertices();
 
     Vertex_handle vh = insert(P);
 
+    bool pointInserted = true;
+
     if (nVert == number_of_vertices())
     {
-        Pout << "Failed to insert point " << topoint(P) << endl;
+        Pout<< "Failed to insert point " << topoint(P)
+            << " type: " << type << " index: " << index
+            << " proc: " << processor << endl;
+        pointInserted = false;
     }
     else
     {
         vh->index() = index;
         vh->type() = type;
+        vh->procIndex() = processor;
     }
-}
 
-
-inline void Foam::conformalVoronoiMesh::insertPointPair
-(
-    const scalar ppDist,
-    const Foam::point& surfPt,
-    const vector& n
-)
-{
-    Pout<< "insertPointPair is depricated, "
-        << " it does not check parallel insertion." << endl;
-
-    vector ppDistn = ppDist*n;
-
-    label master = insertPoint
-    (
-        surfPt - ppDistn,
-        number_of_vertices() + 1
-    );
-
-    insertPoint(surfPt + ppDistn, master);
+    return pointInserted;
 }
 
 
@@ -314,30 +329,62 @@ inline void Foam::conformalVoronoiMesh::createPointPair
     const scalar ppDist,
     const Foam::point& surfPt,
     const vector& n,
-    DynamicList<Foam::point>& pts,
-    DynamicList<label>& indices,
-    DynamicList<label>& types
+    DynamicList<Vb>& pts
 )
 {
     vector ppDistn = ppDist*n;
 
-    // Result when the points are eventually inserted.
-    // Add number_of_vertices() at insertion of first vertex to all numbers:
-    // pt               index type
-    // surfPt - ppDistn 0     1
-    // surfPt + ppDistn 1     0
+    pts.append
+    (
+        Vb(surfPt - ppDistn, Vb::vtInternalSurface)
+    );
 
-    // Master, index = number_of_vertices(), type = number_of_vertices() + 1
-    pts.append(surfPt - ppDistn);
-    indices.append(0);
-    types.append(1);
+    pts.append
+    (
+        Vb(surfPt + ppDistn, Vb::vtExternalSurface)
+    );
+}
 
-    // Slave, index = number_of_vertices()(new) + 1, type = index of master.
-    // This will be inserted after the master, so number_of_vertices() will
-    // have increased
-    pts.append(surfPt + ppDistn);
-    indices.append(0);
-    types.append(-1);
+
+inline Foam::point Foam::conformalVoronoiMesh::perturbPoint
+(
+    const Foam::point& pt
+) const
+{
+    Foam::point perturbedPt(pt);
+
+//    vector delta(xR/ni, yR/nj, zR/nk);
+//    scalar pert = randomPerturbationCoeff*cmptMin(delta);
+
+    scalar pert = 1e-12*defaultCellSize();
+
+    perturbedPt.x() += pert*(rndGen_.scalar01() - 0.5);
+    perturbedPt.y() += pert*(rndGen_.scalar01() - 0.5);
+    perturbedPt.z() += pert*(rndGen_.scalar01() - 0.5);
+
+    return perturbedPt;
+}
+
+
+inline void Foam::conformalVoronoiMesh::createBafflePointPair
+(
+    const scalar ppDist,
+    const Foam::point& surfPt,
+    const vector& n,
+    DynamicList<Vb>& pts
+)
+{
+    vector ppDistn = ppDist*n;
+
+    pts.append
+    (
+        Vb(surfPt - ppDistn, Vb::vtInternalSurface)
+    );
+
+    pts.append
+    (
+        Vb(surfPt + ppDistn, Vb::vtInternalSurface)
+    );
 }
 
 
@@ -350,13 +397,30 @@ inline bool Foam::conformalVoronoiMesh::isBoundaryDualFace
     Vertex_handle vA = c->vertex(eit->second);
     Vertex_handle vB = c->vertex(eit->third);
 
+//    if (vA->internalBoundaryPoint() && vB->externalBoundaryPoint())
+//    {
+//        if (vA->index() == vB->index() - 1)
+//        {
+//            return true;
+//        }
+//    }
+//    else if (vA->externalBoundaryPoint() && vB->internalBoundaryPoint())
+//    {
+//        if (vA->index() == vB->index() + 1)
+//        {
+//            return true;
+//        }
+//    }
+//
+//    return false;
+
     // A dual face on the boundary will result from one Dv inside and
     // one outside
     return
     (
         (
-            vA->internalOrBoundaryPoint()
-         || vB->internalOrBoundaryPoint()
+            (vA->internalOrBoundaryPoint() && !vA->referred())
+         || (vB->internalOrBoundaryPoint() && !vB->referred())
         )
      && (
             !vA->internalOrBoundaryPoint()
@@ -458,58 +522,35 @@ inline bool Foam::conformalVoronoiMesh::isParallelDualEdge
 }
 
 
-// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
-
-#ifdef CGAL_INEXACT
-
-inline Foam::conformalVoronoiMesh::pointFromPoint
-Foam::conformalVoronoiMesh::topoint
+inline bool Foam::conformalVoronoiMesh::isProcBoundaryEdge
 (
-    const Point& P
+    const Delaunay::Finite_edges_iterator& eit
 ) const
 {
-    return reinterpret_cast<pointFromPoint>(P);
-}
+    bool isProcBoundaryEdge = false;
 
+    Cell_handle c = eit->first;
+    Vertex_handle vA = c->vertex(eit->second);
+    Vertex_handle vB = c->vertex(eit->third);
 
-inline Foam::conformalVoronoiMesh::PointFrompoint
-Foam::conformalVoronoiMesh::toPoint
-(
-    const Foam::point& p
-) const
-{
-    return reinterpret_cast<PointFrompoint>(p);
-}
-
-#else
-
-
-inline Foam::conformalVoronoiMesh::pointFromPoint
-Foam::conformalVoronoiMesh::topoint
-(
-    const Point& P
-) const
-{
-    return Foam::point
+    if
     (
-        CGAL::to_double(P.x()),
-        CGAL::to_double(P.y()),
-        CGAL::to_double(P.z())
-    );
+        (
+            (vA->referred() && !vB->referred())
+         || (vB->referred() && !vA->referred())
+        )
+     && vA->internalOrBoundaryPoint()
+     && vB->internalOrBoundaryPoint()
+    )
+    {
+        isProcBoundaryEdge = true;
+    }
+
+    return isProcBoundaryEdge;
 }
 
 
-inline Foam::conformalVoronoiMesh::PointFrompoint
-Foam::conformalVoronoiMesh::toPoint
-(
-    const Foam::point& p
-) const
-{
-    return Point(p.x(), p.y(), p.z());
-}
-
-#endif
-
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
 inline Foam::conformalVoronoiMesh::CGALVector
 Foam::conformalVoronoiMesh::toCGALVector(const Foam::vector& v) const
@@ -562,10 +603,10 @@ Foam::conformalVoronoiMesh::decomposition() const
 }
 
 
-inline const Foam::cellSizeControlSurfaces&
-Foam::conformalVoronoiMesh::cellSizeControl() const
+inline const Foam::cellShapeControl&
+Foam::conformalVoronoiMesh::cellShapeControls() const
 {
-    return cellSizeControl_;
+    return cellShapeControl_;
 }
 
 
diff --git a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/conformalVoronoiMeshIO.C b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/conformalVoronoiMeshIO.C
index 68f98e8a9d..e35a711148 100644
--- a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/conformalVoronoiMeshIO.C
+++ b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/conformalVoronoiMeshIO.C
@@ -28,6 +28,11 @@ License
 #include "OFstream.H"
 #include "pointMesh.H"
 #include "pointFields.H"
+#include "ListOps.H"
+#include "polyMeshFilter.H"
+#include "polyTopoChange.H"
+#include "PrintTable.H"
+#include "pointMesh.H"
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
@@ -57,61 +62,185 @@ void Foam::conformalVoronoiMesh::timeCheck
 
         if (m.valid())
         {
-            label mSize = m.size();
-            label mPeak = m.peak();
-            label mRss = m.rss();
+            PrintTable<word, label> memoryTable("Memory Usage (kB)");
 
-            if (Pstream::parRun())
-            {
-                labelList allMSize(Pstream::nProcs());
-                labelList allMPeak(Pstream::nProcs());
-                labelList allMRss(Pstream::nProcs());
+            memoryTable.add("mSize", m.size());
+            memoryTable.add("mPeak", m.peak());
+            memoryTable.add("mRss", m.rss());
 
-                allMSize[Pstream::myProcNo()] = mSize;
-                allMPeak[Pstream::myProcNo()] = mPeak;
-                allMRss[Pstream::myProcNo()] = mRss;
-
-                Pstream::gatherList(allMSize);
-                Pstream::gatherList(allMPeak);
-                Pstream::gatherList(allMRss);
-
-                Info<< "--- [ "
-                    << "mem (kB) " << tab
-                    << "size" << tab
-                    << "peak" << tab
-                    << "rss"
-                    << " ] --- " << endl;
-
-                forAll(allMSize, procI)
-                {
-                    Info<< "--- [ "
-                        << procI << " " << tab
-                        << allMSize[procI] << tab
-                        << allMPeak[procI] << tab
-                        << allMRss[procI]
-                        << " ] --- " << endl;
-                }
-
-                Info<< "--- [ "
-                    << "sum " << tab
-                    << sum(allMSize) << tab
-                    << sum(allMPeak) << tab
-                    << sum(allMRss)
-                    << " ] --- " << endl;
-
-            }
-            else
-            {
-                Info<< "--- [ "
-                    << "mem size " << mSize << " kB, "
-                    << "mem peak " << mPeak << " kB, "
-                    << "mem rss " << mRss << " kB"
-                    << " ] --- " << endl;
-            }
+            Info<< incrIndent;
+            memoryTable.print(Info);
+            Info<< decrIndent;
         }
     }
 }
 
+
+void Foam::conformalVoronoiMesh::printVertexInfo() const
+{
+    label nInternal = 0;
+    label nInternalRef = 0;
+    label nUnassigned = 0;
+    label nUnassignedRef = 0;
+    label nInternalNearBoundary = 0;
+    label nInternalNearBoundaryRef = 0;
+    label nInternalSurface = 0;
+    label nInternalSurfaceRef = 0;
+    label nInternalFeatureEdge = 0;
+    label nInternalFeatureEdgeRef = 0;
+    label nInternalFeaturePoint = 0;
+    label nInternalFeaturePointRef = 0;
+    label nExternalSurface = 0;
+    label nExternalSurfaceRef = 0;
+    label nExternalFeatureEdge = 0;
+    label nExternalFeatureEdgeRef = 0;
+    label nExternalFeaturePoint = 0;
+    label nExternalFeaturePointRef = 0;
+    label nFar = 0;
+    label nReferred = 0;
+
+    for
+    (
+        Delaunay::Finite_vertices_iterator vit = finite_vertices_begin();
+        vit != finite_vertices_end();
+        ++vit
+    )
+    {
+        if (vit->type() == Vb::vtInternal)
+        {
+            if (vit->referred())
+            {
+                nReferred++;
+                nInternalRef++;
+            }
+
+            nInternal++;
+        }
+        else if (vit->type() == Vb::vtUnassigned)
+        {
+            if (vit->referred())
+            {
+                nReferred++;
+                nUnassignedRef++;
+            }
+
+            nUnassigned++;
+        }
+        else if (vit->type() == Vb::vtInternalNearBoundary)
+        {
+            if (vit->referred())
+            {
+                nReferred++;
+                nInternalNearBoundaryRef++;
+            }
+
+            nInternalNearBoundary++;
+        }
+        else if (vit->type() == Vb::vtInternalSurface)
+        {
+            if (vit->referred())
+            {
+                nReferred++;
+                nInternalSurfaceRef++;
+            }
+
+            nInternalSurface++;
+        }
+        else if (vit->type() == Vb::vtInternalFeatureEdge)
+        {
+            if (vit->referred())
+            {
+                nReferred++;
+                nInternalFeatureEdgeRef++;
+            }
+
+            nInternalFeatureEdge++;
+        }
+        else if (vit->type() == Vb::vtInternalFeaturePoint)
+        {
+            if (vit->referred())
+            {
+                nReferred++;
+                nInternalFeaturePointRef++;
+            }
+
+            nInternalFeaturePoint++;
+        }
+        else if (vit->type() == Vb::vtExternalSurface)
+        {
+            if (vit->referred())
+            {
+                nReferred++;
+                nExternalSurfaceRef++;
+            }
+
+            nExternalSurface++;
+        }
+        else if (vit->type() == Vb::vtExternalFeatureEdge)
+        {
+            if (vit->referred())
+            {
+                nReferred++;
+                nExternalFeatureEdgeRef++;
+            }
+
+            nExternalFeatureEdge++;
+        }
+        else if (vit->type() == Vb::vtExternalFeaturePoint)
+        {
+            if (vit->referred())
+            {
+                nReferred++;
+                nExternalFeaturePointRef++;
+            }
+
+            nExternalFeaturePoint++;
+        }
+        else if (vit->type() == Vb::vtFar)
+        {
+            nFar++;
+        }
+    }
+
+    label nTotalVertices
+        = nUnassigned
+        + nInternal
+        + nInternalNearBoundary
+        + nInternalSurface
+        + nInternalFeatureEdge
+        + nInternalFeaturePoint
+        + nExternalSurface
+        + nExternalFeatureEdge
+        + nExternalFeaturePoint
+        + nFar;
+
+    if (nTotalVertices != label(number_of_vertices()))
+    {
+        WarningIn("Foam::conformalVoronoiMesh::printVertexInfo()")
+            << nTotalVertices << " does not equal " << number_of_vertices()
+            << endl;
+    }
+
+    PrintTable<word, label> vertexTable("Vertex Type Information");
+
+    vertexTable.add("Total", nTotalVertices);
+    vertexTable.add("Unassigned", nUnassigned);
+    vertexTable.add("nInternal", nInternal);
+    vertexTable.add("nInternalNearBoundary", nInternalNearBoundary);
+    vertexTable.add("nInternalSurface", nInternalSurface);
+    vertexTable.add("nInternalFeatureEdge", nInternalFeatureEdge);
+    vertexTable.add("nInternalFeaturePoint", nInternalFeaturePoint);
+    vertexTable.add("nExternalSurface", nExternalSurface);
+    vertexTable.add("nExternalFeatureEdge", nExternalFeatureEdge);
+    vertexTable.add("nExternalFeaturePoint", nExternalFeaturePoint);
+    vertexTable.add("nFar", nFar);
+    vertexTable.add("nReferred", nReferred);
+
+    Info<< endl;
+    vertexTable.print(Info);
+}
+
+
 void Foam::conformalVoronoiMesh::drawDelaunayCell
 (
     Ostream& os,
@@ -120,7 +249,7 @@ void Foam::conformalVoronoiMesh::drawDelaunayCell
 ) const
 {
     // Supply offset as tet number
-    offset *= 5;
+    offset *= 4;
 
     os  << "# cell index: " << label(c->cellIndex()) << endl;
 
@@ -130,9 +259,10 @@ void Foam::conformalVoronoiMesh::drawDelaunayCell
 
     for (int i = 0; i < 4; i++)
     {
-        os  << "# index type: "
+        os  << "# index / type / procIndex: "
             << label(c->vertex(i)->index()) << " "
-            << label(c->vertex(i)->type()) << endl;
+            << label(c->vertex(i)->type()) << " "
+            << label(c->vertex(i)->procIndex()) << endl;
 
         meshTools::writeOBJ(os, topoint(c->vertex(i)->point()));
     }
@@ -142,23 +272,39 @@ void Foam::conformalVoronoiMesh::drawDelaunayCell
         << "f " << 1 + offset << " " << 4 + offset << " " << 3 + offset << nl
         << "f " << 1 + offset << " " << 2 + offset << " " << 4 + offset << endl;
 
-    os  << "# cicumcentre " << endl;
+//    os  << "# cicumcentre " << endl;
 
-    meshTools::writeOBJ(os, c->dual());
+//    meshTools::writeOBJ(os, c->dual());
 
-    os  << "l " << 1 + offset << " " << 5 + offset << endl;
+//    os  << "l " << 1 + offset << " " << 5 + offset << endl;
 }
 
 
 void Foam::conformalVoronoiMesh::writePoints
 (
     const fileName& fName,
-    bool internalOnly
+    const Foam::indexedVertexEnum::vertexType startPointType,
+    const Foam::indexedVertexEnum::vertexType endPointType
 ) const
 {
     OFstream str(runTime_.path()/fName);
 
-    Pout<< nl << "Writing points to " << str.name() << endl;
+    Pout<< nl << "Writing points of types:" << nl;
+
+    forAllConstIter
+    (
+        HashTable<int>,
+        Foam::indexedVertexEnum::vertexTypeNames_,
+        iter
+    )
+    {
+        if (iter() >= startPointType && iter() <= endPointType)
+        {
+            Pout<< "    " << iter.key() << nl;
+        }
+    }
+
+    Pout<< "to " << str.name() << endl;
 
     for
     (
@@ -167,7 +313,7 @@ void Foam::conformalVoronoiMesh::writePoints
         ++vit
     )
     {
-        if (!internalOnly || vit->internalPoint())
+        if (vit->type() >= startPointType && vit->type() <= endPointType)
         {
             meshTools::writeOBJ(str, topoint(vit->point()));
         }
@@ -175,6 +321,16 @@ void Foam::conformalVoronoiMesh::writePoints
 }
 
 
+void Foam::conformalVoronoiMesh::writePoints
+(
+    const fileName& fName,
+    const Foam::indexedVertexEnum::vertexType pointType
+) const
+{
+    writePoints(fName, pointType, pointType);
+}
+
+
 void Foam::conformalVoronoiMesh::writeBoundaryPoints
 (
     const fileName& fName
@@ -220,6 +376,27 @@ void Foam::conformalVoronoiMesh::writePoints
 }
 
 
+void Foam::conformalVoronoiMesh::writePoints
+(
+    const fileName& fName,
+    const List<Vb>& points
+) const
+{
+    if (points.size())
+    {
+        OFstream str(runTime_.path()/fName);
+
+        Pout<< nl << "Writing " << points.size() << " points from pointList to "
+            << str.name() << endl;
+
+        forAll(points, p)
+        {
+            meshTools::writeOBJ(str, topoint(points[p].point()));
+        }
+    }
+}
+
+
 void Foam::conformalVoronoiMesh::writeProcessorInterface
 (
     const fileName& fName,
@@ -228,9 +405,7 @@ void Foam::conformalVoronoiMesh::writeProcessorInterface
 {
     OFstream str(runTime_.path()/fName);
 
-    Pout<< "Writing processor interface" << endl;
-
-    pointField points(number_of_cells(), point::max);
+    pointField points(number_of_finite_cells(), point::max);
 
     for
     (
@@ -239,15 +414,13 @@ void Foam::conformalVoronoiMesh::writeProcessorInterface
         ++cit
     )
     {
-        if (!cit->farCell())
+        if (!cit->hasFarPoint() && !is_infinite(cit))
         {
             points[cit->cellIndex()] = cit->dual();
         }
     }
 
     meshTools::writeOBJ(str, faces, points);
-
-    Pout<< "Written processor interface" << endl;
 }
 
 
@@ -297,11 +470,7 @@ void Foam::conformalVoronoiMesh::writeInternalDelaunayVertices
 }
 
 
-void Foam::conformalVoronoiMesh::writeMesh
-(
-    const fileName& instance,
-    bool filterFaces
-)
+void Foam::conformalVoronoiMesh::writeMesh(const fileName& instance)
 {
     writeInternalDelaunayVertices(instance);
 
@@ -314,6 +483,7 @@ void Foam::conformalVoronoiMesh::writeMesh
 
     {
         pointField points;
+        labelList boundaryPts(number_of_finite_cells(), -1);
         faceList faces;
         labelList owner;
         labelList neighbour;
@@ -323,9 +493,12 @@ void Foam::conformalVoronoiMesh::writeMesh
         labelList procNeighbours;
         pointField cellCentres;
 
+        PackedBoolList boundaryFacesToRemove;
+
         calcDualMesh
         (
             points,
+            boundaryPts,
             faces,
             owner,
             neighbour,
@@ -337,7 +510,7 @@ void Foam::conformalVoronoiMesh::writeMesh
             cellCentres,
             cellToDelaunayVertex,
             patchToDelaunayVertex,
-            filterFaces
+            boundaryFacesToRemove
         );
 
         Info<< nl << "Writing polyMesh to " << instance << endl;
@@ -347,6 +520,7 @@ void Foam::conformalVoronoiMesh::writeMesh
             Foam::polyMesh::defaultRegion,
             instance,
             points,
+            boundaryPts,
             faces,
             owner,
             neighbour,
@@ -355,12 +529,11 @@ void Foam::conformalVoronoiMesh::writeMesh
             patchSizes,
             dualPatchStarts,
             procNeighbours,
-            cellCentres
+            cellCentres,
+            boundaryFacesToRemove
         );
     }
 
-
-
     if (cvMeshControls().writeTetDualMesh())
     {
         // Determine map from Delaunay vertex to Dual mesh
@@ -389,6 +562,7 @@ void Foam::conformalVoronoiMesh::writeMesh
         forAll(patchToDelaunayVertex, patchI)
         {
             const labelList& patchVertices = patchToDelaunayVertex[patchI];
+
             forAll(patchVertices, i)
             {
                 label vertI = patchVertices[i];
@@ -416,6 +590,7 @@ void Foam::conformalVoronoiMesh::writeMesh
         // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
         pointField points;
+        labelList boundaryPts(number_of_finite_cells(), -1);
         // From tet point back to Delaunay vertex index
         labelList pointToDelaunayVertex;
         faceList faces;
@@ -541,23 +716,24 @@ void Foam::conformalVoronoiMesh::writeMesh
 
         labelList procNeighbours(patchNames.size(), -1);
 
-        Info<< nl << "Writing tetDualMesh to " << instance << endl;
+//        Info<< nl << "Writing tetDualMesh to " << instance << endl;
 
-        writeMesh
-        (
-            "tetDualMesh",
-            instance,
-            points,
-            faces,
-            owner,
-            neighbour,
-            patchTypes,
-            patchNames,
-            patchSizes,
-            patchStarts,
-            procNeighbours,
-            cellCentres
-        );
+//        writeMesh
+//        (
+//            "tetDualMesh",
+//            instance,
+//            points,
+//            boundaryPts,
+//            faces,
+//            owner,
+//            neighbour,
+//            patchTypes,
+//            patchNames,
+//            patchSizes,
+//            patchStarts,
+//            procNeighbours,
+//            cellCentres
+//        );
     }
 }
 
@@ -598,7 +774,8 @@ Foam::autoPtr<Foam::fvMesh> Foam::conformalVoronoiMesh::createDummyMesh
                 patchI,
                 mesh.boundaryMesh(),
                 Pstream::myProcNo(),
-                procNeighbours[patchI]
+                procNeighbours[patchI],
+                coupledPolyPatch::COINCIDENTFULLMATCH
             );
         }
         else
@@ -620,6 +797,122 @@ Foam::autoPtr<Foam::fvMesh> Foam::conformalVoronoiMesh::createDummyMesh
 }
 
 
+void Foam::conformalVoronoiMesh::checkProcessorPatchesMatch
+(
+    const wordList& patchTypes,
+    const labelList& patchSizes,
+    const labelList& procNeighbours
+) const
+{
+    // Check patch sizes
+    labelListList procPatchSizes
+    (
+        Pstream::nProcs(),
+        labelList(Pstream::nProcs(), -1)
+    );
+
+    forAll(patchTypes, patchI)
+    {
+        if (patchTypes[patchI] == processorPolyPatch::typeName)
+        {
+            procPatchSizes[Pstream::myProcNo()][procNeighbours[patchI]]
+                = patchSizes[patchI];
+        }
+    }
+
+    Pstream::gatherList(procPatchSizes);
+
+    if (Pstream::master())
+    {
+        bool allMatch = true;
+
+        forAll(procPatchSizes, procI)
+        {
+            const labelList& patchSizes = procPatchSizes[procI];
+
+            forAll(patchSizes, patchI)
+            {
+                if (patchSizes[patchI] != procPatchSizes[patchI][procI])
+                {
+                    allMatch = false;
+
+                    Info<< indent << "Patches " << procI << " and " << patchI
+                        << " have different sizes: " << patchSizes[patchI]
+                        << " and " << procPatchSizes[patchI][procI] << endl;
+                }
+            }
+        }
+
+        if (allMatch)
+        {
+            Info<< indent << "All processor patches have matching numbers of "
+                << "faces" << endl;
+        }
+    }
+}
+
+
+void Foam::conformalVoronoiMesh::reorderPoints
+(
+    pointField& points,
+    labelList& boundaryPts,
+    faceList& faces,
+    const label nInternalFaces
+) const
+{
+    Info<< incrIndent << indent << "Reordering points into internal/external"
+        << endl;
+
+    labelList oldToNew(points.size(), 0);
+
+    // Find points that are internal
+    for (label fI = nInternalFaces; fI < faces.size(); ++fI)
+    {
+        const face& f = faces[fI];
+
+        forAll(f, fpI)
+        {
+            oldToNew[f[fpI]] = 1;
+        }
+    }
+
+    const label nInternalPoints = points.size() - sum(oldToNew);
+
+    label countInternal = 0;
+    label countExternal = nInternalPoints;
+
+    forAll(points, pI)
+    {
+        if (oldToNew[pI] == 0)
+        {
+            oldToNew[pI] = countInternal++;
+        }
+        else
+        {
+            oldToNew[pI] = countExternal++;
+        }
+    }
+
+    Info<< indent
+        << "Number of internal points: " << countInternal << nl
+        << indent << "Number of external points: " << countExternal
+        << decrIndent << endl;
+
+    inplaceReorder(oldToNew, points);
+    inplaceReorder(oldToNew, boundaryPts);
+
+    forAll(faces, fI)
+    {
+        face& f = faces[fI];
+
+        forAll(f, fpI)
+        {
+            f[fpI] = oldToNew[f[fpI]];
+        }
+    }
+}
+
+
 void Foam::conformalVoronoiMesh::reorderProcessorPatches
 (
     const word& meshName,
@@ -633,6 +926,11 @@ void Foam::conformalVoronoiMesh::reorderProcessorPatches
     const labelList& procNeighbours
 ) const
 {
+    Info<< incrIndent << indent << "Reordering processor patches" << endl;
+
+    Info<< incrIndent;
+    checkProcessorPatchesMatch(patchTypes, patchSizes, procNeighbours);
+
     // Create dummy mesh with correct proc boundaries to do sorting
     autoPtr<fvMesh> sortMeshPtr
     (
@@ -656,8 +954,26 @@ void Foam::conformalVoronoiMesh::reorderProcessorPatches
     );
     const fvMesh& sortMesh = sortMeshPtr();
 
+    // Change the transform type on processors to coincident full match.
+//    forAll(sortMesh.boundaryMesh(), patchI)
+//    {
+//        const polyPatch& patch = sortMesh.boundaryMesh()[patchI];
+//
+//        if (isA<processorPolyPatch>(patch))
+//        {
+//            const processorPolyPatch& cpPatch
+//                = refCast<const processorPolyPatch>(patch);
+//
+//            processorPolyPatch& pPatch
+//                = const_cast<processorPolyPatch&>(cpPatch);
+//
+//            pPatch.transform() = coupledPolyPatch::COINCIDENTFULLMATCH;
+//        }
+//    }
+
     // Rotation on new faces.
-    labelList rotation(faces.size(), 0);
+    labelList rotation(faces.size(), -1);
+    labelList faceMap(faces.size(), -1);
 
     PstreamBuffers pBufs(Pstream::nonBlocking);
 
@@ -699,23 +1015,22 @@ void Foam::conformalVoronoiMesh::reorderProcessorPatches
             labelList patchFaceMap(patchSizes[patchI], -1);
             labelList patchFaceRotation(patchSizes[patchI], 0);
 
-            bool changed =
-                refCast<const processorPolyPatch>(pp).order
+            bool changed = refCast<const processorPolyPatch>(pp).order
+            (
+                pBufs,
+                primitivePatch
                 (
-                    pBufs,
-                    primitivePatch
+                    SubList<face>
                     (
-                        SubList<face>
-                        (
-                            faces,
-                            patchSizes[patchI],
-                            patchStarts[patchI]
-                        ),
-                        points
+                        faces,
+                        patchSizes[patchI],
+                        patchStarts[patchI]
                     ),
-                    patchFaceMap,
-                    patchFaceRotation
-                );
+                    points
+                ),
+                patchFaceMap,
+                patchFaceRotation
+            );
 
             if (changed)
             {
@@ -724,8 +1039,17 @@ void Foam::conformalVoronoiMesh::reorderProcessorPatches
 
                 forAll(patchFaceRotation, patchFaceI)
                 {
-                    rotation[patchFaceI + start] =
-                        patchFaceRotation[patchFaceI];
+                    rotation[patchFaceI + start]
+                        = patchFaceRotation[patchFaceI];
+                }
+
+                forAll(patchFaceMap, patchFaceI)
+                {
+                    if (patchFaceMap[patchFaceI] != patchFaceI)
+                    {
+                        faceMap[patchFaceI + start]
+                            = patchFaceMap[patchFaceI] + start;
+                    }
                 }
 
                 anyChanged = true;
@@ -738,13 +1062,26 @@ void Foam::conformalVoronoiMesh::reorderProcessorPatches
     if (anyChanged)
     {
         // Rotate faces (rotation is already in new face indices).
+        label nRotated = 0;
+
         forAll(rotation, faceI)
         {
+            if (rotation[faceI] == -1)
+            {
+                continue;
+            }
+
             if (rotation[faceI] != 0)
             {
-                faces[faceI] = faces[faceI].rotateFace(rotation[faceI]);
+                inplaceRotateList<List, label>(faces[faceI], rotation[faceI]);
+                nRotated++;
             }
         }
+
+        inplaceReorder(faceMap, faces);
+
+        Info<< indent << returnReduce(nRotated, sumOp<label>())
+            << " faces have been rotated" << decrIndent << decrIndent << endl;
     }
 }
 
@@ -754,6 +1091,7 @@ void Foam::conformalVoronoiMesh::writeMesh
     const word& meshName,
     const fileName& instance,
     pointField& points,
+    labelList& boundaryPts,
     faceList& faces,
     labelList& owner,
     labelList& neighbour,
@@ -762,7 +1100,8 @@ void Foam::conformalVoronoiMesh::writeMesh
     const labelList& patchSizes,
     const labelList& patchStarts,
     const labelList& procNeighbours,
-    const pointField& cellCentres
+    const pointField& cellCentres,
+    const PackedBoolList& boundaryFacesToRemove
 ) const
 {
     if (cvMeshControls().objOutput())
@@ -770,6 +1109,8 @@ void Foam::conformalVoronoiMesh::writeMesh
         writeObjMesh(points, faces, word(meshName + ".obj"));
     }
 
+    reorderPoints(points, boundaryPts, faces, patchStarts[0]);
+
     if (Pstream::parRun())
     {
         reorderProcessorPatches
@@ -786,6 +1127,10 @@ void Foam::conformalVoronoiMesh::writeMesh
         );
     }
 
+    Info<< "    Constructing mesh" << endl;
+
+    timeCheck("Before fvMesh construction");
+
     fvMesh mesh
     (
         IOobject
@@ -802,6 +1147,8 @@ void Foam::conformalVoronoiMesh::writeMesh
         xferMove(neighbour)
     );
 
+    Info<< "    Adding patches to mesh" << endl;
+
     List<polyPatch*> patches(patchStarts.size());
 
     label nValidPatches = 0;
@@ -811,7 +1158,6 @@ void Foam::conformalVoronoiMesh::writeMesh
         if (patchTypes[p] == processorPolyPatch::typeName)
         {
             // Do not create empty processor patches
-
             if (patchSizes[p] > 0)
             {
                 patches[nValidPatches] = new processorPolyPatch
@@ -822,7 +1168,8 @@ void Foam::conformalVoronoiMesh::writeMesh
                     nValidPatches,
                     mesh.boundaryMesh(),
                     Pstream::myProcNo(),
-                    procNeighbours[p]
+                    procNeighbours[p],
+                    coupledPolyPatch::NOORDERING
                 );
 
                 nValidPatches++;
@@ -848,18 +1195,224 @@ void Foam::conformalVoronoiMesh::writeMesh
 
     mesh.addFvPatches(patches);
 
+    timeCheck("Before fvMesh filtering");
+
+    autoPtr<polyMeshFilter> meshFilter;
+
+    label nInitialBadFaces = 0;
+
+    if (cvMeshControls().filterEdges())
+    {
+        Info<< nl << "Filtering edges on polyMesh" << nl << endl;
+
+        meshFilter.reset(new polyMeshFilter(mesh));
+
+        // Filter small edges only. This reduces the number of faces so that
+        // the face filtering is sped up.
+        nInitialBadFaces = meshFilter().filterEdges(0);
+        {
+            const autoPtr<fvMesh>& newMesh = meshFilter().filteredMesh();
+
+            polyTopoChange meshMod(newMesh);
+
+            meshMod.changeMesh(mesh, false);
+        }
+    }
+
+    if (cvMeshControls().filterFaces())
+    {
+        Info<< nl << "Filtering faces on polyMesh" << nl << endl;
+
+        meshFilter.reset(new polyMeshFilter(mesh));
+
+        meshFilter().filter(nInitialBadFaces);
+        {
+            const autoPtr<fvMesh>& newMesh = meshFilter().filteredMesh();
+
+            polyTopoChange meshMod(newMesh);
+
+            meshMod.changeMesh(mesh, false);
+        }
+    }
+
+    timeCheck("After fvMesh filtering");
+
+    mesh.setInstance(instance);
+
     if (!mesh.write())
     {
         FatalErrorIn("Foam::conformalVoronoiMesh::writeMesh(..)")
             << "Failed writing polyMesh."
             << exit(FatalError);
     }
+    else
+    {
+        Info<< nl << "Written filtered mesh to "
+            << mesh.polyMesh::instance() << nl
+            << endl;
+    }
 
-    writeCellSizes(mesh);
 
-    writeCellCentres(mesh);
+    volTensorField alignments
+    (
+        IOobject
+        (
+            "alignmentsField",
+            runTime_.timeName(),
+            runTime_,
+            IOobject::NO_READ,
+            IOobject::AUTO_WRITE
+        ),
+        mesh,
+        tensor::zero
+    );
 
-    findRemainingProtrusionSet(mesh);
+    forAll(mesh.cellCentres(), pI)
+    {
+        Vertex_handle nearV =
+            nearest_vertex
+            (
+                toPoint<Point>(mesh.cellCentres()[pI])
+            );
+        alignments[pI] = nearV->alignment();
+    }
+    alignments.write();
+
+    {
+        volVectorField alignmentx
+        (
+            IOobject
+            (
+                "alignmentsx",
+                runTime_.timeName(),
+                runTime_,
+                IOobject::NO_READ,
+                IOobject::AUTO_WRITE
+            ),
+            mesh,
+            vector::zero
+        );
+        forAll(alignmentx, aI)
+        {
+            alignmentx[aI] = alignments[aI].x();
+        }
+        alignmentx.write();
+    }
+    {
+        volVectorField alignmenty
+        (
+            IOobject
+            (
+                "alignmentsy",
+                runTime_.timeName(),
+                runTime_,
+                IOobject::NO_READ,
+                IOobject::AUTO_WRITE
+            ),
+            mesh,
+            vector::zero
+        );
+        forAll(alignmenty, aI)
+        {
+            alignmenty[aI] = alignments[aI].y();
+        }
+        alignmenty.write();
+    }
+    {
+        volVectorField alignmentz
+        (
+            IOobject
+            (
+                "alignmentsz",
+                runTime_.timeName(),
+                runTime_,
+                IOobject::NO_READ,
+                IOobject::AUTO_WRITE
+            ),
+            mesh,
+            vector::zero
+        );
+        forAll(alignmentz, aI)
+        {
+            alignmentz[aI] = alignments[aI].z();
+        }
+        alignmentz.write();
+    }
+    labelIOList boundaryIOPts
+    (
+        IOobject
+        (
+            "boundaryPoints",
+            instance,
+            runTime_,
+            IOobject::NO_READ,
+            IOobject::AUTO_WRITE
+        ),
+        boundaryPts
+    );
+
+
+
+
+    // Dump list of boundary points
+    forAll(mesh.boundaryMesh(), patchI)
+    {
+        const polyPatch& pp = mesh.boundaryMesh()[patchI];
+
+        if (!isA<coupledPolyPatch>(pp))
+        {
+            forAll(pp, fI)
+            {
+                const face& boundaryFace = pp[fI];
+
+                forAll(boundaryFace, pI)
+                {
+                    const label boundaryPointI = boundaryFace[pI];
+
+                    boundaryIOPts[boundaryPointI] = boundaryPts[boundaryPointI];
+                }
+            }
+        }
+    }
+
+    boundaryIOPts.write();
+
+//    forAllConstIter(labelHashSet, pointsInPatch, pI)
+//    {
+//        const Foam::point& ptMaster = mesh.points()[pI.key()];
+//
+//        forAllConstIter(labelHashSet, pointsInPatch, ptI)
+//        {
+//            if (ptI.key() != pI.key())
+//            {
+//                const Foam::point& ptSlave = mesh.points()[ptI.key()];
+//
+//                const scalar dist = mag(ptMaster - ptSlave);
+//                if (ptMaster == ptSlave)
+//                {
+//                    Pout<< "Point(" << pI.key() << ") " << ptMaster
+//                        << " == "
+//                        << "(" << ptI.key() << ") " << ptSlave
+//                        << endl;
+//                }
+//                else if (dist == 0)
+//                {
+//                    Pout<< "Point(" << pI.key() << ") " << ptMaster
+//                        << " ~= "
+//                        << "(" << ptI.key() << ") " << ptSlave
+//                        << endl;
+//                }
+//            }
+//        }
+//    }
+
+//    writeCellSizes(mesh);
+
+//    writeCellAlignments(mesh);
+
+//    writeCellCentres(mesh);
+
+//    findRemainingProtrusionSet(mesh);
 }
 
 
@@ -926,7 +1479,7 @@ void Foam::conformalVoronoiMesh::writeCellSizes
 
         forAll(cellSize, i)
         {
-            cellSize[i] = cellSizeControl().cellSize(C[i]);
+            cellSize[i] = cellShapeControls().cellSize(C[i]);
         }
 
         // Info<< nl << "Create targetCellVolume volScalarField" << endl;
@@ -1036,7 +1589,7 @@ void Foam::conformalVoronoiMesh::writeCellSizes
 
     //     forAll(cellSize, i)
     //     {
-    //         cellSize[i] = cellSizeControl().cellSize(P[i]);
+    //         cellSize[i] = cellShapeControls().cellSize(P[i]);
     //     }
 
     //     ptTargetCellSize.write();
@@ -1044,6 +1597,61 @@ void Foam::conformalVoronoiMesh::writeCellSizes
 }
 
 
+void Foam::conformalVoronoiMesh::writeCellAlignments
+(
+    const fvMesh& mesh
+) const
+{
+//    Info<< nl << "Create cellAlignments volTensorField" << endl;
+//
+//    volTensorField cellAlignments
+//    (
+//        IOobject
+//        (
+//            "cellAlignments",
+//            mesh.polyMesh::instance(),
+//            mesh,
+//            IOobject::NO_READ,
+//            IOobject::AUTO_WRITE
+//        ),
+//        mesh,
+//        tensor::I,
+//        zeroGradientFvPatchTensorField::typeName
+//    );
+//
+//    tensorField& cellAlignment = cellAlignments.internalField();
+//
+//    const vectorField& C = mesh.cellCentres();
+//
+//    vectorField xDir(cellAlignment.size());
+//    vectorField yDir(cellAlignment.size());
+//    vectorField zDir(cellAlignment.size());
+//
+//    forAll(cellAlignment, i)
+//    {
+//        cellAlignment[i] = cellShapeControls().cellAlignment(C[i]);
+//        xDir[i] = cellAlignment[i] & vector(1, 0, 0);
+//        yDir[i] = cellAlignment[i] & vector(0, 1, 0);
+//        zDir[i] = cellAlignment[i] & vector(0, 0, 1);
+//    }
+//
+//    OFstream xStr("xDir.obj");
+//    OFstream yStr("yDir.obj");
+//    OFstream zStr("zDir.obj");
+//
+//    forAll(xDir, i)
+//    {
+//        meshTools::writeOBJ(xStr, C[i], C[i] + xDir[i]);
+//        meshTools::writeOBJ(yStr, C[i], C[i] + yDir[i]);
+//        meshTools::writeOBJ(zStr, C[i], C[i] + zDir[i]);
+//    }
+//
+//    cellAlignments.correctBoundaryConditions();
+//
+//    cellAlignments.write();
+}
+
+
 void Foam::conformalVoronoiMesh::writeCellCentres
 (
     const fvMesh& mesh
diff --git a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/indexedCell.C b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/indexedCell/indexedCell.C
similarity index 67%
rename from applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/indexedCell.C
rename to applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/indexedCell/indexedCell.C
index 06b2c4d400..bd4973b32b 100644
--- a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/indexedCell.C
+++ b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/indexedCell/indexedCell.C
@@ -21,11 +21,6 @@ License
     You should have received a copy of the GNU General Public License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
-    As a special exception, you have permission to link this program with the
-    CGAL library and distribute executables, as long as you follow the
-    requirements of the GNU GPL in regard to all of the software in the
-    executable aside from CGAL.
-
 \*---------------------------------------------------------------------------*/
 
 #include "indexedCell.H"
@@ -41,8 +36,47 @@ Foam::Ostream& Foam::operator<<
 {
     const CGAL::indexedCell<Gt, Cb>& iv = p.t_;
 
-    os  << "Cell : index:" << iv.index_ << " filterCount:" << iv.filterCount_
-        << nl;
+    os  << "Cell: ";
+
+    if (iv.index_ == CGAL::indexedCell<Gt, Cb>::ctFar)
+    {
+        os  << "far";
+    }
+    else if (iv.index_ >= 0)
+    {
+        os  << iv.index_;
+    }
+    else if (iv.index_ == CGAL::indexedCell<Gt, Cb>::ctInternal)
+    {
+        os  << "internal";
+    }
+    else if (iv.index_ == CGAL::indexedCell<Gt, Cb>::ctSurface)
+    {
+        os  << "surface";
+    }
+    else if (iv.index_ == CGAL::indexedCell<Gt, Cb>::ctFeatureEdge)
+    {
+        os  << "featureEdge";
+    }
+    else if (iv.index_ == CGAL::indexedCell<Gt, Cb>::ctFeaturePoint)
+    {
+        os  << "featurePoint";
+    }
+    else
+    {
+        os  << "unassigned";
+    }
+
+    if (iv.parallelDualVertex())
+    {
+        os  << " (processor)";
+    }
+    else
+    {
+        os  << " (local)";
+    }
+
+    os  << " filterCount: " << iv.filterCount_ << nl;
     os  << "    " << iv.vertex(0)->info();
     os  << "    " << iv.vertex(1)->info();
     os  << "    " << iv.vertex(2)->info();
diff --git a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/indexedCell.H b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/indexedCell/indexedCell.H
similarity index 84%
rename from applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/indexedCell.H
rename to applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/indexedCell/indexedCell.H
index eab096819a..4669110b6e 100644
--- a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/indexedCell.H
+++ b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/indexedCell/indexedCell.H
@@ -21,11 +21,6 @@ License
     You should have received a copy of the GNU General Public License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
-    As a special exception, you have permission to link this program with the
-    CGAL library and distribute executables, as long as you follow the
-    requirements of the GNU GPL in regard to all of the software in the
-    executable aside from CGAL.
-
 Class
     indexedCell
 
@@ -52,6 +47,8 @@ SourceFiles
 #include "InfoProxy.H"
 #include "tetCell.H"
 #include "typeInfo.H"
+#include "vectorTools.H"
+#include "indexedCellEnum.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -85,6 +82,7 @@ template
 >
 class indexedCell
 :
+    public Foam::indexedCellEnum,
     public Cb
 {
     // Private data
@@ -98,6 +96,7 @@ class indexedCell
         //           not on a processor face
         //  < 0 && > ctFar : the (global) index of a dual point on a processor
         //                   face
+
         int index_;
 
         //- The number of times that this Delaunay cell has been limited
@@ -105,14 +104,17 @@ class indexedCell
         int filterCount_;
 
 
+    // Private member functions
+
+        //- Same as globallyOrderedCellVertices but without sorting
+        Foam::tetCell unsortedVertexGlobalIndices
+        (
+            const Foam::globalIndex& globalDelaunayVertexIndices
+        ) const;
+
+
 public:
 
-    enum cellTypes
-    {
-        ctFar = INT_MIN
-    };
-
-
     typedef typename Cb::Vertex_handle                   Vertex_handle;
     typedef typename Cb::Cell_handle                     Cell_handle;
 
@@ -155,9 +157,13 @@ public:
 
         inline int cellIndex() const;
 
+#ifdef CGAL_INEXACT
         inline const Foam::point& dual();
+#else
+        inline const Foam::point dual();
+#endif
 
-        inline bool farCell() const;
+        inline bool unassigned() const;
 
         inline int& filterCount();
 
@@ -169,6 +175,12 @@ public:
         //- Does the Delaunay cell have a far point
         inline bool hasFarPoint() const;
 
+        //- Does the Delaunay cell have a feature point
+        inline bool hasFeaturePoint() const;
+
+        //- Does the Delaunay cell have a seed point
+        inline bool hasSeedPoint() const;
+
         inline bool hasInternalPoint() const;
 
         //- Does the Dual vertex form part of a processor patch
@@ -186,6 +198,13 @@ public:
             const Foam::globalIndex& globalDelaunayVertexIndices
         ) const;
 
+        //- Using the globalIndex object, return a list of four vertices with
+        //  so that the cell has a consistent orientation in parallel.
+        inline Foam::FixedList<Foam::label, 4> globallyOrderedCellVertices
+        (
+            const Foam::globalIndex& globalDelaunayVertexIndices
+        ) const;
+
         //- Is the Delaunay cell part of the final dual mesh, i.e. any vertex
         //  form part of the internal or boundary definition
         inline bool internalOrBoundaryDualVertex() const;
@@ -198,8 +217,13 @@ public:
         //  least one Delaunay vertex outside and at least one inside
         inline bool boundaryDualVertex() const;
 
+        //- A dual vertex on a feature edge will result from this Delaunay cell
+        inline bool featureEdgeDualVertex() const;
+
         inline bool nearProcBoundary() const;
 
+        inline bool potentialCoplanarCell() const;
+
 
     // Info
 
diff --git a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/indexedCell/indexedCellChecks.C b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/indexedCell/indexedCellChecks.C
new file mode 100644
index 0000000000..7213739844
--- /dev/null
+++ b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/indexedCell/indexedCellChecks.C
@@ -0,0 +1,128 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "plane.H"
+#include "tetrahedron.H"
+#include "pointConversion.H"
+#include "CGALTriangulation3DKernel.H"
+
+
+template <typename Cell>
+Foam::scalar Foam::cvMeshChecks::coplanarTet
+(
+    Cell& c,
+    const scalar tol
+)
+{
+    tetPointRef tet
+    (
+        topoint(c->vertex(0)->point()),
+        topoint(c->vertex(1)->point()),
+        topoint(c->vertex(2)->point()),
+        topoint(c->vertex(3)->point())
+    );
+
+    const scalar quality = tet.quality();
+
+    if (quality < tol)
+    {
+        return quality;
+    }
+
+    return 0;
+
+//    plane triPlane
+//    (
+//        topoint(c->vertex(0)->point()),
+//        topoint(c->vertex(1)->point()),
+//        topoint(c->vertex(2)->point())
+//    );
+//
+//    const scalar distance = triPlane.distance(topoint(c->vertex(3)->point()));
+//
+//    // Check if the four points are roughly coplanar. If they are then we
+//    // cannot calculate the circumcentre. Better test might be the volume
+//    // of the tet.
+//    if (distance < tol)
+//    {
+//        return 0;
+//    }
+//
+//    return distance;
+}
+
+
+template <typename Cell>
+bool Foam::cvMeshChecks::closePoints
+(
+    Cell& c,
+    const scalar tol
+)
+{
+    for (label v = 0; v < 4; ++v)
+    {
+        for (label vA = v + 1; vA < 4; ++vA)
+        {
+            if
+            (
+                mag
+                (
+                    topoint(c->vertex(v)->point())
+                  - topoint(c->vertex(vA)->point())
+                )
+              < tol
+            )
+            {
+                return true;
+            }
+        }
+    }
+
+    return false;
+}
+
+
+template <typename Cell>
+bool Foam::cvMeshChecks::smallVolume
+(
+    Cell& c,
+    const scalar tol
+)
+{
+    CGAL::Tetrahedron_3<baseK> tet
+    (
+        c->vertex(0)->point(),
+        c->vertex(1)->point(),
+        c->vertex(2)->point(),
+        c->vertex(3)->point()
+    );
+
+    if (tet.volume() < tol)
+    {
+        return true;
+    }
+
+    return false;
+}
diff --git a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/indexedCell/indexedCellChecks.H b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/indexedCell/indexedCellChecks.H
new file mode 100644
index 0000000000..c040eafab6
--- /dev/null
+++ b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/indexedCell/indexedCellChecks.H
@@ -0,0 +1,77 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef indexedCellChecks_H
+#define indexedCellChecks_H
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+namespace cvMeshChecks
+{
+
+    template <typename Cell>
+    scalar coplanarTet
+    (
+        Cell& c,
+        const scalar tol = 1e-12
+    );
+
+    template <typename Cell>
+    bool closePoints
+    (
+        Cell& c,
+        const scalar tol = 1e-12
+    );
+
+    template <typename Cell>
+    bool smallVolume
+    (
+        Cell& c,
+        const scalar tol = 0.0
+    );
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace cvMeshChecks
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+#   include "indexedCellChecks.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/indexedCell/indexedCellEnum.C b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/indexedCell/indexedCellEnum.C
new file mode 100644
index 0000000000..5d7d953948
--- /dev/null
+++ b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/indexedCell/indexedCellEnum.C
@@ -0,0 +1,46 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "indexedCellEnum.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+template<>
+const char*
+Foam::NamedEnum<Foam::indexedCellEnum::cellTypes, 6>::names[] =
+{
+    "Unassigned",
+    "Internal",
+    "Surface",
+    "FeatureEdge",
+    "FeaturePoint",
+    "Far"
+};
+
+const Foam::NamedEnum<Foam::indexedCellEnum::cellTypes, 6>
+cellTypesNames_;
+
+
+// ************************************************************************* //
diff --git a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/indexedCell/indexedCellEnum.H b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/indexedCell/indexedCellEnum.H
new file mode 100644
index 0000000000..5ccef621e7
--- /dev/null
+++ b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/indexedCell/indexedCellEnum.H
@@ -0,0 +1,80 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 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
+    indexedCellEnum
+
+Description
+
+SourceFiles
+    indexedCellEnum.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef indexedCellEnum_H
+#define indexedCellEnum_H
+
+#include "NamedEnum.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+class indexedCellEnum
+{
+public:
+
+
+    enum cellTypes
+    {
+        ctUnassigned    = INT_MIN,
+        ctFar           = INT_MIN + 1,
+        ctInternal      = INT_MIN + 2,
+        ctSurface       = INT_MIN + 3,
+        ctFeatureEdge   = INT_MIN + 4,
+        ctFeaturePoint  = INT_MIN + 5
+    };
+
+    static const Foam::NamedEnum<cellTypes, 6> cellTypesNames_;
+};
+
+
+template<>
+inline bool contiguous<indexedCellEnum>()
+{
+    return true;
+}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/indexedCellI.H b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/indexedCell/indexedCellI.H
similarity index 51%
rename from applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/indexedCellI.H
rename to applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/indexedCell/indexedCellI.H
index eb5e0b44bd..83434ba2f1 100644
--- a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/indexedCellI.H
+++ b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/indexedCell/indexedCellI.H
@@ -21,20 +21,41 @@ License
     You should have received a copy of the GNU General Public License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
-    As a special exception, you have permission to link this program with the
-    CGAL library and distribute executables, as long as you follow the
-    requirements of the GNU GPL in regard to all of the software in the
-    executable aside from CGAL.
-
 \*---------------------------------------------------------------------------*/
 
+//#include "indexedCellChecks.H"
+
+template<class Gt, class Cb>
+Foam::tetCell CGAL::indexedCell<Gt, Cb>::unsortedVertexGlobalIndices
+(
+    const Foam::globalIndex& globalDelaunayVertexIndices
+) const
+{
+    Foam::tetCell tVGI;
+
+    for (int i = 0; i < 4; i++)
+    {
+        Vertex_handle v = this->vertex(i);
+
+        // Finding the global index of each Delaunay vertex
+        tVGI[i] = globalDelaunayVertexIndices.toGlobal
+        (
+            Foam::Pstream::myProcNo(),
+            v->index()
+        );
+    }
+
+    return tVGI;
+}
+
+
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
 template<class Gt, class Cb>
 CGAL::indexedCell<Gt, Cb>::indexedCell()
 :
     Cb(),
-    index_(ctFar),
+    index_(ctUnassigned),
     filterCount_(0)
 {}
 
@@ -46,7 +67,7 @@ CGAL::indexedCell<Gt, Cb>::indexedCell
 )
 :
     Cb(v0, v1, v2, v3),
-    index_(ctFar),
+    index_(ctUnassigned),
     filterCount_(0)
 {}
 
@@ -65,7 +86,7 @@ CGAL::indexedCell<Gt, Cb>::indexedCell
 )
 :
     Cb(v0, v1, v2, v3, n0, n1, n2, n3),
-    index_(ctFar),
+    index_(ctUnassigned),
     filterCount_(0)
 {}
 
@@ -86,28 +107,37 @@ int CGAL::indexedCell<Gt, Cb>::cellIndex() const
 }
 
 
-template<class Gt, class Cb>
-const Foam::point& CGAL::indexedCell<Gt, Cb>::dual()
-{
 #ifdef CGAL_INEXACT
-    return reinterpret_cast<const Foam::point&>(this->circumcenter());
-#else
-    const typename Gt::Point_3& P = this->circumcenter();
+    template<class Gt, class Cb>
+    const Foam::point& CGAL::indexedCell<Gt, Cb>::dual()
+    {
+    //    if (Foam::cvMeshChecks::coplanarTet(*this, 1e-20) == 0)
+    //    {
+            // Do exact calc
+    //    }
 
-    return
-    (
-        CGAL::to_double(P.x()),
-        CGAL::to_double(P.y()),
-        CGAL::to_double(P.z())
-    );
+        return reinterpret_cast<const Foam::point&>(this->circumcenter());
+    }
+#else
+    template<class Gt, class Cb>
+    const Foam::point CGAL::indexedCell<Gt, Cb>::dual()
+    {
+        const typename Gt::Point_3& P = this->circumcenter();
+
+        return Foam::point
+        (
+            CGAL::to_double(P.x()),
+            CGAL::to_double(P.y()),
+            CGAL::to_double(P.z())
+        );
+    }
 #endif
-}
 
 
 template<class Gt, class Cb>
-inline bool CGAL::indexedCell<Gt, Cb>::farCell() const
+inline bool CGAL::indexedCell<Gt, Cb>::unassigned() const
 {
-    return index_ == ctFar;
+    return index_ == ctUnassigned;
 }
 
 
@@ -160,6 +190,32 @@ inline bool CGAL::indexedCell<Gt, Cb>::hasFarPoint() const
 }
 
 
+template<class Gt, class Cb>
+inline bool CGAL::indexedCell<Gt, Cb>::hasFeaturePoint() const
+{
+    return
+    (
+        this->vertex(0)->featurePoint()
+     || this->vertex(1)->featurePoint()
+     || this->vertex(2)->featurePoint()
+     || this->vertex(3)->featurePoint()
+    );
+}
+
+
+template<class Gt, class Cb>
+inline bool CGAL::indexedCell<Gt, Cb>::hasSeedPoint() const
+{
+    return
+    (
+        this->vertex(0)->seedPoint()
+     || this->vertex(1)->seedPoint()
+     || this->vertex(2)->seedPoint()
+     || this->vertex(3)->seedPoint()
+    );
+}
+
+
 template<class Gt, class Cb>
 inline bool CGAL::indexedCell<Gt, Cb>::hasInternalPoint() const
 {
@@ -178,10 +234,21 @@ inline bool CGAL::indexedCell<Gt, Cb>::parallelDualVertex() const
 {
     return
     (
-        this->vertex(0)->referred()
-     || this->vertex(1)->referred()
-     || this->vertex(2)->referred()
-     || this->vertex(3)->referred()
+        !this->hasFarPoint()
+    &&
+        (
+            this->vertex(0)->referred()
+         || this->vertex(1)->referred()
+         || this->vertex(2)->referred()
+         || this->vertex(3)->referred()
+        )
+    &&
+        (
+            this->vertex(0)->real()
+         || this->vertex(1)->real()
+         || this->vertex(2)->real()
+         || this->vertex(3)->real()
+        )
     );
 }
 
@@ -247,33 +314,8 @@ inline Foam::tetCell CGAL::indexedCell<Gt, Cb>::vertexGlobalIndices
 ) const
 {
     // tetVertexGlobalIndices
-    Foam::tetCell tVGI;
-
-    for (int i = 0; i < 4; i++)
-    {
-        Vertex_handle v = this->vertex(i);
-
-        // Finding the global index of each Delaunay vertex
-
-        if (v->referred())
-        {
-            // Referred vertices may have negative indices
-
-            tVGI[i] = globalDelaunayVertexIndices.toGlobal
-            (
-                v->procIndex(),
-                Foam::mag(v->index())
-            );
-        }
-        else
-        {
-            tVGI[i] = globalDelaunayVertexIndices.toGlobal
-            (
-                Foam::Pstream::myProcNo(),
-                v->index()
-            );
-        }
-    }
+    Foam::tetCell tVGI
+        = unsortedVertexGlobalIndices(globalDelaunayVertexIndices);
 
     // bubble sort
     for (int i = 0; i < tVGI.size(); i++)
@@ -291,6 +333,41 @@ inline Foam::tetCell CGAL::indexedCell<Gt, Cb>::vertexGlobalIndices
 }
 
 
+template<class Gt, class Cb>
+inline Foam::FixedList<Foam::label, 4>
+CGAL::indexedCell<Gt, Cb>::globallyOrderedCellVertices
+(
+    const Foam::globalIndex& globalDelaunayVertexIndices
+) const
+{
+    // tetVertexGlobalIndices
+    Foam::tetCell tVGI
+        = unsortedVertexGlobalIndices(globalDelaunayVertexIndices);
+
+    Foam::FixedList<Foam::label, 4> vertexMap(Foam::identity(4));
+
+    // bubble sort
+    for (int i = 0; i < tVGI.size(); i++)
+    {
+        for (int j = tVGI.size() - 1 ; j > i; j--)
+        {
+            if (tVGI[j - 1] > tVGI[j])
+            {
+                Foam::Swap(tVGI[j - 1], tVGI[j]);
+                Foam::Swap(vertexMap[j - 1], vertexMap[j]);
+            }
+        }
+    }
+
+    for (int i = 0; i < 4; i++)
+    {
+        tVGI[i] = vertexMap[i];
+    }
+
+    return tVGI;
+}
+
+
 template<class Gt, class Cb>
 inline bool CGAL::indexedCell<Gt, Cb>::internalOrBoundaryDualVertex() const
 {
@@ -309,10 +386,14 @@ inline bool CGAL::indexedCell<Gt, Cb>::anyInternalOrBoundaryDualVertex() const
 {
     return
     (
-        this->vertex(0)->anyInternalOrBoundaryPoint()
-     || this->vertex(1)->anyInternalOrBoundaryPoint()
-     || this->vertex(2)->anyInternalOrBoundaryPoint()
-     || this->vertex(3)->anyInternalOrBoundaryPoint()
+        this->vertex(0)->internalOrBoundaryPoint()
+     || this->vertex(0)->externalBoundaryPoint()
+     || this->vertex(1)->internalOrBoundaryPoint()
+     || this->vertex(1)->externalBoundaryPoint()
+     || this->vertex(2)->internalOrBoundaryPoint()
+     || this->vertex(2)->externalBoundaryPoint()
+     || this->vertex(3)->internalOrBoundaryPoint()
+     || this->vertex(3)->externalBoundaryPoint()
     );
 }
 
@@ -323,21 +404,34 @@ inline bool CGAL::indexedCell<Gt, Cb>::boundaryDualVertex() const
     return
     (
         (
-           this->vertex(0)->internalOrBoundaryPoint()
-        || this->vertex(1)->internalOrBoundaryPoint()
-        || this->vertex(2)->internalOrBoundaryPoint()
-        || this->vertex(3)->internalOrBoundaryPoint()
+           this->vertex(0)->internalBoundaryPoint()
+        || this->vertex(1)->internalBoundaryPoint()
+        || this->vertex(2)->internalBoundaryPoint()
+        || this->vertex(3)->internalBoundaryPoint()
         )
      && (
-           !this->vertex(0)->internalOrBoundaryPoint()
-        || !this->vertex(1)->internalOrBoundaryPoint()
-        || !this->vertex(2)->internalOrBoundaryPoint()
-        || !this->vertex(3)->internalOrBoundaryPoint()
+           this->vertex(0)->externalBoundaryPoint()
+        || this->vertex(1)->externalBoundaryPoint()
+        || this->vertex(2)->externalBoundaryPoint()
+        || this->vertex(3)->externalBoundaryPoint()
         )
     );
 }
 
 
+template<class Gt, class Cb>
+inline bool CGAL::indexedCell<Gt, Cb>::featureEdgeDualVertex() const
+{
+    return
+    (
+        this->vertex(0)->featureEdgePoint()
+     && this->vertex(1)->featureEdgePoint()
+     && this->vertex(2)->featureEdgePoint()
+     && this->vertex(3)->featureEdgePoint()
+    );
+}
+
+
 template<class Gt, class Cb>
 inline bool CGAL::indexedCell<Gt, Cb>::nearProcBoundary() const
 {
@@ -351,4 +445,94 @@ inline bool CGAL::indexedCell<Gt, Cb>::nearProcBoundary() const
 }
 
 
+template<class Gt, class Cb>
+inline bool CGAL::indexedCell<Gt, Cb>::potentialCoplanarCell() const
+{
+    Foam::label nMasters = 0;
+    Foam::label nSlaves = 0;
+
+    Vertex_handle vM[2];
+    Vertex_handle vS[2];
+
+    for (Foam::label i = 0; i < 4; ++i)
+    {
+        Vertex_handle v = this->vertex(i);
+
+        if (v->internalBoundaryPoint())
+        {
+            vM[nMasters] = v;
+            nMasters++;
+        }
+
+        if (v->externalBoundaryPoint())
+        {
+            vS[nSlaves] = v;
+            nSlaves++;
+        }
+    }
+
+    Foam::label nPairs = 0;
+
+    if (nMasters == 2 && nSlaves == 2)
+    {
+        Foam::vector vp0(Foam::vector::zero);
+        Foam::vector vp1(Foam::vector::zero);
+
+        if
+        (
+            vM[0]->type() == vS[0]->index()
+         && vM[0]->index() == vS[0]->type()
+        )
+        {
+            vp0 = reinterpret_cast<const Foam::point&>(vM[0]->point())
+                - reinterpret_cast<const Foam::point&>(vS[0]->point());
+            nPairs++;
+        }
+        else if
+        (
+            vM[0]->type() == vS[1]->index()
+         && vM[0]->index() == vS[1]->type()
+        )
+        {
+            vp0 = reinterpret_cast<const Foam::point&>(vM[0]->point())
+                - reinterpret_cast<const Foam::point&>(vS[1]->point());
+            nPairs++;
+        }
+
+        if
+        (
+            vM[1]->type() == vS[0]->index()
+         && vM[1]->index() == vS[0]->type()
+        )
+        {
+            vp1 = reinterpret_cast<const Foam::point&>(vM[1]->point())
+                - reinterpret_cast<const Foam::point&>(vS[0]->point());
+            nPairs++;
+        }
+        else if
+        (
+            vM[1]->type() == vS[1]->index()
+         && vM[1]->index() == vS[1]->type()
+        )
+        {
+            vp1 = reinterpret_cast<const Foam::point&>(vM[1]->point())
+                - reinterpret_cast<const Foam::point&>(vS[1]->point());
+            nPairs++;
+        }
+
+        if (nPairs == 2)
+        {
+            if (Foam::vectorTools::areParallel(vp0, vp1))
+            {
+                Foam::Pout<< "PARALLEL" << Foam::endl;
+
+                return true;
+            }
+        }
+    }
+
+    return false;
+}
+
+
 // * * * * * * * * * * * * * * * Friend Functions  * * * * * * * * * * * * * //
diff --git a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/indexedVertex.C b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/indexedVertex.C
deleted file mode 100644
index 2f1fa3c5bb..0000000000
--- a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/indexedVertex.C
+++ /dev/null
@@ -1,115 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 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/>.
-
-    As a special exception, you have permission to link this program with the
-    CGAL library and distribute executables, as long as you follow the
-    requirements of the GNU GPL in regard to all of the software in the
-    executable aside from CGAL.
-
-\*---------------------------------------------------------------------------*/
-
-#include "indexedVertex.H"
-#include "point.H"
-
-// * * * * * * * * * * * * * * * *  IOStream operators * * * * * * * * * * * //
-
-template<class Gt, class Vb>
-Foam::Ostream& Foam::operator<<
-(
-    Ostream& os,
-    const InfoProxy<CGAL::indexedVertex<Gt, Vb> >& p
-)
-{
-    const CGAL::indexedVertex<Gt, Vb>& iv = p.t_;
-
-    if (iv.type_ == CGAL::indexedVertex<Gt, Vb>::vtNearBoundary)
-    {
-        os  << "internal near boundary point" << nl;
-    }
-    else if (iv.type_ == CGAL::indexedVertex<Gt, Vb>::vtInternal)
-    {
-        os  << "internal point" << nl;
-    }
-    else if (iv.type_ == CGAL::indexedVertex<Gt, Vb>::vtFar)
-    {
-        os  << "far point" << nl;
-    }
-    else if (iv.type_ > CGAL::indexedVertex<Gt, Vb>::vtFar && iv.type_ < 0)
-    {
-        if (iv.index_ >= 0)
-        {
-            os  << "referred (master) point from processor " << iv.procIndex()
-                << nl;
-        }
-        else
-        {
-            os  << "referred (slave) point from processor " << iv.procIndex()
-                << nl;
-        }
-    }
-    else if (iv.type_ >= 0)
-    {
-        if (iv.ppMaster())
-        {
-            os  << "master of point pair. paired up with point " << iv.index_
-            << nl;
-        }
-        else if (iv.ppSlave())
-        {
-            os  << "slave of point pair. paired up with point " << iv.index_
-            << nl;
-        }
-        else
-        {
-            FatalErrorIn
-            (
-                "operator<<"
-                "(Ostream&, const InfoProxy<CGAL::indexedVertex<Gt, Vb> >&)"
-            )   << "unhandled type " << iv.type_ << " index " << iv.index_
-                << abort(FatalError);
-        }
-    }
-    else
-    {
-        FatalErrorIn
-        (
-            "operator<<"
-            "(Ostream&, const InfoProxy<CGAL::indexedVertex<Gt, Vb> >&)"
-        )   << "unhandled type " << iv.type_ << " index " << iv.index_
-            << abort(FatalError);
-    }
-    const Foam::point pos
-    (
-        CGAL::to_double(iv.point().x()),
-        CGAL::to_double(iv.point().y()),
-        CGAL::to_double(iv.point().z())
-    );
-
-    os  << "    type:" << iv.type_ << " index:" << iv.index_
-        << " at:" << pos << nl;
-
-    return os;
-}
-
-
-// ************************************************************************* //
diff --git a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/indexedVertex/indexedVertex.C b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/indexedVertex/indexedVertex.C
new file mode 100644
index 0000000000..5aa3936874
--- /dev/null
+++ b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/indexedVertex/indexedVertex.C
@@ -0,0 +1,185 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "indexedVertex.H"
+#include "point.H"
+#include "Istream.H"
+#include "Ostream.H"
+#include "OStringStream.H"
+#include "IStringStream.H"
+
+// * * * * * * * * * * * * * * * *  IOStream operators * * * * * * * * * * * //
+
+Foam::Istream& Foam::operator>>
+(
+    Istream& is,
+    CGAL::Point_3<baseK>& p
+)
+{
+//    string data(is);
+//
+//    std::istringstream stdIs;
+//
+//    CGAL::set_ascii_mode(stdIs);
+//
+//    stdIs.str(data);
+//
+//    CGAL::Gmpz xNumer, xDenom;
+//    CGAL::Gmpz yNumer, yDenom;
+//    CGAL::Gmpz zNumer, zDenom;
+//
+//    stdIs >> xNumer >> xDenom >> yNumer >> yDenom >> zNumer >> zDenom;
+//
+//    CGAL::Gmpq x(xNumer, xDenom);
+//    CGAL::Gmpq y(yNumer, yDenom);
+//    CGAL::Gmpq z(zNumer, zDenom);
+//
+//    p = CGAL::Point_3<baseK>
+//    (
+//        CGAL::to_double(x),
+//        CGAL::to_double(y),
+//        CGAL::to_double(z)
+//    );
+
+    Foam::point pt;
+
+    is >> pt.x() >> pt.y() >> pt.z();
+
+    p = CGAL::Point_3<baseK>
+    (
+        pt.x(),
+        pt.y(),
+        pt.z()
+    );
+
+    return is;
+}
+
+
+Foam::Ostream& Foam::operator<<
+(
+    Ostream& os,
+    const CGAL::Point_3<baseK>& p
+)
+{
+//    CGAL::Gmpq x(CGAL::to_double(p.x()));
+//    CGAL::Gmpq y(CGAL::to_double(p.y()));
+//    CGAL::Gmpq z(CGAL::to_double(p.z()));
+//
+//    std::ostringstream stdOs;
+//
+//    CGAL::set_ascii_mode(stdOs);
+//
+//    stdOs<< x.numerator() << ' ' << x.denominator() << ' '
+//         << y.numerator() << ' ' << y.denominator() << ' '
+//         << z.numerator() << ' ' << z.denominator();
+//
+//    os << stdOs.str();
+
+    os  << CGAL::to_double(p.x()) << ' '
+        << CGAL::to_double(p.y()) << ' '
+        << CGAL::to_double(p.z());
+
+    return os;
+}
+
+
+template<class Gt, class Vb>
+Foam::Ostream& Foam::operator<<
+(
+    Ostream& os,
+    const CGAL::indexedVertex<Gt, Vb>& p
+)
+{
+    os  << p.point()
+        << p.index()
+        << static_cast<int>(p.type())
+        << p.procIndex()
+        << p.alignment()
+        << p.targetCellSize();
+
+    return os;
+}
+
+
+template<class Gt, class Vb>
+Foam::Istream& Foam::operator>>
+(
+    Istream& is,
+    CGAL::indexedVertex<Gt, Vb>& p
+)
+{
+    is  >> p.point()
+        >> p.index();
+
+    int type;
+    is  >> type;
+
+    p.type() = static_cast<Foam::indexedVertexEnum::vertexType>(type);
+
+    is  >> p.procIndex()
+        >> p.alignment()
+        >> p.targetCellSize();
+
+    return is;
+}
+
+
+template<class Gt, class Vb>
+Foam::Ostream& Foam::operator<<
+(
+    Ostream& os,
+    const InfoProxy<CGAL::indexedVertex<Gt, Vb> >& p
+)
+{
+    const CGAL::indexedVertex<Gt, Vb>& iv = p.t_;
+
+    const Foam::point pt
+    (
+        CGAL::to_double(iv.point().x()),
+        CGAL::to_double(iv.point().y()),
+        CGAL::to_double(iv.point().z())
+    );
+
+    string referred
+    (
+        Pstream::myProcNo() == iv.processor_
+      ? string(" (local)")
+      : string(" (from " + name(iv.processor_) + ")")
+    );
+
+    os  << iv.index_ << " "
+        << CGAL::indexedVertex<Gt, Vb>::vertexTypeNames_[iv.type_]
+        << " at:" << pt
+        << " size:" << iv.targetCellSize_
+        << " alignment:" << iv.alignment_
+        << referred.c_str()
+        << endl;
+
+    return os;
+}
+
+
+// ************************************************************************* //
diff --git a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/indexedVertex.H b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/indexedVertex/indexedVertex.H
similarity index 57%
rename from applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/indexedVertex.H
rename to applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/indexedVertex/indexedVertex.H
index c3d13ab05e..f39e90761d 100644
--- a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/indexedVertex.H
+++ b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/indexedVertex/indexedVertex.H
@@ -21,11 +21,6 @@ License
     You should have received a copy of the GNU General Public License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
-    As a special exception, you have permission to link this program with the
-    CGAL library and distribute executables, as long as you follow the
-    requirements of the GNU GPL in regard to all of the software in the
-    executable aside from CGAL.
-
 Class
     indexedVertex
 
@@ -43,9 +38,11 @@ SourceFiles
 #define indexedVertex_H
 
 #include <CGAL/Triangulation_3.h>
+#include "CGALTriangulation3DKernel.H"
 #include "tensor.H"
 #include "InfoProxy.H"
 #include "point.H"
+#include "indexedVertexEnum.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -56,13 +53,41 @@ template<class Gt, class Vb> class indexedVertex;
 
 namespace Foam
 {
+
 class Ostream;
+class Istream;
+
 template<class Gt, class Vb> Ostream& operator<<
 (
     Ostream&,
     const Foam::InfoProxy<CGAL::indexedVertex<Gt, Vb> >&
 );
-}
+
+template<class Gt, class Vb> Ostream& operator<<
+(
+    Ostream&,
+    const CGAL::indexedVertex<Gt, Vb>&
+);
+
+template<class Gt, class Vb> Istream& operator>>
+(
+    Istream&,
+    CGAL::indexedVertex<Gt, Vb>&
+);
+
+inline Istream& operator>>
+(
+    Istream& is,
+    CGAL::Point_3<baseK>& p
+);
+
+inline Ostream& operator<<
+(
+    Ostream& os,
+    const CGAL::Point_3<baseK>& p
+);
+
+} // End namespace Foam
 
 
 namespace CGAL
@@ -72,26 +97,24 @@ namespace CGAL
                          Class indexedVertex Declaration
 \*---------------------------------------------------------------------------*/
 
-template<class Gt, class Vb=CGAL::Triangulation_vertex_base_3<Gt> >
+template<class Gt, class Vb = CGAL::Triangulation_vertex_base_3<Gt> >
 class indexedVertex
 :
+    public Foam::indexedVertexEnum,
     public Vb
 {
     // Private data
 
+        //- Type of pair-point
+        vertexType type_;
+
         //- The index for this Delaunay vertex.  For referred vertices, the
         //  index is negative for vertices that are the outer (slave) of point
         //  pairs
         int index_;
 
-        //- type of pair-point   :
-        //  vtNearBoundary       : internal near boundary point.
-        //  vtInternal           : internal point.
-        //  vtFar                : far-point.
-        //  > vtFar, < 0         : referred point from processor -(type_ + 1)
-        //  >= 0                 : part of point-pair. Index of other point.
-        //                         Lowest numbered is inside one (master).
-        int type_;
+        //- Number of the processor that owns this vertex
+        int processor_;
 
         //- Required alignment of the dual cell of this vertex
         Foam::tensor alignment_;
@@ -100,29 +123,15 @@ class indexedVertex
         Foam::scalar targetCellSize_;
 
         //- Specify whether the vertex is fixed or movable.
-        bool vertexFixed_;
-
-        bool nearProcBoundary_;
+//        bool vertexFixed_;
 
 
 public:
 
-    enum vertexTypes
-    {
-        vtNearBoundary  = INT_MIN,
-        vtInternal      = INT_MIN + 1,
-        vtFar           = INT_MIN + 2
-    };
-
-    enum vertexMotion
-    {
-        fixed   = 0,
-        movable = 1
-    };
-
-    typedef typename Vb::Vertex_handle      Vertex_handle;
-    typedef typename Vb::Cell_handle        Cell_handle;
-    typedef typename Vb::Point              Point;
+    typedef typename Vb::Triangulation_data_structure   Tds;
+    typedef typename Vb::Point                          Point;
+    typedef typename Tds::Vertex_handle                 Vertex_handle;
+    typedef typename Tds::Cell_handle                   Cell_handle;
 
     template<typename TDS2>
     struct Rebind_TDS
@@ -131,14 +140,23 @@ public:
         typedef indexedVertex<Gt,Vb2>                           Other;
     };
 
-
     // Constructors
 
         inline indexedVertex();
 
         inline indexedVertex(const Point& p);
 
-        inline indexedVertex(const Point& p, int index, int type);
+        inline indexedVertex(const Point& p, vertexType type);
+
+        inline indexedVertex(const Foam::point& p, vertexType type);
+
+        inline indexedVertex
+        (
+            const Point& p,
+            int index,
+            vertexType type,
+            int processor
+        );
 
         inline indexedVertex(const Point& p, Cell_handle f);
 
@@ -151,9 +169,9 @@ public:
 
         inline int index() const;
 
-        inline int& type();
+        inline vertexType& type();
 
-        inline int type() const;
+        inline vertexType type() const;
 
         inline Foam::tensor& alignment();
 
@@ -171,26 +189,18 @@ public:
         //- Is point internal, i.e. not on boundary
         inline bool internalPoint() const;
 
-        //- Is point internal, i.e. not on boundary, external query.
-        inline static bool internalPoint(int type);
-
-        // is this a referred vertex
+        //- Is this a referred vertex
         inline bool referred() const;
 
-        // is this a referred internal or boundary vertex
-        inline bool referredInternalOrBoundaryPoint() const;
-
-        // is this a referred external (pair slave) vertex
-        inline bool referredExternal() const;
-
-        // Is this a "real" point on this processor, i.e. is it internal or part
-        // of the boundary description, and not a "far" or "referred" point
+        //- Is this a "real" point on this processor, i.e. is internal or part
+        //  of the boundary description, and not a "far" or "referred" point
         inline bool real() const;
 
         // For referred vertices, what is the original processor index
         inline int procIndex() const;
 
-        inline static int encodeProcIndex(int procI);
+        // For referred vertices, set the original processor index
+        inline int& procIndex();
 
         //- Set the point to be internal
         inline void setInternal();
@@ -208,45 +218,61 @@ public:
         inline void setNearProcBoundary();
 
         //- Either master or slave of pointPair.
-        inline bool pairPoint() const;
-
-        //- Master of a pointPair is the lowest numbered one.
-        inline bool ppMaster() const;
-
-        //- Master of a pointPair is the lowest numbered one, external query.
-        inline static bool ppMaster(int index, int type);
-
-        //- Slave of a pointPair is the highest numbered one.
-        inline bool ppSlave() const;
+        inline bool boundaryPoint() const;
 
         //- Either original internal point or master of pointPair.
         inline bool internalOrBoundaryPoint() const;
 
-        //- Either original internal point or master of pointPair.
-        //  External query.
-        inline static bool internalOrBoundaryPoint(int index, int type);
-
         //- Is point near the boundary or part of the boundary definition
         inline bool nearOrOnBoundary() const;
 
-        //- Either a real or referred internal or boundary point
-        inline bool anyInternalOrBoundaryPoint() const;
+        //- Part of a feature point
+        inline bool featurePoint() const;
 
-        //- Is the vertex fixed or movable
-        inline bool isVertexFixed() const;
+        //- Part of a feature edge
+        inline bool featureEdgePoint() const;
 
-        //- Fix the vertex so that it can't be moved
-        inline void setVertexFixed();
+        //- Part of a surface point pair
+        inline bool surfacePoint() const;
 
-    // inline void operator=(const Delaunay::Finite_vertices_iterator vit)
-    // {
-    //     Vb::operator=indexedVertex(vit->point());
+        inline bool internalBoundaryPoint() const;
 
-    //     this->index_ = vit->index();
+        inline bool externalBoundaryPoint() const;
 
-    //     this->type_ = vit->type();
-    // }
+//        //- Is the vertex fixed or movable
+//        inline bool isVertexFixed() const;
+//
+//        //- Fix the vertex so that it can't be moved
+//        inline void setVertexFixed();
 
+        inline indexedVertex& operator=(const indexedVertex& rhs)
+        {
+            Vb::operator=(rhs);
+
+            this->type_ = rhs.type();
+            this->index_ = rhs.index();
+            this->processor_ = rhs.procIndex();
+            this->alignment_ = rhs.alignment();
+            this->targetCellSize_ = rhs.targetCellSize();
+
+            return *this;
+        }
+
+        inline bool operator==(const indexedVertex& rhs) const
+        {
+            return
+            (
+                //this->point() == rhs.point()
+                this->type_ == rhs.type()
+             && this->index_ == rhs.index()
+             && this->processor_ == rhs.procIndex()
+            );
+        }
+
+        inline bool operator!=(const indexedVertex& rhs) const
+        {
+            return !(*this == rhs);
+        }
 
 
     // Info
@@ -264,6 +290,17 @@ public:
             const Foam::InfoProxy<indexedVertex<Gt, Vb> >&
         );
 
+        friend Foam::Ostream& Foam::operator<< <Gt, Vb>
+        (
+            Foam::Ostream&,
+            const indexedVertex<Gt, Vb>&
+        );
+
+        friend Foam::Istream& Foam::operator>> <Gt, Vb>
+        (
+            Foam::Istream&,
+            indexedVertex<Gt, Vb>&
+        );
 };
 
 
@@ -271,6 +308,37 @@ public:
 
 } // End namespace CGAL
 
+// * * * * * * * * * * * * * * * Global Functions  * * * * * * * * * * * * * //
+
+#ifdef CGAL_INEXACT
+namespace Foam
+{
+    // For inexact representations where the storage type is a double, the data
+    // is contiguous. This may not be true for exact number types.
+    template<>
+    inline bool contiguous
+    <
+        CGAL::indexedVertex
+        <
+            K,
+            CGAL::Triangulation_vertex_base_3<K>
+        >
+    >()
+    {
+        return true;
+    }
+
+
+    template<>
+    inline bool contiguous<CGAL::Triangulation_vertex_base_3<K>::Point>()
+    {
+        return true;
+    }
+
+} // End namespace Foam
+#endif
+
+
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 #include "indexedVertexI.H"
diff --git a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/indexedVertex/indexedVertexEnum.C b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/indexedVertex/indexedVertexEnum.C
new file mode 100644
index 0000000000..ee394b16fa
--- /dev/null
+++ b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/indexedVertex/indexedVertexEnum.C
@@ -0,0 +1,88 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "indexedVertexEnum.H"
+#include "Pstream.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+template<>
+const char*
+Foam::NamedEnum<Foam::indexedVertexEnum::vertexType, 10>::names[] =
+{
+    "Unassigned",
+    "Internal",
+    "InternalNearBoundary",
+    "InternalSurface",
+    "InternalFeatureEdge",
+    "InternalFeaturePoint",
+    "ExternalSurface",
+    "ExternalFeatureEdge",
+    "ExternalFeaturePoint",
+    "Far"
+};
+
+const Foam::NamedEnum<Foam::indexedVertexEnum::vertexType, 10>
+Foam::indexedVertexEnum::vertexTypeNames_;
+
+
+template<>
+const char*
+Foam::NamedEnum<Foam::indexedVertexEnum::vertexMotion, 2>::names[] =
+{
+    "fixed",
+    "movable"
+};
+
+const Foam::NamedEnum<Foam::indexedVertexEnum::vertexMotion, 2>
+vertexMotionNames_;
+
+
+Foam::Ostream& Foam::operator<<
+(
+    Ostream& os,
+    const Foam::indexedVertexEnum::vertexType& v
+)
+{
+    os  << static_cast<int>(v);
+
+    return os;
+}
+
+Foam::Istream& Foam::operator>>
+(
+    Istream& is,
+    Foam::indexedVertexEnum::vertexType& v
+)
+{
+    int type;
+    is  >> type;
+
+    v = static_cast<Foam::indexedVertexEnum::vertexType>(type);
+
+    return is;
+}
+
+// ************************************************************************* //
diff --git a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/indexedVertex/indexedVertexEnum.H b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/indexedVertex/indexedVertexEnum.H
new file mode 100644
index 0000000000..c597d8a173
--- /dev/null
+++ b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/indexedVertex/indexedVertexEnum.H
@@ -0,0 +1,95 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 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
+    indexedVertexEnum
+
+Description
+
+SourceFiles
+    indexedVertexEnum.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef indexedVertexEnum_H
+#define indexedVertexEnum_H
+
+#include "NamedEnum.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+class indexedVertexEnum
+{
+public:
+
+    enum vertexType
+    {
+        vtUnassigned            = 0,
+        vtInternal              = 1,
+        vtInternalNearBoundary  = 2,
+        vtInternalSurface       = 3,
+        vtInternalFeatureEdge   = 4,
+        vtInternalFeaturePoint  = 5,
+        vtExternalSurface       = 6,
+        vtExternalFeatureEdge   = 7,
+        vtExternalFeaturePoint  = 8,
+        vtFar                   = 9
+    };
+
+    enum vertexMotion
+    {
+        fixed   = 0,
+        movable = 1
+    };
+
+    static const Foam::NamedEnum<vertexType, 10> vertexTypeNames_;
+
+    static const Foam::NamedEnum<vertexMotion, 2> vertexMotionNames_;
+
+    friend Ostream& operator<<(Foam::Ostream&, const vertexType&);
+
+    friend Istream& operator>>(Foam::Istream&, vertexType&);
+};
+
+
+template<>
+inline bool contiguous<indexedVertexEnum>()
+{
+    return true;
+}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/indexedVertexI.H b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/indexedVertex/indexedVertexI.H
similarity index 56%
rename from applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/indexedVertexI.H
rename to applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/indexedVertex/indexedVertexI.H
index f427316fc5..02d37c1b05 100644
--- a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/indexedVertexI.H
+++ b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/indexedVertex/indexedVertexI.H
@@ -21,25 +21,21 @@ License
     You should have received a copy of the GNU General Public License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
-    As a special exception, you have permission to link this program with the
-    CGAL library and distribute executables, as long as you follow the
-    requirements of the GNU GPL in regard to all of the software in the
-    executable aside from CGAL.
-
 \*---------------------------------------------------------------------------*/
 
+#include "Pstream.H"
+
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
 template<class Gt, class Vb>
 inline CGAL::indexedVertex<Gt, Vb>::indexedVertex()
 :
     Vb(),
-    index_(vtInternal),
-    type_(vtInternal),
-    alignment_(),
-    targetCellSize_(0.0),
-    vertexFixed_(false),
-    nearProcBoundary_(false)
+    type_(vtUnassigned),
+    index_(vtUnassigned),
+    processor_(Foam::Pstream::myProcNo()),
+    alignment_(Foam::tensor::zero),
+    targetCellSize_(0.0)
 {}
 
 
@@ -47,12 +43,43 @@ template<class Gt, class Vb>
 inline CGAL::indexedVertex<Gt, Vb>::indexedVertex(const Point& p)
 :
     Vb(p),
-    index_(vtInternal),
-    type_(vtInternal),
-    alignment_(),
-    targetCellSize_(0.0),
-    vertexFixed_(false),
-    nearProcBoundary_(false)
+    type_(vtUnassigned),
+    index_(vtUnassigned),
+    processor_(Foam::Pstream::myProcNo()),
+    alignment_(Foam::tensor::zero),
+    targetCellSize_(0.0)
+{}
+
+
+template<class Gt, class Vb>
+inline CGAL::indexedVertex<Gt, Vb>::indexedVertex
+(
+    const Point& p,
+    vertexType type
+)
+:
+    Vb(p),
+    type_(type),
+    index_(-1),
+    processor_(Foam::Pstream::myProcNo()),
+    alignment_(Foam::tensor::zero),
+    targetCellSize_(0.0)
+{}
+
+
+template<class Gt, class Vb>
+inline CGAL::indexedVertex<Gt, Vb>::indexedVertex
+(
+    const Foam::point& p,
+    vertexType type
+)
+:
+    Vb(Point(p.x(), p.y(), p.z())),
+    type_(type),
+    index_(-1),
+    processor_(Foam::Pstream::myProcNo()),
+    alignment_(Foam::tensor::zero),
+    targetCellSize_(0.0)
 {}
 
 
@@ -61,16 +88,16 @@ inline CGAL::indexedVertex<Gt, Vb>::indexedVertex
 (
     const Point& p,
     int index,
-    int type
+    vertexType type,
+    int processor
 )
 :
     Vb(p),
-    index_(index),
     type_(type),
-    alignment_(),
-    targetCellSize_(0.0),
-    vertexFixed_(false),
-    nearProcBoundary_(false)
+    index_(index),
+    processor_(processor),
+    alignment_(Foam::tensor::zero),
+    targetCellSize_(0.0)
 {}
 
 
@@ -78,12 +105,11 @@ template<class Gt, class Vb>
 inline CGAL::indexedVertex<Gt, Vb>::indexedVertex(const Point& p, Cell_handle f)
 :
     Vb(f, p),
-    index_(vtInternal),
-    type_(vtInternal),
-    alignment_(),
-    targetCellSize_(0.0),
-    vertexFixed_(false),
-    nearProcBoundary_(false)
+    type_(vtUnassigned),
+    index_(vtUnassigned),
+    processor_(Foam::Pstream::myProcNo()),
+    alignment_(Foam::tensor::zero),
+    targetCellSize_(0.0)
 {}
 
 
@@ -91,12 +117,11 @@ template<class Gt, class Vb>
 inline CGAL::indexedVertex<Gt, Vb>::indexedVertex(Cell_handle f)
 :
     Vb(f),
-    index_(vtInternal),
-    type_(vtInternal),
-    alignment_(),
-    targetCellSize_(0.0),
-    vertexFixed_(false),
-    nearProcBoundary_(false)
+    type_(vtUnassigned),
+    index_(vtUnassigned),
+    processor_(Foam::Pstream::myProcNo()),
+    alignment_(Foam::tensor::zero),
+    targetCellSize_(0.0)
 {}
 
 
@@ -117,14 +142,16 @@ inline int CGAL::indexedVertex<Gt, Vb>::index() const
 
 
 template<class Gt, class Vb>
-inline int& CGAL::indexedVertex<Gt, Vb>::type()
+inline typename CGAL::indexedVertex<Gt, Vb>::vertexType&
+CGAL::indexedVertex<Gt, Vb>::type()
 {
     return type_;
 }
 
 
 template<class Gt, class Vb>
-inline int CGAL::indexedVertex<Gt, Vb>::type() const
+inline typename CGAL::indexedVertex<Gt, Vb>::vertexType
+CGAL::indexedVertex<Gt, Vb>::type() const
 {
     return type_;
 }
@@ -161,7 +188,7 @@ inline Foam::scalar CGAL::indexedVertex<Gt, Vb>::targetCellSize() const
 template<class Gt, class Vb>
 inline bool CGAL::indexedVertex<Gt, Vb>::uninitialised() const
 {
-    return type_ == vtInternal && index_ == vtInternal;
+    return type_ == vtUnassigned;
 }
 
 
@@ -175,63 +202,41 @@ inline bool CGAL::indexedVertex<Gt, Vb>::farPoint() const
 template<class Gt, class Vb>
 inline bool CGAL::indexedVertex<Gt, Vb>::internalPoint() const
 {
-    return internalPoint(type_);
-}
-
-
-template<class Gt, class Vb>
-inline bool CGAL::indexedVertex<Gt, Vb>::internalPoint(int type)
-{
-    return type <= vtInternal;
+    return type_ == vtInternal || type_ == vtInternalNearBoundary;
 }
 
 
 template<class Gt, class Vb>
 inline bool CGAL::indexedVertex<Gt, Vb>::referred() const
 {
-    return (type_ < 0 && type_ > vtFar);
-}
+    // Can't be zero as the first few points are far points which won't be
+    // referred
+    //return index_ < 0;
 
-
-template<class Gt, class Vb>
-inline bool CGAL::indexedVertex<Gt, Vb>::referredInternalOrBoundaryPoint() const
-{
-    return referred() && index_ >= 0;
-}
-
-
-template<class Gt, class Vb>
-inline bool CGAL::indexedVertex<Gt, Vb>::referredExternal() const
-{
-    return referred() && index_ < 0;
+    // processor_ will be take the value of the processor that this vertex is
+    // from, so it cannot be on this processor.
+    return processor_ != Foam::Pstream::myProcNo();
 }
 
 
 template<class Gt, class Vb>
 inline bool CGAL::indexedVertex<Gt, Vb>::real() const
 {
-    return internalPoint() || pairPoint();
+    return (internalPoint() || boundaryPoint()) && !referred();
 }
 
 
 template<class Gt, class Vb>
 inline int CGAL::indexedVertex<Gt, Vb>::procIndex() const
 {
-    if (referred())
-    {
-        return -(type_ + 1);
-    }
-    else
-    {
-        return -1;
-    }
+    return processor_;
 }
 
 
 template<class Gt, class Vb>
-inline int CGAL::indexedVertex<Gt, Vb>::encodeProcIndex(int procI)
+inline int& CGAL::indexedVertex<Gt, Vb>::procIndex()
 {
-    return -(procI + 1);
+    return processor_;
 }
 
 
@@ -245,115 +250,85 @@ inline void CGAL::indexedVertex<Gt, Vb>::setInternal()
 template<class Gt, class Vb>
 inline bool CGAL::indexedVertex<Gt, Vb>::nearBoundary() const
 {
-    return type_ == vtNearBoundary;
+    return type_ == vtInternalNearBoundary;
 }
 
 
 template<class Gt, class Vb>
 inline void CGAL::indexedVertex<Gt, Vb>::setNearBoundary()
 {
-    type_ = vtNearBoundary;
+    type_ = vtInternalNearBoundary;
 }
 
 
 template<class Gt, class Vb>
-inline bool CGAL::indexedVertex<Gt, Vb>::nearProcBoundary() const
+inline bool CGAL::indexedVertex<Gt, Vb>::boundaryPoint() const
 {
-    return nearProcBoundary_;
-}
-
-
-template<class Gt, class Vb>
-inline void CGAL::indexedVertex<Gt, Vb>::setNearProcBoundary()
-{
-    nearProcBoundary_ = true;
-}
-
-
-template<class Gt, class Vb>
-inline bool CGAL::indexedVertex<Gt, Vb>::pairPoint() const
-{
-    return type_ >= 0;
-}
-
-
-template<class Gt, class Vb>
-inline bool CGAL::indexedVertex<Gt, Vb>::ppMaster() const
-{
-    return ppMaster(index_, type_);
-}
-
-
-template<class Gt, class Vb>
-inline bool CGAL::indexedVertex<Gt, Vb>::ppMaster(int index, int type)
-{
-    if (index >= 0 && type > index)
-    {
-        return true;
-    }
-
-    return false;
-}
-
-
-template<class Gt, class Vb>
-inline bool CGAL::indexedVertex<Gt, Vb>::ppSlave() const
-{
-    if (type_ >= 0 && type_ < index_)
-    {
-        return true;
-    }
-    else
-    {
-        return false;
-    }
+    return type_ >= vtInternalSurface && !farPoint();
 }
 
 
 template<class Gt, class Vb>
 inline bool CGAL::indexedVertex<Gt, Vb>::internalOrBoundaryPoint() const
 {
-    return internalOrBoundaryPoint(index_, type_);
-}
-
-
-template<class Gt, class Vb>
-inline bool CGAL::indexedVertex<Gt, Vb>::internalOrBoundaryPoint
-(
-    int index,
-    int type
-)
-{
-    return internalPoint(type) || ppMaster(index, type);
+    return internalPoint() || internalBoundaryPoint();
 }
 
 
 template<class Gt, class Vb>
 inline bool CGAL::indexedVertex<Gt, Vb>::nearOrOnBoundary() const
 {
-    return pairPoint() || nearBoundary();
+    return boundaryPoint() || nearBoundary();
 }
 
 
 template<class Gt, class Vb>
-inline bool CGAL::indexedVertex<Gt, Vb>::anyInternalOrBoundaryPoint() const
+inline bool CGAL::indexedVertex<Gt, Vb>::internalBoundaryPoint() const
 {
-    return internalOrBoundaryPoint() || referredInternalOrBoundaryPoint();
+    return type_ >= vtInternalSurface && type_ <= vtInternalFeaturePoint;
 }
 
 
 template<class Gt, class Vb>
-inline bool CGAL::indexedVertex<Gt, Vb>::isVertexFixed() const
+inline bool CGAL::indexedVertex<Gt, Vb>::externalBoundaryPoint() const
 {
-    return vertexFixed_;
+    return type_ >= vtExternalSurface && type_ <= vtExternalFeaturePoint;
 }
 
 
 template<class Gt, class Vb>
-inline void CGAL::indexedVertex<Gt, Vb>::setVertexFixed()
+inline bool CGAL::indexedVertex<Gt, Vb>::featurePoint() const
 {
-    vertexFixed_ = true;
+    return type_ == vtInternalFeaturePoint || type_ == vtExternalFeaturePoint;
 }
 
 
+template<class Gt, class Vb>
+inline bool CGAL::indexedVertex<Gt, Vb>::featureEdgePoint() const
+{
+    return type_ == vtInternalFeatureEdge || type_ == vtExternalFeatureEdge;
+}
+
+
+template<class Gt, class Vb>
+inline bool CGAL::indexedVertex<Gt, Vb>::surfacePoint() const
+{
+    return type_ == vtInternalSurface || type_ == vtExternalSurface;
+}
+
+
+//template<class Gt, class Vb>
+//inline bool CGAL::indexedVertex<Gt, Vb>::isVertexFixed() const
+//{
+//    return vertexFixed_;
+//}
+//
+//
+//template<class Gt, class Vb>
+//inline void CGAL::indexedVertex<Gt, Vb>::setVertexFixed()
+//{
+//    vertexFixed_ = true;
+//}
+
+
 // * * * * * * * * * * * * * * * Friend Functions  * * * * * * * * * * * * * //
diff --git a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/pointConversion.H b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/pointConversion.H
new file mode 100644
index 0000000000..6242a3a6fe
--- /dev/null
+++ b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/pointConversion.H
@@ -0,0 +1,99 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 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
+    pointConversion
+
+Description
+
+    Conversion functions between point (FOAM::) and Point (CGAL)
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef pointConversion_H
+#define pointConversion_H
+
+#include "point.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef CGAL_INEXACT
+
+    // Define Point to be contiguous for inexact (double storage) kernel
+    typedef const Foam::point& pointFromPoint;
+    typedef const CGAL::Triangulation_vertex_base_3<K>::Point& PointFrompoint;
+
+#else
+
+    typedef Foam::point pointFromPoint;
+    typedef CGAL::Triangulation_vertex_base_3<K>::Point PointFrompoint;
+
+#endif
+
+namespace Foam
+{
+
+#ifdef CGAL_INEXACT
+
+    template<typename Point>
+    inline pointFromPoint topoint(const Point& P)
+    {
+        return reinterpret_cast<pointFromPoint>(P);
+    }
+
+    template<typename Point>
+    inline PointFrompoint toPoint(const Foam::point& p)
+    {
+        return reinterpret_cast<PointFrompoint>(p);
+    }
+
+#else
+
+    template<typename Point>
+    inline pointFromPoint topoint(const Point& P)
+    {
+        return Foam::point
+        (
+            CGAL::to_double(P.x()),
+            CGAL::to_double(P.y()),
+            CGAL::to_double(P.z())
+        );
+    }
+
+    template<typename Point>
+    inline Point toPoint(const Foam::point& p)
+    {
+        return Point(p.x(), p.y(), p.z());
+    }
+
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/pointFeatureEdgesTypes.H b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/pointFeatureEdgesTypes.H
index 8838487f1e..5bae06d86f 100644
--- a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/pointFeatureEdgesTypes.H
+++ b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformalVoronoiMesh/pointFeatureEdgesTypes.H
@@ -21,11 +21,6 @@ License
     You should have received a copy of the GNU General Public License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
-    As a special exception, you have permission to link this program with the
-    CGAL library and distribute executables, as long as you follow the
-    requirements of the GNU GPL in regard to all of the software in the
-    executable aside from CGAL.
-
 Class
     pointFeatureEdgesTypes
 
@@ -48,28 +43,39 @@ namespace Foam
 \*---------------------------------------------------------------------------*/
 
 //- Hold the types of feature edges attached to the point.
-struct pointFeatureEdgesTypes
+class pointFeatureEdgesTypes
+:
+    public HashTable<label, extendedFeatureEdgeMesh::edgeStatus>
 {
-    label ptI;
-    label nExternal, nInternal;
-    label nFlat, nOpen, nMultiple, nNonFeature;
+    label pointLabel_;
+
+public:
 
     pointFeatureEdgesTypes(const label pointLabel)
-    {
-        ptI = pointLabel;
-        nExternal = nInternal = 0;
-        nFlat = nOpen = nMultiple = nNonFeature = 0;
-    }
+    :
+        HashTable<label, extendedFeatureEdgeMesh::edgeStatus>(),
+        pointLabel_(pointLabel)
+    {}
+
 
     friend Ostream& operator<<(Ostream& os, const pointFeatureEdgesTypes& p)
     {
-        os  << "E " << "I " << "F " << "O " << "M " << "N "
-            << "Pt" << nl
-            << p.nExternal << " " << p.nInternal << " "
-            << p.nFlat << " " << p.nOpen << " "
-            << p.nMultiple << " " << p.nNonFeature << " "
-            << p.ptI
-            << endl;
+        os  << "Point = " << p.pointLabel_ << endl;
+
+        for
+        (
+            HashTable<label, extendedFeatureEdgeMesh::edgeStatus>
+                ::const_iterator iter = p.cbegin();
+            iter != p.cend();
+            ++iter
+        )
+        {
+            os  << "    "
+                << extendedFeatureEdgeMesh::edgeStatusNames_[iter.key()]
+                << " = "
+                << iter()
+                << endl;
+        }
 
         return os;
     }
diff --git a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformationSurfaces/conformationSurfaces.C b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformationSurfaces/conformationSurfaces.C
index 50d2384f24..64f753fb99 100644
--- a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformationSurfaces/conformationSurfaces.C
+++ b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformationSurfaces/conformationSurfaces.C
@@ -117,7 +117,6 @@ Foam::conformationSurfaces::conformationSurfaces
             }
         }
 
-
         word featureMethod = surfaceSubDict.lookup("featureMethod");
 
         if (featureMethod == "extendedFeatureEdgeMesh")
@@ -230,7 +229,12 @@ Foam::conformationSurfaces::conformationSurfaces
 
     // Extend the global bounds to stop the bound box sitting on the surfaces
     // to be conformed to
-    globalBounds_ = globalBounds_.extend(rndGen_, 1e-4);
+    //globalBounds_ = globalBounds_.extend(rndGen_, 1e-4);
+
+    vector newSpan = 1e-4*globalBounds_.span();
+
+    globalBounds_.min() -= newSpan;
+    globalBounds_.max() += newSpan;
 
     // Look at all surfaces at determine whether the locationInMesh point is
     // inside or outside each, to establish a signature for the domain to be
diff --git a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformationSurfaces/conformationSurfaces.H b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformationSurfaces/conformationSurfaces.H
index c1bdac76ba..3acb10d53a 100644
--- a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformationSurfaces/conformationSurfaces.H
+++ b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/conformationSurfaces/conformationSurfaces.H
@@ -45,9 +45,6 @@ SourceFiles
 namespace Foam
 {
 
-// Forward declaration of classes
-class conformalVoronoiMesh;
-
 /*---------------------------------------------------------------------------*\
                      Class conformationSurfaces Declaration
 \*---------------------------------------------------------------------------*/
diff --git a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cvControls/cvControls.C b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cvControls/cvControls.C
index 15c82e64c5..e65cbea4e9 100644
--- a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cvControls/cvControls.C
+++ b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cvControls/cvControls.C
@@ -84,126 +84,42 @@ Foam::cvControls::cvControls
 
     // Controls for coarse surface conformation
 
-    const dictionary& coarseDict
+    const dictionary& conformationControlsDict
     (
-        surfDict.subDict("coarseConformationControls")
-    );
-
-    const dictionary& coarseInitialDict
-    (
-        coarseDict.subDict("initial")
-    );
-
-    const dictionary& coarseIterationDict
-    (
-        coarseDict.subDict("iteration")
+        surfDict.subDict("conformationControls")
     );
 
     surfacePtExclusionDistanceCoeff_ = readScalar
     (
-        coarseInitialDict.lookup("surfacePtExclusionDistanceCoeff")
+        conformationControlsDict.lookup("surfacePtExclusionDistanceCoeff")
     );
 
-    edgeSearchDistCoeffSqr_coarse_initial_ = sqr
+    edgeSearchDistCoeffSqr_ = sqr
     (
         readScalar
         (
-            coarseInitialDict.lookup("edgeSearchDistCoeff")
+            conformationControlsDict.lookup("edgeSearchDistCoeff")
         )
     );
 
-    edgeSearchDistCoeffSqr_coarse_iteration_ = sqr
+    surfacePtReplaceDistCoeffSqr_ = sqr
     (
         readScalar
         (
-            coarseIterationDict.lookup("edgeSearchDistCoeff")
+            conformationControlsDict.lookup("surfacePtReplaceDistCoeff")
         )
     );
 
-    surfacePtReplaceDistCoeffSqr_coarse_initial_ = sqr
+    maxConformationIterations_ = readLabel
     (
-        readScalar
-        (
-            coarseInitialDict.lookup("surfacePtReplaceDistCoeff")
-        )
+        conformationControlsDict.lookup("maxIterations")
     );
 
-    surfacePtReplaceDistCoeffSqr_coarse_iteration_ = sqr
+    iterationToInitialHitRatioLimit_ = readScalar
     (
-        readScalar
-        (
-            coarseIterationDict.lookup("surfacePtReplaceDistCoeff")
-        )
+        conformationControlsDict.lookup("iterationToInitialHitRatioLimit")
     );
 
-    maxConformationIterations_coarse_ = readLabel
-    (
-        coarseDict.lookup("maxIterations")
-    );
-
-    iterationToInitialHitRatioLimit_coarse_ = readScalar
-    (
-        coarseDict.lookup("iterationToInitialHitRatioLimit")
-    );
-
-    // Controls for fine surface conformation
-
-    const dictionary& fineDict
-    (
-        surfDict.subDict("fineConformationControls")
-    );
-
-    const dictionary& fineInitialDict
-    (
-        fineDict.subDict("initial")
-    );
-
-    const dictionary& fineIterationDict
-    (
-        fineDict.subDict("iteration")
-    );
-
-    edgeSearchDistCoeffSqr_fine_initial_ = sqr
-    (
-        readScalar
-        (
-            fineInitialDict.lookup("edgeSearchDistCoeff")
-        )
-    );
-
-    edgeSearchDistCoeffSqr_fine_iteration_ = sqr
-    (
-        readScalar
-        (
-            fineIterationDict.lookup("edgeSearchDistCoeff")
-        )
-    );
-
-    surfacePtReplaceDistCoeffSqr_fine_initial_ = sqr
-    (
-        readScalar
-        (
-            fineInitialDict.lookup("surfacePtReplaceDistCoeff")
-        )
-    );
-
-    surfacePtReplaceDistCoeffSqr_fine_iteration_ = sqr
-    (
-        readScalar
-        (
-            fineIterationDict.lookup("surfacePtReplaceDistCoeff")
-        )
-    );
-
-    maxConformationIterations_fine_ = readLabel
-    (
-        fineDict.lookup("maxIterations")
-    );
-
-    iterationToInitialHitRatioLimit_fine_ = readScalar
-    (
-        fineDict.lookup("iterationToInitialHitRatioLimit")
-    );
 
     // Motion control controls
 
@@ -279,248 +195,22 @@ Foam::cvControls::cvControls
 
     const dictionary& filteringDict(cvMeshDict_.subDict("polyMeshFiltering"));
 
+    filterEdges_ = Switch
+    (
+        filteringDict.lookupOrDefault<Switch>("filterEdges", true)
+    );
+
+    filterFaces_ = Switch
+    (
+        filteringDict.lookupOrDefault<Switch>("filterFaces", false)
+    );
+
+    if (filterFaces_)
+    {
+        filterEdges_ = Switch::ON;
+    }
+
     writeTetDualMesh_ = Switch(filteringDict.lookup("writeTetDualMesh"));
-
-    filterSizeCoeff_ = readScalar
-    (
-        filteringDict.lookup("filterSizeCoeff")
-    );
-
-    mergeClosenessCoeff_ = readScalar
-    (
-        filteringDict.lookup("mergeClosenessCoeff")
-    );
-
-    edgeMergeAngle_ = readScalar
-    (
-        filteringDict.lookup("edgeMergeAngle")
-    );
-
-    continueFilteringOnBadInitialPolyMesh_ = Switch
-    (
-        filteringDict.lookupOrDefault<Switch>
-        (
-            "continueFilteringOnBadInitialPolyMesh",
-            false
-        )
-    );
-
-    filterErrorReductionCoeff_ = readScalar
-    (
-        filteringDict.lookup("filterErrorReductionCoeff")
-    );
-
-    filterCountSkipThreshold_ = readLabel
-    (
-        filteringDict.lookup("filterCountSkipThreshold")
-    );
-
-    maxCollapseIterations_ = readLabel
-    (
-        filteringDict.lookup("maxCollapseIterations")
-    );
-
-    maxConsecutiveEqualFaceSets_ = readLabel
-    (
-        filteringDict.lookup("maxConsecutiveEqualFaceSets")
-    );
-
-    surfaceStepFaceAngle_ = readScalar
-    (
-        filteringDict.lookup("surfaceStepFaceAngle")
-    );
-
-    edgeCollapseGuardFraction_ = readScalar
-    (
-        filteringDict.lookup("edgeCollapseGuardFraction")
-    );
-
-    maxCollapseFaceToPointSideLengthCoeff_ = readScalar
-    (
-        filteringDict.lookup("maxCollapseFaceToPointSideLengthCoeff")
-    );
-}
-
-
-// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
-
-Foam::scalar Foam::cvControls::edgeSearchDistCoeffSqrInitial
-(
-    int reconfMode
-) const
-{
-    if (reconfMode == conformalVoronoiMesh::rmCoarse)
-    {
-        return edgeSearchDistCoeffSqr_coarse_initial_;
-    }
-
-    else if (reconfMode == conformalVoronoiMesh::rmFine)
-    {
-        return edgeSearchDistCoeffSqr_fine_initial_;
-    }
-    else
-    {
-        FatalErrorIn
-        (
-            "Foam::cvControls::edgeSearchDistCoeffSqrInitial"
-            "("
-                "int reconfMode"
-            ") const"
-        )   << "Unknown reconformationMode " << reconfMode
-            << exit(FatalError);
-    }
-
-    return 0;
-}
-
-
-Foam::scalar Foam::cvControls::edgeSearchDistCoeffSqrIteration
-(
-    int reconfMode
-) const
-{
-    if (reconfMode == conformalVoronoiMesh::rmCoarse)
-    {
-        return edgeSearchDistCoeffSqr_coarse_iteration_;
-    }
-
-    else if (reconfMode == conformalVoronoiMesh::rmFine)
-    {
-        return edgeSearchDistCoeffSqr_fine_iteration_;
-    }
-    else
-    {
-        FatalErrorIn
-        (
-            "Foam::cvControls::edgeSearchDistCoeffSqrIteration"
-            "("
-                "int reconfMode"
-            ") const"
-        )   << "Unknown reconformationMode " << reconfMode
-            << exit(FatalError);
-    }
-
-    return 0;
-}
-
-
-Foam::scalar Foam::cvControls::surfacePtReplaceDistCoeffSqrInitial
-(
-    int reconfMode
-) const
-{
-    if (reconfMode == conformalVoronoiMesh::rmCoarse)
-    {
-        return surfacePtReplaceDistCoeffSqr_coarse_initial_;
-    }
-
-    else if (reconfMode == conformalVoronoiMesh::rmFine)
-    {
-        return surfacePtReplaceDistCoeffSqr_fine_initial_;
-    }
-    else
-    {
-        FatalErrorIn
-        (
-            "Foam::cvControls::surfacePtReplaceDistCoeffSqrInitial"
-            "("
-                "int reconfMode"
-            ") const"
-        )   << "Unknown reconformationMode " << reconfMode
-            << exit(FatalError);
-    }
-
-    return 0;
-}
-
-
-Foam::scalar Foam::cvControls::surfacePtReplaceDistCoeffSqrIteration
-(
-    int reconfMode
-) const
-{
-    if (reconfMode == conformalVoronoiMesh::rmCoarse)
-    {
-        return surfacePtReplaceDistCoeffSqr_coarse_iteration_;
-    }
-
-    else if (reconfMode == conformalVoronoiMesh::rmFine)
-    {
-        return surfacePtReplaceDistCoeffSqr_fine_iteration_;
-    }
-    else
-    {
-        FatalErrorIn
-        (
-            "Foam::cvControls::surfacePtReplaceDistCoeffSqrIteration"
-            "("
-                "int reconfMode"
-            ") const"
-        )   << "Unknown reconformationMode " << reconfMode
-            << exit(FatalError);
-    }
-
-    return 0;
-}
-
-
-Foam::label Foam::cvControls::maxConformationIterations
-(
-    int reconfMode
-) const
-{
-    if (reconfMode == conformalVoronoiMesh::rmCoarse)
-    {
-        return maxConformationIterations_coarse_;
-    }
-
-    else if (reconfMode == conformalVoronoiMesh::rmFine)
-    {
-        return maxConformationIterations_fine_;
-    }
-    else
-    {
-        FatalErrorIn
-        (
-            "Foam::cvControls::maxConformationIterations"
-            "("
-                "int reconfMode"
-            ") const"
-        )   << "Unknown reconformationMode " << reconfMode
-            << exit(FatalError);
-    }
-
-    return 0;
-}
-
-
-Foam::scalar Foam::cvControls::iterationToInitialHitRatioLimit
-(
-    int reconfMode
-) const
-{
-    if (reconfMode == conformalVoronoiMesh::rmCoarse)
-    {
-        return iterationToInitialHitRatioLimit_coarse_;
-    }
-
-    else if (reconfMode == conformalVoronoiMesh::rmFine)
-    {
-        return iterationToInitialHitRatioLimit_fine_;
-    }
-    else
-    {
-        FatalErrorIn
-        (
-            "Foam::cvControls::iterationToInitialHitRatioLimit"
-            "("
-                "int reconfMode"
-            ") const"
-        )   << "Unknown reconformationMode " << reconfMode
-            << exit(FatalError);
-    }
-
-    return 0;
 }
 
 
diff --git a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cvControls/cvControls.H b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cvControls/cvControls.H
index 58dd06fc74..e8184753b0 100644
--- a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cvControls/cvControls.H
+++ b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cvControls/cvControls.H
@@ -37,6 +37,7 @@ SourceFiles
 
 #include "dictionary.H"
 #include "Switch.H"
+#include "vector.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -106,74 +107,21 @@ class cvControls
 
                 //- Distance to search for feature edges near to
                 //  surface protrusions - fraction of the local target
-                //  cell size. Coarse conformation, initial protrusion
-                //  tests.
-                scalar edgeSearchDistCoeffSqr_coarse_initial_;
-
-                //- Distance to search for feature edges near to
-                //  surface protrusions - fraction of the local target
-                //  cell size. Coarse conformation, iteration
-                //  protrusion tests.
-                scalar edgeSearchDistCoeffSqr_coarse_iteration_;
+                //  cell size.
+                scalar edgeSearchDistCoeffSqr_;
 
                 //- Proximity to a feature edge where a surface hit is
                 //  not created, only the edge conformation is created
-                //  - fraction of the local target cell size. Coarse
-                //  conformation, initial protrusion tests.
-                scalar surfacePtReplaceDistCoeffSqr_coarse_initial_;
+                //  - fraction of the local target cell size.
+                scalar surfacePtReplaceDistCoeffSqr_;
 
-                //- Proximity to a feature edge where a surface hit is
-                //  not created, only the edge conformation is created
-                //  - fraction of the local target cell size. Coarse
-                //  conformation, iteration protrusion tests.
-                scalar surfacePtReplaceDistCoeffSqr_coarse_iteration_;
+                //- Maximum allowed number surface conformation iterations.
+                label maxConformationIterations_;
 
-                //- Maximum allowed number coarse surface conformation
-                //  iterations.
-                label maxConformationIterations_coarse_;
-
-                //- Termination criterion for coarse surface
-                //  conformation iterations.  When the number of
-                //  surface protrusions drops below this ratio of the
-                //  initial number of protrusions.
-                scalar iterationToInitialHitRatioLimit_coarse_;
-
-
-            // Controls for fine surface conformation
-
-                //- Distance to search for feature edges near to
-                //  surface protrusions - fraction of the local target
-                //  cell size. Fine conformation, initial protrusion
-                //  tests.
-                scalar edgeSearchDistCoeffSqr_fine_initial_;
-
-                //- Distance to search for feature edges near to
-                //  surface protrusions - fraction of the local target
-                //  cell size. Fine conformation, iteration protrusion
-                //  tests.
-                scalar edgeSearchDistCoeffSqr_fine_iteration_;
-
-                //- Proximity to a feature edge where a surface hit is
-                //  not created, only the edge conformation is created
-                //  - fraction of the local target cell size. Fine
-                //  conformation, initial protrusion tests.
-                scalar surfacePtReplaceDistCoeffSqr_fine_initial_;
-
-                //- Proximity to a feature edge where a surface hit is
-                //  not created, only the edge conformation is created
-                //  - fraction of the local target cell size. Fine
-                //  conformation, iteration protrusion tests.
-                scalar surfacePtReplaceDistCoeffSqr_fine_iteration_;
-
-                //- Maximum allowed number fine surface conformation
-                //  iterations.
-                label maxConformationIterations_fine_;
-
-                //- Termination criterion for fine surface conformation
-                //  iterations.  When the number of surface protrusions
-                //  drops below this ratio of the initial number of
-                //  protrusions.
-                scalar iterationToInitialHitRatioLimit_fine_;
+                //- Termination criterion for conformation iterations.
+                //  When the number of surface protrusions drops below this
+                //  ratio of the initial number of protrusions.
+                scalar iterationToInitialHitRatioLimit_;
 
 
     // Motion control controls
@@ -198,6 +146,7 @@ class cvControls
         //- Now often to re-store the size and alignment data
         label sizeAndAlignmentRebuildFrequency_;
 
+
         // Point insertion criteria
 
             //- Length between Delaunay vertices above which a new Dv should be
@@ -223,67 +172,15 @@ class cvControls
 
     // polyMesh filtering controls
 
+        //- Activates the mesh edge filtering. On by default.
+        Switch filterEdges_;
+
+        //- Activates the mesh face filtering. Off by default.
+        Switch filterFaces_;
+
         //- Write tet mesh at output time (it always writes the Voronoi)
         Switch writeTetDualMesh_;
 
-        //- Upper limit on the size of faces to be filtered from,
-        //  fraction of the local target cell size
-        scalar filterSizeCoeff_;
-
-        //- Upper limit on how close two dual vertices can be before
-        //  being merged, fraction of the local target cell size
-        scalar mergeClosenessCoeff_;
-
-        //- If the angle between two dual edges that are connected by a single
-        //  point is less than this angle, then the edges will be merged into a
-        //  single edge.
-        scalar edgeMergeAngle_;
-
-        //- If the mesh quality criteria cannot be satisfied, continue
-        //  with filtering anyway?
-        Switch continueFilteringOnBadInitialPolyMesh_;
-
-        //- When a face is "bad", what fraction should the filterSizeCoeff_ be
-        //  reduced by.  Recursive, so for a filterCount value of fC, the
-        //  filterSizeCoeff is reduced by pow(filterErrorReductionCoeff_, fC)
-        scalar filterErrorReductionCoeff_;
-
-        //- Maximum number of filterCount applications before a face
-        //  is not attempted to be filtered
-        label filterCountSkipThreshold_;
-
-        //- Maximum number of permissible iterations of the face collapse
-        //  algorithm.  The value to choose will be related the maximum number
-        //  of points on a face that is to be collapsed and how many faces
-        //  around it need to be collapsed.
-        label maxCollapseIterations_;
-
-        //- Maximum number of times an to allow an equal faceSet to be
-        //  returned from the face quality assessment before stopping iterations
-        //  to break an infinitie loop.
-        label maxConsecutiveEqualFaceSets_;
-
-        //- The maximum allowed angle between a boundary face normal and the
-        //  local surface normal before face will be aggressively collapsed
-        scalar surfaceStepFaceAngle_;
-
-        //- Defining how close to the midpoint (M) of the projected
-        //  vertices line a projected vertex (X) can be before making
-        //  an edge collapse invalid
-        //
-        //  X---X-g----------------M----X-----------g----X--X
-        //
-        //  Only allow a collapse if all projected vertices are
-        //  outwith edgeCollapseGuardFraction (g) of the distance form
-        //  the face centre to the furthest vertex in the considered
-        //  direction
-        scalar edgeCollapseGuardFraction_;
-
-        //- The maximum allowed length of the longest edge of a face
-        //  to enable a face to be collapsed to a point, fraction of
-        //  the local target cell size
-        scalar maxCollapseFaceToPointSideLengthCoeff_;
-
 
     // Private Member Functions
 
@@ -346,30 +243,17 @@ public:
             //- Return the surfaceConformationRebuildFrequency
             inline label surfaceConformationRebuildFrequency() const;
 
-            //- Return the edgeSearchDistCoeffSqr for initial
-            //  conformation for the given reconformationMode.
-            scalar edgeSearchDistCoeffSqrInitial(int reconfMode) const;
+            //- Return the edgeSearchDistCoeffSqr for conformation.
+            scalar edgeSearchDistCoeffSqr() const;
 
-            //- Return the edgeSearchDistCoeffSqr for conformation
-            //  iterations for the given reconformationMode.
-            scalar edgeSearchDistCoeffSqrIteration(int reconfMode) const;
+            //- Return the surfacePtReplaceDistCoeffSqr for conformation.
+            scalar surfacePtReplaceDistCoeffSqr() const;
 
-            //- Return the surfacePtReplaceDistCoeffSqr for initial
-            //  conformation for the given reconformationMode.
-            scalar surfacePtReplaceDistCoeffSqrInitial(int reconfMode) const;
+            //- Return the maxConformationIterations
+            label maxConformationIterations() const;
 
-            //- Return the surfacePtReplaceDistCoeffSqr for
-            //  conformation iterations for the given
-            //  reconformationMode.
-            scalar surfacePtReplaceDistCoeffSqrIteration(int reconfMode) const;
-
-            //- Return the maxConformationIterations for the given
-            //  reconformationMode.
-            label maxConformationIterations(int reconfMode) const;
-
-            //- Return the iterationToInitialHitRatioLimit for the
-            //  given reconformationMode.
-            scalar iterationToInitialHitRatioLimit(int reconfMode) const;
+            //- Return the iterationToInitialHitRatioLimit
+            scalar iterationToInitialHitRatioLimit() const;
 
             //- Return the objOutput Switch
             inline Switch objOutput() const;
@@ -389,6 +273,12 @@ public:
             //- Return the sizeAndAlignmentRebuildFrequency
             inline label sizeAndAlignmentRebuildFrequency() const;
 
+            //- Return the aspectRatio
+            inline scalar aspectRatio() const;
+
+            //- Return the aspectRatioDirection
+            inline const vector& aspectRatioDirection() const;
+
             //- Return the insertionDistCoeff
             inline scalar insertionDistCoeff() const;
 
@@ -401,44 +291,14 @@ public:
             //- Return removalDistCoeff
             inline scalar removalDistCoeff() const;
 
+            //- Filter edges at output time
+            inline Switch filterEdges() const;
+
+            //- Filter faces at output time
+            inline Switch filterFaces() const;
+
             //- Write tetMesh at output time
             inline Switch writeTetDualMesh() const;
-
-            //- Return the filterSizeCoeff
-            inline scalar filterSizeCoeff() const;
-
-            //- Return the mergeClosenessCoeff
-            inline scalar mergeClosenessCoeff() const;
-
-            //- Return the edgeMergeAngle
-            inline scalar edgeMergeAngle() const;
-
-            //- Return the continueFilteringOnBadInitialPolyMesh Switch
-            inline Switch continueFilteringOnBadInitialPolyMesh() const;
-
-            //- Return the filterErrorReductionCoeff
-            inline scalar filterErrorReductionCoeff() const;
-
-            //- Return the maxCollapseIterations
-            inline label maxCollapseIterations() const;
-
-            //- Return the maxConsecutiveEqualFaceSets
-            inline label maxConsecutiveEqualFaceSets() const;
-
-            //- Return the filterCountSkipThreshold
-            inline label filterCountSkipThreshold() const;
-
-            //- Return the maxCollapseIterations
-            inline label minCollapseFaces() const;
-
-            //- Return the surfaceStepFaceAngle
-            inline scalar surfaceStepFaceAngle() const;
-
-            //- Return the edgeCollapseGuardFraction
-            inline scalar edgeCollapseGuardFraction() const;
-
-            //- Return the maxCollapseFaceToPointSideLengthCoeff
-            inline scalar maxCollapseFaceToPointSideLengthCoeff() const;
 };
 
 
diff --git a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cvControls/cvControlsI.H b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cvControls/cvControlsI.H
index 50df7e8f58..befc7b5666 100644
--- a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cvControls/cvControlsI.H
+++ b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/cvControls/cvControlsI.H
@@ -88,6 +88,30 @@ inline Foam::label Foam::cvControls::surfaceConformationRebuildFrequency() const
 }
 
 
+inline Foam::scalar Foam::cvControls::edgeSearchDistCoeffSqr() const
+{
+    return edgeSearchDistCoeffSqr_;
+}
+
+
+inline Foam::scalar Foam::cvControls::surfacePtReplaceDistCoeffSqr() const
+{
+    return surfacePtReplaceDistCoeffSqr_;
+}
+
+
+inline Foam::label Foam::cvControls::maxConformationIterations() const
+{
+    return maxConformationIterations_;
+}
+
+
+inline Foam::scalar Foam::cvControls::iterationToInitialHitRatioLimit() const
+{
+    return iterationToInitialHitRatioLimit_;
+}
+
+
 inline Foam::Switch Foam::cvControls::objOutput() const
 {
     return objOutput_;
@@ -148,78 +172,20 @@ inline Foam::scalar Foam::cvControls::removalDistCoeff() const
 }
 
 
+inline Foam::Switch Foam::cvControls::filterEdges() const
+{
+    return filterEdges_;
+}
+
+inline Foam::Switch Foam::cvControls::filterFaces() const
+{
+    return filterFaces_;
+}
+
 inline Foam::Switch Foam::cvControls::writeTetDualMesh() const
 {
     return writeTetDualMesh_;
 }
 
 
-inline Foam::scalar Foam::cvControls::filterSizeCoeff() const
-{
-    return filterSizeCoeff_;
-}
-
-
-inline Foam::scalar Foam::cvControls::mergeClosenessCoeff() const
-{
-    return mergeClosenessCoeff_;
-}
-
-
-inline Foam::scalar Foam::cvControls::edgeMergeAngle() const
-{
-    return edgeMergeAngle_;
-}
-
-
-inline Foam::Switch
-Foam::cvControls::continueFilteringOnBadInitialPolyMesh() const
-{
-    return continueFilteringOnBadInitialPolyMesh_;
-}
-
-
-inline Foam::scalar Foam::cvControls::filterErrorReductionCoeff() const
-{
-    return filterErrorReductionCoeff_;
-}
-
-
-inline Foam::label Foam::cvControls::filterCountSkipThreshold() const
-{
-    return filterCountSkipThreshold_;
-}
-
-
-inline Foam::label Foam::cvControls::maxCollapseIterations() const
-{
-    return maxCollapseIterations_;
-}
-
-
-inline Foam::label Foam::cvControls::maxConsecutiveEqualFaceSets() const
-{
-    return maxConsecutiveEqualFaceSets_;
-}
-
-
-inline Foam::scalar Foam::cvControls::surfaceStepFaceAngle() const
-{
-    return surfaceStepFaceAngle_;
-}
-
-
-inline Foam::scalar Foam::cvControls::edgeCollapseGuardFraction() const
-{
-    return edgeCollapseGuardFraction_;
-}
-
-
-inline Foam::scalar
-Foam::cvControls::maxCollapseFaceToPointSideLengthCoeff() const
-{
-    return maxCollapseFaceToPointSideLengthCoeff_;
-}
-
-
 // ************************************************************************* //
diff --git a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/initialPointsMethod/autoDensity/autoDensity.C b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/initialPointsMethod/autoDensity/autoDensity.C
index 2b7d83f2b2..0aace4f77f 100644
--- a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/initialPointsMethod/autoDensity/autoDensity.C
+++ b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/initialPointsMethod/autoDensity/autoDensity.C
@@ -339,7 +339,7 @@ bool Foam::autoDensity::fillBox
 
         pointField corners(bb.points());
 
-        scalarField cornerSizes = cvMesh_.cellSizeControl().cellSize(corners);
+        scalarField cornerSizes = cvMesh_.cellShapeControls().cellSize(corners);
 
         Field<bool> insideCorners = combinedWellInside(corners, cornerSizes);
 
@@ -448,7 +448,7 @@ bool Foam::autoDensity::fillBox
                         );
                 }
 
-                lineSizes = cvMesh_.cellSizeControl().cellSize(linePoints);
+                lineSizes = cvMesh_.cellShapeControls().cellSize(linePoints);
 
                 Field<bool> insideLines = combinedWellInside
                 (
@@ -547,7 +547,7 @@ bool Foam::autoDensity::fillBox
         // corner when only some these points are required.
         shuffle(samplePoints);
 
-        scalarField sampleSizes = cvMesh_.cellSizeControl().cellSize
+        scalarField sampleSizes = cvMesh_.cellShapeControls().cellSize
         (
             samplePoints
         );
@@ -713,7 +713,7 @@ bool Foam::autoDensity::fillBox
 
             point p = min + cmptMultiply(span, rnd.vector01());
 
-            scalar localSize = cvMesh_.cellSizeControl().cellSize(p);
+            scalar localSize = cvMesh_.cellShapeControls().cellSize(p);
 
             bool insidePoint = false;
 
diff --git a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/initialPointsMethod/bodyCentredCubic/bodyCentredCubic.C b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/initialPointsMethod/bodyCentredCubic/bodyCentredCubic.C
index 751a743e6d..c69e7ac8fb 100644
--- a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/initialPointsMethod/bodyCentredCubic/bodyCentredCubic.C
+++ b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/initialPointsMethod/bodyCentredCubic/bodyCentredCubic.C
@@ -167,7 +167,7 @@ List<Vb::Point> bodyCentredCubic::initialPoints() const
                 minimumSurfaceDistanceCoeffSqr_
                *sqr
                 (
-                    cvMesh_.cellSizeControl().cellSize(points)
+                    cvMesh_.cellShapeControls().cellSize(points)
                 )
             );
 
diff --git a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/initialPointsMethod/faceCentredCubic/faceCentredCubic.C b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/initialPointsMethod/faceCentredCubic/faceCentredCubic.C
index a1c1f383b0..af2e7dfbf4 100644
--- a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/initialPointsMethod/faceCentredCubic/faceCentredCubic.C
+++ b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/initialPointsMethod/faceCentredCubic/faceCentredCubic.C
@@ -228,7 +228,7 @@ List<Vb::Point> faceCentredCubic::initialPoints() const
                 minimumSurfaceDistanceCoeffSqr_
                *sqr
                 (
-                    cvMesh_.cellSizeControl().cellSize(points)
+                    cvMesh_.cellShapeControls().cellSize(points)
                 )
             );
 
diff --git a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/initialPointsMethod/pointFile/pointFile.C b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/initialPointsMethod/pointFile/pointFile.C
index eb67cf60e2..19861f3e81 100644
--- a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/initialPointsMethod/pointFile/pointFile.C
+++ b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/initialPointsMethod/pointFile/pointFile.C
@@ -132,7 +132,7 @@ List<Vb::Point> pointFile::initialPoints() const
         minimumSurfaceDistanceCoeffSqr_
        *sqr
         (
-            cvMesh_.cellSizeControl().cellSize(points)
+            cvMesh_.cellShapeControls().cellSize(points)
         )
     );
 
diff --git a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/initialPointsMethod/uniformGrid/uniformGrid.C b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/initialPointsMethod/uniformGrid/uniformGrid.C
index 3bc914ea43..2538c90702 100644
--- a/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/initialPointsMethod/uniformGrid/uniformGrid.C
+++ b/applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/initialPointsMethod/uniformGrid/uniformGrid.C
@@ -144,7 +144,7 @@ List<Vb::Point> uniformGrid::initialPoints() const
                 minimumSurfaceDistanceCoeffSqr_
                *sqr
                 (
-                    cvMesh_.cellSizeControl().cellSize(points)
+                    cvMesh_.cellShapeControls().cellSize(points)
                 )
             );
 
diff --git a/applications/utilities/mesh/generation/cvMesh/cvMesh.C b/applications/utilities/mesh/generation/cvMesh/cvMesh.C
index f15ebea29a..cf21964271 100644
--- a/applications/utilities/mesh/generation/cvMesh/cvMesh.C
+++ b/applications/utilities/mesh/generation/cvMesh/cvMesh.C
@@ -21,11 +21,6 @@ License
     You should have received a copy of the GNU General Public License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
-    As a special exception, you have permission to link this program with the
-    CGAL library and distribute executables, as long as you follow the
-    requirements of the GNU GPL in regard to all of the software in the
-    executable aside from CGAL.
-
 Application
     cvMesh
 
@@ -44,11 +39,6 @@ using namespace Foam;
 
 int main(int argc, char *argv[])
 {
-    argList::addBoolOption
-    (
-        "noFilter",
-        "Do not filter the mesh"
-    );
     Foam::argList::addBoolOption
     (
         "checkGeometry",
@@ -60,11 +50,8 @@ int main(int argc, char *argv[])
 
     runTime.functionObjects().off();
 
-    const bool noFilter = !args.optionFound("noFilter");
     const bool checkGeometry = args.optionFound("checkGeometry");
 
-    Info<< "Mesh filtering is " << (noFilter ? "on" : "off") << endl;
-
     IOdictionary cvMeshDict
     (
         IOobject
@@ -112,15 +99,9 @@ int main(int argc, char *argv[])
 
         Info<< nl << "ExecutionTime = " << runTime.elapsedCpuTime() << " s"
             << "  ClockTime = " << runTime.elapsedClockTime() << " s"
-            << nl << endl;
+            << endl;
     }
 
-    mesh.writeMesh(runTime.constant(), noFilter);
-
-    Info<< nl << "ExecutionTime = " << runTime.elapsedCpuTime() << " s"
-        << "  ClockTime = " << runTime.elapsedClockTime() << " s"
-        << nl << endl;
-
     Info<< nl << "End" << nl << endl;
 
     return 0;
diff --git a/applications/utilities/mesh/generation/cvMesh/cvMeshBackgroundMesh/Make/options b/applications/utilities/mesh/generation/cvMesh/cvMeshBackgroundMesh/Make/options
index ed71a80029..0322435c8c 100644
--- a/applications/utilities/mesh/generation/cvMesh/cvMeshBackgroundMesh/Make/options
+++ b/applications/utilities/mesh/generation/cvMesh/cvMeshBackgroundMesh/Make/options
@@ -14,14 +14,14 @@ EXE_INC = \
     -I$(LIB_SRC)/triSurface/lnInclude \
     -I$(LIB_SRC)/finiteVolume/lnInclude \
     -I$(LIB_SRC)/meshTools/lnInclude \
-    -I$(LIB_SRC)/fileFormats/lnInclude \
-    -I$(LIB_SRC)/sampling/lnInclude \
-    -I$(LIB_SRC)/dynamicMesh/lnInclude
+    -I$(LIB_SRC)/dynamicMesh/lnInclude \
+    -I../vectorTools
 
 EXE_LIBS = \
     $(CGAL_LIBS) \
     -lboost_thread \
     -lmpfr \
+    -lgmp \
     -lconformalVoronoiMesh \
     -ldecompositionMethods /* -L$(FOAM_LIBBIN)/dummy -lscotchDecomp */ \
     -ledgeMesh \
diff --git a/applications/utilities/mesh/generation/cvMesh/cvMeshBackgroundMesh/cvMeshBackgroundMesh.C b/applications/utilities/mesh/generation/cvMesh/cvMeshBackgroundMesh/cvMeshBackgroundMesh.C
index 485c5568b4..53766c59a0 100644
--- a/applications/utilities/mesh/generation/cvMesh/cvMeshBackgroundMesh/cvMeshBackgroundMesh.C
+++ b/applications/utilities/mesh/generation/cvMesh/cvMeshBackgroundMesh/cvMeshBackgroundMesh.C
@@ -36,7 +36,7 @@ Description
 #include "triSurface.H"
 #include "searchableSurfaces.H"
 #include "conformationSurfaces.H"
-#include "cellSizeControlSurfaces.H"
+#include "cellShapeControl.H"
 #include "backgroundMeshDecomposition.H"
 #include "cellShape.H"
 #include "cellModeller.H"
@@ -450,10 +450,15 @@ int main(int argc, char *argv[])
         cvMeshDict.subDict("surfaceConformation")
     );
 
-    cellSizeControlSurfaces cellSizeControl
+    autoPtr<cellShapeControl> cellShapeControls
     (
-        allGeometry,
-        cvMeshDict.subDict("motionControl")
+        cellShapeControl::New
+        (
+            runTime,
+            cvMeshDict.subDict("motionControl"),
+            allGeometry,
+            geometryToConformTo
+        )
     );
 
 
@@ -464,7 +469,7 @@ int main(int argc, char *argv[])
 
         // Determine the number of cells in each direction.
         const vector span = bb.span();
-        vector nScalarCells = span/cellSizeControl.defaultCellSize();
+        vector nScalarCells = span/cellShapeControls().defaultCellSize();
 
         // Calculate initial cell size to be a little bit smaller than the
         // defaultCellSize to avoid initial refinement triggering.
@@ -580,7 +585,7 @@ int main(int argc, char *argv[])
         20.0,   //maxCellWeightCoeff
         runTime,
         geometryToConformTo,
-        cellSizeControl,
+        cellShapeControls(),
         rndGen,
         cvMeshDict
     );
diff --git a/applications/utilities/mesh/generation/cvMesh/cvMeshDict b/applications/utilities/mesh/generation/cvMesh/cvMeshDict
index 513d73573b..28f3b0043b 100644
--- a/applications/utilities/mesh/generation/cvMesh/cvMeshDict
+++ b/applications/utilities/mesh/generation/cvMesh/cvMeshDict
@@ -263,7 +263,7 @@ initialPoints
 // It determines the cell size given a location. It then uses all
 // the rules
 // - defaultCellSize
-// - cellSizeControlGeometry
+// - cellShapeControl
 // to determine target cell size. Rule with highest priority wins. If same
 // priority smallest cell size wins.
 motionControl
@@ -271,10 +271,28 @@ motionControl
     // Absolute cell size of back ground mesh. This is the maximum cell size.
     defaultCellSize     0.00075;
 
-    // Assign a priority to all requests for cell sizes, the highest overrules.
-    defaultPriority     0;
+    //cellShapeControl    constantControl;
+    //cellShapeControl    fileControl;
+    cellShapeControl    surfaceControl;
 
-    cellSizeControlGeometry
+    // Provide constant values for cell size and alignment
+    constantControlCoeffs
+    {
+        cellSize      0.00075;
+        cellAlignment (1 0 0 0 1 0 0 0 1);
+    }
+
+    // Read in the points of the background grid used for cell shape control
+    // from a file, with corresponding files for alignment and size
+    fileControlCoeffs
+    {
+        pointFile       "";
+        sizesFile       "";
+        alignmentsFile  "";
+    }
+
+    // Calculate the sizes and alignments from surfaces
+    surfaceControlCoeffs
     {
         ref7_outside
         {
@@ -319,6 +337,16 @@ motionControl
         }
     }
 
+    // Provide an aspect ratio and the direction in which it acts on the mesh.
+    // Default is 1.0 if this section is not present in the dictionary
+    cellAspectRatioControl
+    {
+        // Aspect ratio.
+        aspectRatio                 2.0;
+        // Direction of action of the aspect ratio
+        aspectRatioDirection        (1 0 0);
+    }
+
     // Underrelaxation for point motion. Simulated annealing: starts off at 1
     // and lowers to 0 (at simulation endTime) to converge points.
     // adaptiveLinear is preferred choice.
@@ -396,6 +424,12 @@ motionControl
 // Do not change. See cvControls.H
 polyMeshFiltering
 {
+    // Filter small edges
+    filterEdges                             on;
+
+    // Filter small and sliver faces
+    filterFaces                             off;
+
     // Write the underlying Delaunay tet mesh at output time
     writeTetDualMesh                        false;  //true;
 
diff --git a/applications/utilities/mesh/generation/extrude/extrudeMesh/extrudeMesh.C b/applications/utilities/mesh/generation/extrude/extrudeMesh/extrudeMesh.C
index 1f72f1d221..bafe305504 100644
--- a/applications/utilities/mesh/generation/extrude/extrudeMesh/extrudeMesh.C
+++ b/applications/utilities/mesh/generation/extrude/extrudeMesh/extrudeMesh.C
@@ -473,6 +473,7 @@ int main(int argc, char *argv[])
             )
             {
                 label nbrProcI = patchToNbrProc[patchI];
+
                 word name =
                         "procBoundary"
                       + Foam::name(Pstream::myProcNo())
@@ -755,6 +756,9 @@ int main(int argc, char *argv[])
         const edgeList& edges = mesh.edges();
         const pointField& points = mesh.points();
 
+        PackedBoolList collapseEdge(mesh.nEdges());
+        Map<point> collapsePointToLocation(mesh.nPoints());
+
         forAll(edges, edgeI)
         {
             const edge& e = edges[edgeI];
@@ -766,15 +770,29 @@ int main(int argc, char *argv[])
                 Info<< "Merging edge " << e << " since length " << d
                     << " << " << mergeDim << nl;
 
-                // Collapse edge to e[0]
-                collapser.collapseEdge(edgeI, e[0]);
+                collapseEdge[edgeI] = true;
+                collapsePointToLocation.set(e[1], points[e[0]]);
             }
         }
 
+        List<pointEdgeCollapse> allPointInfo;
+        const globalIndex globalPoints(mesh.nPoints());
+        labelList pointPriority(mesh.nPoints(), 0);
+
+        collapser.consistentCollapse
+        (
+            globalPoints,
+            pointPriority,
+            collapsePointToLocation,
+            collapseEdge,
+            allPointInfo
+        );
+
         // Topo change container
         polyTopoChange meshMod(mesh);
+
         // Put all modifications into meshMod
-        bool anyChange = collapser.setRefinement(meshMod);
+        bool anyChange = collapser.setRefinement(allPointInfo, meshMod);
 
         if (anyChange)
         {
diff --git a/applications/utilities/mesh/generation/extrude2DMesh/extrude2DMeshApp.C b/applications/utilities/mesh/generation/extrude2DMesh/extrude2DMeshApp.C
index f161523ffd..aa033f26d3 100644
--- a/applications/utilities/mesh/generation/extrude2DMesh/extrude2DMeshApp.C
+++ b/applications/utilities/mesh/generation/extrude2DMesh/extrude2DMeshApp.C
@@ -43,6 +43,7 @@ Note
 #include "edgeCollapser.H"
 #include "addPatchCellLayer.H"
 #include "patchToPoly2DMesh.H"
+#include "globalIndex.H"
 
 using namespace Foam;
 
@@ -260,6 +261,9 @@ int main(int argc, char *argv[])
         const boundBox& bb = mesh().bounds();
         const scalar mergeDim = 1e-4 * bb.minDim();
 
+        PackedBoolList collapseEdge(mesh().nEdges());
+        Map<point> collapsePointToLocation(mesh().nPoints());
+
         forAll(edges, edgeI)
         {
             const edge& e = edges[edgeI];
@@ -271,14 +275,27 @@ int main(int argc, char *argv[])
                 Info<< "Merging edge " << e << " since length " << d
                     << " << " << mergeDim << nl;
 
-                // Collapse edge to e[0]
-                collapser.collapseEdge(edgeI, e[0]);
+                collapseEdge[edgeI] = true;
+                collapsePointToLocation.set(e[1], points[e[0]]);
             }
         }
 
+        List<pointEdgeCollapse> allPointInfo;
+        const globalIndex globalPoints(mesh().nPoints());
+        labelList pointPriority(mesh().nPoints(), 0);
+
+        collapser.consistentCollapse
+        (
+            globalPoints,
+            pointPriority,
+            collapsePointToLocation,
+            collapseEdge,
+            allPointInfo
+        );
+
         polyTopoChange meshModCollapse(mesh());
 
-        collapser.setRefinement(meshModCollapse);
+        collapser.setRefinement(allPointInfo, meshModCollapse);
 
         // Create a mesh from topo changes.
         autoPtr<mapPolyMesh> morphMap
diff --git a/applications/utilities/mesh/generation/snappyHexMesh/snappyHexMeshDict b/applications/utilities/mesh/generation/snappyHexMesh/snappyHexMeshDict
index 78cdb47ad0..99d1d5dcfb 100644
--- a/applications/utilities/mesh/generation/snappyHexMesh/snappyHexMeshDict
+++ b/applications/utilities/mesh/generation/snappyHexMesh/snappyHexMeshDict
@@ -149,6 +149,7 @@ castellatedMeshControls
             patchInfo
             {
                 type patch;
+                inGroups (meshedPatches);
             }
 
             //- Optional angle to detect small-large cell situation
diff --git a/applications/utilities/mesh/manipulation/checkMesh/checkGeometry.C b/applications/utilities/mesh/manipulation/checkMesh/checkGeometry.C
index 4eb19041aa..d964ac12cc 100644
--- a/applications/utilities/mesh/manipulation/checkMesh/checkGeometry.C
+++ b/applications/utilities/mesh/manipulation/checkMesh/checkGeometry.C
@@ -262,6 +262,74 @@ bool Foam::checkWedges
 }
 
 
+namespace Foam
+{
+    //- Default transformation behaviour for position
+    class transformPositionList
+    {
+    public:
+
+        //- Transform patch-based field
+        void operator()
+        (
+            const coupledPolyPatch& cpp,
+            List<pointField>& pts
+        ) const
+        {
+            // Each element of pts is all the points in the face. Convert into
+            // lists of size cpp to transform.
+
+            List<pointField> newPts(pts.size());
+            forAll(pts, faceI)
+            {
+                newPts[faceI].setSize(pts[faceI].size());
+            }
+
+            label index = 0;
+            while (true)
+            {
+                label n = 0;
+
+                // Extract for every face the i'th position
+                pointField ptsAtIndex(pts.size(), vector::zero);
+                forAll(cpp, faceI)
+                {
+                    const pointField& facePts = pts[faceI];
+                    if (facePts.size() > index)
+                    {
+                        ptsAtIndex[faceI] = facePts[index];
+                        n++;
+                    }
+                }
+
+                if (n == 0)
+                {
+                    break;
+                }
+
+                // Now ptsAtIndex will have for every face either zero or
+                // the position of the i'th vertex. Transform.
+                cpp.transformPosition(ptsAtIndex);
+
+                // Extract back from ptsAtIndex into newPts
+                forAll(cpp, faceI)
+                {
+                    pointField& facePts = newPts[faceI];
+                    if (facePts.size() > index)
+                    {
+                        facePts[index] = ptsAtIndex[faceI];
+                    }
+                }
+
+                index++;
+            }
+
+            pts.transfer(newPts);
+        }
+    };
+}
+
+
 bool Foam::checkCoupledPoints
 (
     const polyMesh& mesh,
@@ -273,164 +341,106 @@ bool Foam::checkCoupledPoints
     const faceList& fcs = mesh.faces();
     const polyBoundaryMesh& patches = mesh.boundaryMesh();
 
-    // Check size of faces
-    label maxSize = 0;
-    {
-        labelList nbrSize(fcs.size()-mesh.nInternalFaces(), 0);
+    // Zero'th point on coupled faces
+    //pointField nbrZeroPoint(fcs.size()-mesh.nInternalFaces(), vector::max);
+    List<pointField> nbrPoints(fcs.size() - mesh.nInternalFaces());
 
-        // Exchange size
-        forAll(patches, patchI)
+    // Exchange zero point
+    forAll(patches, patchI)
+    {
+        if (patches[patchI].coupled())
         {
-            if (patches[patchI].coupled())
+            const coupledPolyPatch& cpp = refCast<const coupledPolyPatch>
+            (
+                patches[patchI]
+            );
+
+            forAll(cpp, i)
             {
-                const coupledPolyPatch& cpp = refCast<const coupledPolyPatch>
+                label bFaceI = cpp.start() + i - mesh.nInternalFaces();
+                const face& f = cpp[i];
+                nbrPoints[bFaceI].setSize(f.size());
+                forAll(f, fp)
+                {
+                    const point& p0 = p[f[fp]];
+                    nbrPoints[bFaceI][fp] = p0;
+                }
+            }
+        }
+    }
+    syncTools::syncBoundaryFaceList
+    (
+        mesh,
+        nbrPoints,
+        eqOp<pointField>(),
+        transformPositionList()
+    );
+
+    // Compare to local ones. Use same tolerance as for matching
+    label nErrorFaces = 0;
+    scalar avgMismatch = 0;
+    label nCoupledPoints = 0;
+
+    forAll(patches, patchI)
+    {
+        if (patches[patchI].coupled())
+        {
+            const coupledPolyPatch& cpp = refCast<const coupledPolyPatch>
+            (
+                patches[patchI]
+            );
+
+            if (cpp.owner())
+            {
+                scalarField smallDist
                 (
-                    patches[patchI]
+                    cpp.calcFaceTol
+                    (
+                        //cpp.matchTolerance(),
+                        cpp,
+                        cpp.points(),
+                        cpp.faceCentres()
+                    )
                 );
 
                 forAll(cpp, i)
                 {
-                    label bFaceI = cpp.start()+i-mesh.nInternalFaces();
-                    nbrSize[bFaceI] = cpp[i].size();
-                    maxSize = max(maxSize, cpp[i].size());
-                }
-            }
-        }
-        syncTools::swapBoundaryFaceList(mesh, nbrSize);
+                    label bFaceI = cpp.start() + i - mesh.nInternalFaces();
+                    const face& f = cpp[i];
 
-
-        // Check on owner
-        label nErrorFaces = 0;
-        forAll(patches, patchI)
-        {
-            if (patches[patchI].coupled())
-            {
-                const coupledPolyPatch& cpp = refCast<const coupledPolyPatch>
-                (
-                    patches[patchI]
-                );
-
-                if (cpp.owner())
-                {
-                    forAll(cpp, i)
+                    if (f.size() != nbrPoints[bFaceI].size())
                     {
-                        label bFaceI = cpp.start()+i-mesh.nInternalFaces();
+                        FatalErrorIn
+                        (
+                            "Foam::checkCoupledPoints\n"
+                            "(\n"
+                            "   const polyMesh&, const bool, labelHashSet*\n"
+                            ")\n"
+                        )   << "Local face size : " << f.size()
+                            << " does not equal neighbour face size : "
+                            << nbrPoints[bFaceI].size()
+                            << abort(FatalError);
+                    }
 
-                        if (cpp[i].size() != nbrSize[bFaceI])
+                    label fp = 0;
+                    forAll(f, j)
+                    {
+                        const point& p0 = p[f[fp]];
+                        scalar d = mag(p0 - nbrPoints[bFaceI][j]);
+
+                        if (d > smallDist[i])
                         {
                             if (setPtr)
                             {
                                 setPtr->insert(cpp.start()+i);
                             }
                             nErrorFaces++;
+                            break;
                         }
-                    }
-                }
-            }
-        }
+                        avgMismatch += d;
+                        nCoupledPoints++;
 
-        reduce(nErrorFaces, sumOp<label>());
-        if (nErrorFaces > 0)
-        {
-            if (report)
-            {
-                Info<< "  **Error in coupled faces: "
-                    << nErrorFaces
-                    << " faces have different size "
-                    << " compared to their coupled equivalent." << endl;
-            }
-            return true;
-        }
-
-        reduce(maxSize, maxOp<label>());
-    }
-
-
-    label nErrorFaces = 0;
-    scalar avgMismatch = 0;
-    label nCoupledPoints = 0;
-
-    for (label index = 0; index < maxSize; index++)
-    {
-        // point at index on coupled faces
-        pointField nbrPoint(fcs.size()-mesh.nInternalFaces(), vector::max);
-
-        // Exchange point
-        forAll(patches, patchI)
-        {
-            if (patches[patchI].coupled())
-            {
-                const coupledPolyPatch& cpp = refCast<const coupledPolyPatch>
-                (
-                    patches[patchI]
-                );
-
-                forAll(cpp, i)
-                {
-                    const face& f = cpp[i];
-                    if (f.size() > index)
-                    {
-                        label bFaceI = cpp.start()+i-mesh.nInternalFaces();
-                        nbrPoint[bFaceI] = p[f[index]];
-                    }
-                }
-            }
-        }
-        syncTools::swapBoundaryFacePositions(mesh, nbrPoint);
-
-
-        // Compare to local ones. Use same tolerance as for matching
-
-        forAll(patches, patchI)
-        {
-            if (patches[patchI].coupled())
-            {
-                const coupledPolyPatch& cpp = refCast<const coupledPolyPatch>
-                (
-                    patches[patchI]
-                );
-
-                if (cpp.owner())
-                {
-                    scalarField smallDist
-                    (
-                        cpp.calcFaceTol
-                        (
-                            //cpp.matchTolerance(),
-                            cpp,
-                            cpp.points(),
-                            cpp.faceCentres()
-                        )
-                    );
-
-                    forAll(cpp, i)
-                    {
-                        const face& f = cpp[i];
-                        if (f.size() > index)
-                        {
-                            label bFaceI = cpp.start()+i-mesh.nInternalFaces();
-                            label reverseIndex = (f.size()-index)%f.size();
-                            scalar d = mag(p[f[reverseIndex]]-nbrPoint[bFaceI]);
-
-                            if (d > smallDist[i])
-                            {
-                                if (setPtr)
-                                {
-                                    // Avoid duplicate counting of faces
-                                    if (setPtr->insert(cpp.start()+i))
-                                    {
-                                        nErrorFaces++;
-                                    }
-                                }
-                                else
-                                {
-                                    // No checking on duplicates
-                                    nErrorFaces++;
-                                }
-                            }
-                            avgMismatch += d;
-                            nCoupledPoints++;
-                        }
+                        fp = f.rcIndex(fp);
                     }
                 }
             }
diff --git a/applications/utilities/mesh/manipulation/checkMesh/checkTopology.C b/applications/utilities/mesh/manipulation/checkMesh/checkTopology.C
index 39e7375a67..7e395be879 100644
--- a/applications/utilities/mesh/manipulation/checkMesh/checkTopology.C
+++ b/applications/utilities/mesh/manipulation/checkMesh/checkTopology.C
@@ -235,7 +235,7 @@ Foam::label Foam::checkTopology
         if (nOneCells > 0)
         {
             Info<< "  <<Writing " << nOneCells
-                << " cells with with zero or one non-boundary face to set "
+                << " cells with zero or one non-boundary face to set "
                 << oneCells.name()
                 << endl;
             oneCells.instance() = mesh.pointsInstance();
@@ -247,7 +247,7 @@ Foam::label Foam::checkTopology
         if (nTwoCells > 0)
         {
             Info<< "  <<Writing " << nTwoCells
-                << " cells with with two non-boundary faces to set "
+                << " cells with two non-boundary faces to set "
                 << twoCells.name()
                 << endl;
             twoCells.instance() = mesh.pointsInstance();
diff --git a/applications/utilities/mesh/manipulation/checkMesh/printMeshStats.C b/applications/utilities/mesh/manipulation/checkMesh/printMeshStats.C
index 9ff4ed0334..9d49ffa2a9 100644
--- a/applications/utilities/mesh/manipulation/checkMesh/printMeshStats.C
+++ b/applications/utilities/mesh/manipulation/checkMesh/printMeshStats.C
@@ -155,11 +155,11 @@ void Foam::printMeshStats(const polyMesh& mesh, const bool allTopology)
         Info<< "    Breakdown of polyhedra by number of faces:" << nl
             << "        faces" << "   number of cells" << endl;
 
-        labelList sortedKeys = polyhedralFaces.sortedToc();
+        const labelList sortedKeys = polyhedralFaces.sortedToc();
 
         forAll(sortedKeys, keyI)
         {
-            label nFaces = sortedKeys[keyI];
+            const label nFaces = sortedKeys[keyI];
 
             Info<< setf(std::ios::right) << setw(13)
                 << nFaces << "   " << polyhedralFaces[nFaces] << nl;
diff --git a/applications/utilities/parallelProcessing/decomposePar/domainDecomposition.C b/applications/utilities/parallelProcessing/decomposePar/domainDecomposition.C
index 1dd38329e7..c682da6701 100644
--- a/applications/utilities/parallelProcessing/decomposePar/domainDecomposition.C
+++ b/applications/utilities/parallelProcessing/decomposePar/domainDecomposition.C
@@ -428,12 +428,12 @@ bool Foam::domainDecomposition::writeDecomposition()
                   : curProcessorPatchSizes[procPatchI] - subStarts[i]
                 );
 
-                //Info<< "From processor:" << procI << endl
-                //    << "  to processor:" << curNeighbourProcessors[procPatchI]
-                //    << endl
-                //    << "    via patch:" << subPatchID[i] << endl
-                //    << "    start    :" << curStart << endl
-                //    << "    size     :" << size << endl;
+//                Info<< "From processor:" << procI << endl
+//                    << "  to processor:" << curNeighbourProcessors[procPatchI]
+//                    << endl
+//                    << "    via patch:" << subPatchID[i] << endl
+//                    << "    start    :" << curStart << endl
+//                    << "    size     :" << size << endl;
 
                 if (subPatchID[i] == -1)
                 {
@@ -454,9 +454,14 @@ bool Foam::domainDecomposition::writeDecomposition()
                 }
                 else
                 {
+                    const coupledPolyPatch& pcPatch
+                        = refCast<const coupledPolyPatch>
+                          (
+                              boundaryMesh()[subPatchID[i]]
+                          );
+
                     // From cyclic
-                    const word& referPatch =
-                        boundaryMesh()[subPatchID[i]].name();
+                    const word& referPatch = pcPatch.name();
 
                     procPatches[nPatches] =
                         new processorCyclicPolyPatch
@@ -472,7 +477,8 @@ bool Foam::domainDecomposition::writeDecomposition()
                             procMesh.boundaryMesh(),
                             procI,
                             curNeighbourProcessors[procPatchI],
-                            referPatch
+                            referPatch,
+                            pcPatch.transform()
                         );
                 }
 
diff --git a/applications/utilities/surface/surfaceBooleanFeatures/surfaceBooleanFeatures.C b/applications/utilities/surface/surfaceBooleanFeatures/surfaceBooleanFeatures.C
index 3393edb00d..ce64e65f3a 100644
--- a/applications/utilities/surface/surfaceBooleanFeatures/surfaceBooleanFeatures.C
+++ b/applications/utilities/surface/surfaceBooleanFeatures/surfaceBooleanFeatures.C
@@ -446,6 +446,7 @@ int main(int argc, char *argv[])
         edgeDirections,
         edgeNormals,
         labelListList(0),   // featurePointNormals,
+        labelListList(0),   // featurePointEdges,
         labelList(0)        // regionEdges
     );
 
diff --git a/applications/utilities/surface/surfaceFeatureExtract/surfaceFeatureExtract.C b/applications/utilities/surface/surfaceFeatureExtract/surfaceFeatureExtract.C
index 03d1ba874d..fb54a417a1 100644
--- a/applications/utilities/surface/surfaceFeatureExtract/surfaceFeatureExtract.C
+++ b/applications/utilities/surface/surfaceFeatureExtract/surfaceFeatureExtract.C
@@ -761,7 +761,7 @@ int main(int argc, char *argv[])
         // Either construct features from surface & featureAngle or read set.
         // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-        surfaceFeatures set(surf);
+        autoPtr<surfaceFeatures> set;
 
         scalar includedAngle = -1;
 
@@ -781,7 +781,7 @@ int main(int argc, char *argv[])
             Info<< nl << "Reading existing feature edges from file "
                 << featureEdgeFile << endl;
 
-            set = surfaceFeatures(surf, eMesh.points(), eMesh.edges());
+            set.set(new surfaceFeatures(surf, eMesh.points(), eMesh.edges()));
         }
         else if (extractionMethod == "extractFromSurface")
         {
@@ -796,7 +796,7 @@ int main(int argc, char *argv[])
             Info<< nl << "Constructing feature set from included angle "
                 << includedAngle << endl;
 
-            set = surfaceFeatures(surf, includedAngle);
+            set.set(new surfaceFeatures(surf, includedAngle));
         }
         else
         {
@@ -807,16 +807,6 @@ int main(int argc, char *argv[])
                 << exit(FatalError);
         }
 
-        Info<< nl
-            << "Initial feature set:" << nl
-            << "    feature points : " << set.featurePoints().size() << nl
-            << "    feature edges  : " << set.featureEdges().size() << nl
-            << "    of which" << nl
-            << "        region edges   : " << set.nRegionEdges() << nl
-            << "        external edges : " << set.nExternalEdges() << nl
-            << "        internal edges : " << set.nInternalEdges() << nl
-            << endl;
-
 
         // Trim set
         // ~~~~~~~~
@@ -838,7 +828,7 @@ int main(int argc, char *argv[])
                 Info<< "Removing features with number of edges < "
                     << minElem << endl;
 
-                set.trimFeatures(minLen, minElem);
+                set().trimFeatures(minLen, minElem);
             }
         }
 
@@ -847,7 +837,7 @@ int main(int argc, char *argv[])
         // ~~~~~~
 
         // Convert to marked edges, points
-        List<surfaceFeatures::edgeStatus> edgeStat(set.toStatus());
+        List<surfaceFeatures::edgeStatus> edgeStat(set().toStatus());
 
         if (surfaceDict.isDict("subsetFeatures"))
         {
@@ -940,6 +930,16 @@ int main(int argc, char *argv[])
         surfaceFeatures newSet(surf);
         newSet.setFromStatus(edgeStat);
 
+        Info<< nl
+            << "Initial feature set:" << nl
+            << "    feature points : " << newSet.featurePoints().size() << nl
+            << "    feature edges  : " << newSet.featureEdges().size() << nl
+            << "    of which" << nl
+            << "        region edges   : " << newSet.nRegionEdges() << nl
+            << "        external edges : " << newSet.nExternalEdges() << nl
+            << "        internal edges : " << newSet.nInternalEdges() << nl
+            << endl;
+
         //if (writeObj)
         //{
         //    newSet.writeObj("final");
@@ -956,17 +956,10 @@ int main(int argc, char *argv[])
 
         if (surfaceDict.isDict("addFeatures"))
         {
-            const dictionary& subsetDict = surfaceDict.subDict
-            (
-                "addFeatures"
-            );
-
-            const word addFeName = subsetDict["name"];
+            const word addFeName = surfaceDict.subDict("addFeatures")["name"];
             Info<< "Adding (without merging) features from " << addFeName
                 << nl << endl;
 
-            const Switch flip = subsetDict["flip"];
-
             extendedFeatureEdgeMesh addFeMesh
             (
                 IOobject
@@ -982,14 +975,6 @@ int main(int argc, char *argv[])
             Info<< "Read " << addFeMesh.name() << nl;
             writeStats(addFeMesh, Info);
 
-            if (flip)
-            {
-                Info<< "Flipping " << addFeMesh.name() << endl;
-                addFeMesh.flipNormals();
-                Info<< "After flipping " << addFeMesh.name() << nl;
-                writeStats(addFeMesh, Info);
-            }
-
             feMesh.add(addFeMesh);
         }
 
diff --git a/bin/tools/RunFunctions b/bin/tools/RunFunctions
index 093c6ed037..3632a62d76 100644
--- a/bin/tools/RunFunctions
+++ b/bin/tools/RunFunctions
@@ -28,6 +28,11 @@
 #     Miscellaneous functions for running tutorial cases
 #------------------------------------------------------------------------------
 
+getNumberOfProcessors()
+{
+    sed -ne 's/^numberOfSubdomains *\(.*\);/\1/p' system/decomposeParDict
+}
+
 getApplication()
 {
     sed -ne 's/^ *application *\([a-zA-Z]*\) *;.*$/\1/p' system/controlDict
diff --git a/etc/bashrc b/etc/bashrc
index 0e7c7c62a4..d146684e9a 100644
--- a/etc/bashrc
+++ b/etc/bashrc
@@ -213,6 +213,7 @@ _foamSource $WM_PROJECT_DIR/etc/config/aliases.sh
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 _foamSource `$WM_PROJECT_DIR/bin/foamEtcFile config/paraview.sh`
 _foamSource `$WM_PROJECT_DIR/bin/foamEtcFile config/ensight.sh`
+_foamSource `$WM_PROJECT_DIR/bin/foamEtcFile config/gperftools.sh`
 
 
 # Clean environment paths again. Only remove duplicates
diff --git a/etc/config/gperftools.sh b/etc/config/gperftools.sh
new file mode 100644
index 0000000000..f71a6cf2af
--- /dev/null
+++ b/etc/config/gperftools.sh
@@ -0,0 +1,41 @@
+#----------------------------------*-sh-*--------------------------------------
+# =========                 |
+# \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+#  \\    /   O peration     |
+#   \\  /    A nd           | Copyright (C) 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/>.
+#
+# File
+#     config/gperftools.sh
+#
+# Description
+#     Setup file for gperftools binaries libraries.
+#
+#------------------------------------------------------------------------------
+
+version=svn
+gperftools_install=$WM_THIRD_PARTY_DIR/platforms/$WM_ARCH$WM_COMPILER
+
+GPERFTOOLS_VERSION=gperftools-$version
+GPERFTOOLS_ARCH_PATH=$gperftools_install/$GPERFTOOLS_VERSION
+
+export PATH=$GPERFTOOLS_ARCH_PATH/bin:$PATH
+export LD_LIBRARY_PATH=$GPERFTOOLS_ARCH_PATH/lib:$LD_LIBRARY_PATH
+
+# -----------------------------------------------------------------------------
diff --git a/src/OpenFOAM/Make/files b/src/OpenFOAM/Make/files
index d1061458e8..1cd7f37fe8 100644
--- a/src/OpenFOAM/Make/files
+++ b/src/OpenFOAM/Make/files
@@ -63,6 +63,7 @@ primitives/globalIndexAndTransform/globalIndexAndTransform.C
 primitives/globalIndexAndTransform/vectorTensorTransform/vectorTensorTransform.C
 primitives/quaternion/quaternion.C
 primitives/septernion/septernion.C
+primitives/triad/triad.C
 
 /* functions, data entries */
 primitives/functions/DataEntry/makeDataEntries.C
@@ -524,6 +525,7 @@ $(Fields)/sphericalTensorField/sphericalTensorField.C
 $(Fields)/diagTensorField/diagTensorField.C
 $(Fields)/symmTensorField/symmTensorField.C
 $(Fields)/tensorField/tensorField.C
+$(Fields)/triadField/triadField.C
 $(Fields)/complexFields/complexFields.C
 
 $(Fields)/labelField/labelIOField.C
@@ -542,6 +544,7 @@ $(Fields)/symmTensorField/symmTensorIOField.C
 $(Fields)/symmTensorField/symmTensorFieldIOField.C
 $(Fields)/tensorField/tensorIOField.C
 $(Fields)/tensorField/tensorFieldIOField.C
+$(Fields)/triadField/triadIOField.C
 $(Fields)/transformField/transformField.C
 
 pointPatchFields = fields/pointPatchFields
diff --git a/src/OpenFOAM/algorithms/dynamicIndexedOctree/dynamicIndexedOctreeName.C b/src/OpenFOAM/algorithms/dynamicIndexedOctree/dynamicIndexedOctreeName.C
index 4e842cb28f..29bc6634aa 100644
--- a/src/OpenFOAM/algorithms/dynamicIndexedOctree/dynamicIndexedOctreeName.C
+++ b/src/OpenFOAM/algorithms/dynamicIndexedOctree/dynamicIndexedOctreeName.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -27,6 +27,10 @@ License
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-defineTypeNameAndDebug(Foam::dynamicIndexedOctreeName, 0);
+namespace Foam
+{
+defineTypeNameAndDebug(dynamicIndexedOctreeName, 0);
+}
+
 
 // ************************************************************************* //
diff --git a/src/OpenFOAM/algorithms/dynamicIndexedOctree/dynamicTreeDataPoint.C b/src/OpenFOAM/algorithms/dynamicIndexedOctree/dynamicTreeDataPoint.C
index 05b37e2f76..ebc93a63c7 100644
--- a/src/OpenFOAM/algorithms/dynamicIndexedOctree/dynamicTreeDataPoint.C
+++ b/src/OpenFOAM/algorithms/dynamicIndexedOctree/dynamicTreeDataPoint.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -29,7 +29,10 @@ License
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-defineTypeNameAndDebug(Foam::dynamicTreeDataPoint, 0);
+namespace Foam
+{
+defineTypeNameAndDebug(dynamicTreeDataPoint, 0);
+}
 
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
diff --git a/src/OpenFOAM/algorithms/indexedOctree/indexedOctree.C b/src/OpenFOAM/algorithms/indexedOctree/indexedOctree.C
index f16dd2595c..0e588f1b73 100644
--- a/src/OpenFOAM/algorithms/indexedOctree/indexedOctree.C
+++ b/src/OpenFOAM/algorithms/indexedOctree/indexedOctree.C
@@ -47,36 +47,9 @@ bool Foam::indexedOctree<Type>::overlaps
     const point& sample
 )
 {
-    // Find out where sample is in relation to bb.
-    // Find nearest point on bb.
-    scalar distSqr = 0;
+    boundBox bb(p0, p1);
 
-    for (direction dir = 0; dir < vector::nComponents; dir++)
-    {
-        scalar d0 = p0[dir] - sample[dir];
-        scalar d1 = p1[dir] - sample[dir];
-
-        if ((d0 > 0) != (d1 > 0))
-        {
-            // sample inside both extrema. This component does not add any
-            // distance.
-        }
-        else if (mag(d0) < mag(d1))
-        {
-            distSqr += d0*d0;
-        }
-        else
-        {
-            distSqr += d1*d1;
-        }
-
-        if (distSqr > nearestDistSqr)
-        {
-            return false;
-        }
-    }
-
-    return true;
+    return bb.overlaps(sample, nearestDistSqr);
 }
 
 
@@ -379,124 +352,6 @@ Foam::label Foam::indexedOctree<Type>::compactContents
 }
 
 
-template <class Type>
-bool Foam::indexedOctree<Type>::quickCircumsphereRejection
-(
-    const label nodeI,
-    const point& cc,
-    const scalar crSqr,
-    const List<scalar>& nearestDistances
-) const
-{
-    const node& nod = nodes_[nodeI];
-
-    volumeType nodeType = volumeType(nodeTypes_.get(nodeI<<3));
-
-    //scalar boxDist = nearestDistances[nodeI] + 0.5*nod.bb_.mag();
-    scalar boxDist = crSqr + magSqr(cc - nod.bb_.midpoint());
-
-    if
-    (
-         nodeType == INSIDE
-      //&& (crSqr < sqr(boxDist))
-      && (boxDist < sqr(nearestDistances[nodeI]))
-    )
-    {
-        return true;
-    }
-    else
-    {
-        direction octant = nod.bb_.subOctant(cc);
-
-        labelBits index = nod.subNodes_[octant];
-
-        if (isNode(index))
-        {
-            return quickCircumsphereRejection
-            (
-                getNode(index),
-                cc,
-                crSqr,
-                nearestDistances
-            );
-        }
-        else
-        {
-            return false;
-        }
-    }
-}
-
-
-template <class Type>
-bool Foam::indexedOctree<Type>::quickCircumsphereRejection
-(
-    const point& cc,
-    const scalar crSqr,
-    const List<scalar>& nearestDistances
-) const
-{
-    if (nodes_.size())
-    {
-        return quickCircumsphereRejection
-        (
-            0,
-            cc,
-            crSqr,
-            nearestDistances
-        );
-    }
-
-    return false;
-}
-
-
-template <class Type>
-Foam::scalar
-Foam::indexedOctree<Type>::calcNearestDistance
-(
-    const label nodeI
-) const
-{
-    const node& nod = nodes_[nodeI];
-
-    const point& nodeCentre = nod.bb_.midpoint();
-
-    scalar nearestDistance = 0.0;
-
-    pointIndexHit pHit = findNearest(nodeCentre, sqr(GREAT));
-
-    if (pHit.hit())
-    {
-        nearestDistance = mag(pHit.hitPoint() - nodeCentre);
-    }
-    else
-    {
-        WarningIn("Foam::indexedOctree<Type>::calcNearestDistance(const label)")
-            << "Cannot calculate distance of nearest point on surface from "
-            << "the midpoint of the octree node. Returning distance of zero."
-            << endl;
-    }
-
-    return nearestDistance;
-}
-
-
-template <class Type>
-Foam::List<Foam::scalar>
-Foam::indexedOctree<Type>::calcNearestDistance() const
-{
-    List<scalar> nearestDistances(nodes_.size());
-
-    forAll(nearestDistances, nodeI)
-    {
-        nearestDistances[nodeI] = calcNearestDistance(nodeI);
-    }
-
-    return nearestDistances;
-}
-
-
 // Pre-calculates wherever possible the volume status per node/subnode.
 // Recurses to determine status of lowest level boxes. Level above is
 // combination of octants below.
diff --git a/src/OpenFOAM/algorithms/indexedOctree/indexedOctree.H b/src/OpenFOAM/algorithms/indexedOctree/indexedOctree.H
index 40ee7a8a32..0a70bee918 100644
--- a/src/OpenFOAM/algorithms/indexedOctree/indexedOctree.H
+++ b/src/OpenFOAM/algorithms/indexedOctree/indexedOctree.H
@@ -201,16 +201,6 @@ private:
                 label& compactI
             );
 
-            scalar calcNearestDistance(const label nodeI) const;
-
-            bool quickCircumsphereRejection
-            (
-                const label nodeI,
-                const point& cc,
-                const scalar crSqr,
-                const List<scalar>& nearestDistances
-            ) const;
-
             //- Determine inside/outside per node (mixed if cannot be
             //  determined). Only valid for closed shapes.
             volumeType calcVolumeType(const label nodeI) const;
@@ -658,16 +648,6 @@ public:
                 CompareOp& cop
             ) const;
 
-            //- Return a list containing the nearest distance of nodes to any
-            //  shapes
-            List<scalar> calcNearestDistance() const;
-
-            bool quickCircumsphereRejection
-            (
-                const point& cc,
-                const scalar crSqr,
-                const List<scalar>& nearestDistances
-            ) const;
 
         // Write
 
diff --git a/src/OpenFOAM/algorithms/indexedOctree/indexedOctreeName.C b/src/OpenFOAM/algorithms/indexedOctree/indexedOctreeName.C
index 26574b0089..1f1ce408d3 100644
--- a/src/OpenFOAM/algorithms/indexedOctree/indexedOctreeName.C
+++ b/src/OpenFOAM/algorithms/indexedOctree/indexedOctreeName.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -27,6 +27,10 @@ License
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-defineTypeNameAndDebug(Foam::indexedOctreeName, 0);
+namespace Foam
+{
+defineTypeNameAndDebug(indexedOctreeName, 0);
+}
+
 
 // ************************************************************************* //
diff --git a/src/OpenFOAM/algorithms/indexedOctree/treeDataCell.C b/src/OpenFOAM/algorithms/indexedOctree/treeDataCell.C
index 1bb57a44d7..e4d78fc83d 100644
--- a/src/OpenFOAM/algorithms/indexedOctree/treeDataCell.C
+++ b/src/OpenFOAM/algorithms/indexedOctree/treeDataCell.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -29,7 +29,10 @@ License
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-defineTypeNameAndDebug(Foam::treeDataCell, 0);
+namespace Foam
+{
+defineTypeNameAndDebug(treeDataCell, 0);
+}
 
 
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
diff --git a/src/OpenFOAM/containers/Circulators/CirculatorBase/CirculatorBase.H b/src/OpenFOAM/containers/Circulators/CirculatorBase/CirculatorBase.H
new file mode 100644
index 0000000000..d1ab166bab
--- /dev/null
+++ b/src/OpenFOAM/containers/Circulators/CirculatorBase/CirculatorBase.H
@@ -0,0 +1,77 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 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::CirculatorBase
+
+Description
+    Base class for circulators
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef CirculatorBase_H
+#define CirculatorBase_H
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+
+/*---------------------------------------------------------------------------*\
+                       Class CirculatorBase Declaration
+\*---------------------------------------------------------------------------*/
+
+class CirculatorBase
+{
+public:
+
+    // Public data
+
+        //- Direction type enumeration
+        enum direction
+        {
+            NONE,
+            CLOCKWISE,
+            ANTICLOCKWISE
+        };
+
+
+    // Constructors
+
+        //- Construct null
+        CirculatorBase(){};
+
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/OpenFOAM/containers/Circulators/circulator/circulator.H b/src/OpenFOAM/containers/Circulators/circulator/circulator.H
new file mode 100644
index 0000000000..15188df982
--- /dev/null
+++ b/src/OpenFOAM/containers/Circulators/circulator/circulator.H
@@ -0,0 +1,227 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 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::circulator
+
+Description
+    Walks over a container as if it were circular. The container must have the
+    following members defined:
+        - value_type
+        - size_type
+        - difference_type
+        - iterator
+        - reference
+
+    Examples
+
+    \code
+        face f(identity(5));
+
+        // Construct circulator from the face
+        circulator<face> circ(f);
+
+        // First check that the circulator has a size to iterate over.
+        // Then circulate around the list starting and finishing at the fulcrum.
+        if (circ.size()) do
+        {
+            circ() += 1;
+
+            Info<< "Iterate forwards over face : " << circ() << endl;
+
+        } while (circ.circulate(CirculatorBase::CLOCKWISE));
+    \endcode
+
+SourceFiles
+    circulatorI.H
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef circulator_H
+#define circulator_H
+
+#include "CirculatorBase.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+
+/*---------------------------------------------------------------------------*\
+                         Class circulator Declaration
+\*---------------------------------------------------------------------------*/
+
+template<class ContainerType>
+class circulator
+:
+    public CirculatorBase
+{
+
+protected:
+
+    // Protected data
+
+        //- Iterator pointing to the beginning of the container
+        typename ContainerType::iterator begin_;
+
+        //- Iterator pointing to the end of the container
+        typename ContainerType::iterator end_;
+
+        //- Random access iterator for traversing ContainerType.
+        typename ContainerType::iterator iter_;
+
+        //- Iterator holding the location of the fulcrum (start and end) of
+        //  the container. Used to decide when the iterator should stop
+        //  circulating over the container
+        typename ContainerType::iterator fulcrum_;
+
+
+public:
+
+    // STL type definitions
+
+        //- Type of values ContainerType contains.
+        typedef typename ContainerType::value_type      value_type;
+
+        //- The type that can represent the size of ContainerType
+        typedef typename ContainerType::size_type       size_type;
+
+        //- The type that can represent the difference between any two
+        //  iterator objects.
+        typedef typename ContainerType::difference_type difference_type;
+
+        //- Random access iterator for traversing ContainerType.
+        typedef typename ContainerType::iterator        iterator;
+
+        //- Type that can be used for storing into
+        //  ContainerType::value_type objects.
+        typedef typename ContainerType::reference       reference;
+
+
+    // Constructors
+
+        //- Construct null
+        inline circulator();
+
+        //- Construct from a container.
+        inline explicit circulator(ContainerType& container);
+
+        //- Construct from two iterators
+        inline circulator(const iterator& begin, const iterator& end);
+
+        //- Construct as copy
+        inline circulator(const circulator<ContainerType>&);
+
+
+    //- Destructor
+    ~circulator();
+
+
+    // Member Functions
+
+        //- Return the range of the iterator
+        inline size_type size() const;
+
+        //- Circulate around the list in the given direction
+        inline bool circulate(const CirculatorBase::direction dir = NONE);
+
+        //- Set the fulcrum to the current position of the iterator
+        inline void setFulcrumToIterator();
+
+        //- Set the iterator to the current position of the fulcrum
+        inline void setIteratorToFulcrum();
+
+        //- Return the distance between the iterator and the fulcrum. This is
+        //  equivalent to the number of rotations of the circulator.
+        inline difference_type nRotations() const;
+
+        //- Dereference the next iterator and return
+        inline reference next() const;
+
+        //- Dereference the previous iterator and return
+        inline reference prev() const;
+
+
+    // Member Operators
+
+        //- Assignment operator for circulators that operate on the same
+        //  container type
+        inline void operator=(const circulator<ContainerType>&);
+
+        //- Prefix increment. Increments the iterator.
+        //  Sets the iterator to the beginning of the container if it reaches
+        //  the end
+        inline circulator<ContainerType>& operator++();
+
+        //- Postfix increment. Increments the iterator.
+        //  Sets the iterator to the beginning of the container if it reaches
+        //  the end
+        inline circulator<ContainerType> operator++(int);
+
+        //- Prefix decrement. Decrements the iterator.
+        //  Sets the iterator to the end of the container if it reaches
+        //  the beginning
+        inline circulator<ContainerType>& operator--();
+
+        //- Postfix decrement. Decrements the iterator.
+        //  Sets the iterator to the end of the container if it reaches
+        //  the beginning
+        inline circulator<ContainerType> operator--(int);
+
+        //- Check for equality of this iterator with another iterator that
+        //  operate on the same container type
+        inline bool operator==(const circulator<ContainerType>& c) const;
+
+        //- Check for inequality of this iterator with another iterator that
+        //  operate on the same container type
+        inline bool operator!=(const circulator<ContainerType>& c) const;
+
+        //- Dereference the iterator and return
+        inline reference operator*() const;
+
+        //- Dereference the iterator and return
+        inline reference operator()() const;
+
+        //- Return the difference between this iterator and another iterator
+        //  that operate on the same container type
+        inline difference_type operator-
+        (
+            const circulator<ContainerType>& c
+        ) const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#include "circulatorI.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/OpenFOAM/containers/Circulators/circulator/circulatorI.H b/src/OpenFOAM/containers/Circulators/circulator/circulatorI.H
new file mode 100644
index 0000000000..e39f1fa27d
--- /dev/null
+++ b/src/OpenFOAM/containers/Circulators/circulator/circulatorI.H
@@ -0,0 +1,290 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+template<class ContainerType>
+Foam::circulator<ContainerType>::circulator()
+:
+    CirculatorBase(),
+    begin_(0),
+    end_(0),
+    iter_(0),
+    fulcrum_(0)
+{}
+
+
+template<class ContainerType>
+Foam::circulator<ContainerType>::circulator(ContainerType& container)
+:
+    CirculatorBase(),
+    begin_(container.begin()),
+    end_(container.end()),
+    iter_(begin_),
+    fulcrum_(begin_)
+{}
+
+
+template<class ContainerType>
+Foam::circulator<ContainerType>::circulator
+(
+    const iterator& begin,
+    const iterator& end
+)
+:
+    CirculatorBase(),
+    begin_(begin),
+    end_(end),
+    iter_(begin),
+    fulcrum_(begin)
+{}
+
+
+template<class ContainerType>
+Foam::circulator<ContainerType>::circulator
+(
+    const circulator<ContainerType>& rhs
+)
+:
+    CirculatorBase(),
+    begin_(rhs.begin_),
+    end_(rhs.end_),
+    iter_(rhs.iter_),
+    fulcrum_(rhs.fulcrum_)
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructors * * * * * * * * * * * * * * * //
+
+template<class ContainerType>
+Foam::circulator<ContainerType>::~circulator()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+template<class ContainerType>
+typename Foam::circulator<ContainerType>::size_type
+Foam::circulator<ContainerType>::size() const
+{
+    return end_ - begin_;
+}
+
+
+template<class ContainerType>
+bool Foam::circulator<ContainerType>::circulate
+(
+    const CirculatorBase::direction dir
+)
+{
+    if (dir == CirculatorBase::CLOCKWISE)
+    {
+        operator++();
+    }
+    else if (dir == CirculatorBase::ANTICLOCKWISE)
+    {
+        operator--();
+    }
+
+    return !(iter_ == fulcrum_);
+}
+
+
+template<class ContainerType>
+void Foam::circulator<ContainerType>::setFulcrumToIterator()
+{
+    fulcrum_ = iter_;
+}
+
+
+template<class ContainerType>
+void Foam::circulator<ContainerType>::setIteratorToFulcrum()
+{
+    iter_ = fulcrum_;
+}
+
+
+template<class ContainerType>
+typename Foam::circulator<ContainerType>::difference_type
+Foam::circulator<ContainerType>::nRotations() const
+{
+    return (iter_ - fulcrum_);
+}
+
+
+template<class ContainerType>
+typename Foam::circulator<ContainerType>::reference
+Foam::circulator<ContainerType>::next() const
+{
+    if (iter_ == end_ - 1)
+    {
+        return *begin_;
+    }
+
+    return *(iter_ + 1);
+}
+
+
+template<class ContainerType>
+typename Foam::circulator<ContainerType>::reference
+Foam::circulator<ContainerType>::prev() const
+{
+    if (iter_ == begin_)
+    {
+        return *(end_ - 1);
+    }
+
+    return *(iter_ - 1);
+}
+
+
+// * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
+
+template<class ContainerType>
+void Foam::circulator<ContainerType>::operator=
+(
+    const circulator<ContainerType>& rhs
+)
+{
+    // Check for assignment to self
+    if (this == &rhs)
+    {
+        FatalErrorIn
+        (
+            "Foam::circulator<ContainerType>::operator="
+            "(const Foam::circulator<ContainerType>&)"
+        )   << "Attempted assignment to self"
+            << abort(FatalError);
+    }
+
+    begin_ = rhs.begin_;
+    end_ = rhs.end_;
+    iter_ = rhs.iter_;
+    fulcrum_ = rhs.fulcrum_;
+}
+
+
+template<class ContainerType>
+Foam::circulator<ContainerType>&
+Foam::circulator<ContainerType>::operator++()
+{
+    ++iter_;
+    if (iter_ == end_)
+    {
+        iter_ = begin_;
+    }
+
+    return *this;
+}
+
+
+template<class ContainerType>
+Foam::circulator<ContainerType>
+Foam::circulator<ContainerType>::operator++(int)
+{
+    circulator<ContainerType> tmp = *this;
+    ++(*this);
+    return tmp;
+}
+
+
+template<class ContainerType>
+Foam::circulator<ContainerType>&
+Foam::circulator<ContainerType>::operator--()
+{
+    if (iter_ == begin_)
+    {
+        iter_ = end_;
+    }
+    --iter_;
+
+    return *this;
+}
+
+
+template<class ContainerType>
+Foam::circulator<ContainerType>
+Foam::circulator<ContainerType>::operator--(int)
+{
+    circulator<ContainerType> tmp = *this;
+    --(*this);
+    return tmp;
+}
+
+
+template<class ContainerType>
+bool Foam::circulator<ContainerType>::operator==
+(
+    const circulator<ContainerType>& c
+) const
+{
+    return
+    (
+        begin_ == c.begin_
+     && end_ == c.end_
+     && iter_ == c.iter_
+     && fulcrum_ == c.fulcrum_
+    );
+}
+
+
+template<class ContainerType>
+bool Foam::circulator<ContainerType>::operator!=
+(
+    const circulator<ContainerType>& c
+) const
+{
+    return !(*this == c);
+}
+
+
+template<class ContainerType>
+typename Foam::circulator<ContainerType>::reference
+Foam::circulator<ContainerType>::operator*() const
+{
+    return *iter_;
+}
+
+
+template<class ContainerType>
+typename Foam::circulator<ContainerType>::reference
+Foam::circulator<ContainerType>::operator()() const
+{
+    return operator*();
+}
+
+
+template<class ContainerType>
+typename Foam::circulator<ContainerType>::difference_type
+Foam::circulator<ContainerType>::operator-
+(
+    const circulator<ContainerType>& c
+) const
+{
+    return iter_ - c.iter_;
+}
+
+
+// ************************************************************************* //
diff --git a/src/OpenFOAM/containers/Circulators/const_circulator/const_circulator.H b/src/OpenFOAM/containers/Circulators/const_circulator/const_circulator.H
new file mode 100644
index 0000000000..fc8ba633aa
--- /dev/null
+++ b/src/OpenFOAM/containers/Circulators/const_circulator/const_circulator.H
@@ -0,0 +1,247 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 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::const_circulator
+
+Description
+    Walks over a container as if it were circular. The container must have the
+    following members defined:
+        - value_type
+        - size_type
+        - difference_type
+        - const_iterator
+        - const_reference
+
+    Examples:
+
+    \code
+        face f(identity(5));
+
+        // Construct circulator from the face
+        const_circulator<face> circ(f);
+
+        // First check that the circulator has a size to iterate over.
+        // Then circulate around the list starting and finishing at the fulcrum.
+        if (circ.size()) do
+        {
+            Info<< "Iterate forwards over face : " << circ() << endl;
+
+        } while (circ.circulate(CirculatorBase::CLOCKWISE));
+    \endcode
+
+    \code
+        face f(identity(5));
+
+        const_circulator<face> circClockwise(f);
+        const_circulator<face> circAnticlockwise(f);
+
+        if (circClockwise.size() && circAnticlockwise.size()) do
+        {
+            Info<< "Iterate forward over face :" << circClockwise() << endl;
+            Info<< "Iterate backward over face:" << circAnticlockwise() << endl;
+        }
+        while
+        (
+            circClockwise.circulate(CirculatorBase::CLOCKWISE),
+            circAnticlockwise.circulate(CirculatorBase::ANTICLOCKWISE)
+        );
+    \endcode
+
+SourceFiles
+    const_circulatorI.H
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef const_circulator_H
+#define const_circulator_H
+
+#include "CirculatorBase.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+
+/*---------------------------------------------------------------------------*\
+                      Class const_circulator Declaration
+\*---------------------------------------------------------------------------*/
+
+template<class ContainerType>
+class const_circulator
+:
+    public CirculatorBase
+{
+
+protected:
+
+    // Protected data
+
+        //- Iterator pointing to the beginning of the container
+        typename ContainerType::const_iterator begin_;
+
+        //- Iterator pointing to the end of the container
+        typename ContainerType::const_iterator end_;
+
+        //- Iterator
+        typename ContainerType::const_iterator iter_;
+
+        //- Iterator holding the location of the fulcrum (start and end) of
+        //  the container. Used to decide when the iterator should stop
+        //  circulating over the container
+        typename ContainerType::const_iterator fulcrum_;
+
+
+public:
+
+    // STL type definitions
+
+        //- Type of values ContainerType contains.
+        typedef typename ContainerType::value_type      value_type;
+
+        //- The type that can represent the size of ContainerType
+        typedef typename ContainerType::size_type       size_type;
+
+        //- The type that can represent the difference between any two
+        //  iterator objects.
+        typedef typename ContainerType::difference_type difference_type;
+
+        //- Random access iterator for traversing ContainerType.
+        typedef typename ContainerType::const_iterator  const_iterator;
+
+        //- Type that can be used for storing into
+        //  const ContainerType::value_type objects.
+        typedef typename ContainerType::const_reference const_reference;
+
+
+    // Constructors
+
+        //- Construct null
+        inline const_circulator();
+
+        //- Construct from a container.
+        inline explicit const_circulator(const ContainerType& container);
+
+        //- Construct from two iterators
+        inline const_circulator
+        (
+            const const_iterator& begin,
+            const const_iterator& end
+        );
+
+        //- Construct as copy
+        inline const_circulator(const const_circulator<ContainerType>&);
+
+
+    //- Destructor
+    ~const_circulator();
+
+
+    // Member Functions
+
+        //- Return the range of the iterator
+        inline size_type size() const;
+
+        //- Circulate around the list in the given direction
+        inline bool circulate(const CirculatorBase::direction dir = NONE);
+
+        //- Set the fulcrum to the current position of the iterator
+        inline void setFulcrumToIterator();
+
+        //- Set the iterator to the current position of the fulcrum
+        inline void setIteratorToFulcrum();
+
+        //- Return the distance between the iterator and the fulcrum. This is
+        //  equivalent to the number of rotations of the circulator.
+        inline difference_type nRotations() const;
+
+        //- Dereference the next iterator and return
+        inline const_reference next() const;
+
+        //- Dereference the previous iterator and return
+        inline const_reference prev() const;
+
+
+    // Member Operators
+
+        //- Assignment operator for circulators that operate on the same
+        //  container type
+        inline void operator=(const const_circulator<ContainerType>&);
+
+        //- Prefix increment. Increments the iterator.
+        //  Sets the iterator to the beginning of the container if it reaches
+        //  the end
+        inline const_circulator<ContainerType>& operator++();
+
+        //- Postfix increment. Increments the iterator.
+        //  Sets the iterator to the beginning of the container if it reaches
+        //  the end
+        inline const_circulator<ContainerType> operator++(int);
+
+        //- Prefix decrement. Decrements the iterator.
+        //  Sets the iterator to the end of the container if it reaches
+        //  the beginning
+        inline const_circulator<ContainerType>& operator--();
+
+        //- Postfix decrement. Decrements the iterator.
+        //  Sets the iterator to the end of the container if it reaches
+        //  the beginning
+        inline const_circulator<ContainerType> operator--(int);
+
+        //- Check for equality of this iterator with another iterator that
+        //  operate on the same container type
+        inline bool operator==(const const_circulator<ContainerType>& c) const;
+
+        //- Check for inequality of this iterator with another iterator that
+        //  operate on the same container type
+        inline bool operator!=(const const_circulator<ContainerType>& c) const;
+
+        //- Dereference the iterator and return
+        inline const_reference operator*() const;
+
+        //- Dereference the iterator and return
+        inline const_reference operator()() const;
+
+        //- Return the difference between this iterator and another iterator
+        //  that operate on the same container type
+        inline difference_type operator-
+        (
+            const const_circulator<ContainerType>& c
+        ) const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#include "const_circulatorI.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/OpenFOAM/containers/Circulators/const_circulator/const_circulatorI.H b/src/OpenFOAM/containers/Circulators/const_circulator/const_circulatorI.H
new file mode 100644
index 0000000000..47cdb69f06
--- /dev/null
+++ b/src/OpenFOAM/containers/Circulators/const_circulator/const_circulatorI.H
@@ -0,0 +1,293 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+template<class ContainerType>
+Foam::const_circulator<ContainerType>::const_circulator()
+:
+    CirculatorBase(),
+    begin_(0),
+    end_(0),
+    iter_(0),
+    fulcrum_(0)
+{}
+
+
+template<class ContainerType>
+Foam::const_circulator<ContainerType>::const_circulator
+(
+    const ContainerType& container
+)
+:
+    CirculatorBase(),
+    begin_(container.begin()),
+    end_(container.end()),
+    iter_(begin_),
+    fulcrum_(begin_)
+{}
+
+
+template<class ContainerType>
+Foam::const_circulator<ContainerType>::const_circulator
+(
+    const const_iterator& begin,
+    const const_iterator& end
+)
+:
+    CirculatorBase(),
+    begin_(begin),
+    end_(end),
+    iter_(begin),
+    fulcrum_(begin)
+{}
+
+
+template<class ContainerType>
+Foam::const_circulator<ContainerType>::const_circulator
+(
+    const const_circulator<ContainerType>& rhs
+)
+:
+    CirculatorBase(),
+    begin_(rhs.begin_),
+    end_(rhs.end_),
+    iter_(rhs.iter_),
+    fulcrum_(rhs.fulcrum_)
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructors * * * * * * * * * * * * * * * //
+
+template<class ContainerType>
+Foam::const_circulator<ContainerType>::~const_circulator()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+template<class ContainerType>
+typename Foam::const_circulator<ContainerType>::size_type
+Foam::const_circulator<ContainerType>::size() const
+{
+    return end_ - begin_;
+}
+
+
+template<class ContainerType>
+bool Foam::const_circulator<ContainerType>::circulate
+(
+    const CirculatorBase::direction dir
+)
+{
+    if (dir == CirculatorBase::CLOCKWISE)
+    {
+        operator++();
+    }
+    else if (dir == CirculatorBase::ANTICLOCKWISE)
+    {
+        operator--();
+    }
+
+    return !(iter_ == fulcrum_);
+}
+
+
+template<class ContainerType>
+void Foam::const_circulator<ContainerType>::setFulcrumToIterator()
+{
+    fulcrum_ = iter_;
+}
+
+
+template<class ContainerType>
+void Foam::const_circulator<ContainerType>::setIteratorToFulcrum()
+{
+    iter_ = fulcrum_;
+}
+
+
+template<class ContainerType>
+typename Foam::const_circulator<ContainerType>::difference_type
+Foam::const_circulator<ContainerType>::nRotations() const
+{
+    return (iter_ - fulcrum_);
+}
+
+
+template<class ContainerType>
+typename Foam::const_circulator<ContainerType>::const_reference
+Foam::const_circulator<ContainerType>::next() const
+{
+    if (iter_ == end_ - 1)
+    {
+        return *begin_;
+    }
+
+    return *(iter_ + 1);
+}
+
+
+template<class ContainerType>
+typename Foam::const_circulator<ContainerType>::const_reference
+Foam::const_circulator<ContainerType>::prev() const
+{
+    if (iter_ == begin_)
+    {
+        return *(end_ - 1);
+    }
+
+    return *(iter_ - 1);
+}
+
+
+// * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
+
+template<class ContainerType>
+void Foam::const_circulator<ContainerType>::operator=
+(
+    const const_circulator<ContainerType>& rhs
+)
+{
+    // Check for assignment to self
+    if (this == &rhs)
+    {
+        FatalErrorIn
+        (
+            "Foam::const_circulator<ContainerType>::operator="
+            "(const Foam::const_circulator<ContainerType>&)"
+        )   << "Attempted assignment to self"
+            << abort(FatalError);
+    }
+
+    begin_ = rhs.begin_;
+    end_ = rhs.end_;
+    iter_ = rhs.iter_;
+    fulcrum_ = rhs.fulcrum_;
+}
+
+
+template<class ContainerType>
+Foam::const_circulator<ContainerType>&
+Foam::const_circulator<ContainerType>::operator++()
+{
+    ++iter_;
+    if (iter_ == end_)
+    {
+        iter_ = begin_;
+    }
+
+    return *this;
+}
+
+
+template<class ContainerType>
+Foam::const_circulator<ContainerType>
+Foam::const_circulator<ContainerType>::operator++(int)
+{
+    const_circulator<ContainerType> tmp = *this;
+    ++(*this);
+    return tmp;
+}
+
+
+template<class ContainerType>
+Foam::const_circulator<ContainerType>&
+Foam::const_circulator<ContainerType>::operator--()
+{
+    if (iter_ == begin_)
+    {
+        iter_ = end_;
+    }
+    --iter_;
+
+    return *this;
+}
+
+
+template<class ContainerType>
+Foam::const_circulator<ContainerType>
+Foam::const_circulator<ContainerType>::operator--(int)
+{
+    const_circulator<ContainerType> tmp = *this;
+    --(*this);
+    return tmp;
+}
+
+
+template<class ContainerType>
+bool Foam::const_circulator<ContainerType>::operator==
+(
+    const const_circulator<ContainerType>& c
+) const
+{
+    return
+    (
+        begin_ == c.begin_
+     && end_ == c.end_
+     && iter_ == c.iter_
+     && fulcrum_ == c.fulcrum_
+    );
+}
+
+
+template<class ContainerType>
+bool Foam::const_circulator<ContainerType>::operator!=
+(
+    const const_circulator<ContainerType>& c
+) const
+{
+    return !(*this == c);
+}
+
+
+template<class ContainerType>
+typename Foam::const_circulator<ContainerType>::const_reference
+Foam::const_circulator<ContainerType>::operator*() const
+{
+    return *iter_;
+}
+
+
+template<class ContainerType>
+typename Foam::const_circulator<ContainerType>::const_reference
+Foam::const_circulator<ContainerType>::operator()() const
+{
+    return operator*();
+}
+
+
+template<class ContainerType>
+typename Foam::const_circulator<ContainerType>::difference_type
+Foam::const_circulator<ContainerType>::operator-
+(
+    const const_circulator<ContainerType>& c
+) const
+{
+    return iter_ - c.iter_;
+}
+
+
+// ************************************************************************* //
diff --git a/src/OpenFOAM/containers/HashTables/HashTable/HashTableCore.C b/src/OpenFOAM/containers/HashTables/HashTable/HashTableCore.C
index 7058ac6139..58fcdf27b1 100644
--- a/src/OpenFOAM/containers/HashTables/HashTable/HashTableCore.C
+++ b/src/OpenFOAM/containers/HashTables/HashTable/HashTableCore.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -28,7 +28,10 @@ License
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-defineTypeNameAndDebug(Foam::HashTableCore, 0);
+namespace Foam
+{
+defineTypeNameAndDebug(HashTableCore, 0);
+}
 
 const Foam::label Foam::HashTableCore::maxTableSize
 (
@@ -38,6 +41,7 @@ const Foam::label Foam::HashTableCore::maxTableSize
     )
 );
 
+
 // * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
 
 Foam::label Foam::HashTableCore::canonicalSize(const label size)
diff --git a/src/OpenFOAM/containers/HashTables/StaticHashTable/StaticHashTableCore.C b/src/OpenFOAM/containers/HashTables/StaticHashTable/StaticHashTableCore.C
index 380317fdc1..760839b0c6 100644
--- a/src/OpenFOAM/containers/HashTables/StaticHashTable/StaticHashTableCore.C
+++ b/src/OpenFOAM/containers/HashTables/StaticHashTable/StaticHashTableCore.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -27,6 +27,10 @@ License
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-defineTypeNameAndDebug(Foam::StaticHashTableCore, 0);
+namespace Foam
+{
+defineTypeNameAndDebug(StaticHashTableCore, 0);
+}
+
 
 // ************************************************************************* //
diff --git a/src/OpenFOAM/containers/Lists/ListOps/ListOps.H b/src/OpenFOAM/containers/Lists/ListOps/ListOps.H
index 86fdc7ba51..8da376020d 100644
--- a/src/OpenFOAM/containers/Lists/ListOps/ListOps.H
+++ b/src/OpenFOAM/containers/Lists/ListOps/ListOps.H
@@ -254,6 +254,27 @@ public:
 };
 
 
+//- Reverse a list. First element becomes last element etc.
+template <class ListType>
+ListType reverseList(const ListType& list);
+
+
+//- Inplace reversal of a list using Swap.
+template <class ListType>
+void inplaceReverseList(ListType& list);
+
+
+//- Rotate a list by n places. If n is positive rotate clockwise/right/down.
+//  If n is negative rotate anti-clockwise/left/up.
+template <class ListType>
+ListType rotateList(const ListType& list, const label n);
+
+
+//- Inplace reversal of a list using the Reversal Block Swapping algorithm.
+template <template <typename> class ListType, class DataType>
+void inplaceRotateList(ListType<DataType>& list, label n);
+
+
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 } // End namespace Foam
diff --git a/src/OpenFOAM/containers/Lists/ListOps/ListOpsTemplates.C b/src/OpenFOAM/containers/Lists/ListOps/ListOpsTemplates.C
index 49daa408c1..d55e3fd982 100644
--- a/src/OpenFOAM/containers/Lists/ListOps/ListOpsTemplates.C
+++ b/src/OpenFOAM/containers/Lists/ListOps/ListOpsTemplates.C
@@ -706,4 +706,83 @@ void Foam::ListAppendEqOp<T>::operator()(List<T>& x, const List<T>& y) const
 }
 
 
+template <class ListType>
+ListType Foam::reverseList(const ListType& list)
+{
+    const label listSize = list.size();
+    const label lastIndex = listSize - 1;
+
+    ListType tmpList(listSize);
+
+    forAll(tmpList, elemI)
+    {
+        tmpList[elemI] = list[lastIndex - elemI];
+    }
+
+    return tmpList;
+}
+
+
+template <class ListType>
+void Foam::inplaceReverseList(ListType& list)
+{
+    const label listSize = list.size();
+    const label lastIndex = listSize - 1;
+    const label nIterations = listSize >> 1;
+
+    label elemI = 0;
+    while (elemI < nIterations)
+    {
+        Swap(list[elemI], list[lastIndex - elemI]);
+
+        elemI++;
+    }
+}
+
+
+template <class ListType>
+ListType Foam::rotateList(const ListType& list, const label n)
+{
+    const label listSize = list.size();
+
+    ListType tmpList(listSize);
+
+    forAll(tmpList, elemI)
+    {
+        label index = (elemI - n) % listSize;
+
+        if (index < 0)
+        {
+            index += listSize;
+        }
+
+        tmpList[elemI] = list[index];
+    }
+
+    return tmpList;
+}
+
+
+template <template <typename> class ListType, class DataType>
+void Foam::inplaceRotateList(ListType<DataType>& list, label n)
+{
+    const label listSize = list.size();
+
+    n = (listSize - n) % listSize;
+
+    if (n < 0)
+    {
+        n += listSize;
+    }
+
+    SubList<DataType> firstHalf(list, n, 0);
+    SubList<DataType> secondHalf(list, listSize - n, n);
+
+    inplaceReverseList(firstHalf);
+    inplaceReverseList(secondHalf);
+
+    inplaceReverseList(list);
+}
+
+
 // ************************************************************************* //
diff --git a/src/OpenFOAM/containers/Lists/PackedList/PackedListCore.C b/src/OpenFOAM/containers/Lists/PackedList/PackedListCore.C
index 9b69437698..92f3b3603d 100644
--- a/src/OpenFOAM/containers/Lists/PackedList/PackedListCore.C
+++ b/src/OpenFOAM/containers/Lists/PackedList/PackedListCore.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -27,7 +27,10 @@ License
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-defineTypeNameAndDebug(Foam::PackedListCore, 0);
+namespace Foam
+{
+defineTypeNameAndDebug(PackedListCore, 0);
+}
 
 
 // ************************************************************************* //
diff --git a/src/OpenFOAM/containers/Lists/SortableList/ParSortableListName.C b/src/OpenFOAM/containers/Lists/SortableList/ParSortableListName.C
index 654633f7cc..8818406b15 100644
--- a/src/OpenFOAM/containers/Lists/SortableList/ParSortableListName.C
+++ b/src/OpenFOAM/containers/Lists/SortableList/ParSortableListName.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -27,6 +27,10 @@ License
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-defineTypeNameAndDebug(Foam::ParSortableListName, 0);
+namespace Foam
+{
+defineTypeNameAndDebug(ParSortableListName, 0);
+}
+
 
 // ************************************************************************* //
diff --git a/src/OpenFOAM/db/CallbackRegistry/CallbackRegistryName.C b/src/OpenFOAM/db/CallbackRegistry/CallbackRegistryName.C
index 313dafb491..6251032e8b 100644
--- a/src/OpenFOAM/db/CallbackRegistry/CallbackRegistryName.C
+++ b/src/OpenFOAM/db/CallbackRegistry/CallbackRegistryName.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -27,6 +27,10 @@ License
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-defineTypeNameAndDebug(Foam::CallbackRegistryName, 0);
+namespace Foam
+{
+defineTypeNameAndDebug(CallbackRegistryName, 0);
+}
+
 
 // ************************************************************************* //
diff --git a/src/OpenFOAM/db/IOobject/IOobject.C b/src/OpenFOAM/db/IOobject/IOobject.C
index 47e14b0577..a603a76dd9 100644
--- a/src/OpenFOAM/db/IOobject/IOobject.C
+++ b/src/OpenFOAM/db/IOobject/IOobject.C
@@ -29,7 +29,11 @@ License
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-defineTypeNameAndDebug(Foam::IOobject, 0);
+namespace Foam
+{
+defineTypeNameAndDebug(IOobject, 0);
+}
+
 
 // * * * * * * * * * * * * Static Member Functions * * * * * * * * * * * * * //
 
diff --git a/src/OpenFOAM/db/IOobjects/IOdictionary/IOdictionary.C b/src/OpenFOAM/db/IOobjects/IOdictionary/IOdictionary.C
index a21be89f8a..75dbaa8dd4 100644
--- a/src/OpenFOAM/db/IOobjects/IOdictionary/IOdictionary.C
+++ b/src/OpenFOAM/db/IOobjects/IOdictionary/IOdictionary.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -29,12 +29,15 @@ License
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-defineTypeNameAndDebug(Foam::IOdictionary, 0);
+namespace Foam
+{
+defineTypeNameAndDebug(IOdictionary, 0);
 
-bool Foam::IOdictionary::writeDictionaries
+bool IOdictionary::writeDictionaries
 (
-    Foam::debug::infoSwitch("writeDictionaries", 0)
+    debug::infoSwitch("writeDictionaries", 0)
 );
+}
 
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
diff --git a/src/OpenFOAM/db/IOstreams/Fstreams/IFstream.C b/src/OpenFOAM/db/IOstreams/Fstreams/IFstream.C
index fb2480f413..3c62255d97 100644
--- a/src/OpenFOAM/db/IOstreams/Fstreams/IFstream.C
+++ b/src/OpenFOAM/db/IOstreams/Fstreams/IFstream.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -29,7 +29,10 @@ License
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-defineTypeNameAndDebug(Foam::IFstream, 0);
+namespace Foam
+{
+defineTypeNameAndDebug(IFstream, 0);
+}
 
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
diff --git a/src/OpenFOAM/db/IOstreams/Fstreams/OFstream.C b/src/OpenFOAM/db/IOstreams/Fstreams/OFstream.C
index da9fc290a2..3feefdaf40 100644
--- a/src/OpenFOAM/db/IOstreams/Fstreams/OFstream.C
+++ b/src/OpenFOAM/db/IOstreams/Fstreams/OFstream.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -29,7 +29,10 @@ License
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-defineTypeNameAndDebug(Foam::OFstream, 0);
+namespace Foam
+{
+defineTypeNameAndDebug(OFstream, 0);
+}
 
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
diff --git a/src/OpenFOAM/db/IOstreams/Pstreams/Pstream.C b/src/OpenFOAM/db/IOstreams/Pstreams/Pstream.C
index 7a1ebeb9ac..314651c629 100644
--- a/src/OpenFOAM/db/IOstreams/Pstreams/Pstream.C
+++ b/src/OpenFOAM/db/IOstreams/Pstreams/Pstream.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -27,13 +27,10 @@ License
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-defineTypeNameAndDebug(Foam::Pstream, 0);
-
-
-// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
-
-
-// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+namespace Foam
+{
+defineTypeNameAndDebug(Pstream, 0);
+}
 
 
 // ************************************************************************* //
diff --git a/src/OpenFOAM/db/IOstreams/Pstreams/UPstream.C b/src/OpenFOAM/db/IOstreams/Pstreams/UPstream.C
index d0a3d87276..2f1611a5e2 100644
--- a/src/OpenFOAM/db/IOstreams/Pstreams/UPstream.C
+++ b/src/OpenFOAM/db/IOstreams/Pstreams/UPstream.C
@@ -30,10 +30,10 @@ License
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-defineTypeNameAndDebug(Foam::UPstream, 0);
-
 namespace Foam
 {
+    defineTypeNameAndDebug(UPstream, 0);
+
     template<>
     const char* Foam::NamedEnum
     <
diff --git a/src/OpenFOAM/db/IOstreams/token/token.C b/src/OpenFOAM/db/IOstreams/token/token.C
index 53eadb70ed..d90f7f2b20 100644
--- a/src/OpenFOAM/db/IOstreams/token/token.C
+++ b/src/OpenFOAM/db/IOstreams/token/token.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -27,11 +27,14 @@ License
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-const char* const Foam::token::typeName = "token";
-Foam::token Foam::token::undefinedToken;
+namespace Foam
+{
+const char* const token::typeName = "token";
+token token::undefinedToken;
 
-defineTypeNameAndDebug(Foam::token::compound, 0);
-defineRunTimeSelectionTable(Foam::token::compound, Istream);
+defineTypeNameAndDebug(token::compound, 0);
+defineRunTimeSelectionTable(token::compound, Istream);
+}
 
 
 // * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * * //
diff --git a/src/OpenFOAM/db/Time/Time.C b/src/OpenFOAM/db/Time/Time.C
index b589dfc883..1bcf42e5dc 100644
--- a/src/OpenFOAM/db/Time/Time.C
+++ b/src/OpenFOAM/db/Time/Time.C
@@ -31,10 +31,10 @@ License
 
 // * * * * * * * * * * * * * Static Member Data  * * * * * * * * * * * * * * //
 
-defineTypeNameAndDebug(Foam::Time, 0);
-
 namespace Foam
 {
+    defineTypeNameAndDebug(Time, 0);
+
     template<>
     const char* Foam::NamedEnum
     <
diff --git a/src/OpenFOAM/db/Time/TimeIO.C b/src/OpenFOAM/db/Time/TimeIO.C
index 1637d35bfc..cace29f02f 100644
--- a/src/OpenFOAM/db/Time/TimeIO.C
+++ b/src/OpenFOAM/db/Time/TimeIO.C
@@ -25,6 +25,7 @@ License
 
 #include "Time.H"
 #include "Pstream.H"
+#include "simpleObjectRegistry.H"
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
@@ -37,6 +38,86 @@ void Foam::Time::readDict()
         setEnv("FOAM_APPLICATION", application, false);
     }
 
+
+    // Check for local switches and settings
+    if (controlDict_.found("DebugSwitches"))
+    {
+        simpleObjectRegistry& objects = debug::debugObjects();
+        const dictionary& localSettings = controlDict_.subDict("DebugSwitches");
+        forAllConstIter(dictionary, localSettings, iter)
+        {
+            const word& name = iter().keyword();
+            simpleObjectRegistry::iterator fnd = objects.find(name);
+            if (fnd != objects.end())
+            {
+                Info<< controlDict_.name() << " : overriding debug switch "
+                    << name << endl;
+
+                if (iter().isDict())
+                {
+                    OStringStream os(IOstream::ASCII);
+                    os  << iter().dict();
+                    IStringStream is(os.str());
+                    fnd()->readData(is);
+                }
+                else
+                {
+                    fnd()->readData(iter().stream());
+                }
+            }
+        }
+    }
+    if (controlDict_.found("DimensionSets"))
+    {
+        dictionary dict(Foam::dimensionSystems());
+        dict.merge(controlDict_.subDict("DimensionSets"));
+
+        simpleObjectRegistry& objects = debug::dimensionSetObjects();
+        simpleObjectRegistry::iterator fnd = objects.find("DimensionSets");
+        if (fnd != objects.end())
+        {
+            Info<< controlDict_.name() << " : overriding DimensionSets" << endl;
+
+            OStringStream os(IOstream::ASCII);
+            os  << dict;
+            IStringStream is(os.str());
+            fnd()->readData(is);
+        }
+    }
+    if (controlDict_.found("OptimisationSwitches"))
+    {
+        simpleObjectRegistry& objects = debug::optimisationObjects();
+        const dictionary& localSettings = controlDict_.subDict
+        (
+            "OptimisationSwitches"
+        );
+        forAllConstIter(dictionary, localSettings, iter)
+        {
+            const word& name = iter().keyword();
+            simpleObjectRegistry::iterator fnd = objects.find(name);
+            if (fnd != objects.end())
+            {
+                Info<< controlDict_.name()
+                    << " : overriding optimisation switch "
+                    << name << endl;
+
+                if (iter().isDict())
+                {
+                    OStringStream os(IOstream::ASCII);
+                    os  << iter().dict();
+                    IStringStream is(os.str());
+                    fnd()->readData(is);
+                }
+                else
+                {
+                    fnd()->readData(iter().stream());
+                }
+            }
+        }
+    }
+
+
+
     if (!deltaTchanged_)
     {
         deltaT_ = readScalar(controlDict_.lookup("deltaT"));
diff --git a/src/OpenFOAM/db/dictionary/dictionary.C b/src/OpenFOAM/db/dictionary/dictionary.C
index 2a2ae85253..e6f7c6c7db 100644
--- a/src/OpenFOAM/db/dictionary/dictionary.C
+++ b/src/OpenFOAM/db/dictionary/dictionary.C
@@ -31,9 +31,11 @@ License
 
 /* * * * * * * * * * * * * * * Static Member Data  * * * * * * * * * * * * * */
 
-defineTypeNameAndDebug(Foam::dictionary, 0);
-
-const Foam::dictionary Foam::dictionary::null;
+namespace Foam
+{
+defineTypeNameAndDebug(dictionary, 0);
+const dictionary dictionary::null;
+}
 
 
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
diff --git a/src/OpenFOAM/db/dynamicLibrary/dlLibraryTable/dlLibraryTable.C b/src/OpenFOAM/db/dynamicLibrary/dlLibraryTable/dlLibraryTable.C
index 48bc178ac6..43229b18fd 100644
--- a/src/OpenFOAM/db/dynamicLibrary/dlLibraryTable/dlLibraryTable.C
+++ b/src/OpenFOAM/db/dynamicLibrary/dlLibraryTable/dlLibraryTable.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -29,7 +29,10 @@ License
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-defineTypeNameAndDebug(Foam::dlLibraryTable, 0);
+namespace Foam
+{
+defineTypeNameAndDebug(dlLibraryTable, 0);
+}
 
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
diff --git a/src/OpenFOAM/db/functionObjects/functionObject/functionObject.C b/src/OpenFOAM/db/functionObjects/functionObject/functionObject.C
index c67b51ce82..2e67818359 100644
--- a/src/OpenFOAM/db/functionObjects/functionObject/functionObject.C
+++ b/src/OpenFOAM/db/functionObjects/functionObject/functionObject.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -30,8 +30,11 @@ License
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-defineRunTimeSelectionTable(Foam::functionObject, dictionary);
-int Foam::functionObject::debug(Foam::debug::debugSwitch("functionObject", 0));
+namespace Foam
+{
+defineDebugSwitchWithName(functionObject, "functionObject", 0);
+defineRunTimeSelectionTable(functionObject, dictionary);
+}
 
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
diff --git a/src/OpenFOAM/db/objectRegistry/objectRegistry.C b/src/OpenFOAM/db/objectRegistry/objectRegistry.C
index 09307c3a5c..4903ca4e28 100644
--- a/src/OpenFOAM/db/objectRegistry/objectRegistry.C
+++ b/src/OpenFOAM/db/objectRegistry/objectRegistry.C
@@ -28,7 +28,10 @@ License
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-defineTypeNameAndDebug(Foam::objectRegistry, 0);
+namespace Foam
+{
+defineTypeNameAndDebug(objectRegistry, 0);
+}
 
 
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
diff --git a/src/OpenFOAM/db/regIOobject/regIOobject.C b/src/OpenFOAM/db/regIOobject/regIOobject.C
index 5d8d9972e2..a01634d344 100644
--- a/src/OpenFOAM/db/regIOobject/regIOobject.C
+++ b/src/OpenFOAM/db/regIOobject/regIOobject.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -29,19 +29,19 @@ License
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-defineTypeNameAndDebug(Foam::regIOobject, 0);
-
-int Foam::regIOobject::fileModificationSkew
-(
-    Foam::debug::optimisationSwitch("fileModificationSkew", 30)
-);
-
 namespace Foam
 {
+    defineTypeNameAndDebug(regIOobject, 0);
+
+    int regIOobject::fileModificationSkew
+    (
+        debug::optimisationSwitch("fileModificationSkew", 30)
+    );
+
     template<>
-    const char* Foam::NamedEnum
+    const char* NamedEnum
     <
-        Foam::regIOobject::fileCheckTypes,
+        regIOobject::fileCheckTypes,
         4
     >::names[] =
     {
diff --git a/src/OpenFOAM/db/typeInfo/className.H b/src/OpenFOAM/db/typeInfo/className.H
index fa1f4bfdb6..a6a247d234 100644
--- a/src/OpenFOAM/db/typeInfo/className.H
+++ b/src/OpenFOAM/db/typeInfo/className.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -137,6 +137,30 @@ public:                                                                       \
 // definitions (debug information only)
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
+//- Define the debug information, lookup as \a Name
+#define registerDebugSwitchWithName(Type,Tag,Name)\
+    class add##Tag##ToDebug\
+    :\
+        public ::Foam::simpleRegIOobject\
+    {\
+    public:\
+        add##Tag##ToDebug(const char* name)\
+        :\
+            ::Foam::simpleRegIOobject(Foam::debug::addDebugObject, name)\
+        {}\
+        virtual ~add##Tag##ToDebug()\
+        {}\
+        virtual void readData(Foam::Istream& is)\
+        {\
+            Type::debug = readLabel(is);\
+        }\
+        virtual void writeData(Foam::Ostream& os) const\
+        {\
+            os << Type::debug;\
+        }\
+    };\
+    add##Tag##ToDebug add##Tag##ToDebug_(Name)
+
 
 //- Define the debug information, lookup as \a Name
 #define defineDebugSwitchWithName(Type, Name, DebugSwitch)                    \
diff --git a/src/OpenFOAM/dimensionSet/dimensionSet.C b/src/OpenFOAM/dimensionSet/dimensionSet.C
index 64396290eb..eb13cdf60b 100644
--- a/src/OpenFOAM/dimensionSet/dimensionSet.C
+++ b/src/OpenFOAM/dimensionSet/dimensionSet.C
@@ -29,8 +29,11 @@ License
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-defineTypeNameAndDebug(Foam::dimensionSet, 1);
-const Foam::scalar Foam::dimensionSet::smallExponent = SMALL;
+namespace Foam
+{
+defineTypeNameAndDebug(dimensionSet, 1);
+const scalar dimensionSet::smallExponent = SMALL;
+}
 
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
diff --git a/src/OpenFOAM/dimensionSet/dimensionSets.C b/src/OpenFOAM/dimensionSet/dimensionSets.C
index 474be10181..7486781df8 100644
--- a/src/OpenFOAM/dimensionSet/dimensionSets.C
+++ b/src/OpenFOAM/dimensionSet/dimensionSets.C
@@ -25,13 +25,15 @@ License
 
 #include "dimensionSet.H"
 #include "dimensionedScalar.H"
+#include "simpleRegIOobject.H"
+#include "demandDrivenData.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 namespace Foam
 {
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+/* * * * * * * * * * * * * * * Static Member Data  * * * * * * * * * * * * * */
 
 dictionary* dimensionSystemsPtr_(NULL);
 
@@ -45,11 +47,35 @@ dictionary& dimensionSystems()
 }
 
 
-/* * * * * * * * * * * * * * * Static Member Data  * * * * * * * * * * * * * */
-
 autoPtr<HashTable<dimensionedScalar> > unitSetPtr_;
 autoPtr<dimensionSets> writeUnitSetPtr_;
 
+class addDimensionSetsToDebug
+:
+    public ::Foam::simpleRegIOobject
+{
+public:
+    addDimensionSetsToDebug(const char* name)
+    :
+        ::Foam::simpleRegIOobject(Foam::debug::addDimensionSetObject, name)
+    {}
+    virtual ~addDimensionSetsToDebug()
+    {}
+    virtual void readData(Foam::Istream& is)
+    {
+        deleteDemandDrivenData(dimensionSystemsPtr_);
+        unitSetPtr_.clear();
+        writeUnitSetPtr_.clear();
+        dimensionSystemsPtr_ = new dictionary(is);
+    }
+    virtual void writeData(Foam::Ostream& os) const
+    {
+        os << dimensionSystems();
+    }
+};
+addDimensionSetsToDebug addDimensionSetsToDebug_("DimensionSets");
+
+
 
 const HashTable<dimensionedScalar>& unitSet()
 {
diff --git a/src/OpenFOAM/fields/Fields/fieldTypes.H b/src/OpenFOAM/fields/Fields/fieldTypes.H
index f0f27039dc..59b37b88d9 100644
--- a/src/OpenFOAM/fields/Fields/fieldTypes.H
+++ b/src/OpenFOAM/fields/Fields/fieldTypes.H
@@ -36,6 +36,7 @@ Description
 #include "sphericalTensor.H"
 #include "symmTensor.H"
 #include "tensor.H"
+#include "triad.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
diff --git a/src/OpenFOAM/fields/Fields/triadField/triadField.C b/src/OpenFOAM/fields/Fields/triadField/triadField.C
new file mode 100644
index 0000000000..56d2fdd657
--- /dev/null
+++ b/src/OpenFOAM/fields/Fields/triadField/triadField.C
@@ -0,0 +1,46 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 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 "triadField.H"
+#include "transformField.H"
+
+#define TEMPLATE
+#include "FieldFunctionsM.C"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#include "undefFieldFunctionsM.H"
+
+// ************************************************************************* //
diff --git a/src/OpenFOAM/fields/Fields/triadField/triadField.H b/src/OpenFOAM/fields/Fields/triadField/triadField.H
new file mode 100644
index 0000000000..c31f1ab2d4
--- /dev/null
+++ b/src/OpenFOAM/fields/Fields/triadField/triadField.H
@@ -0,0 +1,63 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 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/>.
+
+Typedef
+    Foam::triadField
+
+Description
+    Specialisation of Field\<T\> for triad.
+
+SourceFiles
+    triadField.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef triadField_H
+#define triadField_H
+
+#include "Field.H"
+#include "triad.H"
+
+#define TEMPLATE
+#include "FieldFunctionsM.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+typedef Field<triad> triadField;
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#include "undefFieldFunctionsM.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/OpenFOAM/fields/Fields/triadField/triadIOField.C b/src/OpenFOAM/fields/Fields/triadField/triadIOField.C
new file mode 100644
index 0000000000..a27e1ef6e7
--- /dev/null
+++ b/src/OpenFOAM/fields/Fields/triadField/triadIOField.C
@@ -0,0 +1,38 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 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/>.
+
+Description
+    triadField with IO.
+
+\*---------------------------------------------------------------------------*/
+
+#include "triadIOField.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTemplateTypeNameAndDebugWithName(triadIOField, "triadField", 0);
+}
+
+// ************************************************************************* //
diff --git a/src/OpenFOAM/fields/Fields/triadField/triadIOField.H b/src/OpenFOAM/fields/Fields/triadField/triadIOField.H
new file mode 100644
index 0000000000..b1eb0b0098
--- /dev/null
+++ b/src/OpenFOAM/fields/Fields/triadField/triadIOField.H
@@ -0,0 +1,49 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 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/>.
+
+Typedef
+    Foam::triadIOField
+
+Description
+    triadField with IO.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef triadIOField_H
+#define triadIOField_H
+
+#include "triadField.H"
+#include "IOField.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    typedef IOField<triad> triadIOField;
+}
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/OpenFOAM/fields/cloud/cloud.C b/src/OpenFOAM/fields/cloud/cloud.C
index 74f296fa0d..cae1cce299 100644
--- a/src/OpenFOAM/fields/cloud/cloud.C
+++ b/src/OpenFOAM/fields/cloud/cloud.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -28,10 +28,14 @@ License
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-defineTypeNameAndDebug(Foam::cloud, 0);
+namespace Foam
+{
+defineTypeNameAndDebug(cloud, 0);
+
+const word cloud::prefix("lagrangian");
+word cloud::defaultName("defaultCloud");
+}
 
-const Foam::word Foam::cloud::prefix("lagrangian");
-Foam::word Foam::cloud::defaultName("defaultCloud");
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
diff --git a/src/OpenFOAM/global/debug/debug.C b/src/OpenFOAM/global/debug/debug.C
index cd2a0b2486..2abbc5826d 100644
--- a/src/OpenFOAM/global/debug/debug.C
+++ b/src/OpenFOAM/global/debug/debug.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -30,6 +30,9 @@ Description
 #include "dictionary.H"
 #include "IFstream.H"
 #include "OSspecific.H"
+#include "Ostream.H"
+#include "demandDrivenData.H"
+#include "simpleObjectRegistry.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -54,15 +57,35 @@ public:
 
     ~deleteControlDictPtr()
     {
-        if (controlDictPtr_)
-        {
-            delete controlDictPtr_;
-            controlDictPtr_ = 0;
-        }
+        deleteDemandDrivenData(controlDictPtr_);
     }
 };
 
 deleteControlDictPtr deleteControlDictPtr_;
+
+
+// Debug switch read and write callback tables.
+simpleObjectRegistry* debugObjectsPtr_(NULL);
+simpleObjectRegistry* infoObjectsPtr_(NULL);
+simpleObjectRegistry* optimisationObjectsPtr_(NULL);
+simpleObjectRegistry* dimensionSetObjectsPtr_(NULL);
+class deleteDebugSwitchPtr
+{
+public:
+
+    deleteDebugSwitchPtr()
+    {}
+
+    ~deleteDebugSwitchPtr()
+    {
+        deleteDemandDrivenData(debugObjectsPtr_);
+        deleteDemandDrivenData(infoObjectsPtr_);
+        deleteDemandDrivenData(optimisationObjectsPtr_);
+        deleteDemandDrivenData(dimensionSetObjectsPtr_);
+    }
+};
+
+deleteDebugSwitchPtr deleteDebugSwitchPtr_;
 //! \endcond
 
 
@@ -165,6 +188,82 @@ int Foam::debug::optimisationSwitch(const char* name, const int defaultValue)
 }
 
 
+void Foam::debug::addDebugObject(const char* name, simpleRegIOobject* obj)
+{
+    debugObjects().insert(name, obj);
+}
+
+
+void Foam::debug::addInfoObject(const char* name, simpleRegIOobject* obj)
+{
+    infoObjects().insert(name, obj);
+}
+
+
+void Foam::debug::addOptimisationObject
+(
+    const char* name,
+    simpleRegIOobject* obj
+)
+{
+    optimisationObjects().insert(name, obj);
+}
+
+
+void Foam::debug::addDimensionSetObject
+(
+    const char* name,
+    simpleRegIOobject* obj
+)
+{
+    dimensionSetObjects().insert(name, obj);
+}
+
+
+Foam::simpleObjectRegistry& Foam::debug::debugObjects()
+{
+    if (!debugObjectsPtr_)
+    {
+        debugObjectsPtr_ = new simpleObjectRegistry(1000);
+    }
+
+    return *debugObjectsPtr_;
+}
+
+
+Foam::simpleObjectRegistry& Foam::debug::infoObjects()
+{
+    if (!infoObjectsPtr_)
+    {
+        infoObjectsPtr_ = new simpleObjectRegistry(1000);
+    }
+
+    return *infoObjectsPtr_;
+}
+
+
+Foam::simpleObjectRegistry& Foam::debug::optimisationObjects()
+{
+    if (!optimisationObjectsPtr_)
+    {
+        optimisationObjectsPtr_ = new simpleObjectRegistry(1000);
+    }
+
+    return *optimisationObjectsPtr_;
+}
+
+
+Foam::simpleObjectRegistry& Foam::debug::dimensionSetObjects()
+{
+    if (!dimensionSetObjectsPtr_)
+    {
+        dimensionSetObjectsPtr_ = new simpleObjectRegistry(1000);
+    }
+
+    return *dimensionSetObjectsPtr_;
+}
+
+
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 
diff --git a/src/OpenFOAM/global/debug/debug.H b/src/OpenFOAM/global/debug/debug.H
index b941fcbb7e..09697c57a7 100644
--- a/src/OpenFOAM/global/debug/debug.H
+++ b/src/OpenFOAM/global/debug/debug.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -42,6 +42,10 @@ namespace Foam
 
 // Forward declaration of classes
 class dictionary;
+class Istream;
+class Ostream;
+class simpleRegIOobject;
+class simpleObjectRegistry;
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -73,6 +77,36 @@ namespace debug
     //- Internal function to lookup a sub-dictionary from controlDict.
     dictionary& switchSet(const char* subDictName, dictionary*& subDictPtr);
 
+
+
+    // Registered debug switches
+
+        //- Register debug switch read/write object
+        void addDebugObject(const char* name, simpleRegIOobject* obj);
+
+        //- Register info switch read/write object
+        void addInfoObject(const char* name, simpleRegIOobject* obj);
+
+        //- Register optimisation switch read/write object
+        void addOptimisationObject(const char* name, simpleRegIOobject* obj);
+
+        //- Register DimensionSets read/write object
+        void addDimensionSetObject(const char* name, simpleRegIOobject* obj);
+
+
+        //- Get access to registered debug switch objects
+        simpleObjectRegistry& debugObjects();
+
+        //- Get access to registered info switch objects
+        simpleObjectRegistry& infoObjects();
+
+        //- Get access to registered optimisation switch objects
+        simpleObjectRegistry& optimisationObjects();
+
+        //- Get access to registered dimensionSets switch objects
+        simpleObjectRegistry& dimensionSetObjects();
+
+
 } // End namespace debug
 
 
diff --git a/src/OpenFOAM/global/debug/simpleObjectRegistry.H b/src/OpenFOAM/global/debug/simpleObjectRegistry.H
new file mode 100644
index 0000000000..61d0931f49
--- /dev/null
+++ b/src/OpenFOAM/global/debug/simpleObjectRegistry.H
@@ -0,0 +1,74 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 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::simpleObjectRegistry
+
+Description
+    Object registry for simpleRegIOobject
+
+SourceFiles
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef simpleObjectRegistry_H
+#define simpleObjectRegistry_H
+
+#include "HashTable.H"
+#include "simpleRegIOobject.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                         Class simpleObjectRegistry Declaration
+\*---------------------------------------------------------------------------*/
+
+class simpleObjectRegistry
+:
+    public HashTable<simpleRegIOobject*>
+{
+public:
+
+    // Constructors
+
+        //- Construct from initial estimate
+        simpleObjectRegistry(const label nIoObjects = 128)
+        :
+            HashTable<simpleRegIOobject*>(nIoObjects)
+        {}
+
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/OpenFOAM/global/debug/simpleRegIOobject.H b/src/OpenFOAM/global/debug/simpleRegIOobject.H
new file mode 100644
index 0000000000..c7ede5e818
--- /dev/null
+++ b/src/OpenFOAM/global/debug/simpleRegIOobject.H
@@ -0,0 +1,92 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 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::simpleRegIOobject
+
+Description
+    Abstract base class for registered object with I/O. Used in debug symbol
+    registration.
+
+SourceFiles
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef simpleRegIOobject_H
+#define simpleRegIOobject_H
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// Forward declaration of classes
+class Istream;
+class Ostream;
+
+/*---------------------------------------------------------------------------*\
+                         Class simpleRegIOobject Declaration
+\*---------------------------------------------------------------------------*/
+
+class simpleRegIOobject
+{
+public:
+
+    // Constructors
+
+        //- Construct from objectregistry inserter and name
+        simpleRegIOobject
+        (
+            void (*fn)(const char* name, simpleRegIOobject*),
+            const char* name
+        )
+        {
+            (*fn)(name, this);
+        }
+
+
+    //- Destructor
+    virtual ~simpleRegIOobject()
+    {};
+
+
+    // Member Functions
+
+        //- Read
+        virtual void readData(Istream&) = 0;
+
+        //- Write
+        virtual void writeData(Ostream&) const = 0;
+
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/OpenFOAM/graph/writers/gnuplotGraph/gnuplotGraph.C b/src/OpenFOAM/graph/writers/gnuplotGraph/gnuplotGraph.C
index ef2a2ddf71..1b00ef40b9 100644
--- a/src/OpenFOAM/graph/writers/gnuplotGraph/gnuplotGraph.C
+++ b/src/OpenFOAM/graph/writers/gnuplotGraph/gnuplotGraph.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -28,11 +28,11 @@ License
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-defineTypeNameAndDebug(Foam::gnuplotGraph, 0);
-const Foam::word Foam::gnuplotGraph::ext_("gplt");
-
 namespace Foam
 {
+    defineTypeNameAndDebug(gnuplotGraph, 0);
+    const word gnuplotGraph::ext_("gplt");
+
     typedef graph::writer graphWriter;
     addToRunTimeSelectionTable(graphWriter, gnuplotGraph, word);
 }
diff --git a/src/OpenFOAM/graph/writers/jplotGraph/jplotGraph.C b/src/OpenFOAM/graph/writers/jplotGraph/jplotGraph.C
index e41939eed1..1352498cf5 100644
--- a/src/OpenFOAM/graph/writers/jplotGraph/jplotGraph.C
+++ b/src/OpenFOAM/graph/writers/jplotGraph/jplotGraph.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -28,15 +28,16 @@ License
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-defineTypeNameAndDebug(Foam::jplotGraph, 0);
-const Foam::word Foam::jplotGraph::ext_("dat");
-
 namespace Foam
 {
+    defineTypeNameAndDebug(jplotGraph, 0);
+    const word jplotGraph::ext_("dat");
+
     typedef graph::writer graphWriter;
     addToRunTimeSelectionTable(graphWriter, jplotGraph, word);
 }
 
+
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
 void Foam::jplotGraph::write(const graph& g, Ostream& os) const
diff --git a/src/OpenFOAM/graph/writers/rawGraph/rawGraph.C b/src/OpenFOAM/graph/writers/rawGraph/rawGraph.C
index b791975db0..8f2a1938bf 100644
--- a/src/OpenFOAM/graph/writers/rawGraph/rawGraph.C
+++ b/src/OpenFOAM/graph/writers/rawGraph/rawGraph.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -28,15 +28,16 @@ License
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-defineTypeNameAndDebug(Foam::rawGraph, 0);
-const Foam::word Foam::rawGraph::ext_("xy");
-
 namespace Foam
 {
+    defineTypeNameAndDebug(rawGraph, 0);
+    const word rawGraph::ext_("xy");
+
     typedef graph::writer graphWriter;
     addToRunTimeSelectionTable(graphWriter, rawGraph, word);
 }
 
+
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
 void Foam::rawGraph::write(const graph& g, Ostream& os) const
diff --git a/src/OpenFOAM/graph/writers/xmgrGraph/xmgrGraph.C b/src/OpenFOAM/graph/writers/xmgrGraph/xmgrGraph.C
index db3d4657d5..806ba183a8 100644
--- a/src/OpenFOAM/graph/writers/xmgrGraph/xmgrGraph.C
+++ b/src/OpenFOAM/graph/writers/xmgrGraph/xmgrGraph.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -28,11 +28,11 @@ License
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-defineTypeNameAndDebug(Foam::xmgrGraph, 0);
-const Foam::word Foam::xmgrGraph::ext_("agr");
-
 namespace Foam
 {
+    defineTypeNameAndDebug(xmgrGraph, 0);
+    const word xmgrGraph::ext_("agr");
+
     typedef graph::writer graphWriter;
     addToRunTimeSelectionTable(graphWriter, xmgrGraph, word);
 }
diff --git a/src/OpenFOAM/interpolations/patchToPatchInterpolation/PatchToPatchInterpolationName.C b/src/OpenFOAM/interpolations/patchToPatchInterpolation/PatchToPatchInterpolationName.C
index 97221f73ce..c93e41f6ea 100644
--- a/src/OpenFOAM/interpolations/patchToPatchInterpolation/PatchToPatchInterpolationName.C
+++ b/src/OpenFOAM/interpolations/patchToPatchInterpolation/PatchToPatchInterpolationName.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -27,6 +27,10 @@ License
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-defineTypeNameAndDebug(Foam::PatchToPatchInterpolationName, 0);
+namespace Foam
+{
+defineTypeNameAndDebug(PatchToPatchInterpolationName, 0);
+}
+
 
 // ************************************************************************* //
diff --git a/src/OpenFOAM/matrices/lduMatrix/lduAddressing/lduInterface/cyclicLduInterface.C b/src/OpenFOAM/matrices/lduMatrix/lduAddressing/lduInterface/cyclicLduInterface.C
index 65854c5e62..83203c1b39 100644
--- a/src/OpenFOAM/matrices/lduMatrix/lduAddressing/lduInterface/cyclicLduInterface.C
+++ b/src/OpenFOAM/matrices/lduMatrix/lduAddressing/lduInterface/cyclicLduInterface.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -28,7 +28,10 @@ License
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-defineTypeNameAndDebug(Foam::cyclicLduInterface, 0);
+namespace Foam
+{
+defineTypeNameAndDebug(cyclicLduInterface, 0);
+}
 
 
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
diff --git a/src/OpenFOAM/matrices/lduMatrix/lduAddressing/lduInterface/lduInterface.C b/src/OpenFOAM/matrices/lduMatrix/lduAddressing/lduInterface/lduInterface.C
index fccc40c35d..ee0779ddea 100644
--- a/src/OpenFOAM/matrices/lduMatrix/lduAddressing/lduInterface/lduInterface.C
+++ b/src/OpenFOAM/matrices/lduMatrix/lduAddressing/lduInterface/lduInterface.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -27,7 +27,10 @@ License
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-defineTypeNameAndDebug(Foam::lduInterface, 0);
+namespace Foam
+{
+defineTypeNameAndDebug(lduInterface, 0);
+}
 
 
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
diff --git a/src/OpenFOAM/matrices/lduMatrix/lduAddressing/lduInterface/processorLduInterface.C b/src/OpenFOAM/matrices/lduMatrix/lduAddressing/lduInterface/processorLduInterface.C
index e7f824ab60..769f7b4160 100644
--- a/src/OpenFOAM/matrices/lduMatrix/lduAddressing/lduInterface/processorLduInterface.C
+++ b/src/OpenFOAM/matrices/lduMatrix/lduAddressing/lduInterface/processorLduInterface.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -27,7 +27,10 @@ License
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-defineTypeNameAndDebug(Foam::processorLduInterface, 0);
+namespace Foam
+{
+defineTypeNameAndDebug(processorLduInterface, 0);
+}
 
 
 // * * * * * * * * * * * * * Private Member Functions *  * * * * * * * * * * //
diff --git a/src/OpenFOAM/matrices/lduMatrix/lduAddressing/lduInterfaceFields/cyclicLduInterfaceField/cyclicLduInterfaceField.C b/src/OpenFOAM/matrices/lduMatrix/lduAddressing/lduInterfaceFields/cyclicLduInterfaceField/cyclicLduInterfaceField.C
index b6ccfe754b..1cb4968df5 100644
--- a/src/OpenFOAM/matrices/lduMatrix/lduAddressing/lduInterfaceFields/cyclicLduInterfaceField/cyclicLduInterfaceField.C
+++ b/src/OpenFOAM/matrices/lduMatrix/lduAddressing/lduInterfaceFields/cyclicLduInterfaceField/cyclicLduInterfaceField.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -28,7 +28,10 @@ License
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-defineTypeNameAndDebug(Foam::cyclicLduInterfaceField, 0);
+namespace Foam
+{
+defineTypeNameAndDebug(cyclicLduInterfaceField, 0);
+}
 
 
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
diff --git a/src/OpenFOAM/matrices/lduMatrix/lduAddressing/lduInterfaceFields/lduInterfaceField/lduInterfaceField.C b/src/OpenFOAM/matrices/lduMatrix/lduAddressing/lduInterfaceFields/lduInterfaceField/lduInterfaceField.C
index 25834cc430..57a5c10345 100644
--- a/src/OpenFOAM/matrices/lduMatrix/lduAddressing/lduInterfaceFields/lduInterfaceField/lduInterfaceField.C
+++ b/src/OpenFOAM/matrices/lduMatrix/lduAddressing/lduInterfaceFields/lduInterfaceField/lduInterfaceField.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -27,7 +27,11 @@ License
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-defineTypeNameAndDebug(Foam::lduInterfaceField, 0);
+namespace Foam
+{
+defineTypeNameAndDebug(lduInterfaceField, 0);
+}
+
 
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
diff --git a/src/OpenFOAM/matrices/lduMatrix/lduAddressing/lduInterfaceFields/processorLduInterfaceField/processorLduInterfaceField.C b/src/OpenFOAM/matrices/lduMatrix/lduAddressing/lduInterfaceFields/processorLduInterfaceField/processorLduInterfaceField.C
index 060f197e9c..18a9bd1d11 100644
--- a/src/OpenFOAM/matrices/lduMatrix/lduAddressing/lduInterfaceFields/processorLduInterfaceField/processorLduInterfaceField.C
+++ b/src/OpenFOAM/matrices/lduMatrix/lduAddressing/lduInterfaceFields/processorLduInterfaceField/processorLduInterfaceField.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -28,7 +28,10 @@ License
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-defineTypeNameAndDebug(Foam::processorLduInterfaceField, 0);
+namespace Foam
+{
+defineTypeNameAndDebug(processorLduInterfaceField, 0);
+}
 
 
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
diff --git a/src/OpenFOAM/matrices/lduMatrix/lduMatrix/lduMatrix.C b/src/OpenFOAM/matrices/lduMatrix/lduMatrix/lduMatrix.C
index 16dd1a4188..1e4e5b8c42 100644
--- a/src/OpenFOAM/matrices/lduMatrix/lduMatrix/lduMatrix.C
+++ b/src/OpenFOAM/matrices/lduMatrix/lduMatrix/lduMatrix.C
@@ -28,7 +28,10 @@ License
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-defineTypeNameAndDebug(Foam::lduMatrix, 1);
+namespace Foam
+{
+defineTypeNameAndDebug(lduMatrix, 1);
+}
 
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
diff --git a/src/OpenFOAM/matrices/lduMatrix/solvers/GAMG/GAMGAgglomerations/pairGAMGAgglomeration/pairGAMGAgglomeration.C b/src/OpenFOAM/matrices/lduMatrix/solvers/GAMG/GAMGAgglomerations/pairGAMGAgglomeration/pairGAMGAgglomeration.C
index b152ca2821..1c4cbfcd7f 100644
--- a/src/OpenFOAM/matrices/lduMatrix/solvers/GAMG/GAMGAgglomerations/pairGAMGAgglomeration/pairGAMGAgglomeration.C
+++ b/src/OpenFOAM/matrices/lduMatrix/solvers/GAMG/GAMGAgglomerations/pairGAMGAgglomeration/pairGAMGAgglomeration.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -27,7 +27,10 @@ License
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-defineTypeNameAndDebug(Foam::pairGAMGAgglomeration, 0);
+namespace Foam
+{
+defineTypeNameAndDebug(pairGAMGAgglomeration, 0);
+}
 
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
diff --git a/src/OpenFOAM/matrices/lduMatrix/solvers/diagonalSolver/diagonalSolver.C b/src/OpenFOAM/matrices/lduMatrix/solvers/diagonalSolver/diagonalSolver.C
index 73e386f5ed..2170c1b90e 100644
--- a/src/OpenFOAM/matrices/lduMatrix/solvers/diagonalSolver/diagonalSolver.C
+++ b/src/OpenFOAM/matrices/lduMatrix/solvers/diagonalSolver/diagonalSolver.C
@@ -27,7 +27,10 @@ License
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-defineTypeNameAndDebug(Foam::diagonalSolver, 0);
+namespace Foam
+{
+defineTypeNameAndDebug(diagonalSolver, 0);
+}
 
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
diff --git a/src/OpenFOAM/matrices/solution/solution.C b/src/OpenFOAM/matrices/solution/solution.C
index 0b770b7daa..1a1c215444 100644
--- a/src/OpenFOAM/matrices/solution/solution.C
+++ b/src/OpenFOAM/matrices/solution/solution.C
@@ -33,7 +33,10 @@ License
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-int Foam::solution::debug(::Foam::debug::debugSwitch("solution", 0));
+namespace Foam
+{
+defineDebugSwitchWithName(solution, "solution", 0);
+}
 
 // List of sub-dictionaries to rewrite
 //! \cond localScope
diff --git a/src/OpenFOAM/meshes/ProcessorTopology/commSchedule.C b/src/OpenFOAM/meshes/ProcessorTopology/commSchedule.C
index 53d4e8985a..d285ca5ae4 100644
--- a/src/OpenFOAM/meshes/ProcessorTopology/commSchedule.C
+++ b/src/OpenFOAM/meshes/ProcessorTopology/commSchedule.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -33,7 +33,10 @@ License
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-defineTypeNameAndDebug(Foam::commSchedule, 0);
+namespace Foam
+{
+defineTypeNameAndDebug(commSchedule, 0);
+}
 
 
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
diff --git a/src/OpenFOAM/meshes/boundBox/boundBox.C b/src/OpenFOAM/meshes/boundBox/boundBox.C
index f1c297837d..c29e17554c 100644
--- a/src/OpenFOAM/meshes/boundBox/boundBox.C
+++ b/src/OpenFOAM/meshes/boundBox/boundBox.C
@@ -66,6 +66,7 @@ void Foam::boundBox::calculate(const UList<point>& points, const bool doReduce)
         min_ = points[0];
         max_ = points[0];
 
+
         for (label i = 1; i < points.size(); i++)
         {
             min_ = ::Foam::min(min_, points[i]);
@@ -299,6 +300,17 @@ bool Foam::boundBox::containsAny
 }
 
 
+Foam::point Foam::boundBox::nearest(const point& pt) const
+{
+    // Clip the point to the range of the bounding box
+    const scalar surfPtx = Foam::max(Foam::min(pt.x(), max_.x()), min_.x());
+    const scalar surfPty = Foam::max(Foam::min(pt.y(), max_.y()), min_.y());
+    const scalar surfPtz = Foam::max(Foam::min(pt.z(), max_.z()), min_.z());
+
+    return point(surfPtx, surfPty, surfPtz);
+}
+
+
 // * * * * * * * * * * * * * * * Ostream Operator  * * * * * * * * * * * * * //
 
 Foam::Ostream& Foam::operator<<(Ostream& os, const boundBox& bb)
diff --git a/src/OpenFOAM/meshes/boundBox/boundBox.H b/src/OpenFOAM/meshes/boundBox/boundBox.H
index c59281bdf0..f0c353d5df 100644
--- a/src/OpenFOAM/meshes/boundBox/boundBox.H
+++ b/src/OpenFOAM/meshes/boundBox/boundBox.H
@@ -176,6 +176,9 @@ public:
             //- Overlaps/touches boundingBox?
             inline bool overlaps(const boundBox&) const;
 
+            //- Overlaps boundingSphere (centre + sqr(radius))?
+            inline bool overlaps(const point&, const scalar radiusSqr) const;
+
             //- Contains point? (inside or on edge)
             inline bool contains(const point&) const;
 
@@ -222,6 +225,11 @@ public:
                 const FixedList<label, Size>& indices
             ) const;
 
+            //- Return the nearest point on the boundBox to the supplied point.
+            //  If point is inside the boundBox then the point is returned
+            //  unchanged.
+            point nearest(const point&) const;
+
 
     // Friend Operators
 
diff --git a/src/OpenFOAM/meshes/boundBox/boundBoxI.H b/src/OpenFOAM/meshes/boundBox/boundBoxI.H
index efb8d3d9d0..ce0d1017c7 100644
--- a/src/OpenFOAM/meshes/boundBox/boundBoxI.H
+++ b/src/OpenFOAM/meshes/boundBox/boundBoxI.H
@@ -128,6 +128,45 @@ inline bool Foam::boundBox::overlaps(const boundBox& bb) const
 }
 
 
+inline bool Foam::boundBox::overlaps
+(
+    const point& centre,
+    const scalar radiusSqr
+) const
+{
+    // Find out where centre is in relation to bb.
+    // Find nearest point on bb.
+    scalar distSqr = 0;
+
+    for (direction dir = 0; dir < vector::nComponents; dir++)
+    {
+        scalar d0 = min_[dir] - centre[dir];
+        scalar d1 = max_[dir] - centre[dir];
+
+        if ((d0 > 0) != (d1 > 0))
+        {
+            // centre inside both extrema. This component does not add any
+            // distance.
+        }
+        else if (Foam::mag(d0) < Foam::mag(d1))
+        {
+            distSqr += d0*d0;
+        }
+        else
+        {
+            distSqr += d1*d1;
+        }
+
+        if (distSqr > radiusSqr)
+        {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+
 inline bool Foam::boundBox::contains(const point& pt) const
 {
     return
diff --git a/src/OpenFOAM/meshes/lduMesh/lduMesh.C b/src/OpenFOAM/meshes/lduMesh/lduMesh.C
index 44330226b1..2ab4cfe046 100644
--- a/src/OpenFOAM/meshes/lduMesh/lduMesh.C
+++ b/src/OpenFOAM/meshes/lduMesh/lduMesh.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -28,7 +28,10 @@ License
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-defineTypeNameAndDebug(Foam::lduMesh, 0);
+namespace Foam
+{
+defineTypeNameAndDebug(lduMesh, 0);
+}
 
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
diff --git a/src/OpenFOAM/meshes/meshShapes/face/face.C b/src/OpenFOAM/meshes/meshShapes/face/face.C
index 17948c2b24..1d7ee06c2e 100644
--- a/src/OpenFOAM/meshes/meshShapes/face/face.C
+++ b/src/OpenFOAM/meshes/meshShapes/face/face.C
@@ -28,6 +28,7 @@ License
 #include "triPointRef.H"
 #include "mathematicalConstants.H"
 #include "Swap.H"
+#include "const_circulator.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
@@ -299,7 +300,6 @@ Foam::face::face(const triFace& f)
 
 // * * * * * * * * * * * * * Static Member Functions * * * * * * * * * * * * //
 
-
 // return
 //   0: no match
 //  +1: identical
@@ -314,144 +314,89 @@ int Foam::face::compare(const face& a, const face& b)
     label sizeA = a.size();
     label sizeB = b.size();
 
-    if (sizeA != sizeB)
+    if (sizeA != sizeB || sizeA == 0)
     {
         return 0;
     }
 
+    const_circulator<face> aCirc(a);
+    const_circulator<face> bCirc(b);
 
-    // Full list comparison
-    const label firstA = a[0];
-    label Bptr = -1;
-
-    forAll(b, i)
+    // Rotate face b until its element matches the starting element of face a.
+    do
     {
-        if (b[i] == firstA)
+        if (aCirc() == bCirc())
+        {
+            // Set bCirc fulcrum to its iterator and increment the iterators
+            bCirc.setFulcrumToIterator();
+            ++aCirc;
+            ++bCirc;
+
+            break;
+        }
+    } while (bCirc.circulate(CirculatorBase::CLOCKWISE));
+
+    // If the circulator has stopped then faces a and b do not share a matching
+    // point
+    if (!bCirc.circulate())
+    {
+        return 0;
+    }
+
+    // Look forwards around the faces for a match
+    do
+    {
+        if (aCirc() != bCirc())
         {
-            Bptr = i;        // 'found match' at element 'i'
             break;
         }
     }
+    while
+    (
+        aCirc.circulate(CirculatorBase::CLOCKWISE),
+        bCirc.circulate(CirculatorBase::CLOCKWISE)
+    );
 
-    // If no match was found, return 0
-    if (Bptr < 0)
+    // If the circulator has stopped then faces a and b matched.
+    if (!aCirc.circulate())
     {
-        return 0;
-    }
-
-    // Now we must look for the direction, if any
-    label secondA = a[1];
-
-    if (sizeA > 1 && (secondA == firstA || firstA == a[sizeA - 1]))
-    {
-        face ca = a;
-        ca.collapse();
-
-        face cb = b;
-        cb.collapse();
-
-        return face::compare(ca, cb);
-    }
-
-    int dir = 0;
-
-    // Check whether at top of list
-    Bptr++;
-    if (Bptr == b.size())
-    {
-        Bptr = 0;
-    }
-
-    // Test whether upward label matches second A label
-    if (b[Bptr] == secondA)
-    {
-        // Yes - direction is 'up'
-        dir = 1;
+        return 1;
     }
     else
     {
-        // No - so look downwards, checking whether at bottom of list
-        Bptr -= 2;
-
-        if (Bptr < 0)
-        {
-            // wraparound
-            Bptr += b.size();
-        }
-
-        // Test whether downward label matches second A label
-        if (b[Bptr] == secondA)
-        {
-            // Yes - direction is 'down'
-            dir = -1;
-        }
+        // Reset the circulators back to their fulcrum
+        aCirc.setIteratorToFulcrum();
+        bCirc.setIteratorToFulcrum();
+        ++aCirc;
+        --bCirc;
     }
 
-    // Check whether a match was made at all, and exit 0 if not
-    if (dir == 0)
+    // Look backwards around the faces for a match
+    do
     {
-        return 0;
-    }
-
-    // Decrement size by 2 to account for first searches
-    sizeA -= 2;
-
-    // We now have both direction of search and next element
-    // to search, so we can continue search until no more points.
-    label Aptr = 1;
-    if (dir > 0)
-    {
-        while (sizeA--)
+        if (aCirc() != bCirc())
         {
-            Aptr++;
-            if (Aptr >= a.size())
-            {
-                Aptr = 0;
-            }
-
-            Bptr++;
-            if (Bptr >= b.size())
-            {
-                Bptr = 0;
-            }
-
-            if (a[Aptr] != b[Bptr])
-            {
-                return 0;
-            }
+            break;
         }
     }
-    else
+    while
+    (
+        aCirc.circulate(CirculatorBase::CLOCKWISE),
+        bCirc.circulate(CirculatorBase::ANTICLOCKWISE)
+    );
+
+    // If the circulator has stopped then faces a and b matched.
+    if (!aCirc.circulate())
     {
-        while (sizeA--)
-        {
-            Aptr++;
-            if (Aptr >= a.size())
-            {
-                Aptr = 0;
-            }
-
-            Bptr--;
-            if (Bptr < 0)
-            {
-                Bptr = b.size() - 1;
-            }
-
-            if (a[Aptr] != b[Bptr])
-            {
-                return 0;
-            }
-        }
+        return -1;
     }
 
-    // They must be equal - return direction
-    return dir;
+    return 0;
 }
 
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
-
 Foam::label Foam::face::collapse()
 {
     if (size() > 1)
@@ -633,27 +578,6 @@ Foam::face Foam::face::reverseFace() const
 }
 
 
-Foam::face Foam::face::rotateFace(const label nPos) const
-{
-    const labelList& f = *this;
-    labelList newList(size());
-
-    forAll(f, fp)
-    {
-        label fp1 = (fp + nPos) % f.size();
-
-        if (fp1 < 0)
-        {
-            fp1 += f.size();
-        }
-
-        newList[fp1] = f[fp];
-    }
-
-    return face(xferMove(newList));
-}
-
-
 Foam::label Foam::face::which(const label globalIndex) const
 {
     const labelList& f = *this;
diff --git a/src/OpenFOAM/meshes/meshShapes/face/face.H b/src/OpenFOAM/meshes/meshShapes/face/face.H
index c9cd3724dc..c481258a3c 100644
--- a/src/OpenFOAM/meshes/meshShapes/face/face.H
+++ b/src/OpenFOAM/meshes/meshShapes/face/face.H
@@ -198,9 +198,6 @@ public:
         //  The starting points of the original and reverse face are identical.
         face reverseFace() const;
 
-        //- Rotate face by number of positions
-        face rotateFace(const label nPos) const;
-
         //- Navigation through face vertices
 
             //- Which vertex on face (face index given a global index)
diff --git a/src/OpenFOAM/meshes/meshTools/matchPoints.C b/src/OpenFOAM/meshes/meshTools/matchPoints.C
index 0dababace8..e288a62ac6 100644
--- a/src/OpenFOAM/meshes/meshTools/matchPoints.C
+++ b/src/OpenFOAM/meshes/meshTools/matchPoints.C
@@ -124,7 +124,8 @@ bool Foam::matchPoints
                 {
                     label faceI = pts1MagSqr.indices()[j];
 
-                    Pout<< "    Compared coord:" << pts1[faceI]
+                    Pout<< "    Compared coord: " << pts1[faceI]
+                        << " at index " << j
                         << " with difference to point "
                         << mag(pts1[faceI] - pts0[face0I]) << endl;
                 }
@@ -137,4 +138,133 @@ bool Foam::matchPoints
     return fullMatch;
 }
 
+
+bool Foam::matchPoints
+(
+    const UList<point>& pts0,
+    const UList<point>& pts1,
+    const UList<point>& pts0Dir,
+    const UList<point>& pts1Dir,
+    const UList<scalar>& matchDistances,
+    const bool verbose,
+    labelList& from0To1,
+    const point& origin
+)
+{
+    from0To1.setSize(pts0.size());
+    from0To1 = -1;
+
+    bool fullMatch = true;
+
+    point compareOrigin = origin;
+
+    if (origin == point(VGREAT, VGREAT, VGREAT))
+    {
+        if (pts1.size())
+        {
+            compareOrigin = sum(pts1)/pts1.size();
+        }
+    }
+
+    SortableList<scalar> pts0MagSqr(magSqr(pts0 - compareOrigin));
+
+    SortableList<scalar> pts1MagSqr(magSqr(pts1 - compareOrigin));
+
+    forAll(pts0MagSqr, i)
+    {
+        scalar dist0 = pts0MagSqr[i];
+
+        label face0I = pts0MagSqr.indices()[i];
+
+        scalar matchDist = matchDistances[face0I];
+
+        label startI = findLower(pts1MagSqr, 0.99999*dist0 - 2*matchDist);
+
+        if (startI == -1)
+        {
+            startI = 0;
+        }
+
+        // Go through range of equal mag and find nearest vector.
+        scalar minDistSqr = VGREAT;
+        scalar minDistNorm = 0;
+        label minFaceI = -1;
+
+        for
+        (
+            label j = startI;
+            (
+                (j < pts1MagSqr.size())
+             && (pts1MagSqr[j] < 1.00001*dist0 + 2*matchDist)
+            );
+            j++
+        )
+        {
+            label faceI = pts1MagSqr.indices()[j];
+            // Compare actual vectors
+            scalar distSqr = magSqr(pts0[face0I] - pts1[faceI]);
+
+            scalar distNorm = (pts0Dir[face0I] & pts1Dir[faceI]);
+
+            if
+            (
+                magSqr(pts0Dir[face0I]) < sqr(SMALL)
+             && magSqr(pts1Dir[faceI]) < sqr(SMALL)
+            )
+            {
+                distNorm = -1;
+            }
+
+            if (distSqr <= sqr(matchDist) && distSqr < minDistSqr)
+            {
+                // Check that the normals point in equal and opposite directions
+                if (distNorm < minDistNorm)
+                {
+                    minDistNorm = distNorm;
+                    minDistSqr = distSqr;
+                    minFaceI = faceI;
+                }
+            }
+        }
+
+        if (minFaceI == -1)
+        {
+            fullMatch = false;
+
+            if (verbose)
+            {
+                Pout<< "Cannot find point in pts1 matching point " << face0I
+                    << " coord:" << pts0[face0I]
+                    << " in pts0 when using tolerance " << matchDist << endl;
+
+                // Go through range of equal mag and find equal vector.
+                Pout<< "Searching started from:" << startI << " in pts1"
+                    << endl;
+                for
+                (
+                    label j = startI;
+                    (
+                        (j < pts1MagSqr.size())
+                     && (pts1MagSqr[j] < 1.00001*dist0 + 2*matchDist)
+                    );
+                    j++
+                )
+                {
+                    label faceI = pts1MagSqr.indices()[j];
+
+                    Pout<< "    Compared coord: " << pts1[faceI]
+                        << " at index " << j
+                        << " with difference to point "
+                        << mag(pts1[faceI] - pts0[face0I]) << endl;
+                }
+            }
+        }
+
+        from0To1[face0I] = minFaceI;
+    }
+
+    return fullMatch;
+}
+
+
 // ************************************************************************* //
diff --git a/src/OpenFOAM/meshes/meshTools/matchPoints.H b/src/OpenFOAM/meshes/meshTools/matchPoints.H
index cf61c82d4d..0523301b8f 100644
--- a/src/OpenFOAM/meshes/meshTools/matchPoints.H
+++ b/src/OpenFOAM/meshes/meshTools/matchPoints.H
@@ -59,6 +59,24 @@ bool matchPoints
     const point& origin = point::zero
 );
 
+
+//- Supply pts0Dir and pts1Dir. They are directions associated with the points
+//  e.g., a face normal associated with each face centre.
+//  A match between similar points is only allowed if their directions are
+//  equal and opposite
+bool matchPoints
+(
+    const UList<point>& pts0,
+    const UList<point>& pts1,
+    const UList<point>& pts0Dir,
+    const UList<point>& pts1Dir,
+    const UList<scalar>& matchDistance,
+    const bool verbose,
+    labelList& from0To1,
+    const point& origin = point::zero
+);
+
+
 } // End namespace Foam
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
diff --git a/src/OpenFOAM/meshes/pointMesh/pointPatches/basic/coupled/coupledPointPatch.C b/src/OpenFOAM/meshes/pointMesh/pointPatches/basic/coupled/coupledPointPatch.C
index e9a1382aad..7e96f95087 100644
--- a/src/OpenFOAM/meshes/pointMesh/pointPatches/basic/coupled/coupledPointPatch.C
+++ b/src/OpenFOAM/meshes/pointMesh/pointPatches/basic/coupled/coupledPointPatch.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -30,7 +30,11 @@ License
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-defineTypeNameAndDebug(Foam::coupledPointPatch, 0);
+namespace Foam
+{
+defineTypeNameAndDebug(coupledPointPatch, 0);
+}
+
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
diff --git a/src/OpenFOAM/meshes/pointMesh/pointPatches/derived/coupled/coupledFacePointPatch.C b/src/OpenFOAM/meshes/pointMesh/pointPatches/derived/coupled/coupledFacePointPatch.C
index f537df68cd..3fb238c718 100644
--- a/src/OpenFOAM/meshes/pointMesh/pointPatches/derived/coupled/coupledFacePointPatch.C
+++ b/src/OpenFOAM/meshes/pointMesh/pointPatches/derived/coupled/coupledFacePointPatch.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -28,7 +28,10 @@ License
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-defineTypeNameAndDebug(Foam::coupledFacePointPatch, 0);
+namespace Foam
+{
+defineTypeNameAndDebug(coupledFacePointPatch, 0);
+}
 
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
diff --git a/src/OpenFOAM/meshes/pointMesh/pointPatches/pointPatch/pointPatch.C b/src/OpenFOAM/meshes/pointMesh/pointPatches/pointPatch/pointPatch.C
index e76e8b7a4c..c71d901678 100644
--- a/src/OpenFOAM/meshes/pointMesh/pointPatches/pointPatch/pointPatch.C
+++ b/src/OpenFOAM/meshes/pointMesh/pointPatches/pointPatch/pointPatch.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -27,6 +27,10 @@ License
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-defineTypeNameAndDebug(Foam::pointPatch, 0);
+namespace Foam
+{
+defineTypeNameAndDebug(pointPatch, 0);
+}
+
 
 // ************************************************************************* //
diff --git a/src/OpenFOAM/meshes/polyMesh/globalMeshData/globalMeshData.C b/src/OpenFOAM/meshes/polyMesh/globalMeshData/globalMeshData.C
index 2122b282d7..2c0ae4c102 100644
--- a/src/OpenFOAM/meshes/polyMesh/globalMeshData/globalMeshData.C
+++ b/src/OpenFOAM/meshes/polyMesh/globalMeshData/globalMeshData.C
@@ -41,13 +41,13 @@ License
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-defineTypeNameAndDebug(Foam::globalMeshData, 0);
-
-// Geometric matching tolerance. Factor of mesh bounding box.
-const Foam::scalar Foam::globalMeshData::matchTol_ = 1e-8;
-
 namespace Foam
 {
+defineTypeNameAndDebug(globalMeshData, 0);
+
+// Geometric matching tolerance. Factor of mesh bounding box.
+const scalar globalMeshData::matchTol_ = 1e-8;
+
 template<>
 class minEqOp<labelPair>
 {
@@ -881,7 +881,7 @@ void Foam::globalMeshData::calcGlobalEdgeSlaves() const
     // the transformations.
 
 
-    // 1. collect point connectivity - basically recreating globalPoints ouput.
+    // 1. collect point connectivity - basically recreating globalPoints output.
     // All points will now have a string of points. The transforms are
     // in respect to the master.
     List<labelPairList> allPointConnectivity;
diff --git a/src/OpenFOAM/meshes/polyMesh/globalMeshData/globalMeshData.H b/src/OpenFOAM/meshes/polyMesh/globalMeshData/globalMeshData.H
index 895daa91ab..3d254c04ba 100644
--- a/src/OpenFOAM/meshes/polyMesh/globalMeshData/globalMeshData.H
+++ b/src/OpenFOAM/meshes/polyMesh/globalMeshData/globalMeshData.H
@@ -51,7 +51,7 @@ Description
     The exchange needs
     - a field of data
     - a mapDistribute which does all parallel exchange and transformations
-      This appens remote data to the end of the field
+      This appends remote data to the end of the field.
     - a set of indices which indicate where to get untransformed data in the
       field
     - a set of indices which indicate where to get transformed data in the
diff --git a/src/OpenFOAM/meshes/polyMesh/globalMeshData/globalPoints.C b/src/OpenFOAM/meshes/polyMesh/globalMeshData/globalPoints.C
index b4333fc3a7..caad93731c 100644
--- a/src/OpenFOAM/meshes/polyMesh/globalMeshData/globalPoints.C
+++ b/src/OpenFOAM/meshes/polyMesh/globalMeshData/globalPoints.C
@@ -31,7 +31,10 @@ License
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-defineTypeNameAndDebug(Foam::globalPoints, 0);
+namespace Foam
+{
+defineTypeNameAndDebug(globalPoints, 0);
+}
 
 
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
diff --git a/src/OpenFOAM/meshes/polyMesh/mapPolyMesh/mapDistribute/mapDistribute.C b/src/OpenFOAM/meshes/polyMesh/mapPolyMesh/mapDistribute/mapDistribute.C
index 72d386d57b..a4ababac70 100644
--- a/src/OpenFOAM/meshes/polyMesh/mapPolyMesh/mapDistribute/mapDistribute.C
+++ b/src/OpenFOAM/meshes/polyMesh/mapPolyMesh/mapDistribute/mapDistribute.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -33,7 +33,11 @@ License
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-defineTypeNameAndDebug(Foam::mapDistribute, 0);
+namespace Foam
+{
+defineTypeNameAndDebug(mapDistribute, 0);
+}
+
 
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 
diff --git a/src/OpenFOAM/meshes/polyMesh/polyBoundaryMesh/polyBoundaryMesh.C b/src/OpenFOAM/meshes/polyMesh/polyBoundaryMesh/polyBoundaryMesh.C
index b4148405cf..c17e54be53 100644
--- a/src/OpenFOAM/meshes/polyMesh/polyBoundaryMesh/polyBoundaryMesh.C
+++ b/src/OpenFOAM/meshes/polyMesh/polyBoundaryMesh/polyBoundaryMesh.C
@@ -35,7 +35,10 @@ License
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-defineTypeNameAndDebug(Foam::polyBoundaryMesh, 0);
+namespace Foam
+{
+defineTypeNameAndDebug(polyBoundaryMesh, 0);
+}
 
 
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
diff --git a/src/OpenFOAM/meshes/polyMesh/polyBoundaryMesh/polyBoundaryMeshEntries.C b/src/OpenFOAM/meshes/polyMesh/polyBoundaryMesh/polyBoundaryMeshEntries.C
index c70b13211d..df0a21291d 100644
--- a/src/OpenFOAM/meshes/polyMesh/polyBoundaryMesh/polyBoundaryMeshEntries.C
+++ b/src/OpenFOAM/meshes/polyMesh/polyBoundaryMesh/polyBoundaryMeshEntries.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -27,6 +27,10 @@ License
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-defineTypeNameAndDebug(Foam::polyBoundaryMeshEntries, 0);
+namespace Foam
+{
+defineTypeNameAndDebug(polyBoundaryMeshEntries, 0);
+}
+
 
 // ************************************************************************* //
diff --git a/src/OpenFOAM/meshes/polyMesh/polyMesh.C b/src/OpenFOAM/meshes/polyMesh/polyMesh.C
index 63c23dc98f..6388190bf6 100644
--- a/src/OpenFOAM/meshes/polyMesh/polyMesh.C
+++ b/src/OpenFOAM/meshes/polyMesh/polyMesh.C
@@ -38,14 +38,25 @@ License
 #include "SubField.H"
 
 #include "pointMesh.H"
+#include "Istream.H"
+#include "Ostream.H"
+#include "simpleRegIOobject.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-defineTypeNameAndDebug(Foam::polyMesh, 0);
+namespace Foam
+{
+defineTypeNameAndDebug(polyMesh, 0);
+registerDebugSwitchWithName
+(
+    polyMesh,
+    polyMesh,
+    polyMesh::typeName_()
+);
 
-
-Foam::word Foam::polyMesh::defaultRegion = "region0";
-Foam::word Foam::polyMesh::meshSubDir = "polyMesh";
+word polyMesh::defaultRegion = "region0";
+word polyMesh::meshSubDir = "polyMesh";
+}
 
 
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
diff --git a/src/OpenFOAM/meshes/polyMesh/polyPatches/basic/coupled/coupledPolyPatch.C b/src/OpenFOAM/meshes/polyMesh/polyPatches/basic/coupled/coupledPolyPatch.C
index 4e43300134..2ac3b52903 100644
--- a/src/OpenFOAM/meshes/polyMesh/polyPatches/basic/coupled/coupledPolyPatch.C
+++ b/src/OpenFOAM/meshes/polyMesh/polyPatches/basic/coupled/coupledPolyPatch.C
@@ -37,15 +37,16 @@ namespace Foam
     const scalar coupledPolyPatch::defaultMatchTol_ = 1e-4;
 
     template<>
-    const char* NamedEnum<coupledPolyPatch::transformType, 4>::names[] =
+    const char* NamedEnum<coupledPolyPatch::transformType, 5>::names[] =
     {
         "unknown",
         "rotational",
         "translational",
+        "coincidentFullMatch",
         "noOrdering"
     };
 
-    const NamedEnum<coupledPolyPatch::transformType, 4>
+    const NamedEnum<coupledPolyPatch::transformType, 5>
         coupledPolyPatch::transformTypeNames;
 }
 
@@ -129,14 +130,65 @@ void Foam::coupledPolyPatch::writeOBJ
 Foam::pointField Foam::coupledPolyPatch::getAnchorPoints
 (
     const UList<face>& faces,
-    const pointField& points
+    const pointField& points,
+    const transformType transform
 )
 {
     pointField anchors(faces.size());
 
-    forAll(faces, faceI)
+    if (transform == COINCIDENTFULLMATCH)
     {
-        anchors[faceI] = points[faces[faceI][0]];
+        // Return the first point
+        forAll(faces, faceI)
+        {
+            anchors[faceI] = points[faces[faceI][0]];
+        }
+    }
+    else
+    {
+        // Make anchor point unique
+        forAll(faces, faceI)
+        {
+            const face& f = faces[faceI];
+
+            bool unique = true;
+
+            forAll(f, fp1)
+            {
+                const point& p1 = points[f[fp1]];
+
+                unique = true;
+
+                for (label fp2 = 0; fp2 < f.size(); ++fp2)
+                {
+                    if (f[fp1] == f[fp2])
+                    {
+                        continue;
+                    }
+
+                    const point& p2 = points[f[fp2]];
+
+                    // @todo Change to a tolerance and possibly select closest
+                    // point to the origin
+                    if (p1 == p2)
+                    {
+                        unique = false;
+                        break;
+                    }
+                }
+
+                if (unique)
+                {
+                    anchors[faceI] = p1;
+                    break;
+                }
+            }
+
+            if (!unique)
+            {
+                anchors[faceI] = points[faces[faceI][0]];
+            }
+        }
     }
 
     return anchors;
@@ -172,7 +224,12 @@ Foam::scalarField Foam::coupledPolyPatch::calcFaceTol
             maxLenSqr = max(maxLenSqr, magSqr(pt - cc));
             maxCmpt = max(maxCmpt, cmptMax(cmptMag(pt)));
         }
-        tols[faceI] = max(SMALL, max(SMALL*maxCmpt, Foam::sqrt(maxLenSqr)));
+
+        tols[faceI] = max
+        (
+            SMALL,
+            max(SMALL*maxCmpt, Foam::sqrt(maxLenSqr))
+        );
     }
     return tols;
 }
@@ -230,7 +287,7 @@ Foam::label Foam::coupledPolyPatch::getRotation
                     << Foam::sqrt(minDistSqr)
                     << " to the anchor " << anchor
                     << ". Continuing but results might be wrong."
-                    << endl;
+                    << nl << endl;
             }
         }
 
@@ -292,7 +349,8 @@ void Foam::coupledPolyPatch::calcTransformTensors
             transform == ROTATIONAL
          || (
                 transform != TRANSLATIONAL
-             && (sum(mag(nf & nr)) < Cf.size()-error)
+             && transform != COINCIDENTFULLMATCH
+             && (sum(mag(nf & nr)) < Cf.size() - error)
             )
         )
         {
@@ -427,11 +485,13 @@ Foam::coupledPolyPatch::coupledPolyPatch
     const label start,
     const label index,
     const polyBoundaryMesh& bm,
-    const word& patchType
+    const word& patchType,
+    const transformType transform
 )
 :
     polyPatch(name, size, start, index, bm, patchType),
-    matchTolerance_(defaultMatchTol_)
+    matchTolerance_(defaultMatchTol_),
+    transform_(transform)
 {}
 
 
@@ -445,7 +505,13 @@ Foam::coupledPolyPatch::coupledPolyPatch
 )
 :
     polyPatch(name, dict, index, bm, patchType),
-    matchTolerance_(dict.lookupOrDefault("matchTolerance", defaultMatchTol_))
+    matchTolerance_(dict.lookupOrDefault("matchTolerance", defaultMatchTol_)),
+    transform_
+    (
+        dict.found("transform")
+      ? transformTypeNames.read(dict.lookup("transform"))
+      : UNKNOWN
+    )
 {}
 
 
@@ -456,7 +522,8 @@ Foam::coupledPolyPatch::coupledPolyPatch
 )
 :
     polyPatch(pp, bm),
-    matchTolerance_(pp.matchTolerance_)
+    matchTolerance_(pp.matchTolerance_),
+    transform_(pp.transform_)
 {}
 
 
@@ -470,7 +537,8 @@ Foam::coupledPolyPatch::coupledPolyPatch
 )
 :
     polyPatch(pp, bm, index, newSize, newStart),
-    matchTolerance_(pp.matchTolerance_)
+    matchTolerance_(pp.matchTolerance_),
+    transform_(pp.transform_)
 {}
 
 
@@ -484,7 +552,8 @@ Foam::coupledPolyPatch::coupledPolyPatch
 )
 :
     polyPatch(pp, bm, index, mapAddressing, newStart),
-    matchTolerance_(pp.matchTolerance_)
+    matchTolerance_(pp.matchTolerance_),
+    transform_(pp.transform_)
 {}
 
 
@@ -503,6 +572,8 @@ void Foam::coupledPolyPatch::write(Ostream& os) const
     {
         os.writeKeyword("matchTolerance") << matchTolerance_
             << token::END_STATEMENT << nl;
+        os.writeKeyword("transform") << transformTypeNames[transform_]
+            << token::END_STATEMENT << nl;
     }
 }
 
diff --git a/src/OpenFOAM/meshes/polyMesh/polyPatches/basic/coupled/coupledPolyPatch.H b/src/OpenFOAM/meshes/polyMesh/polyPatches/basic/coupled/coupledPolyPatch.H
index 7cb56879c4..0208dacb47 100644
--- a/src/OpenFOAM/meshes/polyMesh/polyPatches/basic/coupled/coupledPolyPatch.H
+++ b/src/OpenFOAM/meshes/polyMesh/polyPatches/basic/coupled/coupledPolyPatch.H
@@ -60,9 +60,12 @@ public:
         UNKNOWN,            // unspecified; automatic ordering
         ROTATIONAL,         // rotation along coordinate axis
         TRANSLATIONAL,      // translation
+        COINCIDENTFULLMATCH,// assume no transforms
+                            // and check the points in faces match
         NOORDERING          // unspecified, no automatic ordering
     };
-    static const NamedEnum<transformType, 4> transformTypeNames;
+
+    static const NamedEnum<transformType, 5> transformTypeNames;
 
 
 private:
@@ -75,6 +78,9 @@ private:
         //- local matching tolerance
         const scalar matchTolerance_;
 
+        //- Type of transformation
+        transformType transform_;
+
         //- offset (distance) vector from one side of the couple to the other
         mutable vectorField separation_;
 
@@ -150,11 +156,12 @@ protected:
             label& vertI
         );
 
-        //- Get f[0] for all faces
+        //- Get a unique anchor point for all faces
         static pointField getAnchorPoints
         (
             const UList<face>&,
-            const pointField&
+            const pointField&,
+            const transformType
         );
 
         //- Get the number of vertices face f needs to be rotated such that
@@ -184,7 +191,8 @@ public:
             const label start,
             const label index,
             const polyBoundaryMesh& bm,
-            const word& patchType
+            const word& patchType,
+            const transformType transform
         );
 
         //- Construct from dictionary
@@ -245,6 +253,20 @@ public:
                 return !owner();
             }
 
+            //- Type of transform
+            virtual transformType transform() const
+            {
+                return transform_;
+            }
+
+            //- Type of transform
+            //  This is currently only for use when collapsing generated
+            //  meshes that can have zero area faces.
+            virtual transformType& transform()
+            {
+                return transform_;
+            }
+
             //- Transform a patch-based position from other side to this side
             virtual void transformPosition(pointField&) const = 0;
 
diff --git a/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/cyclic/cyclicPolyPatch.C b/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/cyclic/cyclicPolyPatch.C
index ce8f260382..730fa40249 100644
--- a/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/cyclic/cyclicPolyPatch.C
+++ b/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/cyclic/cyclicPolyPatch.C
@@ -164,16 +164,16 @@ void Foam::cyclicPolyPatch::calcTransforms
             << exit(FatalError);
     }
 
-    if (transform_ != neighbPatch().transform_)
+    if (transform() != neighbPatch().transform())
     {
         FatalErrorIn
         (
             "cyclicPolyPatch::calcTransforms()"
         )   << "Patch " << name()
-            << " has transform type " << transformTypeNames[transform_]
+            << " has transform type " << transformTypeNames[transform()]
             << ", neighbour patch " << neighbPatchName_
             << " has transform type "
-            << neighbPatch().transformTypeNames[transform_]
+            << neighbPatch().transformTypeNames[neighbPatch().transform()]
             << exit(FatalError);
     }
 
@@ -261,7 +261,7 @@ void Foam::cyclicPolyPatch::calcTransforms
 
         // Calculate transformation tensors
 
-        if (transform_ == ROTATIONAL)
+        if (transform() == ROTATIONAL)
         {
             // Calculate using the given rotation axis and centre. Do not
             // use calculated normals.
@@ -320,11 +320,11 @@ void Foam::cyclicPolyPatch::calcTransforms
                 half1Normals,
                 half0Tols,
                 matchTolerance(),
-                transform_
+                transform()
             );
 
 
-            if (transform_ == TRANSLATIONAL)
+            if (transform() == TRANSLATIONAL)
             {
                 if (debug)
                 {
@@ -406,7 +406,7 @@ void Foam::cyclicPolyPatch::getCentresAndAnchors
 {
     // Get geometric data on both halves.
     half0Ctrs = pp0.faceCentres();
-    anchors0 = getAnchorPoints(pp0, pp0.points());
+    anchors0 = getAnchorPoints(pp0, pp0.points(), transform());
     half1Ctrs = pp1.faceCentres();
 
     if (debug)
@@ -421,7 +421,7 @@ void Foam::cyclicPolyPatch::getCentresAndAnchors
 
     if (half0Ctrs.size())
     {
-        switch (transform_)
+        switch (transform())
         {
             case ROTATIONAL:
             {
@@ -601,13 +601,13 @@ Foam::cyclicPolyPatch::cyclicPolyPatch
     const label start,
     const label index,
     const polyBoundaryMesh& bm,
-    const word& patchType
+    const word& patchType,
+    const transformType transform
 )
 :
-    coupledPolyPatch(name, size, start, index, bm, patchType),
+    coupledPolyPatch(name, size, start, index, bm, patchType, transform),
     neighbPatchName_(word::null),
     neighbPatchID_(-1),
-    transform_(UNKNOWN),
     rotationAxis_(vector::zero),
     rotationCentre_(point::zero),
     separationVector_(vector::zero),
@@ -633,10 +633,9 @@ Foam::cyclicPolyPatch::cyclicPolyPatch
     const vector& separationVector
 )
 :
-    coupledPolyPatch(name, size, start, index, bm, typeName),
+    coupledPolyPatch(name, size, start, index, bm, typeName, transform),
     neighbPatchName_(neighbPatchName),
     neighbPatchID_(-1),
-    transform_(transform),
     rotationAxis_(rotationAxis),
     rotationCentre_(rotationCentre),
     separationVector_(separationVector),
@@ -660,7 +659,6 @@ Foam::cyclicPolyPatch::cyclicPolyPatch
     coupledPolyPatch(name, dict, index, bm, patchType),
     neighbPatchName_(dict.lookupOrDefault("neighbourPatch", word::null)),
     neighbPatchID_(-1),
-    transform_(UNKNOWN),
     rotationAxis_(vector::zero),
     rotationCentre_(point::zero),
     separationVector_(vector::zero),
@@ -693,37 +691,33 @@ Foam::cyclicPolyPatch::cyclicPolyPatch
             << exit(FatalIOError);
     }
 
-    if (dict.found("transform"))
+    switch (transform())
     {
-        transform_ = transformTypeNames.read(dict.lookup("transform"));
-        switch (transform_)
+        case ROTATIONAL:
         {
-            case ROTATIONAL:
-            {
-                dict.lookup("rotationAxis") >> rotationAxis_;
-                dict.lookup("rotationCentre") >> rotationCentre_;
+            dict.lookup("rotationAxis") >> rotationAxis_;
+            dict.lookup("rotationCentre") >> rotationCentre_;
 
-                scalar magRot = mag(rotationAxis_);
-                if (magRot < SMALL)
-                {
-                    FatalIOErrorIn("cyclicPolyPatch::cyclicPolyPatch(..)", dict)
-                        << "Illegal rotationAxis " << rotationAxis_ << endl
-                        << "Please supply a non-zero vector."
-                        << exit(FatalIOError);
-                }
-                rotationAxis_ /= magRot;
+            scalar magRot = mag(rotationAxis_);
+            if (magRot < SMALL)
+            {
+                FatalIOErrorIn("cyclicPolyPatch::cyclicPolyPatch(..)", dict)
+                    << "Illegal rotationAxis " << rotationAxis_ << endl
+                    << "Please supply a non-zero vector."
+                    << exit(FatalIOError);
+            }
+            rotationAxis_ /= magRot;
 
-                break;
-            }
-            case TRANSLATIONAL:
-            {
-                dict.lookup("separationVector") >> separationVector_;
-                break;
-            }
-            default:
-            {
-                // no additional info required
-            }
+            break;
+        }
+        case TRANSLATIONAL:
+        {
+            dict.lookup("separationVector") >> separationVector_;
+            break;
+        }
+        default:
+        {
+            // no additional info required
         }
     }
 
@@ -741,7 +735,6 @@ Foam::cyclicPolyPatch::cyclicPolyPatch
     coupledPolyPatch(pp, bm),
     neighbPatchName_(pp.neighbPatchName()),
     neighbPatchID_(-1),
-    transform_(pp.transform_),
     rotationAxis_(pp.rotationAxis_),
     rotationCentre_(pp.rotationCentre_),
     separationVector_(pp.separationVector_),
@@ -766,7 +759,6 @@ Foam::cyclicPolyPatch::cyclicPolyPatch
     coupledPolyPatch(pp, bm, index, newSize, newStart),
     neighbPatchName_(neighbPatchName),
     neighbPatchID_(-1),
-    transform_(pp.transform_),
     rotationAxis_(pp.rotationAxis_),
     rotationCentre_(pp.rotationCentre_),
     separationVector_(pp.separationVector_),
@@ -798,7 +790,6 @@ Foam::cyclicPolyPatch::cyclicPolyPatch
     coupledPolyPatch(pp, bm, index, mapAddressing, newStart),
     neighbPatchName_(pp.neighbPatchName_),
     neighbPatchID_(-1),
-    transform_(pp.transform_),
     rotationAxis_(pp.rotationAxis_),
     rotationCentre_(pp.rotationCentre_),
     separationVector_(pp.separationVector_),
@@ -857,7 +848,7 @@ void Foam::cyclicPolyPatch::transformPosition(pointField& l) const
 {
     if (!parallel())
     {
-        if (transform_ == ROTATIONAL)
+        if (transform() == ROTATIONAL)
         {
             l =
                 Foam::transform(forwardT(), l-rotationCentre_)
@@ -900,7 +891,7 @@ void Foam::cyclicPolyPatch::transformPosition(point& l, const label facei) const
           : forwardT()[facei]
         );
 
-        if (transform_ == ROTATIONAL)
+        if (transform() == ROTATIONAL)
         {
             l = Foam::transform(T, l-rotationCentre_) + rotationCentre_;
         }
@@ -1274,7 +1265,7 @@ bool Foam::cyclicPolyPatch::order
     rotation.setSize(pp.size());
     rotation = 0;
 
-    if (transform_ == NOORDERING)
+    if (transform() == NOORDERING)
     {
         // No faces, nothing to change.
         return false;
@@ -1455,12 +1446,10 @@ void Foam::cyclicPolyPatch::write(Ostream& os) const
     coupledPolyPatch::write(os);
     os.writeKeyword("neighbourPatch") << neighbPatchName_
         << token::END_STATEMENT << nl;
-    switch (transform_)
+    switch (transform())
     {
         case ROTATIONAL:
         {
-            os.writeKeyword("transform") << transformTypeNames[transform_]
-                << token::END_STATEMENT << nl;
             os.writeKeyword("rotationAxis") << rotationAxis_
                 << token::END_STATEMENT << nl;
             os.writeKeyword("rotationCentre") << rotationCentre_
@@ -1469,16 +1458,12 @@ void Foam::cyclicPolyPatch::write(Ostream& os) const
         }
         case TRANSLATIONAL:
         {
-            os.writeKeyword("transform") << transformTypeNames[transform_]
-                << token::END_STATEMENT << nl;
             os.writeKeyword("separationVector") << separationVector_
                 << token::END_STATEMENT << nl;
             break;
         }
         case NOORDERING:
         {
-            os.writeKeyword("transform") << transformTypeNames[transform_]
-                << token::END_STATEMENT << nl;
             break;
         }
         default:
diff --git a/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/cyclic/cyclicPolyPatch.H b/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/cyclic/cyclicPolyPatch.H
index f2f1c49a87..8f094da8cf 100644
--- a/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/cyclic/cyclicPolyPatch.H
+++ b/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/cyclic/cyclicPolyPatch.H
@@ -72,9 +72,6 @@ class cyclicPolyPatch
         //- Index of other half
         mutable label neighbPatchID_;
 
-        //- Type of transformation - rotational or translational
-        transformType transform_;
-
         // For rotation
 
             //- Axis of rotation for rotational cyclics
@@ -202,7 +199,8 @@ public:
             const label start,
             const label index,
             const polyBoundaryMesh& bm,
-            const word& patchType
+            const word& patchType,
+            const transformType transform = UNKNOWN
         );
 
         //- Construct from components
@@ -371,12 +369,6 @@ public:
             }
         }
 
-        //- Type of transform
-        transformType transform() const
-        {
-            return transform_;
-        }
-
         //- Axis of rotation for rotational cyclics
         const vector& rotationAxis() const
         {
diff --git a/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/cyclicSlip/cyclicSlipPolyPatch.H b/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/cyclicSlip/cyclicSlipPolyPatch.H
index fc2de2d14f..9eed97fafe 100644
--- a/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/cyclicSlip/cyclicSlipPolyPatch.H
+++ b/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/cyclicSlip/cyclicSlipPolyPatch.H
@@ -68,10 +68,11 @@ public:
             const label start,
             const label index,
             const polyBoundaryMesh& bm,
-            const word& patchType
+            const word& patchType,
+            const transformType transform = UNKNOWN
         )
         :
-            cyclicPolyPatch(name, size, start, index, bm, patchType)
+            cyclicPolyPatch(name, size, start, index, bm, patchType, transform)
         {}
 
         //- Construct from dictionary
diff --git a/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/nonuniformTransformCyclic/nonuniformTransformCyclicPolyPatch.H b/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/nonuniformTransformCyclic/nonuniformTransformCyclicPolyPatch.H
index 8ed56b3878..75431fdaa8 100644
--- a/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/nonuniformTransformCyclic/nonuniformTransformCyclicPolyPatch.H
+++ b/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/nonuniformTransformCyclic/nonuniformTransformCyclicPolyPatch.H
@@ -68,10 +68,11 @@ public:
             const label start,
             const label index,
             const polyBoundaryMesh& bm,
-            const word& patchType
+            const word& patchType,
+            const transformType transform = UNKNOWN
         )
         :
-            cyclicPolyPatch(name, size, start, index, bm, patchType)
+            cyclicPolyPatch(name, size, start, index, bm, patchType, transform)
         {}
 
         //- Construct from dictionary
diff --git a/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/oldCyclic/oldCyclicPolyPatch.C b/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/oldCyclic/oldCyclicPolyPatch.C
index 7dc587bbfe..627aced76a 100644
--- a/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/oldCyclic/oldCyclicPolyPatch.C
+++ b/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/oldCyclic/oldCyclicPolyPatch.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -43,23 +43,8 @@ namespace Foam
 
     addToRunTimeSelectionTable(polyPatch, oldCyclicPolyPatch, word);
     addToRunTimeSelectionTable(polyPatch, oldCyclicPolyPatch, dictionary);
-
-    template<>
-    const char* Foam::NamedEnum
-    <
-        Foam::oldCyclicPolyPatch::transformType,
-        3
-    >::names[] =
-    {
-        "unknown",
-        "rotational",
-        "translational"
-    };
 }
 
-const Foam::NamedEnum<Foam::oldCyclicPolyPatch::transformType, 3>
-    Foam::oldCyclicPolyPatch::transformTypeNames;
-
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 Foam::pointField Foam::oldCyclicPolyPatch::calcFaceCentres
@@ -321,7 +306,7 @@ void Foam::oldCyclicPolyPatch::getCentresAndAnchors
     anchors0 = getAnchorPoints(half0Faces, pp.points());
     half1Ctrs = calcFaceCentres(half1Faces, pp.points());
 
-    switch (transform_)
+    switch (transform())
     {
         case ROTATIONAL:
         {
@@ -588,12 +573,12 @@ Foam::oldCyclicPolyPatch::oldCyclicPolyPatch
     const label start,
     const label index,
     const polyBoundaryMesh& bm,
-    const word& patchType
+    const word& patchType,
+    const transformType transform
 )
 :
-    coupledPolyPatch(name, size, start, index, bm, patchType),
+    coupledPolyPatch(name, size, start, index, bm, patchType, transform),
     featureCos_(0.9),
-    transform_(UNKNOWN),
     rotationAxis_(vector::zero),
     rotationCentre_(point::zero),
     separationVector_(vector::zero)
@@ -611,7 +596,6 @@ Foam::oldCyclicPolyPatch::oldCyclicPolyPatch
 :
     coupledPolyPatch(name, dict, index, bm, patchType),
     featureCos_(0.9),
-    transform_(UNKNOWN),
     rotationAxis_(vector::zero),
     rotationCentre_(point::zero),
     separationVector_(vector::zero)
@@ -638,26 +622,22 @@ Foam::oldCyclicPolyPatch::oldCyclicPolyPatch
 
     dict.readIfPresent("featureCos", featureCos_);
 
-    if (dict.found("transform"))
+    switch (transform())
     {
-        transform_ = transformTypeNames.read(dict.lookup("transform"));
-        switch (transform_)
+        case ROTATIONAL:
         {
-            case ROTATIONAL:
-            {
-                dict.lookup("rotationAxis") >> rotationAxis_;
-                dict.lookup("rotationCentre") >> rotationCentre_;
-                break;
-            }
-            case TRANSLATIONAL:
-            {
-                dict.lookup("separationVector") >> separationVector_;
-                break;
-            }
-            default:
-            {
-                // no additional info required
-            }
+            dict.lookup("rotationAxis") >> rotationAxis_;
+            dict.lookup("rotationCentre") >> rotationCentre_;
+            break;
+        }
+        case TRANSLATIONAL:
+        {
+            dict.lookup("separationVector") >> separationVector_;
+            break;
+        }
+        default:
+        {
+            // no additional info required
         }
     }
 }
@@ -671,7 +651,6 @@ Foam::oldCyclicPolyPatch::oldCyclicPolyPatch
 :
     coupledPolyPatch(pp, bm),
     featureCos_(pp.featureCos_),
-    transform_(pp.transform_),
     rotationAxis_(pp.rotationAxis_),
     rotationCentre_(pp.rotationCentre_),
     separationVector_(pp.separationVector_)
@@ -689,7 +668,6 @@ Foam::oldCyclicPolyPatch::oldCyclicPolyPatch
 :
     coupledPolyPatch(pp, bm, index, newSize, newStart),
     featureCos_(pp.featureCos_),
-    transform_(pp.transform_),
     rotationAxis_(pp.rotationAxis_),
     rotationCentre_(pp.rotationCentre_),
     separationVector_(pp.separationVector_)
@@ -1269,12 +1247,10 @@ void Foam::oldCyclicPolyPatch::write(Ostream& os) const
 
 
     os.writeKeyword("featureCos") << featureCos_ << token::END_STATEMENT << nl;
-    switch (transform_)
+    switch (transform())
     {
         case ROTATIONAL:
         {
-            os.writeKeyword("transform") << transformTypeNames[transform_]
-                << token::END_STATEMENT << nl;
             os.writeKeyword("rotationAxis") << rotationAxis_
                 << token::END_STATEMENT << nl;
             os.writeKeyword("rotationCentre") << rotationCentre_
@@ -1283,8 +1259,6 @@ void Foam::oldCyclicPolyPatch::write(Ostream& os) const
         }
         case TRANSLATIONAL:
         {
-            os.writeKeyword("transform") << transformTypeNames[transform_]
-                << token::END_STATEMENT << nl;
             os.writeKeyword("separationVector") << separationVector_
                 << token::END_STATEMENT << nl;
             break;
diff --git a/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/oldCyclic/oldCyclicPolyPatch.H b/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/oldCyclic/oldCyclicPolyPatch.H
index 5d996988c2..d3d623dddb 100644
--- a/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/oldCyclic/oldCyclicPolyPatch.H
+++ b/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/oldCyclic/oldCyclicPolyPatch.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -54,27 +54,12 @@ class oldCyclicPolyPatch
 :
     public coupledPolyPatch
 {
-public:
-
-    enum transformType
-    {
-        UNKNOWN,
-        ROTATIONAL,
-        TRANSLATIONAL
-    };
-    static const NamedEnum<transformType, 3> transformTypeNames;
-
-
-private:
-
     // Private data
 
         //- Morph:angle between normals of neighbouring faces.
         //  Used to split cyclic into halves.
         scalar featureCos_;
 
-        //- Type of transformation - rotational or translational
-        transformType transform_;
 
         // For rotation
 
@@ -199,7 +184,8 @@ public:
             const label start,
             const label index,
             const polyBoundaryMesh& bm,
-            const word& patchType
+            const word& patchType,
+            const transformType transform = UNKNOWN
         );
 
         //- Construct from dictionary
diff --git a/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processor/processorPolyPatch.C b/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processor/processorPolyPatch.C
index 05664dd6ea..5da47a6ce4 100644
--- a/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processor/processorPolyPatch.C
+++ b/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processor/processorPolyPatch.C
@@ -34,6 +34,7 @@ License
 #include "Time.H"
 #include "transformList.H"
 #include "PstreamBuffers.H"
+#include "const_circulator.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -54,10 +55,11 @@ Foam::processorPolyPatch::processorPolyPatch
     const label index,
     const polyBoundaryMesh& bm,
     const int myProcNo,
-    const int neighbProcNo
+    const int neighbProcNo,
+    const transformType transform
 )
 :
-    coupledPolyPatch(name, size, start, index, bm, typeName),
+    coupledPolyPatch(name, size, start, index, bm, typeName, transform),
     myProcNo_(myProcNo),
     neighbProcNo_(neighbProcNo),
     neighbFaceCentres_(),
@@ -173,7 +175,6 @@ void Foam::processorPolyPatch::calcGeometry(PstreamBuffers& pBufs)
                 >> neighbFaceCellCentres_;
         }
 
-
         // My normals
         vectorField faceNormals(size());
 
@@ -181,8 +182,7 @@ void Foam::processorPolyPatch::calcGeometry(PstreamBuffers& pBufs)
         vectorField nbrFaceNormals(neighbFaceAreas_.size());
 
         // Face match tolerances
-        scalarField tols =
-            calcFaceTol(*this, points(), faceCentres());
+        scalarField tols = calcFaceTol(*this, points(), faceCentres());
 
         // Calculate normals from areas and check
         forAll(faceNormals, facei)
@@ -191,13 +191,15 @@ void Foam::processorPolyPatch::calcGeometry(PstreamBuffers& pBufs)
             scalar nbrMagSf = mag(neighbFaceAreas_[facei]);
             scalar avSf = (magSf + nbrMagSf)/2.0;
 
-            if (magSf < ROOTVSMALL && nbrMagSf < ROOTVSMALL)
+            // For small face area calculation the results of the area
+            // calculation have been found to only be accurate to ~1e-20
+            if (magSf < SMALL && nbrMagSf < SMALL)
             {
                 // Undetermined normal. Use dummy normal to force separation
-                // check. (note use of sqrt(VSMALL) since that is how mag
-                // scales)
+                // check.
                 faceNormals[facei] = point(1, 0, 0);
-                nbrFaceNormals[facei] = faceNormals[facei];
+                nbrFaceNormals[facei] = -faceNormals[facei];
+                tols[facei] = GREAT;
             }
             else if (mag(magSf - nbrMagSf) > matchTolerance()*sqr(tols[facei]))
             {
@@ -271,7 +273,8 @@ void Foam::processorPolyPatch::calcGeometry(PstreamBuffers& pBufs)
             faceNormals,
             nbrFaceNormals,
             matchTolerance()*tols,
-            matchTolerance()
+            matchTolerance(),
+            transform()
         );
     }
 }
@@ -391,6 +394,7 @@ void Foam::processorPolyPatch::updateMesh(PstreamBuffers& pBufs)
         {
             // Find face and index in face on this side.
             const face& f = localFaces()[nbrPointFace[nbrPointI]];
+
             label index = (f.size() - nbrPointIndex[nbrPointI]) % f.size();
             label patchPointI = f[index];
 
@@ -486,7 +490,11 @@ void Foam::processorPolyPatch::initOrder
     const primitivePatch& pp
 ) const
 {
-    if (!Pstream::parRun())
+    if
+    (
+        !Pstream::parRun()
+     || transform() == NOORDERING
+    )
     {
         return;
     }
@@ -522,15 +530,154 @@ void Foam::processorPolyPatch::initOrder
 
     if (owner())
     {
-        pointField anchors(getAnchorPoints(pp, pp.points()));
+        if (transform() == COINCIDENTFULLMATCH)
+        {
+            // Pass the patch points and faces across
+            UOPstream toNeighbour(neighbProcNo(), pBufs);
+            toNeighbour << pp.localPoints()
+                        << pp.localFaces();
+        }
+        else
+        {
+            const pointField& ppPoints = pp.points();
 
-        // Now send all info over to the neighbour
-        UOPstream toNeighbour(neighbProcNo(), pBufs);
-        toNeighbour << pp.faceCentres() << anchors;
+            pointField anchors(getAnchorPoints(pp, ppPoints, transform()));
+
+            // Get the average of the points of each face. This is needed in
+            // case the face centroid calculation is incorrect due to the face
+            // having a very high aspect ratio.
+            pointField facePointAverages(pp.size(), point::zero);
+            forAll(pp, fI)
+            {
+                const labelList& facePoints = pp[fI];
+
+                forAll(facePoints, pI)
+                {
+                    facePointAverages[fI] += ppPoints[facePoints[pI]];
+                }
+
+                facePointAverages[fI] /= facePoints.size();
+            }
+
+            // Now send all info over to the neighbour
+            UOPstream toNeighbour(neighbProcNo(), pBufs);
+            toNeighbour << pp.faceCentres() << pp.faceNormals()
+                        << anchors << facePointAverages;
+        }
     }
 }
 
 
+// Returns rotation.
+// + -1 : no match
+// +  0 : match
+// + >0 : match if rotated clockwise by this amount
+Foam::label Foam::processorPolyPatch::matchFace
+(
+    const face& a,
+    const pointField& aPts,
+    const face& b,
+    const pointField& bPts,
+    const bool sameOrientation,
+    const scalar absTolSqr,
+    scalar& matchDistSqr
+)
+{
+    if (a.size() != b.size())
+    {
+        return -1;
+    }
+
+    enum CirculatorBase::direction circulateDirection
+        = CirculatorBase::CLOCKWISE;
+
+    if (!sameOrientation)
+    {
+        circulateDirection = CirculatorBase::ANTICLOCKWISE;
+    }
+
+    label matchFp = -1;
+
+    scalar closestMatchDistSqr = sqr(GREAT);
+
+    const_circulator<face> aCirc(a);
+    const_circulator<face> bCirc(b);
+
+    do
+    {
+        const scalar diffSqr = magSqr(aPts[aCirc()] - bPts[bCirc()]);
+
+        if (diffSqr < absTolSqr)
+        {
+            // Found a matching point. Set the fulcrum of b to the iterator
+            const_circulator<face> bCirc2 = bCirc;
+            ++aCirc;
+
+            bCirc2.setFulcrumToIterator();
+
+            if (!sameOrientation)
+            {
+                --bCirc2;
+            }
+            else
+            {
+                ++bCirc2;
+            }
+
+            matchDistSqr = diffSqr;
+
+            do
+            {
+                const scalar diffSqr2 = magSqr(aPts[aCirc()] - bPts[bCirc2()]);
+
+                if (diffSqr2 > absTolSqr)
+                {
+                    // No match.
+                    break;
+                }
+
+                matchDistSqr += diffSqr2;
+            }
+            while
+            (
+                aCirc.circulate(CirculatorBase::CLOCKWISE),
+                bCirc2.circulate(circulateDirection)
+            );
+
+            if (!aCirc.circulate())
+            {
+                if (matchDistSqr < closestMatchDistSqr)
+                {
+                    closestMatchDistSqr = matchDistSqr;
+
+                    if (!sameOrientation)
+                    {
+                        matchFp = a.size() - bCirc.nRotations();
+                    }
+                    else
+                    {
+                        matchFp = bCirc.nRotations();
+                    }
+
+                    if (closestMatchDistSqr == 0)
+                    {
+                        break;
+                    }
+                }
+            }
+
+            // Reset aCirc
+            aCirc.setIteratorToFulcrum();
+        }
+
+    } while (bCirc.circulate(circulateDirection));
+
+    matchDistSqr = closestMatchDistSqr;
+
+    return matchFp;
+}
+
+
 // Return new ordering. Ordering is -faceMap: for every face index
 // the new face -rotation:for every new face the clockwise shift
 // of the original face. Return false if nothing changes (faceMap
@@ -545,7 +692,11 @@ bool Foam::processorPolyPatch::order
 {
     // Note: we only get the faces that originate from internal faces.
 
-    if (!Pstream::parRun())
+    if
+    (
+        !Pstream::parRun()
+     || transform() == NOORDERING
+    )
     {
         return false;
     }
@@ -556,6 +707,8 @@ bool Foam::processorPolyPatch::order
     rotation.setSize(pp.size());
     rotation = 0;
 
+    bool change = false;
+
     if (owner())
     {
         // Do nothing (i.e. identical mapping, zero rotation).
@@ -565,176 +718,363 @@ bool Foam::processorPolyPatch::order
             faceMap[patchFaceI] = patchFaceI;
         }
 
-        return false;
+        if (transform() != COINCIDENTFULLMATCH)
+        {
+            const pointField& ppPoints = pp.points();
+
+            pointField anchors(getAnchorPoints(pp, ppPoints, transform()));
+
+            // Calculate typical distance from face centre
+            scalarField tols
+            (
+                matchTolerance()*calcFaceTol(pp, pp.points(), pp.faceCentres())
+            );
+
+            forAll(faceMap, patchFaceI)
+            {
+                const point& wantedAnchor = anchors[patchFaceI];
+
+                rotation[patchFaceI] = getRotation
+                (
+                    ppPoints,
+                    pp[patchFaceI],
+                    wantedAnchor,
+                    tols[patchFaceI]
+                );
+
+                if (rotation[patchFaceI] > 0)
+                {
+                    change = true;
+                }
+            }
+        }
+
+        return change;
     }
     else
     {
-        vectorField masterCtrs;
-        vectorField masterAnchors;
-
-        // Receive data from neighbour
+        if (transform() == COINCIDENTFULLMATCH)
         {
-            UIPstream fromNeighbour(neighbProcNo(), pBufs);
-            fromNeighbour >> masterCtrs >> masterAnchors;
-        }
+            vectorField masterPts;
+            faceList masterFaces;
 
-        // Calculate typical distance from face centre
-        scalarField tols
-        (
-            matchTolerance()*calcFaceTol(pp, pp.points(), pp.faceCentres())
-        );
-
-        if (debug || masterCtrs.size() != pp.size())
-        {
             {
-                OFstream nbrStr
+                UIPstream fromNeighbour(neighbProcNo(), pBufs);
+                fromNeighbour >> masterPts >> masterFaces;
+            }
+
+            const pointField& localPts = pp.localPoints();
+            const faceList& localFaces = pp.localFaces();
+
+            label nMatches = 0;
+
+            forAll(pp, lFaceI)
+            {
+                const face& localFace = localFaces[lFaceI];
+                label faceRotation = -1;
+
+                const scalar absTolSqr = sqr(SMALL);
+
+                scalar closestMatchDistSqr = sqr(GREAT);
+                scalar matchDistSqr = sqr(GREAT);
+                label closestFaceMatch = -1;
+                label closestFaceRotation = -1;
+
+                forAll(masterFaces, mFaceI)
+                {
+                    const face& masterFace = masterFaces[mFaceI];
+
+                    faceRotation = matchFace
+                    (
+                        localFace,
+                        localPts,
+                        masterFace,
+                        masterPts,
+                        false,
+                        absTolSqr,
+                        matchDistSqr
+                    );
+
+                    if
+                    (
+                        faceRotation != -1
+                     && matchDistSqr < closestMatchDistSqr
+                    )
+                    {
+                        closestMatchDistSqr = matchDistSqr;
+                        closestFaceMatch = mFaceI;
+                        closestFaceRotation = faceRotation;
+                    }
+
+                    if (closestMatchDistSqr == 0)
+                    {
+                        break;
+                    }
+                }
+
+                if (closestFaceRotation != -1 && closestMatchDistSqr == 0)
+                {
+                    faceMap[lFaceI] = closestFaceMatch;
+
+                    rotation[lFaceI] = closestFaceRotation;
+
+                    if (lFaceI != closestFaceMatch || closestFaceRotation > 0)
+                    {
+                        change = true;
+                    }
+
+                    nMatches++;
+                }
+                else
+                {
+                    Pout<< "Number of matches = " << nMatches << " / "
+                        << pp.size() << endl;
+
+                    pointField pts(localFace.size());
+                    forAll(localFace, pI)
+                    {
+                        const label localPtI = localFace[pI];
+                        pts[pI] = localPts[localPtI];
+                    }
+
+                    FatalErrorIn("Foam::processorPolyPatch::order(...) const")
+                        << "No match for face " << localFace << nl << pts
+                        << abort(FatalError);
+                }
+            }
+
+            return change;
+        }
+        else
+        {
+            vectorField masterCtrs;
+            vectorField masterNormals;
+            vectorField masterAnchors;
+            vectorField masterFacePointAverages;
+
+            // Receive data from neighbour
+            {
+                UIPstream fromNeighbour(neighbProcNo(), pBufs);
+                fromNeighbour >> masterCtrs >> masterNormals
+                              >> masterAnchors >> masterFacePointAverages;
+            }
+
+            // Calculate typical distance from face centre
+            scalarField tols
+            (
+                matchTolerance()*calcFaceTol(pp, pp.points(), pp.faceCentres())
+            );
+
+            if (debug || masterCtrs.size() != pp.size())
+            {
+                {
+                    OFstream nbrStr
+                    (
+                        boundaryMesh().mesh().time().path()
+                       /name() + "_nbrFaceCentres.obj"
+                    );
+                    Pout<< "processorPolyPatch::order : "
+                        << "Dumping neighbour faceCentres to " << nbrStr.name()
+                        << endl;
+                    forAll(masterCtrs, faceI)
+                    {
+                        writeOBJ(nbrStr, masterCtrs[faceI]);
+                    }
+                }
+
+                if (masterCtrs.size() != pp.size())
+                {
+                    FatalErrorIn
+                    (
+                        "processorPolyPatch::order(const primitivePatch&"
+                        ", labelList&, labelList&) const"
+                    )   << "in patch:" << name() << " : "
+                        << "Local size of patch is " << pp.size() << " (faces)."
+                        << endl
+                        << "Received from neighbour " << masterCtrs.size()
+                        << " faceCentres!"
+                        << abort(FatalError);
+                }
+            }
+
+            // Geometric match of face centre vectors
+            // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+            // 1. Try existing ordering and transformation
+            bool matchedAll = matchPoints
+            (
+                pp.faceCentres(),
+                masterCtrs,
+                pp.faceNormals(),
+                masterNormals,
+                tols,
+                false,
+                faceMap
+            );
+
+            // Try using face point average for matching
+            if (!matchedAll)
+            {
+                const pointField& ppPoints = pp.points();
+
+                pointField facePointAverages(pp.size(), point::zero);
+                forAll(pp, fI)
+                {
+                    const labelList& facePoints = pp[fI];
+
+                    forAll(facePoints, pI)
+                    {
+                        facePointAverages[fI] += ppPoints[facePoints[pI]];
+                    }
+
+                    facePointAverages[fI] /= facePoints.size();
+                }
+
+                scalarField tols2
+                (
+                    calcFaceTol(pp, pp.points(), facePointAverages)
+                );
+
+                labelList faceMap2(faceMap.size(), -1);
+                matchedAll = matchPoints
+                (
+                    facePointAverages,
+                    masterFacePointAverages,
+                    pp.faceNormals(),
+                    masterNormals,
+                    tols2,
+                    true,
+                    faceMap2
+                );
+
+                forAll(faceMap, oldFaceI)
+                {
+                    if (faceMap[oldFaceI] == -1)
+                    {
+                        faceMap[oldFaceI] = faceMap2[oldFaceI];
+                    }
+                }
+
+                matchedAll = true;
+
+                forAll(faceMap, oldFaceI)
+                {
+                    if (faceMap[oldFaceI] == -1)
+                    {
+                        matchedAll = false;
+                    }
+                }
+            }
+
+            if (!matchedAll || debug)
+            {
+                // Dump faces
+                fileName str
                 (
                     boundaryMesh().mesh().time().path()
-                   /name() + "_nbrFaceCentres.obj"
+                   /name() + "_faces.obj"
                 );
-                Pout<< "processorPolyPatch::order : "
-                    << "Dumping neighbour faceCentres to " << nbrStr.name()
-                    << endl;
-                forAll(masterCtrs, faceI)
-                {
-                    writeOBJ(nbrStr, masterCtrs[faceI]);
-                }
-            }
+                Pout<< "processorPolyPatch::order :"
+                    << " Writing faces to OBJ file " << str.name() << endl;
+                writeOBJ(str, pp, pp.points());
 
-            if (masterCtrs.size() != pp.size())
-            {
-                FatalErrorIn
+                OFstream ccStr
                 (
-                    "processorPolyPatch::order(const primitivePatch&"
-                    ", labelList&, labelList&) const"
-                )   << "in patch:" << name() << " : "
-                    << "Local size of patch is " << pp.size() << " (faces)."
-                    << endl
-                    << "Received from neighbour " << masterCtrs.size()
-                    << " faceCentres!"
-                    << abort(FatalError);
-            }
-        }
+                    boundaryMesh().mesh().time().path()
+                   /name() + "_faceCentresConnections.obj"
+                );
 
-        // Geometric match of face centre vectors
-        // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+                Pout<< "processorPolyPatch::order :"
+                    << " Dumping newly found match as lines between"
+                    << " corresponding face centres to OBJ file "
+                    << ccStr.name()
+                    << endl;
 
-        // 1. Try existing ordering and transformation
-        bool matchedAll = matchPoints
-        (
-            pp.faceCentres(),
-            masterCtrs,
-            tols,
-            true,
-            faceMap
-        );
+                label vertI = 0;
 
-        if (!matchedAll || debug)
-        {
-            // Dump faces
-            fileName str
-            (
-                boundaryMesh().mesh().time().path()
-               /name() + "_faces.obj"
-            );
-            Pout<< "processorPolyPatch::order :"
-                << " Writing faces to OBJ file " << str.name() << endl;
-            writeOBJ(str, pp, pp.points());
-
-            OFstream ccStr
-            (
-                boundaryMesh().mesh().time().path()
-               /name() + "_faceCentresConnections.obj"
-            );
-
-            Pout<< "processorPolyPatch::order :"
-                << " Dumping newly found match as lines between"
-                << " corresponding face centres to OBJ file " << ccStr.name()
-                << endl;
-
-            label vertI = 0;
-
-            forAll(pp.faceCentres(), faceI)
-            {
-                label masterFaceI = faceMap[faceI];
-
-                if (masterFaceI != -1)
+                forAll(pp.faceCentres(), faceI)
                 {
-                    const point& c0 = masterCtrs[masterFaceI];
-                    const point& c1 = pp.faceCentres()[faceI];
-                    writeOBJ(ccStr, c0, c1, vertI);
+                    label masterFaceI = faceMap[faceI];
+
+                    if (masterFaceI != -1)
+                    {
+                        const point& c0 = masterCtrs[masterFaceI];
+                        const point& c1 = pp.faceCentres()[faceI];
+                        writeOBJ(ccStr, c0, c1, vertI);
+                    }
                 }
             }
-        }
 
-        if (!matchedAll)
-        {
-            SeriousErrorIn
-            (
-                "processorPolyPatch::order(const primitivePatch&"
-                ", labelList&, labelList&) const"
-            )   << "in patch:" << name() << " : "
-                << "Cannot match vectors to faces on both sides of patch"
-                << endl
-                << "    masterCtrs[0]:" << masterCtrs[0] << endl
-                << "    ctrs[0]:" << pp.faceCentres()[0] << endl
-                << "    Please check your topology changes or maybe you have"
-                << " multiple separated (from cyclics) processor patches"
-                << endl
-                << "    Continuing with incorrect face ordering from now on!"
-                << endl;
-
-            return false;
-        }
-
-        // Set rotation.
-        forAll(faceMap, oldFaceI)
-        {
-            // The face f will be at newFaceI (after morphing) and we want its
-            // anchorPoint (= f[0]) to align with the anchorpoint for the
-            // corresponding face on the other side.
-
-            label newFaceI = faceMap[oldFaceI];
-
-            const point& wantedAnchor = masterAnchors[newFaceI];
-
-            rotation[newFaceI] = getRotation
-            (
-                pp.points(),
-                pp[oldFaceI],
-                wantedAnchor,
-                tols[oldFaceI]
-            );
-
-            if (rotation[newFaceI] == -1)
+            if (!matchedAll)
             {
                 SeriousErrorIn
                 (
                     "processorPolyPatch::order(const primitivePatch&"
                     ", labelList&, labelList&) const"
-                )   << "in patch " << name()
-                    << " : "
-                    << "Cannot find point on face " << pp[oldFaceI]
-                    << " with vertices "
-                    << UIndirectList<point>(pp.points(), pp[oldFaceI])()
-                    << " that matches point " << wantedAnchor
-                    << " when matching the halves of processor patch " << name()
-                    << "Continuing with incorrect face ordering from now on!"
+                )   << "in patch:" << name() << " : "
+                    << "Cannot match vectors to faces on both sides of patch"
+                    << endl
+                    << "    masterCtrs[0]:" << masterCtrs[0] << endl
+                    << "    ctrs[0]:" << pp.faceCentres()[0] << endl
+                    << "    Check your topology changes or maybe you have"
+                    << " multiple separated (from cyclics) processor patches"
+                    << endl
+                    << "    Continuing with incorrect face ordering from now on"
                     << endl;
 
                 return false;
             }
-        }
 
-        forAll(faceMap, faceI)
-        {
-            if (faceMap[faceI] != faceI || rotation[faceI] != 0)
+            // Set rotation.
+            forAll(faceMap, oldFaceI)
             {
-                return true;
-            }
-        }
+                // The face f will be at newFaceI (after morphing) and we want
+                // its anchorPoint (= f[0]) to align with the anchorpoint for
+                // the corresponding face on the other side.
 
-        return false;
+                label newFaceI = faceMap[oldFaceI];
+
+                const point& wantedAnchor = masterAnchors[newFaceI];
+
+                rotation[newFaceI] = getRotation
+                (
+                    pp.points(),
+                    pp[oldFaceI],
+                    wantedAnchor,
+                    tols[oldFaceI]
+                );
+
+                if (rotation[newFaceI] == -1)
+                {
+                    SeriousErrorIn
+                    (
+                        "processorPolyPatch::order(const primitivePatch&"
+                        ", labelList&, labelList&) const"
+                    )   << "in patch " << name()
+                        << " : "
+                        << "Cannot find point on face " << pp[oldFaceI]
+                        << " with vertices "
+                        << UIndirectList<point>(pp.points(), pp[oldFaceI])()
+                        << " that matches point " << wantedAnchor
+                        << " when matching the halves of processor patch "
+                        << name()
+                        << "Continuing with incorrect face ordering from now on"
+                        << endl;
+
+                    return false;
+                }
+            }
+
+            forAll(faceMap, faceI)
+            {
+                if (faceMap[faceI] != faceI || rotation[faceI] != 0)
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
     }
 }
 
diff --git a/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processor/processorPolyPatch.H b/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processor/processorPolyPatch.H
index 2b39411ee5..f40f97c94f 100644
--- a/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processor/processorPolyPatch.H
+++ b/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processor/processorPolyPatch.H
@@ -134,7 +134,8 @@ public:
             const label index,
             const polyBoundaryMesh& bm,
             const int myProcNo,
-            const int neighbProcNo
+            const int neighbProcNo,
+            const transformType transform = UNKNOWN  // transformation type
         );
 
         //- Construct from dictionary
@@ -309,6 +310,17 @@ public:
         //  refer to *this (except for name() and type() etc.)
         virtual void initOrder(PstreamBuffers&, const primitivePatch&) const;
 
+        static label matchFace
+        (
+            const face& localFace,
+            const pointField& localPts,
+            const face& masterFace,
+            const pointField& masterPts,
+            const bool sameOrientation,
+            const scalar absTolSqr,
+            scalar& matchDistSqr
+        );
+
         //- Return new ordering for primitivePatch.
         //  Ordering is -faceMap: for every face
         //  index of the new face -rotation:for every new face the clockwise
diff --git a/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processorCyclic/processorCyclicPolyPatch.C b/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processorCyclic/processorCyclicPolyPatch.C
index eaa818b9fe..8988a06eb2 100644
--- a/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processorCyclic/processorCyclicPolyPatch.C
+++ b/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processorCyclic/processorCyclicPolyPatch.C
@@ -51,10 +51,21 @@ Foam::processorCyclicPolyPatch::processorCyclicPolyPatch
     const polyBoundaryMesh& bm,
     const int myProcNo,
     const int neighbProcNo,
-    const word& referPatchName
+    const word& referPatchName,
+    const transformType transform
 )
 :
-    processorPolyPatch(name, size, start, index, bm, myProcNo, neighbProcNo),
+    processorPolyPatch
+    (
+        name,
+        size,
+        start,
+        index,
+        bm,
+        myProcNo,
+        neighbProcNo,
+        transform
+    ),
     tag_
     (
         Pstream::nProcs()*max(myProcNo, neighbProcNo)
diff --git a/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processorCyclic/processorCyclicPolyPatch.H b/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processorCyclic/processorCyclicPolyPatch.H
index 8d94466543..fa59414586 100644
--- a/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processorCyclic/processorCyclicPolyPatch.H
+++ b/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processorCyclic/processorCyclicPolyPatch.H
@@ -123,7 +123,8 @@ public:
             const polyBoundaryMesh& bm,
             const int myProcNo,
             const int neighbProcNo,
-            const word& referPatchName
+            const word& referPatchName,
+            const transformType transform = UNKNOWN
         );
 
         //- Construct from dictionary
@@ -274,6 +275,20 @@ public:
             return referPatch().owner();
         }
 
+        //- Type of transform
+        virtual transformType transform() const
+        {
+            return referPatch().transform();
+        }
+
+        //- Type of transform
+        //  This is currently only for use when collapsing generated
+        //  meshes that can have zero area faces.
+        virtual transformType& transform()
+        {
+            return const_cast<coupledPolyPatch&>(referPatch()).transform();
+        }
+
         //- Transform a patch-based position from other side to this side
         virtual void transformPosition(pointField& l) const
         {
diff --git a/src/OpenFOAM/meshes/polyMesh/zones/zone/zone.C b/src/OpenFOAM/meshes/polyMesh/zones/zone/zone.C
index 9d1b6e1504..23a7ab3d7f 100644
--- a/src/OpenFOAM/meshes/polyMesh/zones/zone/zone.C
+++ b/src/OpenFOAM/meshes/polyMesh/zones/zone/zone.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -30,7 +30,10 @@ License
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-defineTypeNameAndDebug(Foam::zone, 0);
+namespace Foam
+{
+defineTypeNameAndDebug(zone, 0);
+}
 
 
 // * * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * //
diff --git a/src/OpenFOAM/meshes/primitiveMesh/PrimitivePatch/PrimitivePatchName.C b/src/OpenFOAM/meshes/primitiveMesh/PrimitivePatch/PrimitivePatchName.C
index d561c20efa..79dd0e2de4 100644
--- a/src/OpenFOAM/meshes/primitiveMesh/PrimitivePatch/PrimitivePatchName.C
+++ b/src/OpenFOAM/meshes/primitiveMesh/PrimitivePatch/PrimitivePatchName.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -27,6 +27,10 @@ License
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-defineTypeNameAndDebug(Foam::PrimitivePatchName, 0);
+namespace Foam
+{
+defineTypeNameAndDebug(PrimitivePatchName, 0);
+}
+
 
 // ************************************************************************* //
diff --git a/src/OpenFOAM/meshes/primitiveMesh/PrimitivePatch/PrimitivePatchPointAddressing.C b/src/OpenFOAM/meshes/primitiveMesh/PrimitivePatch/PrimitivePatchPointAddressing.C
index 5782820c57..28bae4939c 100644
--- a/src/OpenFOAM/meshes/primitiveMesh/PrimitivePatch/PrimitivePatchPointAddressing.C
+++ b/src/OpenFOAM/meshes/primitiveMesh/PrimitivePatch/PrimitivePatchPointAddressing.C
@@ -28,6 +28,7 @@ Description
 
 #include "PrimitivePatch.H"
 #include "SLList.H"
+#include "ListOps.H"
 
 
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
@@ -62,34 +63,11 @@ calcPointEdges() const
             << abort(FatalError);
     }
 
-    const edgeList& e = edges();
-
-    // set up storage for pointEdges
-    List<SLList<label> > pointEdges(meshPoints().size());
-
-    forAll(e, edgeI)
-    {
-        pointEdges[e[edgeI].start()].append(edgeI);
-        pointEdges[e[edgeI].end()].append(edgeI);
-    }
-
-    // sort out the list
-    pointEdgesPtr_ = new labelListList(pointEdges.size());
+    pointEdgesPtr_ = new labelListList(meshPoints().size());
 
     labelListList& pe = *pointEdgesPtr_;
 
-    forAll(pointEdges, pointI)
-    {
-        const SLList<label>& pEdge = pointEdges[pointI];
-
-        pe[pointI].setSize(pEdge.size());
-
-        label i = 0;
-        forAllConstIter(SLList<label>, pEdge, iter)
-        {
-            pe[pointI][i++] = iter();
-        }
-    }
+    invertManyToMany(pe.size(), edges(), pe);
 
     if (debug)
     {
@@ -97,6 +75,76 @@ calcPointEdges() const
             << "calcPointEdges() finished calculating pointEdges"
             << endl;
     }
+
+    // Now order the edges of each point according to whether they share a
+    // face
+
+//    DynamicList<label> newEdgeList;
+
+//    forAll(pe, pointI)
+//    {
+//        const labelList& pEdges = pe[pointI];
+
+//        label edgeI = pEdges[0];
+
+//        label prevFaceI = edgeFaces()[edgeI][0];
+
+//        newEdgeList.clear();
+//        newEdgeList.setCapacity(pEdges.size());
+
+//        do
+//        {
+//            newEdgeList.append(edgeI);
+
+//            // Cross edge to next face
+//            const labelList& eFaces = edgeFaces()[edgeI];
+
+//            if (eFaces.size() != 2)
+//            {
+//                break;
+//            }
+
+//            label faceI = eFaces[0];
+//            if (faceI == prevFaceI)
+//            {
+//                faceI = eFaces[1];
+//            }
+
+//            // Cross face to next edge
+//            const labelList& fEdges = faceEdges()[faceI];
+
+//            forAll(fEdges, feI)
+//            {
+//                const label nextEdgeI = fEdges[feI];
+//                const edge& nextEdge = edges()[nextEdgeI];
+
+//                if
+//                (
+//                    nextEdgeI != edgeI
+//                 && (nextEdge.start() == pointI || nextEdge.end() == pointI)
+//                )
+//                {
+//                    edgeI = nextEdgeI;
+//                    break;
+//                }
+//            }
+
+//            prevFaceI = faceI;
+
+//        } while (edgeI != pEdges[0]);
+
+//        if (newEdgeList.size() == pEdges.size())
+//        {
+//            pe[pointI] = newEdgeList;
+//        }
+//    }
+
+//    if (debug)
+//    {
+//        Info<< "PrimitivePatch<Face, FaceList, PointField, PointType>::"
+//            << "calcPointEdges() finished ordering pointEdges"
+//            << endl;
+//    }
 }
 
 
diff --git a/src/OpenFOAM/meshes/primitiveMesh/primitiveMesh.C b/src/OpenFOAM/meshes/primitiveMesh/primitiveMesh.C
index 6d7516d7ea..595c286239 100644
--- a/src/OpenFOAM/meshes/primitiveMesh/primitiveMesh.C
+++ b/src/OpenFOAM/meshes/primitiveMesh/primitiveMesh.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -28,7 +28,10 @@ License
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-defineTypeNameAndDebug(Foam::primitiveMesh, 0);
+namespace Foam
+{
+defineTypeNameAndDebug(primitiveMesh, 0);
+}
 
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
diff --git a/src/OpenFOAM/meshes/primitiveMesh/primitiveMeshFaceCentresAndAreas.C b/src/OpenFOAM/meshes/primitiveMesh/primitiveMeshFaceCentresAndAreas.C
index 8de9076603..589ff7a98b 100644
--- a/src/OpenFOAM/meshes/primitiveMesh/primitiveMeshFaceCentresAndAreas.C
+++ b/src/OpenFOAM/meshes/primitiveMesh/primitiveMeshFaceCentresAndAreas.C
@@ -118,13 +118,12 @@ void Foam::primitiveMesh::makeFaceCentresAndAreas
                 sumAc += a*c;
             }
 
-
+            // This is to deal with zero-area faces. Mark very small faces
+            // to be detected in e.g., processorPolyPatch.
             if (sumA < ROOTVSMALL)
             {
-                // Sum of area too small. No chance of reliably calculating
-                // centroid so fallback to average.
                 fCtrs[facei] = fCentre;
-                fAreas[facei] = 0.5*sumN;
+                fAreas[facei] = vector::zero;
             }
             else
             {
diff --git a/src/OpenFOAM/meshes/primitiveMesh/primitivePatch/patchZones.C b/src/OpenFOAM/meshes/primitiveMesh/primitivePatch/patchZones.C
index 5b754a43e2..fe5a09b19f 100644
--- a/src/OpenFOAM/meshes/primitiveMesh/primitivePatch/patchZones.C
+++ b/src/OpenFOAM/meshes/primitiveMesh/primitivePatch/patchZones.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -25,10 +25,12 @@ License
 
 #include "patchZones.H"
 
-
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-defineTypeNameAndDebug(Foam::patchZones, 0);
+namespace Foam
+{
+defineTypeNameAndDebug(patchZones, 0);
+}
 
 
 // * * * * * * * * * * * * * * * Global Functions  * * * * * * * * * * * * * //
diff --git a/src/OpenFOAM/meshes/primitiveMesh/primitivePatch/walkPatch.C b/src/OpenFOAM/meshes/primitiveMesh/primitivePatch/walkPatch.C
index e7015a1f5b..9e1455874b 100644
--- a/src/OpenFOAM/meshes/primitiveMesh/primitivePatch/walkPatch.C
+++ b/src/OpenFOAM/meshes/primitiveMesh/primitivePatch/walkPatch.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -28,7 +28,11 @@ License
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-defineTypeNameAndDebug(Foam::walkPatch, 0);
+namespace Foam
+{
+defineTypeNameAndDebug(walkPatch, 0);
+}
+
 
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 
diff --git a/src/OpenFOAM/meshes/treeBoundBox/treeBoundBox.C b/src/OpenFOAM/meshes/treeBoundBox/treeBoundBox.C
index 956997974f..4c13182f14 100644
--- a/src/OpenFOAM/meshes/treeBoundBox/treeBoundBox.C
+++ b/src/OpenFOAM/meshes/treeBoundBox/treeBoundBox.C
@@ -238,45 +238,6 @@ Foam::treeBoundBox Foam::treeBoundBox::subBbox
 }
 
 
-bool Foam::treeBoundBox::overlaps
-(
-    const point& centre,
-    const scalar radiusSqr
-) const
-{
-    // Find out where centre is in relation to bb.
-    // Find nearest point on bb.
-    scalar distSqr = 0;
-
-    for (direction dir = 0; dir < vector::nComponents; dir++)
-    {
-        scalar d0 = min()[dir] - centre[dir];
-        scalar d1 = max()[dir] - centre[dir];
-
-        if ((d0 > 0) != (d1 > 0))
-        {
-            // centre inside both extrema. This component does not add any
-            // distance.
-        }
-        else if (Foam::mag(d0) < Foam::mag(d1))
-        {
-            distSqr += d0*d0;
-        }
-        else
-        {
-            distSqr += d1*d1;
-        }
-
-        if (distSqr > radiusSqr)
-        {
-            return false;
-        }
-    }
-
-    return true;
-}
-
-
 // line intersection. Returns true if line (start to end) inside
 // bb or intersects bb. Sets pt to intersection.
 //
diff --git a/src/OpenFOAM/meshes/treeBoundBox/treeBoundBox.H b/src/OpenFOAM/meshes/treeBoundBox/treeBoundBox.H
index aecdd905b3..d740c96143 100644
--- a/src/OpenFOAM/meshes/treeBoundBox/treeBoundBox.H
+++ b/src/OpenFOAM/meshes/treeBoundBox/treeBoundBox.H
@@ -272,9 +272,6 @@ public:
             //- Overlaps other bounding box?
             using boundBox::overlaps;
 
-            //- Overlaps boundingSphere (centre + sqr(radius))?
-            bool overlaps(const point&, const scalar radiusSqr) const;
-
             //- Intersects segment; set point to intersection position and face,
             //  return true if intersection found.
             //  (pt argument used during calculation even if not intersecting).
diff --git a/src/OpenFOAM/primitives/Pair/Pair.H b/src/OpenFOAM/primitives/Pair/Pair.H
index 3cd37f4d7b..7cf1aad63b 100644
--- a/src/OpenFOAM/primitives/Pair/Pair.H
+++ b/src/OpenFOAM/primitives/Pair/Pair.H
@@ -167,6 +167,19 @@ public:
         {
             return !(a == b);
         }
+
+        friend bool operator<(const Pair<Type>& a, const Pair<Type>& b)
+        {
+            return
+            (
+                a.first() < b.first()
+             ||
+                (
+                    !(b.first() < a.first())
+                 && a.second() < b.second()
+                )
+            );
+        }
 };
 
 
diff --git a/src/OpenFOAM/primitives/SymmTensor/SymmTensor.H b/src/OpenFOAM/primitives/SymmTensor/SymmTensor.H
index 8d82711e15..1a0dc8e4df 100644
--- a/src/OpenFOAM/primitives/SymmTensor/SymmTensor.H
+++ b/src/OpenFOAM/primitives/SymmTensor/SymmTensor.H
@@ -79,6 +79,7 @@ public:
         static const SymmTensor one;
         static const SymmTensor max;
         static const SymmTensor min;
+        static const SymmTensor I;
 
 
     //- Component labeling enumeration
diff --git a/src/OpenFOAM/primitives/SymmTensor/symmTensor/symmTensor.C b/src/OpenFOAM/primitives/SymmTensor/symmTensor/symmTensor.C
index a70e14c197..a0216ac322 100644
--- a/src/OpenFOAM/primitives/SymmTensor/symmTensor/symmTensor.C
+++ b/src/OpenFOAM/primitives/SymmTensor/symmTensor/symmTensor.C
@@ -75,6 +75,14 @@ const symmTensor symmTensor::min
                       -VGREAT
 );
 
+template<>
+const symmTensor symmTensor::I
+(
+    1, 0, 0,
+       1, 0,
+          1
+);
+
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
diff --git a/src/OpenFOAM/primitives/Tensor/Tensor.H b/src/OpenFOAM/primitives/Tensor/Tensor.H
index a1554dc916..b5d4379c60 100644
--- a/src/OpenFOAM/primitives/Tensor/Tensor.H
+++ b/src/OpenFOAM/primitives/Tensor/Tensor.H
@@ -82,6 +82,7 @@ public:
         static const Tensor one;
         static const Tensor max;
         static const Tensor min;
+        static const Tensor I;
 
 
     //- Component labeling enumeration
diff --git a/src/OpenFOAM/primitives/Tensor/tensor/tensor.C b/src/OpenFOAM/primitives/Tensor/tensor/tensor.C
index 57ecd897b3..a62eeff5e4 100644
--- a/src/OpenFOAM/primitives/Tensor/tensor/tensor.C
+++ b/src/OpenFOAM/primitives/Tensor/tensor/tensor.C
@@ -76,6 +76,14 @@ const tensor tensor::min
     -VGREAT, -VGREAT, -VGREAT
 );
 
+template<>
+const tensor tensor::I
+(
+    1, 0, 0,
+    0, 1, 0,
+    0, 0, 1
+);
+
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
diff --git a/src/OpenFOAM/primitives/Tensor2D/Tensor2D.H b/src/OpenFOAM/primitives/Tensor2D/Tensor2D.H
index ea3bca9d39..93d70e8537 100644
--- a/src/OpenFOAM/primitives/Tensor2D/Tensor2D.H
+++ b/src/OpenFOAM/primitives/Tensor2D/Tensor2D.H
@@ -75,6 +75,7 @@ public:
         static const Tensor2D one;
         static const Tensor2D max;
         static const Tensor2D min;
+        static const Tensor2D I;
 
 
     //- Component labeling enumeration
diff --git a/src/OpenFOAM/primitives/Tensor2D/tensor2D/tensor2D.C b/src/OpenFOAM/primitives/Tensor2D/tensor2D/tensor2D.C
index 08bc334e6d..3d86f738f0 100644
--- a/src/OpenFOAM/primitives/Tensor2D/tensor2D/tensor2D.C
+++ b/src/OpenFOAM/primitives/Tensor2D/tensor2D/tensor2D.C
@@ -70,6 +70,13 @@ const tensor2D tensor2D::min
     -VGREAT, -VGREAT
 );
 
+template<>
+const tensor2D tensor2D::I
+(
+    1, 0,
+    0, 1
+);
+
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
diff --git a/src/OpenFOAM/primitives/globalIndexAndTransform/globalIndexAndTransform.C b/src/OpenFOAM/primitives/globalIndexAndTransform/globalIndexAndTransform.C
index 66b556e27b..ec1e8efdda 100644
--- a/src/OpenFOAM/primitives/globalIndexAndTransform/globalIndexAndTransform.C
+++ b/src/OpenFOAM/primitives/globalIndexAndTransform/globalIndexAndTransform.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -28,9 +28,11 @@ License
 
 // * * * * * * * * * * * * Private Static Data Members * * * * * * * * * * * //
 
-defineTypeNameAndDebug(Foam::globalIndexAndTransform, 0);
-
-const Foam::label Foam::globalIndexAndTransform::base_ = 32;
+namespace Foam
+{
+defineTypeNameAndDebug(globalIndexAndTransform, 0);
+const label globalIndexAndTransform::base_ = 32;
+}
 
 
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
diff --git a/src/OpenFOAM/primitives/triad/triad.C b/src/OpenFOAM/primitives/triad/triad.C
new file mode 100644
index 0000000000..80218dc776
--- /dev/null
+++ b/src/OpenFOAM/primitives/triad/triad.C
@@ -0,0 +1,338 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "triad.H"
+#include "transform.H"
+#include "tensor.H"
+#include "quaternion.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+template<>
+const char* const triad::Vector<vector>::typeName = "triad";
+
+template<>
+const char* triad::Vector<vector>::componentNames[] = {"x", "y", "z"};
+
+const triad triad::zero(vector::zero, vector::zero, vector::zero);
+
+const triad triad::one(vector::one, vector::one, vector::one);
+
+const triad triad::max(vector::max, vector::max, vector::max);
+
+const triad triad::min(vector::min, vector::min, vector::min);
+
+const triad triad::unset(triad::max);
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::triad::triad(const quaternion& q)
+{
+    tensor Rt(q.R().T());
+    x() = Rt.x();
+    y() = Rt.y();
+    z() = Rt.z();
+}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+void Foam::triad::orthogonalize()
+{
+    // Hack for 2D z-slab cases
+    // if (!set(2))
+    // {
+    //     operator[](2) = vector(0, 0, 1);
+    // }
+
+    // If only two of the axes are set, set the third
+    if (set(0) && set(1) && !set(2))
+    {
+        operator[](2) = orthogonal(operator[](0), operator[](1));
+    }
+    else if (set(0) && set(2) && !set(1))
+    {
+        operator[](1) = orthogonal(operator[](0), operator[](2));
+    }
+    else if (set(1) && set(2) && !set(0))
+    {
+        operator[](0) = orthogonal(operator[](1), operator[](2));
+    }
+
+    // If all the axes are set
+    if (set())
+    {
+        for (int i=0; i<2; i++)
+        {
+        scalar o01 = mag(operator[](0) & operator[](1));
+        scalar o02 = mag(operator[](0) & operator[](2));
+        scalar o12 = mag(operator[](1) & operator[](2));
+
+        if (o01 < o02 && o01 < o12)
+        {
+            operator[](2) = orthogonal(operator[](0), operator[](1));
+
+            // if (o02 < o12)
+            // {
+            //     operator[](1) = orthogonal(operator[](0), operator[](2));
+            // }
+            // else
+            // {
+            //     operator[](0) = orthogonal(operator[](1), operator[](2));
+            // }
+        }
+        else if (o02 < o12)
+        {
+            operator[](1) = orthogonal(operator[](0), operator[](2));
+
+            // if (o01 < o12)
+            // {
+            //     operator[](2) = orthogonal(operator[](0), operator[](1));
+            // }
+            // else
+            // {
+            //     operator[](0) = orthogonal(operator[](1), operator[](2));
+            // }
+        }
+        else
+        {
+            operator[](0) = orthogonal(operator[](1), operator[](2));
+
+            // if (o02 < o01)
+            // {
+            //     operator[](1) = orthogonal(operator[](0), operator[](2));
+            // }
+            // else
+            // {
+            //     operator[](2) = orthogonal(operator[](0), operator[](1));
+            // }
+        }
+        }
+    }
+}
+
+
+void Foam::triad::operator+=(const triad& t2)
+{
+    if (t2.set(0) && !set(0))
+    {
+        operator[](0) = t2.operator[](0);
+    }
+
+    if (t2.set(1) && !set(1))
+    {
+        operator[](1) = t2.operator[](1);
+    }
+
+    if (t2.set(2) && !set(2))
+    {
+        operator[](2) = t2.operator[](2);
+    }
+
+    if (set() && t2.set())
+    {
+        direction correspondance[3];
+        short signd[3];
+
+        for (direction i=0; i<3; i++)
+        {
+            scalar mostAligned = -1;
+            for (direction j=0; j<3; j++)
+            {
+                bool set = false;
+                for (direction k=0; k<i; k++)
+                {
+                    if (correspondance[k] == j)
+                    {
+                        set = true;
+                        break;
+                    }
+                }
+
+                if (!set)
+                {
+                    scalar a = operator[](i) & t2.operator[](j);
+                    scalar maga = mag(a);
+
+                    if (maga > mostAligned)
+                    {
+                        correspondance[i] = j;
+                        mostAligned = maga;
+                        signd[i] = sign(a);
+                    }
+                }
+            }
+        }
+
+        for (direction i=0; i<3; i++)
+        {
+            operator[](i) += signd[i]*t2.operator[](correspondance[i]);
+        }
+    }
+}
+
+
+void Foam::triad::align(const vector& v)
+{
+    if (set())
+    {
+        vector mostAligned
+        (
+            mag(v & operator[](0)),
+            mag(v & operator[](1)),
+            mag(v & operator[](2))
+        );
+
+        scalar mav;
+
+        if
+        (
+            mostAligned.x() > mostAligned.y()
+         && mostAligned.x() > mostAligned.z()
+        )
+        {
+            mav = mostAligned.x();
+            mostAligned = operator[](0);
+        }
+        else if (mostAligned.y() > mostAligned.z())
+        {
+            mav = mostAligned.y();
+            mostAligned = operator[](1);
+        }
+        else
+        {
+            mav = mostAligned.z();
+            mostAligned = operator[](2);
+        }
+
+        if (mav < 0.99)
+        {
+            tensor R(rotationTensor(mostAligned, v));
+
+            operator[](0) = transform(R, operator[](0));
+            operator[](1) = transform(R, operator[](1));
+            operator[](2) = transform(R, operator[](2));
+        }
+    }
+}
+
+
+Foam::triad Foam::triad::sortxyz() const
+{
+    triad t;
+
+    if
+    (
+        mag(operator[](0).x()) > mag(operator[](1).x())
+     && mag(operator[](0).x()) > mag(operator[](2).x())
+    )
+    {
+        t[0] = operator[](0);
+
+        if (mag(operator[](1).y()) > mag(operator[](2).y()))
+        {
+            t[1] = operator[](1);
+            t[2] = operator[](2);
+        }
+        else
+        {
+            t[1] = operator[](2);
+            t[2] = operator[](1);
+        }
+    }
+    else if
+    (
+        mag(operator[](1).x()) > mag(operator[](2).x())
+    )
+    {
+        t[0] = operator[](1);
+
+        if (mag(operator[](0).y()) > mag(operator[](2).y()))
+        {
+            t[1] = operator[](0);
+            t[2] = operator[](2);
+        }
+        else
+        {
+            t[1] = operator[](2);
+            t[2] = operator[](0);
+        }
+    }
+    else
+    {
+        t[0] = operator[](2);
+
+        if (mag(operator[](0).y()) > mag(operator[](1).y()))
+        {
+            t[1] = operator[](0);
+            t[2] = operator[](1);
+        }
+        else
+        {
+            t[1] = operator[](1);
+            t[2] = operator[](0);
+        }
+    }
+
+    if (t[0].x() < 0) t[0] *= -1;
+    if (t[1].y() < 0) t[1] *= -1;
+    if (t[2].z() < 0) t[2] *= -1;
+
+    return t;
+}
+
+
+
+Foam::triad::operator quaternion() const
+{
+    tensor R;
+
+    R.xx() = x().x();
+    R.xy() = y().x();
+    R.xz() = z().x();
+
+    R.yx() = x().y();
+    R.yy() = y().y();
+    R.yz() = z().y();
+
+    R.zx() = x().z();
+    R.zy() = y().z();
+    R.zz() = z().z();
+
+    return quaternion(R);
+}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// ************************************************************************* //
diff --git a/src/OpenFOAM/primitives/triad/triad.H b/src/OpenFOAM/primitives/triad/triad.H
new file mode 100644
index 0000000000..624116602e
--- /dev/null
+++ b/src/OpenFOAM/primitives/triad/triad.H
@@ -0,0 +1,169 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 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::triad
+
+Description
+    Representation of a 3D Cartesian coordinate system as a Vector of vectors.
+
+See Also
+    Foam::quaternion
+
+SourceFiles
+    triadI.H
+    triad.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef triad_H
+#define triad_H
+
+#include "vector.H"
+#include "contiguous.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// Forward declaration of classes
+class Istream;
+class Ostream;
+
+// Forward declaration of friend functions and operators
+class triad;
+Istream& operator>>(Istream&, triad&);
+Ostream& operator<<(Ostream&, const triad&);
+
+class quaternion;
+
+
+/*---------------------------------------------------------------------------*\
+                           Class triad Declaration
+\*---------------------------------------------------------------------------*/
+
+class triad
+:
+    public Vector<vector>
+{
+
+public:
+
+    // Constructors
+
+        //- Construct null
+        inline triad();
+
+        //- Construct from components
+        inline triad(const Vector<vector>& vv);
+
+        //- Construct from coordinate axes
+        inline triad(const vector& x, const vector& y, const vector& z);
+
+        //- Construct from a primary axis with the other two unset
+        inline triad(const vector& pa);
+
+        //- Construct from a quaternion
+        triad(const quaternion& q);
+
+        //- Construct from Istream
+        inline triad(Istream&);
+
+
+    // Static data members
+
+        static const triad zero;
+        static const triad one;
+        static const triad max;
+        static const triad min;
+        static const triad unset;
+
+
+    // Member Functions
+
+        //- Is the vector in the direction d set
+        inline bool set(const direction d) const;
+
+        //- Are all the vector set
+        inline bool set() const;
+
+        //- Return the primary direction of the vector v
+        static inline direction primaryDirection(const vector& v);
+
+        //- Return the vector orthogonal to the two provided
+        static inline vector orthogonal(const vector& v1, const vector& v2);
+
+        //- Orthogonalize this triad so that it is ortho-normal
+        void orthogonalize();
+
+        //- Normalize each set axis vector to have a unit magnitude
+        void normalize();
+
+        //- Align this triad with the given vector v
+        //  by rotating the most aligned axis to be coincident with v
+        void align(const vector& v);
+
+        //- Sort the axes such that they are closest to the x, y and z axes
+        triad sortxyz() const;
+
+        //- convert to a quaternion
+        operator quaternion() const;
+
+
+    // Member Operators
+
+        inline void operator=(const Vector<vector>&);
+
+        //- Add the triad t2 to this triad
+        //  without normalizing or orthogonalizing
+        void operator+=(const triad& t2);
+
+
+    // IOstream Operators
+
+        inline friend Istream& operator>>(Istream&, triad&);
+        inline friend Ostream& operator<<(Ostream&, const triad&);
+};
+
+
+// * * * * * * * * * * * * * * * Global Functions  * * * * * * * * * * * * * //
+
+//- Data associated with quaternion type are contiguous
+template<>
+inline bool contiguous<triad>() {return true;}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#include "triadI.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/OpenFOAM/primitives/triad/triadI.H b/src/OpenFOAM/primitives/triad/triadI.H
new file mode 100644
index 0000000000..2025dd6dd7
--- /dev/null
+++ b/src/OpenFOAM/primitives/triad/triadI.H
@@ -0,0 +1,143 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+inline Foam::triad::triad()
+:
+    Vector<vector>(triad::unset)
+{}
+
+
+inline Foam::triad::triad(const Vector<vector>& vv)
+:
+    Vector<vector>(vv)
+{}
+
+
+inline Foam::triad::triad(const vector& x, const vector& y, const vector& z)
+:
+    Vector<vector>(x, y, z)
+{}
+
+
+inline Foam::triad::triad(const vector& pa)
+{
+    operator=(triad::unset);
+    operator[](primaryDirection(pa)) = pa;
+}
+
+
+inline Foam::triad::triad(Istream& is)
+:
+    Vector<vector>(is)
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+inline bool Foam::triad::set(const direction d) const
+{
+    return operator[](d)[0] < GREAT; // vector::zero;
+}
+
+
+inline bool Foam::triad::set() const
+{
+    return set(0) && set(1) && set(2);
+}
+
+
+inline Foam::direction Foam::triad::primaryDirection(const vector& v)
+{
+    if (mag(v.x()) > mag(v.y()) && mag(v.x()) > mag(v.z()))
+    {
+        return triad::X;
+    }
+    else if (mag(v.y()) > mag(v.z()))
+    {
+        return triad::Y;
+    }
+    else
+    {
+        return triad::Z;
+    }
+}
+
+
+inline Foam::vector Foam::triad::orthogonal
+(
+    const vector& v1,
+    const vector& v2
+)
+{
+    vector v3 = v1 ^ v2;
+
+    scalar magV3 = mag(v3);
+
+    if (magV3 > 0.5)
+    {
+        return v3/magV3;
+    }
+    else
+    {
+        return triad::unset[0];
+    }
+}
+
+
+inline void Foam::triad::normalize()
+{
+    if (set(0)) operator[](0) /= mag(operator[](0));
+    if (set(1)) operator[](1) /= mag(operator[](1));
+    if (set(2)) operator[](2) /= mag(operator[](2));
+}
+
+
+// * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
+
+inline void Foam::triad::operator=(const Vector<vector>& vv)
+{
+    Vector<vector>::operator=(vv);
+}
+
+
+// * * * * * * * * * * * * * * IOstream Operators  * * * * * * * * * * * * * //
+
+inline Foam::Istream& Foam::operator>>(Istream& is, triad& t)
+{
+    is >> static_cast<Vector<vector>&>(t);
+    return is;
+}
+
+
+inline Foam::Ostream& Foam::operator<<(Ostream& os, const triad& t)
+{
+    os << static_cast<const Vector<vector>&>(t);
+    return os;
+}
+
+
+// ************************************************************************* //
diff --git a/src/combustionModels/Make/options b/src/combustionModels/Make/options
index 77f96e3a4a..29d5e7e6a5 100644
--- a/src/combustionModels/Make/options
+++ b/src/combustionModels/Make/options
@@ -12,4 +12,5 @@ EXE_INC = \
 
 LIB_LIBS = \
     -lfiniteVolume \
+    -lcompressibleLESModels \
     -lchemistryModel
diff --git a/src/dynamicMesh/Make/files b/src/dynamicMesh/Make/files
index bb0ec3ddef..a3e8de6892 100644
--- a/src/dynamicMesh/Make/files
+++ b/src/dynamicMesh/Make/files
@@ -25,6 +25,7 @@ polyTopoChange/polyTopoChange/topoAction/topoActions.C
 polyTopoChange/polyTopoChanger/polyTopoChanger.C
 polyTopoChange/polyTopoChange/polyTopoChange.C
 polyTopoChange/polyTopoChange/addPatchCellLayer.C
+polyTopoChange/polyTopoChange/pointEdgeCollapse/pointEdgeCollapse.C
 polyTopoChange/polyTopoChange/edgeCollapser.C
 polyTopoChange/polyTopoChange/faceCollapser.C
 polyTopoChange/polyTopoChange/hexRef8.C
@@ -97,5 +98,6 @@ createShellMesh/createShellMesh.C
 
 extrudePatchMesh/extrudePatchMesh.C
 
+polyMeshFilter/polyMeshFilter.C
 
 LIB = $(FOAM_LIBBIN)/libdynamicMesh
diff --git a/src/dynamicMesh/fvMeshDistribute/fvMeshDistribute.C b/src/dynamicMesh/fvMeshDistribute/fvMeshDistribute.C
index e4794b634b..54aebc17e1 100644
--- a/src/dynamicMesh/fvMeshDistribute/fvMeshDistribute.C
+++ b/src/dynamicMesh/fvMeshDistribute/fvMeshDistribute.C
@@ -961,11 +961,14 @@ void Foam::fvMeshDistribute::addProcPatches
                 }
                 else
                 {
+                    const coupledPolyPatch& pcPatch
+                        = refCast<const coupledPolyPatch>
+                          (
+                              mesh_.boundaryMesh()[referPatchID[bFaceI]]
+                          );
+
                     // Processor boundary originating from cyclic
-                    const word& cycName = mesh_.boundaryMesh()
-                    [
-                        referPatchID[bFaceI]
-                    ].name();
+                    const word& cycName = pcPatch.name();
 
                     const word patchName =
                         "procBoundary"
@@ -984,7 +987,8 @@ void Foam::fvMeshDistribute::addProcPatches
                         mesh_.boundaryMesh(),
                         Pstream::myProcNo(),
                         nbrProc[bFaceI],
-                        cycName
+                        cycName,
+                        pcPatch.transform()
                     );
 
                     procPatchID[procI].insert
diff --git a/src/dynamicMesh/polyMeshFilter/polyMeshFilter.C b/src/dynamicMesh/polyMeshFilter/polyMeshFilter.C
new file mode 100644
index 0000000000..0aebc63a0d
--- /dev/null
+++ b/src/dynamicMesh/polyMeshFilter/polyMeshFilter.C
@@ -0,0 +1,1096 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "polyMeshFilter.H"
+#include "polyMesh.H"
+#include "fvMesh.H"
+#include "unitConversion.H"
+#include "edgeCollapser.H"
+#include "syncTools.H"
+#include "polyTopoChange.H"
+#include "globalIndex.H"
+#include "PackedBoolList.H"
+
+// * * * * * * * * * * * * * Static Member Functions * * * * * * * * * * * * //
+
+Foam::autoPtr<Foam::fvMesh> Foam::polyMeshFilter::copyMesh(const fvMesh& mesh)
+{
+    polyTopoChange originalMeshToNewMesh(mesh);
+
+    autoPtr<fvMesh> meshCopy;
+    autoPtr<mapPolyMesh> mapPtr = originalMeshToNewMesh.makeMesh
+    (
+        meshCopy,
+        IOobject
+        (
+            mesh.name(),
+            mesh.polyMesh::instance(),
+            mesh.time(),
+            IOobject::NO_READ,
+            IOobject::NO_WRITE,
+            false
+        ),
+        mesh,
+        true // parallel sync
+    );
+
+    const mapPolyMesh& map = mapPtr();
+
+    // Update fields
+    meshCopy().updateMesh(map);
+    if (map.hasMotionPoints())
+    {
+        meshCopy().movePoints(map.preMotionPoints());
+    }
+
+    return meshCopy;
+}
+
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+void Foam::polyMeshFilter::updatePointErrorCount
+(
+    const PackedBoolList& isErrorPoint,
+    const labelList& oldToNewMesh,
+    labelList& pointErrorCount
+) const
+{
+    forAll(mesh_.points(), pI)
+    {
+        if (isErrorPoint[oldToNewMesh[pI]])
+        {
+            pointErrorCount[pI]++;
+        }
+    }
+}
+
+
+void Foam::polyMeshFilter::checkMeshEdgesAndRelaxEdges
+(
+    const polyMesh& newMesh,
+    const labelList& oldToNewMesh,
+    const PackedBoolList& isErrorPoint,
+    const labelList& pointErrorCount
+)
+{
+    const edgeList& edges = mesh_.edges();
+
+    forAll(edges, edgeI)
+    {
+        const edge& e = edges[edgeI];
+        label newStart = oldToNewMesh[e[0]];
+        label newEnd = oldToNewMesh[e[1]];
+
+        if
+        (
+            pointErrorCount[e[0]] >= maxPointErrorCount_
+         || pointErrorCount[e[1]] >= maxPointErrorCount_
+        )
+        {
+            minEdgeLen_[edgeI] = 0;
+        }
+
+        if
+        (
+            (newStart >= 0 && isErrorPoint[newStart])
+         || (newEnd >= 0 && isErrorPoint[newEnd])
+        )
+        {
+            minEdgeLen_[edgeI] *= edgeReductionFactor_;
+        }
+    }
+
+    syncTools::syncEdgeList(mesh_, minEdgeLen_, minEqOp<scalar>(), scalar(0.0));
+
+    for (label smoothIter = 0; smoothIter < maxSmoothIters_; ++smoothIter)
+    {
+        // Smooth minEdgeLen
+        forAll(mesh_.edges(), edgeI)
+        {
+            const edge& e = mesh_.edges()[edgeI];
+
+            scalar sumMinEdgeLen = 0;
+            label nEdges = 0;
+
+            forAll(e, pointI)
+            {
+                const labelList& pEdges = mesh_.pointEdges()[e[pointI]];
+
+                forAll(pEdges, pEdgeI)
+                {
+                    const label pEdge = pEdges[pEdgeI];
+                    sumMinEdgeLen += minEdgeLen_[pEdge];
+                    nEdges++;
+                }
+            }
+
+            minEdgeLen_[edgeI] = min
+            (
+                minEdgeLen_[edgeI],
+                sumMinEdgeLen/nEdges
+            );
+        }
+
+        syncTools::syncEdgeList
+        (
+            mesh_,
+            minEdgeLen_,
+            minEqOp<scalar>(),
+            scalar(0.0)
+        );
+    }
+}
+
+
+void Foam::polyMeshFilter::checkMeshFacesAndRelaxEdges
+(
+    const polyMesh& newMesh,
+    const labelList& oldToNewMesh,
+    const PackedBoolList& isErrorPoint,
+    const labelList& pointErrorCount
+)
+{
+    const faceList& faces = mesh_.faces();
+
+    forAll(faces, faceI)
+    {
+        const face& f = faces[faceI];
+
+        forAll(f, fpI)
+        {
+            const label ptIndex = oldToNewMesh[f[fpI]];
+
+            if (pointErrorCount[f[fpI]] >= maxPointErrorCount_)
+            {
+                faceFilterFactor_[faceI] = 0;
+            }
+
+            if (isErrorPoint[ptIndex])
+            {
+                faceFilterFactor_[faceI] *= faceReductionFactor_;
+
+                break;
+            }
+        }
+    }
+
+    syncTools::syncFaceList(mesh_, faceFilterFactor_, minEqOp<scalar>());
+
+    for (label smoothIter = 0; smoothIter < maxSmoothIters_; ++smoothIter)
+    {
+        // Smooth faceFilterFactor
+        forAll(faces, faceI)
+        {
+            const labelList& fEdges = mesh_.faceEdges()[faceI];
+
+            scalar sumFaceFilterFactors = 0;
+            label nFaces = 0;
+
+            // This is important: Only smooth around faces that share an
+            // edge with a bad face
+            bool skipFace = true;
+
+            forAll(fEdges, fEdgeI)
+            {
+                const labelList& eFaces = mesh_.edgeFaces()[fEdges[fEdgeI]];
+
+                forAll(eFaces, eFaceI)
+                {
+                    const label eFace = eFaces[eFaceI];
+
+                    const face& f = faces[eFace];
+
+                    forAll(f, fpI)
+                    {
+                        const label ptIndex = oldToNewMesh[f[fpI]];
+
+                        if (isErrorPoint[ptIndex])
+                        {
+                            skipFace = false;
+                            break;
+                        }
+                    }
+
+                    if (eFace != faceI)
+                    {
+                        sumFaceFilterFactors += faceFilterFactor_[eFace];
+                        nFaces++;
+                    }
+                }
+            }
+
+            if (skipFace)
+            {
+                continue;
+            }
+
+            faceFilterFactor_[faceI] = min
+            (
+                faceFilterFactor_[faceI],
+                sumFaceFilterFactors/nFaces
+            );
+        }
+
+        // Face filter factor needs to be synchronised!
+        syncTools::syncFaceList(mesh_, faceFilterFactor_, minEqOp<scalar>());
+    }
+}
+
+
+Foam::labelList Foam::polyMeshFilter::findBoundaryPoints
+(
+    const polyMesh& mesh//,
+//    labelIOList& boundaryIOPts
+) const
+{
+    const polyBoundaryMesh& bMesh = mesh.boundaryMesh();
+
+    labelList boundaryPoint(mesh.nPoints(), -1);
+
+    // Get all processor boundary points and the processor patch label
+    // that they are on.
+    forAll(bMesh, patchI)
+    {
+        const polyPatch& patch = bMesh[patchI];
+
+        if (!isA<coupledPolyPatch>(patch))
+        {
+            forAll(patch, fI)
+            {
+                const face& f = patch[fI];
+
+                forAll(f, fp)
+                {
+                    boundaryPoint[f[fp]] = 0; //boundaryIOPts[f[fp]];
+                }
+            }
+        }
+    }
+
+    syncTools::syncPointList
+    (
+        mesh,
+        boundaryPoint,
+        maxEqOp<label>(),
+        labelMin
+    );
+
+    return boundaryPoint;
+}
+
+
+void Foam::polyMeshFilter::printScalarFieldStats
+(
+    const string desc,
+    const scalarField& fld
+) const
+{
+    Info<< incrIndent << indent << desc
+        << ": min = " << returnReduce(min(fld), minOp<scalar>())
+        << " av = "
+        << returnReduce(sum(fld), sumOp<scalar>())
+          /returnReduce(fld.size(), sumOp<label>())
+        << " max = " << returnReduce(max(fld), maxOp<scalar>())
+        << decrIndent << endl;
+}
+
+
+void Foam::polyMeshFilter::mapOldMeshEdgeFieldToNewMesh
+(
+    const polyMesh& newMesh,
+    const labelList& pointMap,
+    scalarField& newMeshMinEdgeLen
+) const
+{
+    scalarField tmp(newMesh.nEdges());
+
+    const edgeList& newEdges = newMesh.edges();
+
+    forAll(newEdges, newEdgeI)
+    {
+        const edge& newEdge = newEdges[newEdgeI];
+        const label pStart = newEdge.start();
+        const label pEnd = newEdge.end();
+
+        tmp[newEdgeI] = min
+        (
+            newMeshMinEdgeLen[pointMap[pStart]],
+            newMeshMinEdgeLen[pointMap[pEnd]]
+        );
+    }
+
+    newMeshMinEdgeLen.transfer(tmp);
+
+    syncTools::syncEdgeList
+    (
+        newMesh,
+        newMeshMinEdgeLen,
+        maxEqOp<scalar>(),
+        scalar(0.0)
+    );
+}
+
+
+void Foam::polyMeshFilter::mapOldMeshFaceFieldToNewMesh
+(
+    const polyMesh& newMesh,
+    const labelList& faceMap,
+    scalarField& newMeshFaceFilterFactor
+) const
+{
+    scalarField tmp(newMesh.nFaces());
+
+    forAll(faceMap, newFaceI)
+    {
+        const label oldFaceI = faceMap[newFaceI];
+
+        tmp[newFaceI] = newMeshFaceFilterFactor[oldFaceI];
+    }
+
+    newMeshFaceFilterFactor.transfer(tmp);
+
+    syncTools::syncFaceList
+    (
+        newMesh,
+        newMeshFaceFilterFactor,
+        maxEqOp<scalar>()
+    );
+}
+
+
+void Foam::polyMeshFilter::updateOldToNewPointMap
+(
+    const labelList& currToNew,
+    labelList& origToCurrentPointMap
+) const
+{
+    forAll(origToCurrentPointMap, origPointI)
+    {
+        label oldPointI = origToCurrentPointMap[origPointI];
+
+        if (oldPointI < currToNew.size())
+        {
+            label newPointI = currToNew[oldPointI];
+
+            if (newPointI != -1)
+            {
+                origToCurrentPointMap[origPointI] = newPointI;
+            }
+        }
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::polyMeshFilter::polyMeshFilter(const fvMesh& mesh)
+:
+    mesh_(mesh),
+    newMeshPtr_(),
+    dict_
+    (
+        IOobject
+        (
+            "collapseDict",
+            mesh.time().system(),
+            mesh.time(),
+            IOobject::MUST_READ,
+            IOobject::NO_WRITE
+        )
+    ),
+    collapseEdgesCoeffDict_(dict_.subDict("collapseEdgesCoeffs")),
+    collapseFacesCoeffDict_(dict_.subDict("collapseFacesCoeffs")),
+    meshQualityCoeffDict_(dict_.subDict("meshQualityCoeffs")),
+    minLen_(readScalar(collapseEdgesCoeffDict_.lookup("minimumEdgeLength"))),
+    maxCos_
+    (
+        ::cos
+        (
+            degToRad
+            (
+                readScalar(collapseEdgesCoeffDict_.lookup("maximumMergeAngle"))
+            )
+        )
+    ),
+    edgeReductionFactor_
+    (
+        readScalar(collapseEdgesCoeffDict_.lookup("reductionFactor"))
+    ),
+    maxIterations_
+    (
+        readLabel(meshQualityCoeffDict_.lookup("maximumIterations"))
+    ),
+    maxSmoothIters_
+    (
+        readLabel(meshQualityCoeffDict_.lookup("maximumSmoothingIterations"))
+    ),
+    initialFaceLengthFactor_
+    (
+        readScalar(collapseFacesCoeffDict_.lookup("initialFaceLengthFactor"))
+    ),
+    faceReductionFactor_
+    (
+        readScalar(collapseFacesCoeffDict_.lookup("reductionFactor"))
+    ),
+    maxPointErrorCount_
+    (
+        readLabel(meshQualityCoeffDict_.lookup("maxPointErrorCount"))
+    ),
+    minEdgeLen_(),
+    faceFilterFactor_()
+{
+    Info<< "Merging:" << nl
+        << "    edges with length less than " << minLen_ << " meters" << nl
+        << "    edges split by a point with edges in line to within "
+        << radToDeg(::acos(maxCos_)) << " degrees" << nl
+        << "    Minimum edge length reduction factor = "
+        << edgeReductionFactor_ << nl
+        << endl;
+
+    Info<< "Collapse faces with reduction factor = " << faceReductionFactor_
+        << endl;
+
+    Info<< "Selectively disabling wanted collapses until resulting quality"
+        << " satisfies constraints in system/meshQualityDict" << nl
+        << endl;
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::polyMeshFilter::~polyMeshFilter()
+{}
+
+
+// * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
+
+Foam::label Foam::polyMeshFilter::filter(const label nOriginalBadFaces)
+{
+    label nBadFaces = labelMax;
+    label nOuterIterations = 0;
+
+    minEdgeLen_.resize(mesh_.nEdges(), minLen_);
+    faceFilterFactor_.resize(mesh_.nFaces(), initialFaceLengthFactor_);
+
+    // Maintain the number of times a point has been part of a bad face
+    //
+    labelList pointErrorCount(mesh_.nPoints(), 0);
+
+    // Main loop
+    // ~~~~~~~~~
+    // It tries and do some collapses, checks the resulting mesh and
+    // 'freezes' some edges (by marking in minEdgeLen) and tries again.
+    // This will iterate ultimately to the situation where every edge is
+    // frozen and nothing gets collapsed.
+    while
+    (
+        nOuterIterations < maxIterations_
+     && nBadFaces > nOriginalBadFaces
+    )
+    {
+        Info<< nl << "Outer Iteration = " << nOuterIterations++ << nl
+            << endl;
+
+        printScalarFieldStats("Edge Filter Factor", minEdgeLen_);
+        printScalarFieldStats("Face Filter Factor", faceFilterFactor_);
+
+        // Reset the new mesh to the old mesh
+        newMeshPtr_ = copyMesh(mesh_);
+        fvMesh& newMesh = newMeshPtr_();
+
+        scalarField newMeshFaceFilterFactor = faceFilterFactor_;
+
+        labelList origToCurrentPointMap(identity(newMesh.nPoints()));
+        {
+
+            label nInnerIterations = 0;
+            label nPrevLocalCollapse = labelMax;
+
+            Info<< incrIndent;
+
+            while (true)
+            {
+                Info<< nl << indent << "Inner iteration = "
+                    << nInnerIterations++ << nl << incrIndent << endl;
+
+                // Per edge collapse status
+                PackedBoolList collapseEdge(newMesh.nEdges());
+
+                Map<point> collapsePointToLocation(newMesh.nPoints());
+
+                // Mark points on boundary
+                const labelList boundaryPoint = findBoundaryPoints
+                (
+                    newMesh//,
+    //                    boundaryIOPts
+                );
+
+                edgeCollapser collapser(newMesh, collapseFacesCoeffDict_);
+
+                // Per face collapse status:
+                //    -1 : not collapsed
+                //  >= 0 : index of point in face to collapse to
+                List<Map<point> > faceCollapseToPoints
+                (
+                    newMesh.nFaces(),
+                    Map<point>()
+                );
+
+                {
+                    // Collapse faces
+                    labelPair nCollapsedPtEdge = collapser.markSmallSliverFaces
+                    (
+                        newMeshFaceFilterFactor,
+                        boundaryPoint,
+                        collapseEdge,
+                        collapsePointToLocation
+                    );
+
+                    label nCollapsed = 0;
+                    forAll(nCollapsedPtEdge, collapseTypeI)
+                    {
+                        nCollapsed += nCollapsedPtEdge[collapseTypeI];
+                    }
+
+                    reduce(nCollapsed, sumOp<label>());
+
+                    Info<< indent
+                        << "Collapsing " << nCollapsed << " faces"
+                        << " (to point = "
+                        << returnReduce
+                           (
+                               nCollapsedPtEdge.first(),
+                               sumOp<label>()
+                           )
+                        << ", to edge = "
+                        << returnReduce
+                           (
+                               nCollapsedPtEdge.second(),
+                               sumOp<label>()
+                           )
+                        << ")" << endl;
+
+                    if (nCollapsed == 0)
+                    {
+                        Info<< decrIndent;
+                        Info<< decrIndent;
+                        break;
+                    }
+                }
+
+                // Merge edge collapses into consistent collapse-network.
+                // Make sure no cells get collapsed.
+                List<pointEdgeCollapse> allPointInfo;
+                const globalIndex globalPoints(newMesh.nPoints());
+
+                collapser.consistentCollapse
+                (
+                    globalPoints,
+                    boundaryPoint,
+                    collapsePointToLocation,
+                    collapseEdge,
+                    allPointInfo
+                );
+
+                label nLocalCollapse = collapseEdge.count();
+
+                reduce(nLocalCollapse, sumOp<label>());
+                Info<< nl << indent << "Collapsing " << nLocalCollapse
+                    << " edges after synchronisation and PointEdgeWave" << endl;
+
+                if (nLocalCollapse >= nPrevLocalCollapse)
+                {
+                    Info<< decrIndent;
+                    Info<< decrIndent;
+                    break;
+                }
+                else
+                {
+                    nPrevLocalCollapse = nLocalCollapse;
+                }
+
+                {
+                    // Apply collapses to current mesh
+                    polyTopoChange newMeshMod(newMesh);
+
+                    // Insert mesh refinement into polyTopoChange.
+                    collapser.setRefinement(allPointInfo, newMeshMod);
+
+                    Info<< indent << "Apply changes to the current mesh"
+                        << decrIndent << endl;
+
+                    // Apply changes to current mesh
+                    autoPtr<mapPolyMesh> newMapPtr = newMeshMod.changeMesh
+                    (
+                        newMesh,
+                        false
+                    );
+                    const mapPolyMesh& newMap = newMapPtr();
+
+                    // Update fields
+                    newMesh.updateMesh(newMap);
+                    if (newMap.hasMotionPoints())
+                    {
+                        newMesh.movePoints(newMap.preMotionPoints());
+                    }
+
+                    // Relabel the boundary points
+        //            labelList newBoundaryPoints(newMesh.nPoints(), -1);
+        //            forAll(newBoundaryPoints, pI)
+        //            {
+        //                const label newToOldptI= map.pointMap()[pI];
+        //                newBoundaryPoints[pI] = boundaryIOPts[newToOldptI];
+        //            }
+        //            boundaryIOPts = newBoundaryPoints;
+
+
+                    mapOldMeshFaceFieldToNewMesh
+                    (
+                        newMesh,
+                        newMap.faceMap(),
+                        newMeshFaceFilterFactor
+                    );
+
+                    updateOldToNewPointMap
+                    (
+                        newMap.reversePointMap(),
+                        origToCurrentPointMap
+                    );
+                }
+            }
+        }
+
+
+        scalarField newMeshMinEdgeLen = minEdgeLen_;
+
+        label nInnerIterations = 0;
+        label nPrevLocalCollapse = labelMax;
+
+        while (true)
+        {
+            Info<< nl << indent << "Inner iteration = "
+                << nInnerIterations++ << nl << incrIndent << endl;
+
+            // Per edge collapse status
+            PackedBoolList collapseEdge(newMesh.nEdges());
+
+            Map<point> collapsePointToLocation(newMesh.nPoints());
+
+            // Mark points on boundary
+            const labelList boundaryPoint = findBoundaryPoints
+            (
+                newMesh//,
+//                    boundaryIOPts
+            );
+
+            edgeCollapser collapser(newMesh, collapseFacesCoeffDict_);
+
+            // Work out which edges to collapse
+            // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+            // This is by looking at minEdgeLen (to avoid frozen edges)
+            // and marking in collapseEdge.
+            label nSmallCollapsed = collapser.markSmallEdges
+            (
+                newMeshMinEdgeLen,
+                boundaryPoint,
+                collapseEdge,
+                collapsePointToLocation
+            );
+
+            reduce(nSmallCollapsed, sumOp<label>());
+            Info<< indent << "Collapsing " << nSmallCollapsed
+                << " small edges" << endl;
+
+            // Merge inline edges
+            label nMerged = collapser.markMergeEdges
+            (
+                maxCos_,
+                boundaryPoint,
+                collapseEdge,
+                collapsePointToLocation
+            );
+
+            reduce(nMerged, sumOp<label>());
+            Info<< indent << "Collapsing " << nMerged << " in line edges"
+                << endl;
+
+            if (nMerged + nSmallCollapsed == 0)
+            {
+                Info<< decrIndent;
+                break;
+            }
+
+            // Merge edge collapses into consistent collapse-network.
+            // Make sure no cells get collapsed.
+            List<pointEdgeCollapse> allPointInfo;
+            const globalIndex globalPoints(newMesh.nPoints());
+
+            collapser.consistentCollapse
+            (
+                globalPoints,
+                boundaryPoint,
+                collapsePointToLocation,
+                collapseEdge,
+                allPointInfo
+            );
+
+            label nLocalCollapse = collapseEdge.count();
+
+            reduce(nLocalCollapse, sumOp<label>());
+            Info<< nl << indent << "Collapsing " << nLocalCollapse
+                << " edges after synchronisation and PointEdgeWave" << endl;
+
+            if (nLocalCollapse >= nPrevLocalCollapse)
+            {
+                Info<< decrIndent;
+                break;
+            }
+            else
+            {
+                nPrevLocalCollapse = nLocalCollapse;
+            }
+
+            // Apply collapses to current mesh
+            polyTopoChange newMeshMod(newMesh);
+
+            // Insert mesh refinement into polyTopoChange.
+            collapser.setRefinement(allPointInfo, newMeshMod);
+
+            Info<< indent << "Apply changes to the current mesh"
+                << decrIndent << endl;
+
+            // Apply changes to current mesh
+            autoPtr<mapPolyMesh> newMapPtr = newMeshMod.changeMesh
+            (
+                newMesh,
+                false
+            );
+            const mapPolyMesh& newMap = newMapPtr();
+
+            // Update fields
+            newMesh.updateMesh(newMap);
+            if (newMap.hasMotionPoints())
+            {
+                newMesh.movePoints(newMap.preMotionPoints());
+            }
+
+            // Relabel the boundary points
+//            labelList newBoundaryPoints(newMesh.nPoints(), -1);
+//            forAll(newBoundaryPoints, pI)
+//            {
+//                const label newToOldptI= map.pointMap()[pI];
+//                newBoundaryPoints[pI] = boundaryIOPts[newToOldptI];
+//            }
+//            boundaryIOPts = newBoundaryPoints;
+
+            // Synchronise the factors
+            mapOldMeshEdgeFieldToNewMesh
+            (
+                newMesh,
+                newMap.pointMap(),
+                newMeshMinEdgeLen
+            );
+
+            updateOldToNewPointMap
+            (
+                newMap.reversePointMap(),
+                origToCurrentPointMap
+            );
+        }
+
+
+        // Mesh check
+        // ~~~~~~~~~~~~~~~~~~
+        // Do not allow collapses in regions of error.
+        // Updates minEdgeLen, nRelaxedEdges
+
+        PackedBoolList isErrorPoint(newMesh.nPoints());
+        nBadFaces = edgeCollapser::checkMeshQuality
+        (
+            newMesh,
+            meshQualityCoeffDict_,
+            isErrorPoint
+        );
+
+        Info<< nl << "    Number of bad faces     : " << nBadFaces << nl
+            << "    Number of marked points : "
+            << returnReduce(isErrorPoint.count(), sumOp<unsigned int>())
+            << endl;
+
+        updatePointErrorCount
+        (
+            isErrorPoint,
+            origToCurrentPointMap,
+            pointErrorCount
+        );
+
+        checkMeshEdgesAndRelaxEdges
+        (
+            newMesh,
+            origToCurrentPointMap,
+            isErrorPoint,
+            pointErrorCount
+        );
+
+        checkMeshFacesAndRelaxEdges
+        (
+            newMesh,
+            origToCurrentPointMap,
+            isErrorPoint,
+            pointErrorCount
+        );
+    }
+
+    return nBadFaces;
+}
+
+
+Foam::label Foam::polyMeshFilter::filterEdges
+(
+    const label nOriginalBadFaces
+)
+{
+    label nBadFaces = labelMax/2;
+    label nPreviousBadFaces = labelMax;
+    label nOuterIterations = 0;
+
+    minEdgeLen_.resize(mesh_.nEdges(), minLen_);
+    faceFilterFactor_.resize(0);
+
+    labelList pointErrorCount(mesh_.nPoints(), 0);
+
+    // Main loop
+    // ~~~~~~~~~
+    // It tries and do some collapses, checks the resulting mesh and
+    // 'freezes' some edges (by marking in minEdgeLen) and tries again.
+    // This will iterate ultimately to the situation where every edge is
+    // frozen and nothing gets collapsed.
+    while
+    (
+        nOuterIterations < maxIterations_
+     && nBadFaces > nOriginalBadFaces
+     && nBadFaces < nPreviousBadFaces
+    )
+    {
+        Info<< nl << "Outer Iteration = " << nOuterIterations++ << nl
+            << endl;
+
+        printScalarFieldStats("Edge Filter Factor", minEdgeLen_);
+
+        nPreviousBadFaces = nBadFaces;
+
+        // Reset the new mesh to the old mesh
+        newMeshPtr_ = copyMesh(mesh_);
+        fvMesh& newMesh = newMeshPtr_();
+
+        scalarField newMeshMinEdgeLen = minEdgeLen_;
+
+        labelList origToCurrentPointMap(identity(newMesh.nPoints()));
+
+        label nInnerIterations = 0;
+        label nPrevLocalCollapse = labelMax;
+
+        Info<< incrIndent;
+
+        while (true)
+        {
+            Info<< nl << indent << "Inner iteration = "
+                << nInnerIterations++ << nl << incrIndent << endl;
+
+            // Per edge collapse status
+            PackedBoolList collapseEdge(newMesh.nEdges());
+
+            Map<point> collapsePointToLocation(newMesh.nPoints());
+
+            // Mark points on boundary
+            const labelList boundaryPoint = findBoundaryPoints
+            (
+                newMesh//,
+//                    boundaryIOPts
+            );
+
+            edgeCollapser collapser(newMesh, collapseFacesCoeffDict_);
+
+            // Work out which edges to collapse
+            // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+            // This is by looking at minEdgeLen (to avoid frozen edges)
+            // and marking in collapseEdge.
+            label nSmallCollapsed = collapser.markSmallEdges
+            (
+                newMeshMinEdgeLen,
+                boundaryPoint,
+                collapseEdge,
+                collapsePointToLocation
+            );
+
+            reduce(nSmallCollapsed, sumOp<label>());
+            Info<< indent << "Collapsing " << nSmallCollapsed
+                << " small edges" << endl;
+
+            // Merge inline edges
+            label nMerged = collapser.markMergeEdges
+            (
+                maxCos_,
+                boundaryPoint,
+                collapseEdge,
+                collapsePointToLocation
+            );
+
+            reduce(nMerged, sumOp<label>());
+            Info<< indent << "Collapsing " << nMerged << " in line edges"
+                << endl;
+
+            if (nMerged + nSmallCollapsed == 0)
+            {
+                Info<< decrIndent;
+                Info<< decrIndent;
+                break;
+            }
+
+            // Merge edge collapses into consistent collapse-network.
+            // Make sure no cells get collapsed.
+            List<pointEdgeCollapse> allPointInfo;
+            const globalIndex globalPoints(newMesh.nPoints());
+
+            collapser.consistentCollapse
+            (
+                globalPoints,
+                boundaryPoint,
+                collapsePointToLocation,
+                collapseEdge,
+                allPointInfo
+            );
+
+            label nLocalCollapse = collapseEdge.count();
+
+            reduce(nLocalCollapse, sumOp<label>());
+            Info<< nl << indent << "Collapsing " << nLocalCollapse
+                << " edges after synchronisation and PointEdgeWave" << endl;
+
+            if (nLocalCollapse >= nPrevLocalCollapse)
+            {
+                Info<< decrIndent;
+                Info<< decrIndent;
+                break;
+            }
+            else
+            {
+                nPrevLocalCollapse = nLocalCollapse;
+            }
+
+            // Apply collapses to current mesh
+            polyTopoChange newMeshMod(newMesh);
+
+            // Insert mesh refinement into polyTopoChange.
+            collapser.setRefinement(allPointInfo, newMeshMod);
+
+            Info<< indent << "Apply changes to the current mesh"
+                << decrIndent << endl;
+
+            // Apply changes to current mesh
+            autoPtr<mapPolyMesh> newMapPtr = newMeshMod.changeMesh
+            (
+                newMesh,
+                false
+            );
+            const mapPolyMesh& newMap = newMapPtr();
+
+            // Update fields
+            newMesh.updateMesh(newMap);
+            if (newMap.hasMotionPoints())
+            {
+                newMesh.movePoints(newMap.preMotionPoints());
+            }
+
+            // Relabel the boundary points
+//            labelList newBoundaryPoints(newMesh.nPoints(), -1);
+//            forAll(newBoundaryPoints, pI)
+//            {
+//                const label newToOldptI= map.pointMap()[pI];
+//                newBoundaryPoints[pI] = boundaryIOPts[newToOldptI];
+//            }
+//            boundaryIOPts = newBoundaryPoints;
+
+            // Synchronise the factors
+            mapOldMeshEdgeFieldToNewMesh
+            (
+                newMesh,
+                newMap.pointMap(),
+                newMeshMinEdgeLen
+            );
+
+            updateOldToNewPointMap
+            (
+                newMap.reversePointMap(),
+                origToCurrentPointMap
+            );
+        }
+
+        // Mesh check
+        // ~~~~~~~~~~~~~~~~~~
+        // Do not allow collapses in regions of error.
+        // Updates minEdgeLen, nRelaxedEdges
+
+        PackedBoolList isErrorPoint(newMesh.nPoints());
+        nBadFaces = edgeCollapser::checkMeshQuality
+        (
+            newMesh,
+            meshQualityCoeffDict_,
+            isErrorPoint
+        );
+
+        Info<< nl << "    Number of bad faces     : " << nBadFaces << nl
+            << "    Number of marked points : "
+            << returnReduce(isErrorPoint.count(), sumOp<unsigned int>())
+            << endl;
+
+        updatePointErrorCount
+        (
+            isErrorPoint,
+            origToCurrentPointMap,
+            pointErrorCount
+        );
+
+        checkMeshEdgesAndRelaxEdges
+        (
+            newMesh,
+            origToCurrentPointMap,
+            isErrorPoint,
+            pointErrorCount
+        );
+    }
+
+    return nBadFaces;
+}
+
+
+const Foam::autoPtr<Foam::fvMesh>& Foam::polyMeshFilter::filteredMesh() const
+{
+    return newMeshPtr_;
+}
+
+
+// ************************************************************************* //
diff --git a/src/dynamicMesh/polyMeshFilter/polyMeshFilter.H b/src/dynamicMesh/polyMeshFilter/polyMeshFilter.H
new file mode 100644
index 0000000000..e00877a8c1
--- /dev/null
+++ b/src/dynamicMesh/polyMeshFilter/polyMeshFilter.H
@@ -0,0 +1,238 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 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::polyMeshFilter
+
+Description
+
+SourceFiles
+    polyMeshFilter.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef polyMeshFilter_H
+#define polyMeshFilter_H
+
+#include "IOdictionary.H"
+#include "Time.H"
+#include "List.H"
+#include "autoPtr.H"
+#include "scalarField.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+class polyMesh;
+class fvMesh;
+class PackedBoolList;
+
+/*---------------------------------------------------------------------------*\
+                       Class polyMeshFilter Declaration
+\*---------------------------------------------------------------------------*/
+
+class polyMeshFilter
+{
+    // Private data
+
+        //- Reference to the original mesh
+        const fvMesh& mesh_;
+
+        //- Copy of the original mesh to perform the filtering on
+        autoPtr<fvMesh> newMeshPtr_;
+
+        //- Dictionary containing the coefficient sub-dictionaries
+        const IOdictionary dict_;
+
+        //- Coefficients for collapsing edges
+        const dictionary& collapseEdgesCoeffDict_;
+
+        //- Coefficients for collapsing faces
+        const dictionary& collapseFacesCoeffDict_;
+
+        //- Coefficients for controlling the mesh quality
+        const dictionary& meshQualityCoeffDict_;
+
+        //- Remove edges shorter than this length
+        const scalar minLen_;
+
+        //- Merge points that are only attached to two edges and have an angle
+        //  between the edge greater than this value
+        const scalar maxCos_;
+
+        //- The amount that the local minimum edge length will be reduced by if
+        //  the edge is part of a collapse string that generates poor quality
+        //  faces
+        const scalar edgeReductionFactor_;
+
+        //- Maximum number of outer iterations
+        const label maxIterations_;
+
+        //- Maximum number of smoothing iterations of minEdgeLen_ and
+        //  faceFilterFactor_
+        const label maxSmoothIters_;
+
+        //- Initialisation value of faceFilterFactor_
+        const scalar initialFaceLengthFactor_;
+
+        //- The amount that the local face size factor will be reduced by if
+        //  the face is part of a collapse string that generates poor quality
+        //  faces
+        const scalar faceReductionFactor_;
+
+        //-
+        const label maxPointErrorCount_;
+
+
+        //- The minimum edge length for each edge
+        scalarField minEdgeLen_;
+
+        //- The face filter factor for each face
+        scalarField faceFilterFactor_;
+
+
+    // Private Member Functions
+
+        //- Increment pointErrorCount for points attached to a bad face
+        void updatePointErrorCount
+        (
+            const PackedBoolList& isErrorPoint,
+            const labelList& oldToNewMesh,
+            labelList& pointErrorCount
+        ) const;
+
+
+        //- Given the new points that are part of bad faces, and a map from the
+        //  old mesh points to the new mesh points, relax minEdgeLen_
+        void checkMeshEdgesAndRelaxEdges
+        (
+            const polyMesh& newMesh,
+            const labelList& oldToNewMesh,
+            const PackedBoolList& isErrorPoint,
+            const labelList& pointErrorCount
+        );
+
+        //- Given the new points that are part of bad faces, and a map from the
+        //  old mesh points to the new mesh points, relax faceFilterFactor_
+        void checkMeshFacesAndRelaxEdges
+        (
+            const polyMesh& newMesh,
+            const labelList& oldToNewMesh,
+            const PackedBoolList& isErrorPoint,
+            const labelList& pointErrorCount
+        );
+
+        // Mark boundary points
+        // boundaryPoint:
+        // + -1 : point not on boundary
+        // +  0 : point on a real boundary
+        // + >0 : point on a processor patch with that ID
+        // @todo Need to mark boundaryEdges as well, as an edge may have two
+        //       boundary points but not itself lie on a boundary
+        labelList findBoundaryPoints(const polyMesh& mesh) const;
+
+        //- Print min/mean/max data for a field
+        void printScalarFieldStats
+        (
+            const string desc,
+            const scalarField& fld
+        ) const;
+
+        //- Update minEdgeLen_ for the new mesh based upon the movement of the
+        //  old points to the new points
+        void mapOldMeshEdgeFieldToNewMesh
+        (
+            const polyMesh& newMesh,
+            const labelList& pointMap,
+            scalarField& newMeshMinEdgeLen
+        ) const;
+
+        //- Update faceFilterFactor_ for the new mesh based upon the movement
+        //  of the old faces to the new faces
+        void mapOldMeshFaceFieldToNewMesh
+        (
+            const polyMesh& newMesh,
+            const labelList& faceMap,
+            scalarField& newMeshFaceFilterFactor
+        ) const;
+
+        //- Maintain a map of the original mesh points to the latest version of
+        //  the filtered mesh.
+        void updateOldToNewPointMap
+        (
+            const labelList& currToNew,
+            labelList& origToCurrentPointMap
+        ) const;
+
+        //- Disallow default bitwise copy construct
+        polyMeshFilter(const polyMeshFilter&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const polyMeshFilter&);
+
+
+public:
+
+    // Constructors
+
+        //- Construct from fvMesh
+        explicit polyMeshFilter(const fvMesh& mesh);
+
+
+    //- Destructor
+    ~polyMeshFilter();
+
+
+    // Member Functions
+
+        // Access
+
+            //- Return reference to the filtered mesh. Does not check if the
+            //  mesh has actually been filtered.
+            const autoPtr<fvMesh>& filteredMesh() const;
+
+
+        // Edit
+
+            //- Return a copy of an fvMesh
+            static autoPtr<fvMesh> copyMesh(const fvMesh& mesh);
+
+            //- Filter edges and faces
+            label filter(const label nOriginalBadFaces);
+
+            //- Filter edges only.
+            label filterEdges(const label nOriginalBadFaces);
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/dynamicMesh/polyTopoChange/polyTopoChange/edgeCollapser.C b/src/dynamicMesh/polyTopoChange/polyTopoChange/edgeCollapser.C
index 9cc4349803..8290308a50 100644
--- a/src/dynamicMesh/polyTopoChange/polyTopoChange/edgeCollapser.C
+++ b/src/dynamicMesh/polyTopoChange/polyTopoChange/edgeCollapser.C
@@ -26,102 +26,1121 @@ License
 #include "edgeCollapser.H"
 #include "polyMesh.H"
 #include "polyTopoChange.H"
-#include "ListOps.H"
 #include "globalMeshData.H"
-#include "OFstream.H"
-#include "meshTools.H"
 #include "syncTools.H"
+#include "PointEdgeWave.H"
+#include "globalIndex.H"
+#include "removePoints.H"
+#include "motionSmoother.H"
 
-// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+// * * * * * * * * * * * * * Static Member Functions * * * * * * * * * * * * //
 
-Foam::label Foam::edgeCollapser::findIndex
+Foam::label Foam::edgeCollapser::longestEdge
 (
-    const labelList& elems,
-    const label start,
-    const label size,
-    const label val
+    const face& f,
+    const pointField& pts
 )
 {
-    for (label i = start; i < size; i++)
+    const edgeList& eds = f.edges();
+
+    label longestEdgeI = -1;
+    scalar longestEdgeLength = -SMALL;
+
+    forAll(eds, edI)
     {
-        if (elems[i] == val)
+        scalar edgeLength = eds[edI].mag(pts);
+
+        if (edgeLength > longestEdgeLength)
         {
-            return i;
+            longestEdgeI = edI;
+            longestEdgeLength = edgeLength;
         }
     }
-    return -1;
+
+    return longestEdgeI;
+}
+
+
+Foam::HashSet<Foam::label> Foam::edgeCollapser::checkBadFaces
+(
+    const polyMesh& mesh,
+    const dictionary& meshQualityDict
+)
+{
+    labelHashSet badFaces(mesh.nFaces()/100);
+    DynamicList<label> checkFaces(mesh.nFaces());
+
+    const vectorField& fAreas = mesh.faceAreas();
+
+    scalar faceAreaLimit = SMALL;
+
+    forAll(fAreas, fI)
+    {
+        if (mag(fAreas[fI]) > faceAreaLimit)
+        {
+            checkFaces.append(fI);
+        }
+    }
+
+    Info<< endl;
+
+    motionSmoother::checkMesh
+    (
+        false,
+        mesh,
+        meshQualityDict,
+        checkFaces,
+        badFaces
+    );
+
+    return badFaces;
+}
+
+
+Foam::label Foam::edgeCollapser::checkMeshQuality
+(
+    const polyMesh& mesh,
+    const dictionary& meshQualityDict,
+    PackedBoolList& isErrorPoint
+)
+{
+    labelHashSet badFaces = edgeCollapser::checkBadFaces
+    (
+        mesh,
+        meshQualityDict
+    );
+
+    label nBadFaces = returnReduce(badFaces.size(), sumOp<label>());
+
+    forAllConstIter(labelHashSet, badFaces, iter)
+    {
+        const face& f = mesh.faces()[iter.key()];
+
+        forAll(f, pI)
+        {
+            isErrorPoint[f[pI]] = true;
+        }
+    }
+
+    syncTools::syncPointList
+    (
+        mesh,
+        isErrorPoint,
+        orEqOp<unsigned int>(),
+        0
+    );
+
+    return nBadFaces;
 }
 
 
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 
-// Changes region of connected set of points
-Foam::label Foam::edgeCollapser::changePointRegion
+Foam::labelList Foam::edgeCollapser::edgesFromPoints
 (
-    const label pointI,
-    const label oldRegion,
-    const label newRegion
-)
+    const label& faceI,
+    const labelList& pointLabels
+) const
 {
-    label nChanged = 0;
+    labelList edgeLabels(pointLabels.size() - 1, -1);
 
-    if (pointRegion_[pointI] == oldRegion)
+    const labelList& faceEdges = mesh_.faceEdges()[faceI];
+    const edgeList& edges = mesh_.edges();
+
+    label count = 0;
+
+    forAll(faceEdges, eI)
     {
-        pointRegion_[pointI] = newRegion;
-        nChanged++;
+        const label edgeI = faceEdges[eI];
+        const edge& e = edges[edgeI];
 
-        // Step to neighbouring point across edges with same region number
+        label match = 0;
 
-        const labelList& pEdges = mesh_.pointEdges()[pointI];
-
-        forAll(pEdges, i)
+        forAll(pointLabels, pI)
         {
-            label otherPointI = mesh_.edges()[pEdges[i]].otherVertex(pointI);
+            if (e[0] == pointLabels[pI])
+            {
+                match++;
+            }
 
-            nChanged += changePointRegion(otherPointI, oldRegion, newRegion);
+            if (e[1] == pointLabels[pI])
+            {
+                match++;
+            }
+        }
+
+        if (match == 2)
+        {
+            // Edge found
+            edgeLabels[count++] = edgeI;
         }
     }
-    return nChanged;
+
+    if (count != edgeLabels.size())
+    {
+        edgeLabels.setSize(count);
+    }
+
+    return edgeLabels;
 }
 
 
-bool Foam::edgeCollapser::pointRemoved(const label pointI) const
+void Foam::edgeCollapser::collapseToEdge
+(
+    const label faceI,
+    const pointField& pts,
+    const labelList& pointPriority,
+    const vector& collapseAxis,
+    const point& fC,
+    const labelList& facePtsNeg,
+    const labelList& facePtsPos,
+    const scalarList& dNeg,
+    const scalarList& dPos,
+    const scalar dShift,
+    PackedBoolList& collapseEdge,
+    Map<point>& collapsePointToLocation
+) const
 {
-    label region = pointRegion_[pointI];
+    const face& f = mesh_.faces()[faceI];
 
-    if (region == -1 || pointRegionMaster_[region] == pointI)
+    // Negative half
+
+    Foam::point collapseToPtA =
+        collapseAxis*(sum(dNeg)/dNeg.size() - dShift) + fC;
+
+    DynamicList<label> faceBoundaryPts(f.size());
+    DynamicList<label> faceFeaturePts(f.size());
+
+    forAll(facePtsNeg, fPtI)
     {
-        return false;
+        if (pointPriority[facePtsNeg[fPtI]] == 1)
+        {
+            faceFeaturePts.append(facePtsNeg[fPtI]);
+        }
+        else if (pointPriority[facePtsNeg[fPtI]] == 0)
+        {
+            faceBoundaryPts.append(facePtsNeg[fPtI]);
+        }
+    }
+
+    if (!faceBoundaryPts.empty() || !faceFeaturePts.empty())
+    {
+        if (!faceFeaturePts.empty())
+        {
+            collapseToPtA = pts[faceFeaturePts.first()];
+        }
+        else if (faceBoundaryPts.size() == 2)
+        {
+            collapseToPtA =
+                0.5
+               *(
+                    pts[faceBoundaryPts[0]]
+                  + pts[faceBoundaryPts[1]]
+                );
+        }
+        else if (faceBoundaryPts.size() <= f.size())
+        {
+            face bFace(faceBoundaryPts);
+
+            collapseToPtA = bFace.centre(pts);
+        }
+    }
+
+    faceFeaturePts.clear();
+    faceBoundaryPts.clear();
+
+    labelList faceEdgesNeg = edgesFromPoints(faceI, facePtsNeg);
+
+    forAll(faceEdgesNeg, edgeI)
+    {
+        collapseEdge[faceEdgesNeg[edgeI]] = true;
+    }
+
+    forAll(facePtsNeg, pI)
+    {
+        collapsePointToLocation.set(facePtsNeg[pI], collapseToPtA);
+    }
+
+
+    // Positive half
+
+    Foam::point collapseToPtB
+        = collapseAxis*(sum(dPos)/dPos.size() - dShift) + fC;
+
+    forAll(facePtsPos, fPtI)
+    {
+        if (pointPriority[facePtsPos[fPtI]] == 1)
+        {
+            faceFeaturePts.append(facePtsPos[fPtI]);
+        }
+        else if (pointPriority[facePtsPos[fPtI]] == 0)
+        {
+            // If there is a point which is on the boundary,
+            // use it as the point to collapse others to, will
+            // use the first boundary point encountered if
+            // there are multiple boundary points.
+            faceBoundaryPts.append(facePtsPos[fPtI]);
+        }
+    }
+
+    if (!faceBoundaryPts.empty() || !faceFeaturePts.empty())
+    {
+        if (!faceFeaturePts.empty())
+        {
+            collapseToPtB = pts[faceFeaturePts.first()];
+        }
+        else if (faceBoundaryPts.size() == 2)
+        {
+            collapseToPtB =
+                0.5
+               *(
+                    pts[faceBoundaryPts[0]]
+                  + pts[faceBoundaryPts[1]]
+                );
+        }
+        else if (faceBoundaryPts.size() <= f.size())
+        {
+            face bFace(faceBoundaryPts);
+
+            collapseToPtB = bFace.centre(pts);
+        }
+    }
+
+    labelList faceEdgesPos = edgesFromPoints(faceI, facePtsPos);
+
+    forAll(faceEdgesPos, edgeI)
+    {
+        collapseEdge[faceEdgesPos[edgeI]] = true;
+    }
+
+    forAll(facePtsPos, pI)
+    {
+        collapsePointToLocation.set(facePtsPos[pI], collapseToPtB);
+    }
+}
+
+
+void Foam::edgeCollapser::collapseToPoint
+(
+    const label& faceI,
+    const pointField& pts,
+    const labelList& pointPriority,
+    const point& fC,
+    const labelList& facePts,
+    PackedBoolList& collapseEdge,
+    Map<point>& collapsePointToLocation
+) const
+{
+    const face& f = mesh_.faces()[faceI];
+
+    Foam::point collapseToPt = fC;
+
+    DynamicList<label> faceBoundaryPts(f.size());
+    DynamicList<label> faceFeaturePts(f.size());
+
+    forAll(facePts, fPtI)
+    {
+        if (pointPriority[facePts[fPtI]] == 1)
+        {
+            faceFeaturePts.append(facePts[fPtI]);
+        }
+        else if (pointPriority[facePts[fPtI]] == 0)
+        {
+            faceBoundaryPts.append(facePts[fPtI]);
+        }
+    }
+
+    if (!faceBoundaryPts.empty() || !faceFeaturePts.empty())
+    {
+        if (!faceFeaturePts.empty())
+        {
+            collapseToPt = pts[faceFeaturePts.first()];
+        }
+        else if (faceBoundaryPts.size() == 2)
+        {
+            collapseToPt =
+                0.5
+               *(
+                    pts[faceBoundaryPts[0]]
+                  + pts[faceBoundaryPts[1]]
+                );
+        }
+        else if (faceBoundaryPts.size() <= f.size())
+        {
+            face bFace(faceBoundaryPts);
+
+            collapseToPt = bFace.centre(pts);
+        }
+    }
+
+    const labelList faceEdges = mesh_.faceEdges()[faceI];
+
+    forAll(faceEdges, eI)
+    {
+        const label edgeI = faceEdges[eI];
+        collapseEdge[edgeI] = true;
+    }
+
+    forAll(f, pI)
+    {
+        collapsePointToLocation.set(f[pI], collapseToPt);
+    }
+}
+
+
+void Foam::edgeCollapser::faceCollapseAxisAndAspectRatio
+(
+    const face& f,
+    const point& fC,
+    vector& collapseAxis,
+    scalar& aspectRatio
+) const
+{
+    const pointField& pts = mesh_.points();
+
+    tensor J = f.inertia(pts, fC);
+
+    // Find the dominant collapse direction by finding the eigenvector
+    // that corresponds to the normal direction, discarding it.  The
+    // eigenvector corresponding to the smaller of the two remaining
+    // eigenvalues is the dominant axis in a high aspect ratio face.
+
+    scalar magJ = mag(J);
+
+    scalar detJ = SMALL;
+
+    if (magJ > VSMALL)
+    {
+        // Normalise inertia tensor to remove problems with small values
+
+        J /= mag(J);
+        // J /= cmptMax(J);
+        // J /= max(eigenValues(J).x(), SMALL);
+
+        // Calculating determinant, including stabilisation for zero or
+        // small negative values
+
+        detJ = max(det(J), SMALL);
+    }
+
+    if (detJ < 1e-5)
+    {
+        collapseAxis = f.edges()[longestEdge(f, pts)].vec(pts);
+
+        // It is possible that all the points of a face are the same
+        if (magSqr(collapseAxis) > VSMALL)
+        {
+            collapseAxis /= mag(collapseAxis);
+        }
+
+        // Empirical correlation for high aspect ratio faces
+
+        aspectRatio = Foam::sqrt(0.35/detJ);
     }
     else
     {
-        return true;
+        vector eVals = eigenValues(J);
+
+        if (mag(eVals.y() - eVals.x()) < 100*SMALL)
+        {
+            // First two eigenvalues are the same: i.e. a square face
+
+            // Cannot necessarily determine linearly independent
+            // eigenvectors, or any at all, use longest edge direction.
+
+            collapseAxis = f.edges()[longestEdge(f, pts)].vec(pts);
+
+            collapseAxis /= mag(collapseAxis);
+
+            aspectRatio = 1.0;
+        }
+        else
+        {
+            // The maximum eigenvalue (z()) must be the direction of the
+            // normal, as it has the greatest value.  The minimum eigenvalue
+            // is the dominant collapse axis for high aspect ratio faces.
+
+            collapseAxis = eigenVector(J, eVals.x());
+
+            // The inertia calculation describes the mass distribution as a
+            // function of distance squared to the axis, so the square root of
+            // the ratio of face-plane moments gives a good indication of the
+            // aspect ratio.
+
+            aspectRatio = Foam::sqrt(eVals.y()/max(eVals.x(), SMALL));
+        }
     }
 }
 
 
-void Foam::edgeCollapser::filterFace(const label faceI, face& f) const
+Foam::scalarField Foam::edgeCollapser::calcTargetFaceSizes() const
+{
+    scalarField targetFaceSizes(mesh_.nFaces(), -1);
+
+    const scalarField& cellVolumes = mesh_.cellVolumes();
+    const polyBoundaryMesh& patches = mesh_.boundaryMesh();
+
+    const labelList& cellOwner = mesh_.faceOwner();
+    const labelList& cellNeighbour = mesh_.faceNeighbour();
+
+    const label nBoundaryFaces = mesh_.nFaces() - mesh_.nInternalFaces();
+
+    // Calculate face size from cell volumes for internal faces
+    for (label intFaceI = 0; intFaceI < mesh_.nInternalFaces(); ++intFaceI)
+    {
+        const scalar cellOwnerVol = cellVolumes[cellOwner[intFaceI]];
+        const scalar cellNeighbourVol = cellVolumes[cellNeighbour[intFaceI]];
+
+        scalar targetFaceSizeA = Foam::pow(cellOwnerVol, 1.0/3.0);
+        scalar targetFaceSizeB = Foam::pow(cellNeighbourVol, 1.0/3.0);
+
+        targetFaceSizes[intFaceI] = 0.5*(targetFaceSizeA + targetFaceSizeB);
+    }
+
+    scalarField neiCellVolumes(nBoundaryFaces, -1);
+
+    // Now do boundary faces
+    forAll(patches, patchI)
+    {
+        const polyPatch& patch = patches[patchI];
+
+        label bFaceI = patch.start() - mesh_.nInternalFaces();
+
+        if (patch.coupled())
+        {
+            // Processor boundary face: Need to get the cell volume on the other
+            // processor
+            const labelUList& faceCells = patch.faceCells();
+
+            forAll(faceCells, facei)
+            {
+                neiCellVolumes[bFaceI++] = cellVolumes[faceCells[facei]];
+            }
+        }
+        else
+        {
+            // Normal boundary face: Just use owner cell volume to calculate
+            // the target face size
+            forAll(patch, patchFaceI)
+            {
+                const label extFaceI = patchFaceI + patch.start();
+                const scalar cellOwnerVol = cellVolumes[cellOwner[extFaceI]];
+
+                targetFaceSizes[extFaceI] = Foam::pow(cellOwnerVol, 1.0/3.0);
+            }
+        }
+    }
+
+    syncTools::swapBoundaryFaceList(mesh_, neiCellVolumes);
+
+    forAll(patches, patchI)
+    {
+        const polyPatch& patch = patches[patchI];
+
+        label bFaceI = patch.start() - mesh_.nInternalFaces();
+
+        if (patch.coupled())
+        {
+            forAll(patch, patchFaceI)
+            {
+                const label localFaceI = patchFaceI + patch.start();
+                const scalar cellOwnerVol = cellVolumes[cellOwner[localFaceI]];
+                const scalar cellNeighbourVol = neiCellVolumes[bFaceI++];
+
+                scalar targetFaceSizeA = Foam::pow(cellOwnerVol, 1.0/3.0);
+                scalar targetFaceSizeB = Foam::pow(cellNeighbourVol, 1.0/3.0);
+
+                targetFaceSizes[localFaceI]
+                    = 0.5*(targetFaceSizeA + targetFaceSizeB);
+            }
+        }
+    }
+
+    // Returns a characteristic length, not an area
+    return targetFaceSizes;
+}
+
+
+Foam::edgeCollapser::collapseType Foam::edgeCollapser::collapseFace
+(
+    const labelList& pointPriority,
+    const face& f,
+    const label faceI,
+    const scalar targetFaceSize,
+    PackedBoolList& collapseEdge,
+    Map<point>& collapsePointToLocation,
+    const scalarField& faceFilterFactor
+) const
+{
+    const scalar collapseSizeLimitCoeff = faceFilterFactor[faceI];
+
+    const pointField& pts = mesh_.points();
+
+    labelList facePts(f);
+
+    const Foam::point fC = f.centre(pts);
+
+    const scalar fA = f.mag(pts);
+
+    vector collapseAxis = vector::zero;
+    scalar aspectRatio = 1.0;
+
+    faceCollapseAxisAndAspectRatio(f, fC, collapseAxis, aspectRatio);
+
+    // The signed distance along the collapse axis passing through the
+    // face centre that each vertex projects to.
+
+    scalarField d(f.size());
+
+    forAll(f, fPtI)
+    {
+        const Foam::point& pt = pts[f[fPtI]];
+
+        d[fPtI] = (collapseAxis & (pt - fC));
+    }
+
+    // Sort the projected distances and the corresponding vertex
+    // indices along the collapse axis
+
+    labelList oldToNew;
+
+    sortedOrder(d, oldToNew);
+
+    oldToNew = invert(oldToNew.size(), oldToNew);
+
+    inplaceReorder(oldToNew, d);
+
+    inplaceReorder(oldToNew, facePts);
+
+    // Shift the points so that they are relative to the centre of the
+    // collapse line.
+
+    scalar dShift = -0.5*(d.first() + d.last());
+
+    d += dShift;
+
+    // Form two lists, one for each half of the set of points
+    // projected along the collapse axis.
+
+    // Middle value, index of first entry in the second half
+    label middle = -1;
+
+    forAll(d, dI)
+    {
+        if (d[dI] > 0)
+        {
+            middle = dI;
+
+            break;
+        }
+    }
+
+    if (middle == -1)
+    {
+//        SeriousErrorIn("collapseFace")
+//            << "middle == -1, " << f << " " << d
+//            << endl;//abort(FatalError);
+
+        return noCollapse;
+    }
+
+    // Negative half
+    SubList<scalar> dNeg(d, middle, 0);
+    SubList<label> facePtsNeg(facePts, middle, 0);
+
+    // Positive half
+    SubList<scalar> dPos(d, d.size() - middle, middle);
+    SubList<label> facePtsPos(facePts, d.size() - middle, middle);
+
+    // Defining how close to the midpoint (M) of the projected
+    // vertices line a projected vertex (X) can be before making this
+    // an invalid edge collapse
+    //
+    // X---X-g----------------M----X-----------g----X--X
+    //
+    // Only allow a collapse if all projected vertices are outwith
+    // guardFraction (g) of the distance form the face centre to the
+    // furthest vertex in the considered direction
+
+    if (dNeg.size() == 0 || dPos.size() == 0)
+    {
+        WarningIn
+        (
+            "Foam::conformalVoronoiMesh::collapseFace"
+        )
+            << "All points on one side of face centre, not collapsing."
+            << endl;
+    }
+
+//    Info<< "Face : " << f << nl
+//        << "    Collapse Axis: " << collapseAxis << nl
+//        << "    Aspect Ratio : " << aspectRatio << endl;
+
+    collapseType typeOfCollapse = noCollapse;
+
+    if (magSqr(collapseAxis) < VSMALL)
+    {
+        typeOfCollapse = toPoint;
+    }
+    else if (fA < aspectRatio*sqr(targetFaceSize*collapseSizeLimitCoeff))
+    {
+        if
+        (
+            allowEarlyCollapseToPoint_
+         && (d.last() - d.first())
+          < targetFaceSize
+           *allowEarlyCollapseCoeff_*maxCollapseFaceToPointSideLengthCoeff_
+        )
+        {
+            typeOfCollapse = toPoint;
+        }
+        else if
+        (
+            (dNeg.last() < guardFraction_*dNeg.first())
+         && (dPos.first() > guardFraction_*dPos.last())
+        )
+        {
+            typeOfCollapse = toEdge;
+        }
+        else if
+        (
+            (d.last() - d.first())
+          < targetFaceSize
+           *maxCollapseFaceToPointSideLengthCoeff_
+        )
+        {
+            // If the face can't be collapsed to an edge, and it has a
+            // small enough span, collapse it to a point.
+            typeOfCollapse = toPoint;
+        }
+    }
+
+    if (typeOfCollapse == toPoint)
+    {
+        collapseToPoint
+        (
+            faceI,
+            pts,
+            pointPriority,
+            fC,
+            facePts,
+            collapseEdge,
+            collapsePointToLocation
+        );
+    }
+    else if (typeOfCollapse == toEdge)
+    {
+        collapseToEdge
+        (
+            faceI,
+            pts,
+            pointPriority,
+            collapseAxis,
+            fC,
+            facePtsNeg,
+            facePtsPos,
+            dNeg,
+            dPos,
+            dShift,
+            collapseEdge,
+            collapsePointToLocation
+        );
+    }
+
+    return typeOfCollapse;
+}
+
+
+Foam::label Foam::edgeCollapser::edgeMaster
+(
+    const labelList& pointPriority,
+    const edge& e
+) const
+{
+    label masterPoint = -1;
+
+    label e0 = e.start();
+    label e1 = e.end();
+
+    // Collapse edge to point with higher priority.
+    if (pointPriority[e0] >= 0)
+    {
+        if (pointPriority[e1] >= 0)
+        {
+            // Both points have high priority. Choose one to collapse to.
+            // Note: should look at feature edges/points!
+            masterPoint = e0;
+        }
+        else
+        {
+            masterPoint = e0;
+        }
+    }
+    else
+    {
+        if (pointPriority[e1] >= 0)
+        {
+            masterPoint = e1;
+        }
+        else
+        {
+            // None on boundary. Neither is a master.
+            return -1;
+        }
+    }
+
+    return masterPoint;
+}
+
+
+void Foam::edgeCollapser::checkBoundaryPointMergeEdges
+(
+    const label pointI,
+    const label otherPointI,
+    const labelList& pointPriority,
+    Map<point>& collapsePointToLocation
+) const
+{
+   const pointField& points = mesh_.points();
+
+   if
+   (
+       pointPriority[pointI] == 0
+    && pointPriority[otherPointI] < 0
+   )
+   {
+       collapsePointToLocation.set
+       (
+           otherPointI,
+           points[pointI]
+       );
+   }
+   else
+   {
+       collapsePointToLocation.set
+       (
+           pointI,
+           points[otherPointI]
+       );
+   }
+}
+
+
+Foam::label Foam::edgeCollapser::breakStringsAtEdges
+(
+    const PackedBoolList& markedEdges,
+    PackedBoolList& collapseEdge,
+    List<pointEdgeCollapse>& allPointInfo
+) const
+{
+    const edgeList& edges = mesh_.edges();
+    const labelListList& pointEdges = mesh_.pointEdges();
+
+    label nUncollapsed = 0;
+
+    forAll(edges, eI)
+    {
+        if (markedEdges[eI])
+        {
+            const edge& e = edges[eI];
+
+            const label startCollapseIndex
+                = allPointInfo[e.start()].collapseIndex();
+
+            if (startCollapseIndex != -1 && startCollapseIndex != -2)
+            {
+                const label endCollapseIndex
+                    = allPointInfo[e.end()].collapseIndex();
+
+                if
+                (
+                    !collapseEdge[eI]
+                 && startCollapseIndex == endCollapseIndex
+                )
+                {
+                    const labelList& ptEdgesStart = pointEdges[e.start()];
+
+                    forAll(ptEdgesStart, ptEdgeI)
+                    {
+                        const label edgeI = ptEdgesStart[ptEdgeI];
+
+                        const label nbrPointI
+                            = edges[edgeI].otherVertex(e.start());
+                        const label nbrIndex
+                            = allPointInfo[nbrPointI].collapseIndex();
+
+                        if
+                        (
+                            collapseEdge[edgeI]
+                         && nbrIndex == startCollapseIndex
+                        )
+                        {
+                            collapseEdge[edgeI] = false;
+                            nUncollapsed++;
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    return nUncollapsed;
+}
+
+
+void Foam::edgeCollapser::determineDuplicatePointsOnFace
+(
+    const face& f,
+    PackedBoolList& markedPoints,
+    labelHashSet& uniqueCollapses,
+    labelHashSet& duplicateCollapses,
+    List<pointEdgeCollapse>& allPointInfo
+) const
+{
+    uniqueCollapses.clear();
+    duplicateCollapses.clear();
+
+    forAll(f, fpI)
+    {
+        label index = allPointInfo[f[fpI]].collapseIndex();
+
+        // Check for consecutive duplicate
+        if (index != allPointInfo[f.prevLabel(fpI)].collapseIndex())
+        {
+            if (!uniqueCollapses.insert(index))
+            {
+                // Failed inserting so duplicate
+                duplicateCollapses.insert(index);
+            }
+        }
+    }
+
+    // Now duplicateCollapses contains duplicate collapse indices.
+    // Convert to points.
+    forAll(f, fpI)
+    {
+        label index = allPointInfo[f[fpI]].collapseIndex();
+        if (duplicateCollapses.found(index))
+        {
+            markedPoints[f[fpI]] = true;
+        }
+    }
+}
+
+
+Foam::label Foam::edgeCollapser::countEdgesOnFace
+(
+    const face& f,
+    List<pointEdgeCollapse>& allPointInfo
+) const
+{
+    label nEdges = 0;
+
+    forAll(f, fpI)
+    {
+        const label pointI = f[fpI];
+        const label newPointI = allPointInfo[pointI].collapseIndex();
+
+        if (newPointI == -2)
+        {
+            nEdges++;
+        }
+        else
+        {
+            const label prevPointI = f[f.fcIndex(fpI)];
+            const label prevNewPointI
+                = allPointInfo[prevPointI].collapseIndex();
+
+            if (newPointI != prevNewPointI)
+            {
+                nEdges++;
+            }
+        }
+    }
+
+    return nEdges;
+}
+
+
+bool Foam::edgeCollapser::isFaceCollapsed
+(
+    const face& f,
+    List<pointEdgeCollapse>& allPointInfo
+) const
+{
+    label nEdges = countEdgesOnFace(f, allPointInfo);
+
+    // Polygons must have 3 or more edges to be valid
+    if (nEdges < 3)
+    {
+        return true;
+    }
+
+    return false;
+}
+
+
+// Create consistent set of collapses.
+//  collapseEdge : per edge:
+//      -1 : do not collapse
+//       0 : collapse to start
+//       1 : collapse to end
+//  Note: collapseEdge has to be parallel consistent (in orientation)
+Foam::label Foam::edgeCollapser::syncCollapse
+(
+    const globalIndex& globalPoints,
+    const labelList& pointPriority,
+    const PackedBoolList& collapseEdge,
+    const Map<point>& collapsePointToLocation,
+    List<pointEdgeCollapse>& allPointInfo
+) const
+{
+    const edgeList& edges = mesh_.edges();
+
+    label nCollapsed = 0;
+
+    DynamicList<label> initPoints(mesh_.nPoints());
+    DynamicList<pointEdgeCollapse> initPointInfo(mesh_.nPoints());
+
+    allPointInfo.clear();
+    allPointInfo.setSize(mesh_.nPoints());
+
+    // Initialise edges to no collapse
+    List<pointEdgeCollapse> allEdgeInfo
+    (
+        mesh_.nEdges(),
+        pointEdgeCollapse(vector::zero, -1, -1)
+    );
+
+    // Mark selected edges for collapse
+    forAll(edges, edgeI)
+    {
+        if (collapseEdge[edgeI])
+        {
+            const edge& e = edges[edgeI];
+
+            label masterPointI = e.start();
+
+            // Choose the point on the edge with the highest priority.
+            if (pointPriority[e.end()] > pointPriority[e.start()])
+            {
+                masterPointI = e.end();
+            }
+
+            label masterPointPriority = pointPriority[masterPointI];
+
+            label index = globalPoints.toGlobal(masterPointI);
+
+            if (!collapsePointToLocation.found(masterPointI))
+            {
+                const label otherVertex = e.otherVertex(masterPointI);
+
+                if (!collapsePointToLocation.found(otherVertex))
+                {
+                    FatalErrorIn
+                    (
+                        "syncCollapse\n"
+                        "(\n"
+                        "   const polyMesh&,\n"
+                        "   const globalIndex&,\n"
+                        "   const labelList&,\n"
+                        "   const PackedBoolList&,\n"
+                        "   Map<point>&,\n"
+                        "   List<pointEdgeCollapse>&\n"
+                        ")\n"
+                    )   << masterPointI << " on edge " << edgeI << " " << e
+                        << " is not marked for collapse."
+                        << abort(FatalError);
+                }
+                else
+                {
+                    masterPointI = otherVertex;
+                    masterPointPriority = pointPriority[masterPointI];
+                    index = globalPoints.toGlobal(masterPointI);
+                }
+            }
+
+            const point& collapsePoint = collapsePointToLocation[masterPointI];
+
+            const pointEdgeCollapse pec
+            (
+                collapsePoint,
+                index,
+                masterPointPriority
+            );
+
+            // Mark as collapsable but with nonsense master so it gets
+            // overwritten and starts an update wave
+            allEdgeInfo[edgeI] = pointEdgeCollapse
+            (
+                collapsePoint,
+                labelMax,
+                labelMin
+            );
+
+            initPointInfo.append(pec);
+            initPoints.append(e.start());
+
+            initPointInfo.append(pec);
+            initPoints.append(e.end());
+
+            nCollapsed++;
+        }
+    }
+
+    PointEdgeWave<pointEdgeCollapse> collapsePropagator
+    (
+        mesh_,
+        initPoints,
+        initPointInfo,
+        allPointInfo,
+        allEdgeInfo,
+        mesh_.globalData().nTotalPoints()  // Maximum number of iterations
+    );
+
+    return nCollapsed;
+}
+
+
+void Foam::edgeCollapser::filterFace
+(
+    const Map<DynamicList<label> >& collapseStrings,
+    const List<pointEdgeCollapse>& allPointInfo,
+    face& f
+) const
 {
     label newFp = 0;
 
+    face oldFace = f;
+
     forAll(f, fp)
     {
         label pointI = f[fp];
 
-        label region = pointRegion_[pointI];
+        label collapseIndex = allPointInfo[pointI].collapseIndex();
 
-        if (region == -1)
+        // Do we have a local point for this index?
+        if (collapseStrings.found(collapseIndex))
         {
-            f[newFp++] = pointI;
+            label localPointI = collapseStrings[collapseIndex][0];
+
+            if (findIndex(SubList<label>(f, newFp), localPointI) == -1)
+            {
+                f[newFp++] = localPointI;
+            }
+        }
+        else if (collapseIndex == -1)
+        {
+            WarningIn
+            (
+                "filterFace"
+                "(const label, const Map<DynamicList<label> >&, face&)"
+            )   << "Point " << pointI << " was not visited by PointEdgeWave"
+                << endl;
         }
         else
         {
-            label master = pointRegionMaster_[region];
-
-            if (findIndex(f, 0, newFp, master) == -1)
-            {
-                f[newFp++] = master;
-            }
+            f[newFp++] = pointI;
         }
     }
 
@@ -144,7 +1163,7 @@ void Foam::edgeCollapser::filterFace(const label faceI, face& f) const
         label pointI = f[fp];
 
         // Search for previous occurrence.
-        label index = findIndex(f, 0, fp, pointI);
+        label index = findIndex(SubList<label>(f, fp), pointI);
 
         if (index == fp1)
         {
@@ -186,281 +1205,99 @@ void Foam::edgeCollapser::filterFace(const label faceI, face& f) const
 }
 
 
-// Debugging.
-void Foam::edgeCollapser::printRegions() const
-{
-    forAll(pointRegionMaster_, regionI)
-    {
-        label master = pointRegionMaster_[regionI];
-
-        if (master != -1)
-        {
-            Pout<< "Region:" << regionI << nl
-                << "    master:" << master
-                << ' ' << pointRegionMasterLocation_[regionI] << nl;
-
-            forAll(pointRegion_, pointI)
-            {
-                if (pointRegion_[pointI] == regionI && pointI != master)
-                {
-                    Pout<< "    slave:" << pointI
-                        << ' ' <<  mesh_.points()[pointI] << nl;
-                }
-            }
-        }
-    }
-}
-
-
-
-// Collapse list of edges
-void Foam::edgeCollapser::collapseEdges(const labelList& edgeLabels)
-{
-    const edgeList& edges = mesh_.edges();
-
-    forAll(edgeLabels, i)
-    {
-        label edgeI = edgeLabels[i];
-        const edge& e = edges[edgeI];
-
-        label region0 = pointRegion_[e[0]];
-        label region1 = pointRegion_[e[1]];
-
-        if (region0 == -1)
-        {
-            if (region1 == -1)
-            {
-                // Both unaffected. Choose ad lib.
-                collapseEdge(edgeI, e[0]);
-            }
-            else
-            {
-                // Collapse to whatever e[1] collapses
-                collapseEdge(edgeI, e[1]);
-            }
-        }
-        else
-        {
-            if (region1 == -1)
-            {
-                // Collapse to whatever e[0] collapses
-                collapseEdge(edgeI, e[0]);
-            }
-            else
-            {
-                // Both collapsed.
-                if (pointRegionMaster_[region0] == e[0])
-                {
-                    // e[0] is a master
-                    collapseEdge(edgeI, e[0]);
-                }
-                else if (pointRegionMaster_[region1] == e[1])
-                {
-                    // e[1] is a master
-                    collapseEdge(edgeI, e[1]);
-                }
-                else
-                {
-                    // Dont know
-                    collapseEdge(edgeI, e[0]);
-                }
-            }
-        }
-    }
-}
-
-
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
-// Construct from mesh
 Foam::edgeCollapser::edgeCollapser(const polyMesh& mesh)
 :
     mesh_(mesh),
-    pointRegion_(mesh.nPoints(), -1),
-    pointRegionMasterLocation_(mesh.nPoints() / 100),
-    pointRegionMaster_(mesh.nPoints() / 100),
-    freeRegions_()
+    guardFraction_(0),
+    maxCollapseFaceToPointSideLengthCoeff_(0),
+    allowEarlyCollapseToPoint_(false),
+    allowEarlyCollapseCoeff_(0)
+{}
+
+
+Foam::edgeCollapser::edgeCollapser
+(
+    const polyMesh& mesh,
+    const dictionary& dict
+)
+:
+    mesh_(mesh),
+    guardFraction_(readScalar(dict.lookup("guardFraction"))),
+    maxCollapseFaceToPointSideLengthCoeff_
+    (
+        readScalar(dict.lookup("maxCollapseFaceToPointSideLengthCoeff"))
+    ),
+    allowEarlyCollapseToPoint_
+    (
+        dict.lookupOrDefault<Switch>("allowEarlyCollapseToPoint", true)
+    ),
+    allowEarlyCollapseCoeff_
+    (
+        readScalar(dict.lookup("allowEarlyCollapseCoeff"))
+    )
 {}
 
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
-bool Foam::edgeCollapser::unaffectedEdge(const label edgeI) const
-{
-    const edge& e = mesh_.edges()[edgeI];
-
-    return (pointRegion_[e[0]] == -1) && (pointRegion_[e[1]] == -1);
-}
-
-
-bool Foam::edgeCollapser::collapseEdge(const label edgeI, const label master)
-{
-    const pointField& points = mesh_.points();
-
-    const edge& e = mesh_.edges()[edgeI];
-
-    label pointRegion0 = pointRegion_[e[0]];
-    label pointRegion1 = pointRegion_[e[1]];
-
-    if (pointRegion0 == -1)
-    {
-        if (pointRegion1 == -1)
-        {
-            // Both endpoints not collapsed. Create new region.
-
-            label freeRegion = -1;
-
-            if (freeRegions_.size())
-            {
-                freeRegion = freeRegions_.removeHead();
-
-                if (pointRegionMaster_[freeRegion] != -1)
-                {
-                    FatalErrorIn
-                    ("edgeCollapser::collapseEdge(const label, const label)")
-                        << "Problem : freed region :" << freeRegion
-                        << " has already master "
-                        << pointRegionMaster_[freeRegion]
-                        << abort(FatalError);
-                }
-            }
-            else
-            {
-                // If no region found create one. This is the only place where
-                // new regions are created.
-                freeRegion = pointRegionMaster_.size();
-            }
-
-            pointRegion_[e[0]] = freeRegion;
-            pointRegion_[e[1]] = freeRegion;
-
-            pointRegionMaster_(freeRegion) = master;
-            pointRegionMasterLocation_(freeRegion) = points[master];
-        }
-        else
-        {
-            // e[1] is part of collapse network, e[0] not. Add e0 to e1 region.
-            pointRegion_[e[0]] = pointRegion1;
-
-            if
-            (
-                pointRegionMaster_[pointRegion1] == e[0]
-             || pointRegionMaster_[pointRegion1] == e[1]
-            )
-            {
-                pointRegionMaster_[pointRegion1] = master;
-                pointRegionMasterLocation_[pointRegion1] = points[master];
-            }
-        }
-    }
-    else
-    {
-        if (pointRegion1 == -1)
-        {
-            // e[0] is part of collapse network. Add e1 to e0 region
-            pointRegion_[e[1]] = pointRegion0;
-
-            if
-            (
-                pointRegionMaster_[pointRegion0] == e[0]
-             || pointRegionMaster_[pointRegion0] == e[1]
-            )
-            {
-                pointRegionMaster_[pointRegion0] = master;
-                pointRegionMasterLocation_[pointRegion0] = points[master];
-            }
-        }
-        else if (pointRegion0 != pointRegion1)
-        {
-            // Both part of collapse network. Merge the two regions.
-
-            // Use the smaller region number for the whole network.
-            label minRegion = min(pointRegion0, pointRegion1);
-            label maxRegion = max(pointRegion0, pointRegion1);
-
-            // Use minRegion as region for combined net, free maxRegion.
-            pointRegionMaster_[minRegion] = master;
-            pointRegionMaster_[maxRegion] = -1;
-            pointRegionMasterLocation_[minRegion] = points[master];
-            pointRegionMasterLocation_[maxRegion] = point(0, 0, 0);
-
-            freeRegions_.insert(maxRegion);
-
-            if (minRegion != pointRegion0)
-            {
-                changePointRegion(e[0], pointRegion0, minRegion);
-            }
-            if (minRegion != pointRegion1)
-            {
-                changePointRegion(e[1], pointRegion1, minRegion);
-            }
-        }
-    }
-
-    return true;
-}
-
-
-bool Foam::edgeCollapser::setRefinement(polyTopoChange& meshMod)
+bool Foam::edgeCollapser::setRefinement
+(
+    const List<pointEdgeCollapse>& allPointInfo,
+    polyTopoChange& meshMod
+) const
 {
     const cellList& cells = mesh_.cells();
     const labelList& faceOwner = mesh_.faceOwner();
     const labelList& faceNeighbour = mesh_.faceNeighbour();
     const labelListList& pointFaces = mesh_.pointFaces();
-    const labelListList& cellEdges = mesh_.cellEdges();
     const pointZoneMesh& pointZones = mesh_.pointZones();
 
-
-
     bool meshChanged = false;
 
-    // Synchronise pointRegionMasterLocation_
-    const globalMeshData& globalData = mesh_.globalData();
-    const mapDistribute& map = globalData.globalPointSlavesMap();
-    const indirectPrimitivePatch& coupledPatch = globalData.coupledPatch();
-    const labelList& meshPoints = coupledPatch.meshPoints();
-    const Map<label>& meshPointMap = coupledPatch.meshPointMap();
+    PackedBoolList removedPoints(mesh_.nPoints());
 
-
-    List<point> newPoints = coupledPatch.localPoints();
-
-    for (label pI = 0; pI < coupledPatch.nPoints(); ++pI)
+    // Create strings of edges.
+    // Map from collapseIndex(=global master point) to set of points
+    Map<DynamicList<label> > collapseStrings;
     {
-        const label pointRegionMaster = pointRegion_[meshPoints[pI]];
-
-        if (pointRegionMaster != -1)
+        // 1. Count elements per collapseIndex
+        Map<label> nPerIndex(mesh_.nPoints()/10);
+        forAll(allPointInfo, pointI)
         {
-            newPoints[pI]
-                = pointRegionMasterLocation_[pointRegionMaster];
-        }
-    }
+            label collapseIndex = allPointInfo[pointI].collapseIndex();
 
-    globalData.syncData
-    (
-        newPoints,
-        globalData.globalPointSlaves(),
-        globalData.globalPointTransformedSlaves(),
-        map,
-        minMagSqrEqOp<point>()
-    );
-
-        OFstream str1("newPoints_" + name(Pstream::myProcNo()) + ".obj");
-        forAll(pointRegion_, pI)
-        {
-            if (meshPointMap.found(pI))
+            if (collapseIndex != -1 && collapseIndex != -2)
             {
-                meshTools::writeOBJ(str1, newPoints[meshPointMap[pI]]);
+                Map<label>::iterator fnd = nPerIndex.find(collapseIndex);
+                if (fnd != nPerIndex.end())
+                {
+                    fnd()++;
+                }
+                else
+                {
+                    nPerIndex.insert(collapseIndex, 1);
+                }
             }
         }
 
-    for (label pI = 0; pI < coupledPatch.nPoints(); ++pI)
-    {
-        const label pointRegionMaster = pointRegion_[meshPoints[pI]];
-
-        if (pointRegionMaster != -1)
+        // 2. Size
+        collapseStrings.resize(2*nPerIndex.size());
+        forAllConstIter(Map<label>, nPerIndex, iter)
         {
-            pointRegionMasterLocation_[pointRegionMaster]
-                = newPoints[pI];
+            collapseStrings.insert(iter.key(), DynamicList<label>(iter()));
+        }
+
+        // 3. Fill
+        forAll(allPointInfo, pointI)
+        {
+            const label collapseIndex = allPointInfo[pointI].collapseIndex();
+
+            if (collapseIndex != -1 && collapseIndex != -2)
+            {
+                collapseStrings[collapseIndex].append(pointI);
+            }
         }
     }
 
@@ -470,12 +1307,49 @@ bool Foam::edgeCollapser::setRefinement(polyTopoChange& meshMod)
     // Current cellCollapse status
     boolList cellRemoved(mesh_.nCells(), false);
 
+    label nUnvisited = 0;
+    label nUncollapsed = 0;
+    label nCollapsed = 0;
+
+    forAll(allPointInfo, pI)
+    {
+        const pointEdgeCollapse& pec = allPointInfo[pI];
+
+        if (pec.collapseIndex() == -1)
+        {
+            nUnvisited++;
+        }
+        else if (pec.collapseIndex() == -2)
+        {
+            nUncollapsed++;
+        }
+        else
+        {
+            nCollapsed++;
+        }
+    }
+
+    label nPoints = allPointInfo.size();
+
+    reduce(nPoints, sumOp<label>());
+    reduce(nUnvisited, sumOp<label>());
+    reduce(nUncollapsed, sumOp<label>());
+    reduce(nCollapsed, sumOp<label>());
+
+    Info<< incrIndent;
+    Info<< indent << "Number of points : " << nPoints << nl
+        << indent << "Not visited      : " << nUnvisited << nl
+        << indent << "Not collapsed    : " << nUncollapsed << nl
+        << indent << "Collapsed        : " << nCollapsed << nl
+        << endl;
+    Info<< decrIndent;
+
     do
     {
         // Update face collapse from edge collapses
         forAll(newFaces, faceI)
         {
-            filterFace(faceI, newFaces[faceI]);
+            filterFace(collapseStrings, allPointInfo, newFaces[faceI]);
         }
 
         // Check if faces to be collapsed cause cells to become collapsed.
@@ -504,6 +1378,8 @@ bool Foam::edgeCollapser::setRefinement(polyTopoChange& meshMod)
                                 << " of which too many are marked for removal:"
                                 << endl
                                 << "   ";
+
+
                             forAll(cFaces, j)
                             {
                                 if (newFaces[cFaces[j]].size() < 3)
@@ -516,7 +1392,7 @@ bool Foam::edgeCollapser::setRefinement(polyTopoChange& meshMod)
                             cellRemoved[cellI] = true;
 
                             // Collapse all edges of cell to nothing
-                            collapseEdges(cellEdges[cellI]);
+//                            collapseEdges(cellEdges[cellI]);
 
                             nCellCollapsed++;
 
@@ -527,10 +1403,14 @@ bool Foam::edgeCollapser::setRefinement(polyTopoChange& meshMod)
             }
         }
 
+        reduce(nCellCollapsed, sumOp<label>());
+        Info<< indent << "Collapsing " << nCellCollapsed << " cells" << endl;
+
         if (nCellCollapsed == 0)
         {
             break;
         }
+
     } while (true);
 
 
@@ -541,7 +1421,6 @@ bool Foam::edgeCollapser::setRefinement(polyTopoChange& meshMod)
         // Mark points used.
         boolList usedPoint(mesh_.nPoints(), false);
 
-
         forAll(cellRemoved, cellI)
         {
             if (cellRemoved[cellI])
@@ -550,7 +1429,6 @@ bool Foam::edgeCollapser::setRefinement(polyTopoChange& meshMod)
             }
         }
 
-
         // Remove faces
         forAll(newFaces, faceI)
         {
@@ -577,55 +1455,28 @@ bool Foam::edgeCollapser::setRefinement(polyTopoChange& meshMod)
         // Remove unused vertices that have not been marked for removal already
         forAll(usedPoint, pointI)
         {
-            if (!usedPoint[pointI] && !pointRemoved(pointI))
+            if (!usedPoint[pointI])
             {
+                removedPoints[pointI] = true;
                 meshMod.removePoint(pointI, -1);
                 meshChanged = true;
             }
         }
     }
 
-
-
-    // Remove points.
-    forAll(pointRegion_, pointI)
-    {
-        if (pointRemoved(pointI))
-        {
-            meshMod.removePoint(pointI, -1);
-            meshChanged = true;
-        }
-    }
-
     // Modify the point location of the remaining points
-    forAll(pointRegion_, pointI)
+    forAll(allPointInfo, pointI)
     {
-        const label pointRegion = pointRegion_[pointI];
+        const label collapseIndex = allPointInfo[pointI].collapseIndex();
+        const point& collapsePoint = allPointInfo[pointI].collapsePoint();
 
         if
         (
-            !pointRemoved(pointI)
-         && meshPointMap.found(pointI)
+            removedPoints[pointI] == false
+         && collapseIndex != -1
+         && collapseIndex != -2
         )
         {
-            meshMod.modifyPoint
-            (
-                pointI,
-                newPoints[meshPointMap[pointI]],
-                pointZones.whichZone(pointI),
-                false
-            );
-        }
-        else if
-        (
-            pointRegion != -1
-         && !pointRemoved(pointI)
-         && !meshPointMap.found(pointI)
-        )
-        {
-            const point& collapsePoint
-                = pointRegionMasterLocation_[pointRegion];
-
             meshMod.modifyPoint
             (
                 pointI,
@@ -641,9 +1492,9 @@ bool Foam::edgeCollapser::setRefinement(polyTopoChange& meshMod)
     const faceZoneMesh& faceZones = mesh_.faceZones();
 
     // Renumber faces that use points
-    forAll(pointRegion_, pointI)
+    forAll(allPointInfo, pointI)
     {
-        if (pointRemoved(pointI))
+        if (removedPoints[pointI] == true)
         {
             const labelList& changedFaces = pointFaces[pointI];
 
@@ -692,28 +1543,451 @@ bool Foam::edgeCollapser::setRefinement(polyTopoChange& meshMod)
                         zoneID,
                         zoneFlip
                     );
+
                     meshChanged = true;
                 }
             }
         }
     }
 
-    // Print regions:
-//    printRegions();
-
     return meshChanged;
 }
 
 
-void Foam::edgeCollapser::updateMesh(const mapPolyMesh& map)
+void Foam::edgeCollapser::consistentCollapse
+(
+    const globalIndex& globalPoints,
+    const labelList& pointPriority,
+    const Map<point>& collapsePointToLocation,
+    PackedBoolList& collapseEdge,
+    List<pointEdgeCollapse>& allPointInfo,
+    const bool allowCellCollapse
+) const
 {
-    pointRegion_.setSize(mesh_.nPoints());
-    pointRegion_ = -1;
+    // Make sure we don't collapse cells
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    const faceList faces = mesh_.faces();
+    const edgeList& edges = mesh_.edges();
+    const labelListList& faceEdges = mesh_.faceEdges();
+    const labelListList& pointEdges = mesh_.pointEdges();
+    const cellList& cells = mesh_.cells();
 
-    // Reset count, do not remove underlying storage
-    pointRegionMaster_.clear();
-    pointRegionMasterLocation_.clear();
-    freeRegions_.clear();
+    labelHashSet uniqueCollapses;
+    labelHashSet duplicateCollapses;
+
+    while (true)
+    {
+        label nUncollapsed = 0;
+
+        syncTools::syncEdgeList
+        (
+            mesh_,
+            collapseEdge,
+            minEqOp<unsigned int>(),
+            0
+        );
+
+        // Create consistent set of collapses
+        // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+        // Note: requires collapseEdge to be synchronised.
+        syncCollapse
+        (
+            globalPoints,
+            pointPriority,
+            collapseEdge,
+            collapsePointToLocation,
+            allPointInfo
+        );
+
+        // Get collapsed faces
+
+        PackedBoolList isCollapsedFace(mesh_.nFaces());
+        PackedBoolList markedPoints(mesh_.nPoints());
+
+        forAll(faces, faceI)
+        {
+            const face& f = faces[faceI];
+
+            isCollapsedFace[faceI] = isFaceCollapsed(f, allPointInfo);
+
+            if (isCollapsedFace[faceI] < 1)
+            {
+                determineDuplicatePointsOnFace
+                (
+                    f,
+                    markedPoints,
+                    uniqueCollapses,
+                    duplicateCollapses,
+                    allPointInfo
+                );
+            }
+        }
+
+        // Synchronise the marked points
+        syncTools::syncPointList
+        (
+            mesh_,
+            markedPoints,
+            orEqOp<unsigned int>(),
+            0
+        );
+
+        // Mark all edges attached to the point for collapse
+        forAll(markedPoints, pointI)
+        {
+            if (markedPoints[pointI])
+            {
+                const label index = allPointInfo[pointI].collapseIndex();
+
+                const labelList& ptEdges = pointEdges[pointI];
+
+                forAll(ptEdges, ptEdgeI)
+                {
+                    const label edgeI = ptEdges[ptEdgeI];
+                    const label nbrPointI = edges[edgeI].otherVertex(pointI);
+                    const label nbrIndex
+                        = allPointInfo[nbrPointI].collapseIndex();
+
+                    if (collapseEdge[edgeI] && nbrIndex == index)
+                    {
+                        collapseEdge[edgeI] = false;
+                        nUncollapsed++;
+                    }
+                }
+            }
+        }
+
+        PackedBoolList markedEdges(mesh_.nEdges());
+
+        if (!allowCellCollapse)
+        {
+            // Check collapsed cells
+            forAll(cells, cellI)
+            {
+                const cell& cFaces = cells[cellI];
+
+                label nFaces = cFaces.size();
+
+                forAll(cFaces, fI)
+                {
+                    label faceI = cFaces[fI];
+
+                    if (isCollapsedFace[faceI])
+                    {
+                        nFaces--;
+                    }
+                }
+
+                if (nFaces < 4)
+                {
+                    forAll(cFaces, fI)
+                    {
+                        label faceI = cFaces[fI];
+
+                        const labelList& fEdges = faceEdges[faceI];
+
+                        // Unmark this face for collapse
+                        forAll(fEdges, fEdgeI)
+                        {
+                            label edgeI = fEdges[fEdgeI];
+
+                            if (collapseEdge[edgeI])
+                            {
+                                collapseEdge[edgeI] = false;
+                                nUncollapsed++;
+                            }
+
+                            markedEdges[edgeI] = true;
+                        }
+
+                        // Uncollapsed this face.
+                        isCollapsedFace[faceI] = false;
+                        nFaces++;
+                    }
+                }
+
+                if (nFaces < 4)
+                {
+                    FatalErrorIn
+                    (
+                        "consistentCollapse\n"
+                        "(\n"
+                        "   labelList&,\n"
+                        "   Map<point>&,\n"
+                        "   bool&,\n"
+                        ")"
+                    )   << "Cell " << cellI << " " << cFaces << nl
+                        << "is " << nFaces << ", "
+                        << "but cell collapse has been disabled."
+                        << abort(FatalError);
+                }
+            }
+        }
+
+        syncTools::syncEdgeList
+        (
+            mesh_,
+            markedEdges,
+            orEqOp<unsigned int>(),
+            0
+        );
+
+        nUncollapsed += breakStringsAtEdges
+        (
+            markedEdges,
+            collapseEdge,
+            allPointInfo
+        );
+
+        reduce(nUncollapsed, sumOp<label>());
+
+        Info<< "            Uncollapsed edges = " << nUncollapsed << " / "
+            << returnReduce(mesh_.nEdges(), sumOp<label>()) << endl;
+
+        if (nUncollapsed == 0)
+        {
+            break;
+        }
+    }
+}
+
+
+Foam::label Foam::edgeCollapser::markSmallEdges
+(
+    const scalarField& minEdgeLen,
+    const labelList& pointPriority,
+    PackedBoolList& collapseEdge,
+    Map<point>& collapsePointToLocation
+) const
+{
+    // Work out which edges to collapse
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    const pointField& points = mesh_.points();
+    const edgeList& edges = mesh_.edges();
+
+    label nCollapsed = 0;
+
+    forAll(edges, edgeI)
+    {
+        const edge& e = edges[edgeI];
+
+        if (!collapseEdge[edgeI])
+        {
+            if (e.mag(points) < minEdgeLen[edgeI])
+            {
+                collapseEdge[edgeI] = true;
+
+                label masterPointI = edgeMaster(pointPriority, e);
+
+                if (masterPointI == -1)
+                {
+                    const point average
+                        = 0.5*(points[e.start()] + points[e.end()]);
+
+                    collapsePointToLocation.set(e.start(), average);
+                }
+                else
+                {
+                    const point& collapsePt = points[masterPointI];
+
+                    collapsePointToLocation.set(masterPointI, collapsePt);
+                }
+
+
+                nCollapsed++;
+            }
+        }
+    }
+
+    return nCollapsed;
+}
+
+
+Foam::label Foam::edgeCollapser::markMergeEdges
+(
+    const scalar maxCos,
+    const labelList& pointPriority,
+    PackedBoolList& collapseEdge,
+    Map<point>& collapsePointToLocation
+) const
+{
+    const edgeList& edges = mesh_.edges();
+    const pointField& points = mesh_.points();
+    const labelListList& pointEdges = mesh_.pointEdges();
+
+    // Point removal engine
+    removePoints pointRemover(mesh_, false);
+
+    // Find out points that can be deleted
+    boolList pointCanBeDeleted;
+    label nTotRemove = pointRemover.countPointUsage(maxCos, pointCanBeDeleted);
+
+    // Rework point-to-remove into edge-to-collapse.
+
+    label nCollapsed = 0;
+
+    if (nTotRemove > 0)
+    {
+        forAll(pointEdges, pointI)
+        {
+            if (pointCanBeDeleted[pointI])
+            {
+                const labelList& pEdges = pointEdges[pointI];
+
+                if (pEdges.size() == 2)
+                {
+                    // Always the case?
+
+                    label e0 = pEdges[0];
+                    label e1 = pEdges[1];
+
+                    if (!collapseEdge[e0] && !collapseEdge[e1])
+                    {
+                        // Get lengths of both edges and choose the smallest
+                        scalar e0length = mag
+                        (
+                            points[edges[e0][0]] - points[edges[e0][1]]
+                        );
+
+                        scalar e1length = mag
+                        (
+                            points[edges[e1][0]] - points[edges[e1][1]]
+                        );
+
+                        if (e0length <= e1length)
+                        {
+                            if (edges[e0].start() == pointI)
+                            {
+                                collapseEdge[e0] = true;
+
+                                checkBoundaryPointMergeEdges
+                                (
+                                    pointI,
+                                    edges[e0].end(),
+                                    pointPriority,
+                                    collapsePointToLocation
+                                );
+                            }
+                            else
+                            {
+                                collapseEdge[e0] = true;
+
+                                checkBoundaryPointMergeEdges
+                                (
+                                    pointI,
+                                    edges[e0].start(),
+                                    pointPriority,
+                                    collapsePointToLocation
+                                );
+                            }
+                        }
+                        else
+                        {
+                            if (edges[e1].start() == pointI)
+                            {
+                                collapseEdge[e1] = true;
+
+                                checkBoundaryPointMergeEdges
+                                (
+                                    pointI,
+                                    edges[e1].end(),
+                                    pointPriority,
+                                    collapsePointToLocation
+                                );
+                            }
+                            else
+                            {
+                                collapseEdge[e1] = true;
+
+                                checkBoundaryPointMergeEdges
+                                (
+                                    pointI,
+                                    edges[e1].start(),
+                                    pointPriority,
+                                    collapsePointToLocation
+                                );
+                            }
+                        }
+
+//                        if (boundaryPoint[leftV] == -1)
+//                        {
+//                            collapseEdge[e0] = findIndex(edges[e0], leftV);
+//                        }
+//                        else
+//                        {
+//                            collapseEdge[e1] = findIndex(edges[e1], rightV);
+//                        }
+
+                        nCollapsed++;
+                    }
+                }
+            }
+        }
+    }
+
+    return nCollapsed;
+}
+
+
+Foam::labelPair Foam::edgeCollapser::markSmallSliverFaces
+(
+    const scalarField& faceFilterFactor,
+    const labelList& pointPriority,
+    PackedBoolList& collapseEdge,
+    Map<point>& collapsePointToLocation
+) const
+{
+    const faceList& faces = mesh_.faces();
+
+    const scalarField targetFaceSizes = calcTargetFaceSizes();
+
+    // Calculate number of faces that will be collapsed to a point or an edge
+    label nCollapseToPoint = 0;
+    label nCollapseToEdge = 0;
+
+    forAll(faces, fI)
+    {
+        const face& f = faces[fI];
+
+        if (faceFilterFactor[fI] == 0)
+        {
+            continue;
+        }
+
+        collapseType flagCollapseFace = collapseFace
+        (
+            pointPriority,
+            f,
+            fI,
+            targetFaceSizes[fI],
+            collapseEdge,
+            collapsePointToLocation,
+            faceFilterFactor
+        );
+
+        if (flagCollapseFace == noCollapse)
+        {
+            continue;
+        }
+        else if (flagCollapseFace == toPoint)
+        {
+            nCollapseToPoint++;
+        }
+        else if (flagCollapseFace == toEdge)
+        {
+            nCollapseToEdge++;
+        }
+        else
+        {
+            FatalErrorIn("collapseFaces(const polyMesh&, List<labelPair>&)")
+                << "Face is marked to be collapsed to " << flagCollapseFace
+                << ". Currently can only collapse to point/edge."
+                << abort(FatalError);
+        }
+    }
+
+    return labelPair(nCollapseToPoint, nCollapseToEdge);
 }
 
 
diff --git a/src/dynamicMesh/polyTopoChange/polyTopoChange/edgeCollapser.H b/src/dynamicMesh/polyTopoChange/polyTopoChange/edgeCollapser.H
index 3a10a93197..946ee2a72c 100644
--- a/src/dynamicMesh/polyTopoChange/polyTopoChange/edgeCollapser.H
+++ b/src/dynamicMesh/polyTopoChange/polyTopoChange/edgeCollapser.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2012 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -37,10 +37,15 @@ SourceFiles
 #ifndef edgeCollapser_H
 #define edgeCollapser_H
 
-#include "labelList.H"
+#include "pointEdgeCollapse.H"
 #include "DynamicList.H"
-#include "point.H"
+#include "Field.H"
+#include "pointFieldFwd.H"
+#include "Map.H"
+#include "labelPair.H"
+#include "HashSet.H"
 #include "typeInfo.H"
+#include "Switch.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -49,9 +54,11 @@ namespace Foam
 
 // Forward declaration of classes
 class polyMesh;
+class PackedBoolList;
 class polyTopoChange;
+class globalIndex;
 class face;
-class mapPolyMesh;
+class edge;
 
 /*---------------------------------------------------------------------------*\
                            Class edgeCollapser Declaration
@@ -59,59 +66,169 @@ class mapPolyMesh;
 
 class edgeCollapser
 {
+public:
+
+    // The type of collapse of a face
+    enum collapseType
+    {
+        noCollapse = 0,
+        toPoint    = 1,
+        toEdge     = 2
+    };
+
+
+private:
+
     // Private data
 
         //- Reference to mesh
         const polyMesh& mesh_;
 
-        //- For every point -1 or region number
-        labelList pointRegion_;
+        const scalar guardFraction_;
 
-        //- Actual location of the point to collapse to for every region master
-        //  point. This will be forced to be consistent across processors
-        DynamicList<point> pointRegionMasterLocation_;
+        const scalar maxCollapseFaceToPointSideLengthCoeff_;
 
-        //- -1 or master vertex for region number
-        DynamicList<label> pointRegionMaster_;
+        const Switch allowEarlyCollapseToPoint_;
 
-        //- Stack of free region numbers. Corresponds to -1 in pointRegionMaster
-        SLList<label> freeRegions_;
-
-
-    // Static Functions
-
-        //- Find val in list. Search starts at start, continues to size-1.
-        static label findIndex
-        (
-            const labelList&,
-            const label start,
-            const label size,
-            const label val
-        );
+        const scalar allowEarlyCollapseCoeff_;
 
 
     // Private Member Functions
 
-        //- Determine points connected through edgesToRemove_.
-        //  Note: Only routine that uses edgesToRemove!
-        label changePointRegion
+        //- Create an edgeList of edges in faceI which have both their points
+        //  in pointLabels
+        labelList edgesFromPoints
+        (
+            const label& faceI,
+            const labelList& pointLabels
+        ) const;
+
+        //- Collapse a face to an edge, marking the collapsed edges and new
+        //  locations for points that will move as a result of the collapse
+        void collapseToEdge
+        (
+            const label faceI,
+            const pointField& pts,
+            const labelList& pointPriority,
+            const vector& collapseAxis,
+            const point& fC,
+            const labelList& facePtsNeg,
+            const labelList& facePtsPos,
+            const scalarList& dNeg,
+            const scalarList& dPos,
+            const scalar dShift,
+            PackedBoolList& collapseEdge,
+            Map<point>& collapsePointToLocation
+        ) const;
+
+        //- Collapse a face to a point, marking the collapsed edges and new
+        //  locations for points that will move as a result of the collapse
+        void collapseToPoint
+        (
+            const label& faceI,
+            const pointField& pts,
+            const labelList& pointPriority,
+            const point& fC,
+            const labelList& facePts,
+            PackedBoolList& collapseEdge,
+            Map<point>& collapsePointToLocation
+        ) const;
+
+        //- Do an eigenvector analysis of the face to get its collapse axis
+        //  and aspect ratio
+        void faceCollapseAxisAndAspectRatio
+        (
+            const face& f,
+            const point& fC,
+            vector& collapseAxis,
+            scalar& aspectRatio
+        ) const;
+
+        //- Return the target length scale for each face
+        scalarField calcTargetFaceSizes() const;
+
+        //- Decides whether a face should be collapsed (and if so it it is to a
+        //  point or an edge)
+        collapseType collapseFace
+        (
+            const labelList& pointPriority,
+            const face& f,
+            const label faceI,
+            const scalar targetFaceSize,
+            PackedBoolList& collapseEdge,
+            Map<point>& collapsePointToLocation,
+            const scalarField& faceFilterFactor
+        ) const;
+
+        //- Return label of point that has the highest priority. This will be
+        //  the point on the edge that will be collapsed to.
+        label edgeMaster(const labelList& pointPriority, const edge& e) const;
+
+        //- Decides which points in an edge to collapse, based on their priority
+        void checkBoundaryPointMergeEdges
         (
             const label pointI,
-            const label oldRegion,
-            const label newRegion
-        );
+            const label otherPointI,
+            const labelList& pointPriority,
+            Map<point>& collapsePointToLocation
+        ) const;
 
-        //- Whether point is master of region or has been removed
-        bool pointRemoved(const label) const;
+        //- Helper function that breaks strings of collapses if an edge is not
+        //  labelled to collapse, but its points both collapse to the same
+        //  location
+        label breakStringsAtEdges
+        (
+            const PackedBoolList& markedEdges,
+            PackedBoolList& collapseEdge,
+            List<pointEdgeCollapse>& allPointInfo
+        ) const;
 
-        //- Renumber f with new vertices. Removes duplicates.
-        void filterFace(const label faceI, face&) const;
+        //- Prevent face pinching by finding points in a face that will be
+        //  collapsed to the same location, but that are not ordered
+        //  consecutively in the face
+        void determineDuplicatePointsOnFace
+        (
+            const face& f,
+            PackedBoolList& markedPoints,
+            labelHashSet& uniqueCollapses,
+            labelHashSet& duplicateCollapses,
+            List<pointEdgeCollapse>& allPointInfo
+        ) const;
 
-        //- Some debugging printing
-        void printRegions() const;
+        //- Count the number of edges on the face that will exist as a result
+        //  of the collapse
+        label countEdgesOnFace
+        (
+            const face& f,
+            List<pointEdgeCollapse>& allPointInfo
+        ) const;
 
-        //- Collapse list of edges. Tries to find master to collapse to.
-        void collapseEdges(const labelList& edgeLabels);
+        //- Does the face have fewer than 3 edges as a result of the potential
+        //  collapse
+        bool isFaceCollapsed
+        (
+            const face& f,
+            List<pointEdgeCollapse>& allPointInfo
+        ) const;
+
+        //- Given the collapse information, propagates the information using
+        //  PointEdgeWave. Result is a list of new point locations and indices
+        label syncCollapse
+        (
+            const globalIndex& globalPoints,
+            const labelList& boundaryPoint,
+            const PackedBoolList& collapseEdge,
+            const Map<point>& collapsePointToLocation,
+            List<pointEdgeCollapse>& allPointInfo
+        ) const;
+
+        //- Renumber f with new vertices. Removes consecutive duplicates
+        void filterFace
+        (
+            const Map<DynamicList<label> >& collapseStrings,
+            const List<pointEdgeCollapse>& allPointInfo,
+            face& f
+        ) const;
 
         //- Disallow default bitwise copy construct
         edgeCollapser(const edgeCollapser&);
@@ -128,43 +245,92 @@ public:
 
     // Constructors
 
-        //- Construct from mesh.
+        //- Construct from mesh
         edgeCollapser(const polyMesh& mesh);
 
+        //- Construct from mesh and dict
+        edgeCollapser(const polyMesh& mesh, const dictionary& dict);
+
 
     // Member Functions
 
-        // Access
+        // Check
 
-            //- For every point the region it belongs to or -1.
-            const labelList& pointRegion() const
-            {
-                return pointRegion_;
-            }
+            //- Find the longest edge in a face
+            static label longestEdge(const face& f, const pointField& pts);
 
-            //- For every region the master (i.e. the point the region will
-            //  be replaced by)
-            const DynamicList<label>& pointRegionMaster() const
-            {
-                return pointRegionMaster_;
-            }
+            //- Calls motionSmoother::checkMesh and returns a set of bad faces
+            static HashSet<label> checkBadFaces
+            (
+                const polyMesh& mesh,
+                const dictionary& meshQualityDict
+            );
 
-            //- Check that edge is not marked for anything
-            bool unaffectedEdge(const label edgeI) const;
+            // Check mesh and mark points on faces in error
+            // Returns boolList with points in error set
+            static label checkMeshQuality
+            (
+                const polyMesh& mesh,
+                const dictionary& meshQualityDict,
+                PackedBoolList& isErrorPoint
+            );
+
+            //- Ensure that the collapse is parallel consistent and update
+            //  allPointInfo.
+            //  Returns a list of edge collapses that is consistent across
+            //  coupled boundaries and a list of pointEdgeCollapses.
+            void consistentCollapse
+            (
+                const globalIndex& globalPoints,
+                const labelList& pointPriority,
+                const Map<point>& collapsePointToLocation,
+                PackedBoolList& collapseEdge,
+                List<pointEdgeCollapse>& allPointInfo,
+                const bool allowCellCollapse = false
+            ) const;
 
 
-        // Edit
+        // Query
 
-            //- Set edge to collapse and point to collapse it to.
-            //  Return true if collapse is valid.
-            //  (always true at the moment)
-            bool collapseEdge(const label edgeI, const label master);
+            //- Play commands into polyTopoChange to create mesh.
+            //  Return true if anything changed.
+            bool setRefinement
+            (
+                const List<pointEdgeCollapse>& allPointInfo,
+                polyTopoChange& meshMod
+            ) const;
 
-            //- Play commands into polyTopoChange to create mesh. Return true
-            //  if anything changed.
-            bool setRefinement(polyTopoChange&);
+            // Mark (in collapseEdge) any edges to collapse
+            label markSmallEdges
+            (
+                const scalarField& minEdgeLen,
+                const labelList& pointPriority,
+                PackedBoolList& collapseEdge,
+                Map<point>& collapsePointToLocation
+            ) const;
 
-            void updateMesh(const mapPolyMesh&);
+            // Mark (in collapseEdge) any edges to merge
+            label markMergeEdges
+            (
+                const scalar maxCos,
+                const labelList& pointPriority,
+                PackedBoolList& collapseEdge,
+                Map<point>& collapsePointToLocation
+            ) const;
+
+            //- Find small faces and sliver faces in the mesh and mark the
+            //  edges that need to be collapsed in order to remove these faces.
+            //  Also returns a map of new locations for points that will move
+            //  as a result of the collapse.
+            //  Use in conjuctions with edgeCollapser to synchronise the
+            //  collapses and modify the mesh
+            labelPair markSmallSliverFaces
+            (
+                const scalarField& faceFilterFactor,
+                const labelList& pointPriority,
+                PackedBoolList& collapseEdge,
+                Map<point>& collapsePointToLocation
+            ) const;
 };
 
 
diff --git a/applications/utilities/mesh/advanced/collapseEdges/pointEdgeCollapse/pointEdgeCollapse.C b/src/dynamicMesh/polyTopoChange/polyTopoChange/pointEdgeCollapse/pointEdgeCollapse.C
similarity index 88%
rename from applications/utilities/mesh/advanced/collapseEdges/pointEdgeCollapse/pointEdgeCollapse.C
rename to src/dynamicMesh/polyTopoChange/polyTopoChange/pointEdgeCollapse/pointEdgeCollapse.C
index 6830e1c8f5..15747ded56 100644
--- a/applications/utilities/mesh/advanced/collapseEdges/pointEdgeCollapse/pointEdgeCollapse.C
+++ b/src/dynamicMesh/polyTopoChange/polyTopoChange/pointEdgeCollapse/pointEdgeCollapse.C
@@ -34,7 +34,9 @@ Foam::Ostream& Foam::operator<<
 )
 {
     return os
-        << wDist.collapsePoint_ << wDist.collapseIndex_;
+        << wDist.collapsePoint_
+        << wDist.collapseIndex_
+        << wDist.collapsePriority_;
 }
 
 Foam::Istream& Foam::operator>>
@@ -44,7 +46,9 @@ Foam::Istream& Foam::operator>>
 )
 {
     return is
-        >> wDist.collapsePoint_ >> wDist.collapseIndex_;
+        >> wDist.collapsePoint_
+        >> wDist.collapseIndex_
+        >> wDist.collapsePriority_;
 }
 
 
diff --git a/applications/utilities/mesh/advanced/collapseEdges/pointEdgeCollapse/pointEdgeCollapse.H b/src/dynamicMesh/polyTopoChange/polyTopoChange/pointEdgeCollapse/pointEdgeCollapse.H
similarity index 96%
rename from applications/utilities/mesh/advanced/collapseEdges/pointEdgeCollapse/pointEdgeCollapse.H
rename to src/dynamicMesh/polyTopoChange/polyTopoChange/pointEdgeCollapse/pointEdgeCollapse.H
index cd8383b8b3..83ac672b33 100644
--- a/applications/utilities/mesh/advanced/collapseEdges/pointEdgeCollapse/pointEdgeCollapse.H
+++ b/src/dynamicMesh/polyTopoChange/polyTopoChange/pointEdgeCollapse/pointEdgeCollapse.H
@@ -62,6 +62,9 @@ class pointEdgeCollapse
         //- Collapse string index
         label collapseIndex_;
 
+        //- Priority of the collapse
+        label collapsePriority_;
+
 
     // Private Member Functions
 
@@ -89,7 +92,8 @@ public:
         inline pointEdgeCollapse
         (
             const point& collapsePoint,
-            const label collapseIndex
+            const label collapseIndex,
+            const label collapsePriority
         );
 
 
@@ -101,6 +105,8 @@ public:
 
             inline label collapseIndex() const;
 
+            inline label collapsePriority() const;
+
 
         // Needed by meshWave
 
diff --git a/applications/utilities/mesh/advanced/collapseEdges/pointEdgeCollapse/pointEdgeCollapseI.H b/src/dynamicMesh/polyTopoChange/polyTopoChange/pointEdgeCollapse/pointEdgeCollapseI.H
similarity index 85%
rename from applications/utilities/mesh/advanced/collapseEdges/pointEdgeCollapse/pointEdgeCollapseI.H
rename to src/dynamicMesh/polyTopoChange/polyTopoChange/pointEdgeCollapse/pointEdgeCollapseI.H
index eeb4d6baf2..3b01268a92 100644
--- a/applications/utilities/mesh/advanced/collapseEdges/pointEdgeCollapse/pointEdgeCollapseI.H
+++ b/src/dynamicMesh/polyTopoChange/polyTopoChange/pointEdgeCollapse/pointEdgeCollapseI.H
@@ -43,48 +43,58 @@ inline bool Foam::pointEdgeCollapse::update
             << "problem." << abort(FatalError);
     }
 
+    if (!valid(td))
+    {
+        operator=(w2);
+        return true;
+    }
+
     if (w2.collapseIndex_ == -1 || collapseIndex_ == -1)
     {
         // Not marked for collapse; only happens on edges.
         return false;
     }
 
-    if (!valid(td))
+    if (w2.collapsePriority_ < collapsePriority_)
+    {
+        return false;
+    }
+    else if (w2.collapsePriority_ > collapsePriority_)
     {
         operator=(w2);
         return true;
     }
-    else
-    {
-        // Take over w2 if it is 'better'
 
-        if (w2.collapseIndex_ < collapseIndex_)
+    // Get overwritten by w2 if it has a higher priority
+    if (w2.collapseIndex_ < collapseIndex_)
+    {
+        operator=(w2);
+        return true;
+    }
+    else if (w2.collapseIndex_ == collapseIndex_)
+    {
+        bool identicalPoint = samePoint(w2.collapsePoint_);
+
+        bool nearer = magSqr(w2.collapsePoint_)
+                    < magSqr(collapsePoint_);
+
+        if (nearer)
         {
-            // Take over string index and coordinate from w2
             operator=(w2);
-            return true;
         }
-        else if (w2.collapseIndex_ == collapseIndex_)
-        {
-            bool identicalPoint = samePoint(w2.collapsePoint_);
-            bool nearer = magSqr(w2.collapsePoint_) < magSqr(collapsePoint_);
-            if (nearer)
-            {
-                operator=(w2);
-            }
-            if (identicalPoint)
-            {
-                return false;
-            }
-            else
-            {
-                return nearer;
-            }
-        }
-        else
+
+        if (identicalPoint)
         {
             return false;
         }
+        else
+        {
+            return nearer;
+        }
+    }
+    else
+    {
+        return false;
     }
 }
 
@@ -95,7 +105,8 @@ inline bool Foam::pointEdgeCollapse::update
 inline Foam::pointEdgeCollapse::pointEdgeCollapse()
 :
     collapsePoint_(GREAT, GREAT, GREAT),
-    collapseIndex_(-2)
+    collapseIndex_(-2),
+    collapsePriority_(-2)
 {}
 
 
@@ -103,11 +114,13 @@ inline Foam::pointEdgeCollapse::pointEdgeCollapse()
 inline Foam::pointEdgeCollapse::pointEdgeCollapse
 (
     const point& collapsePoint,
-    const label collapseIndex
+    const label collapseIndex,
+    const label collapsePriority
 )
 :
     collapsePoint_(collapsePoint),
-    collapseIndex_(collapseIndex)
+    collapseIndex_(collapseIndex),
+    collapsePriority_(collapsePriority)
 {}
 
 
@@ -125,6 +138,12 @@ inline Foam::label Foam::pointEdgeCollapse::collapseIndex() const
 }
 
 
+inline Foam::label Foam::pointEdgeCollapse::collapsePriority() const
+{
+    return collapsePriority_;
+}
+
+
 inline bool Foam::pointEdgeCollapse::samePoint(const point& pt) const
 {
     bool isLegal1 = (cmptMin(collapsePoint_) < 0.5*GREAT);
@@ -268,6 +287,7 @@ inline bool Foam::pointEdgeCollapse::operator==
 {
     return
         collapseIndex_ == rhs.collapseIndex_
+     && collapsePriority_ == rhs.collapsePriority_
      && samePoint(rhs.collapsePoint_);
 }
 
diff --git a/src/dynamicMesh/polyTopoChange/polyTopoChange/polyTopoChange.C b/src/dynamicMesh/polyTopoChange/polyTopoChange/polyTopoChange.C
index 07618de976..12e4ebb6eb 100644
--- a/src/dynamicMesh/polyTopoChange/polyTopoChange/polyTopoChange.C
+++ b/src/dynamicMesh/polyTopoChange/polyTopoChange/polyTopoChange.C
@@ -39,6 +39,7 @@ License
 #include "processorPolyPatch.H"
 #include "fvMesh.H"
 #include "CompactListList.H"
+#include "ListOps.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
@@ -2051,17 +2052,17 @@ void Foam::polyTopoChange::reorderCoupledFaces
 
     if (anyChanged)
     {
-        // Reorder faces according to oldToNew.
-        reorderCompactFaces(oldToNew.size(), oldToNew);
-
         // Rotate faces (rotation is already in new face indices).
         forAll(rotation, faceI)
         {
             if (rotation[faceI] != 0)
             {
-                faces_[faceI] = faces_[faceI].rotateFace(rotation[faceI]);
+                inplaceRotateList<List, label>(faces_[faceI], rotation[faceI]);
             }
         }
+
+        // Reorder faces according to oldToNew.
+        reorderCompactFaces(oldToNew.size(), oldToNew);
     }
 }
 
diff --git a/src/edgeMesh/extendedFeatureEdgeMesh/extendedFeatureEdgeMesh.C b/src/edgeMesh/extendedFeatureEdgeMesh/extendedFeatureEdgeMesh.C
index f94715922b..c6575f785a 100644
--- a/src/edgeMesh/extendedFeatureEdgeMesh/extendedFeatureEdgeMesh.C
+++ b/src/edgeMesh/extendedFeatureEdgeMesh/extendedFeatureEdgeMesh.C
@@ -39,6 +39,42 @@ License
 
 defineTypeNameAndDebug(Foam::extendedFeatureEdgeMesh, 0);
 
+
+template<>
+const char* Foam::NamedEnum
+<
+    Foam::extendedFeatureEdgeMesh::pointStatus,
+    4
+>::names[] =
+{
+    "convex",
+    "concave",
+    "mixed",
+    "nonFeature"
+};
+
+const Foam::NamedEnum<Foam::extendedFeatureEdgeMesh::pointStatus, 4>
+    Foam::extendedFeatureEdgeMesh::pointStatusNames_;
+
+template<>
+const char* Foam::NamedEnum
+<
+    Foam::extendedFeatureEdgeMesh::edgeStatus,
+    6
+>::names[] =
+{
+    "external",
+    "internal",
+    "flat",
+    "open",
+    "multiple",
+    "none"
+};
+
+const Foam::NamedEnum<Foam::extendedFeatureEdgeMesh::edgeStatus, 6>
+    Foam::extendedFeatureEdgeMesh::edgeStatusNames_;
+
+
 Foam::scalar Foam::extendedFeatureEdgeMesh::cosNormalAngleTol_ =
     Foam::cos(degToRad(0.1));
 
@@ -72,6 +108,7 @@ Foam::extendedFeatureEdgeMesh::extendedFeatureEdgeMesh(const IOobject& io)
     edgeDirections_(0),
     edgeNormals_(0),
     featurePointNormals_(0),
+    featurePointEdges_(0),
     regionEdges_(0),
     pointTree_(),
     edgeTree_(),
@@ -108,6 +145,7 @@ Foam::extendedFeatureEdgeMesh::extendedFeatureEdgeMesh(const IOobject& io)
             >> normals_
             >> edgeNormals_
             >> featurePointNormals_
+            >> featurePointEdges_
             >> regionEdges_;
 
         close();
@@ -160,6 +198,7 @@ Foam::extendedFeatureEdgeMesh::extendedFeatureEdgeMesh
     edgeDirections_(fem.edgeDirections()),
     edgeNormals_(fem.edgeNormals()),
     featurePointNormals_(fem.featurePointNormals()),
+    featurePointEdges_(fem.featurePointEdges()),
     regionEdges_(fem.regionEdges()),
     pointTree_(),
     edgeTree_(),
@@ -187,6 +226,7 @@ Foam::extendedFeatureEdgeMesh::extendedFeatureEdgeMesh
     edgeDirections_(0),
     edgeNormals_(0),
     featurePointNormals_(0),
+    featurePointEdges_(0),
     regionEdges_(0),
     pointTree_(),
     edgeTree_(),
@@ -225,15 +265,13 @@ Foam::extendedFeatureEdgeMesh::extendedFeatureEdgeMesh
     edgeDirections_(0),
     edgeNormals_(0),
     featurePointNormals_(0),
+    featurePointEdges_(0),
     regionEdges_(0),
     pointTree_(),
     edgeTree_(),
     edgeTreesByType_()
 {
     // Extract and reorder the data from surfaceFeatures
-
-
-
     const triSurface& surf = sFeat.surface();
     const labelList& featureEdges = sFeat.featureEdges();
     const labelList& featurePoints = sFeat.featurePoints();
@@ -273,6 +311,7 @@ Foam::extendedFeatureEdgeMesh::extendedFeatureEdgeMesh
     edgeDirections_(0),
     edgeNormals_(0),
     featurePointNormals_(0),
+    featurePointEdges_(0),
     regionEdges_(0),
     pointTree_(),
     edgeTree_(),
@@ -304,6 +343,7 @@ Foam::extendedFeatureEdgeMesh::extendedFeatureEdgeMesh
     const vectorField& edgeDirections,
     const labelListList& edgeNormals,
     const labelListList& featurePointNormals,
+    const labelListList& featurePointEdges,
     const labelList& regionEdges
 )
 :
@@ -320,6 +360,7 @@ Foam::extendedFeatureEdgeMesh::extendedFeatureEdgeMesh
     edgeDirections_(edgeDirections),
     edgeNormals_(edgeNormals),
     featurePointNormals_(featurePointNormals),
+    featurePointEdges_(featurePointEdges),
     regionEdges_(regionEdges),
     pointTree_(),
     edgeTree_(),
@@ -1268,6 +1309,8 @@ bool Foam::extendedFeatureEdgeMesh::writeData(Ostream& os) const
         << edgeNormals_ << nl
         << "// featurePointNormals" << nl
         << featurePointNormals_ << nl
+        << "// featurePointEdges" << nl
+        << featurePointEdges_ << nl
         << "// regionEdges" << nl
         << regionEdges_
         << endl;
diff --git a/src/edgeMesh/extendedFeatureEdgeMesh/extendedFeatureEdgeMesh.H b/src/edgeMesh/extendedFeatureEdgeMesh/extendedFeatureEdgeMesh.H
index 8406658882..b090ad66b1 100644
--- a/src/edgeMesh/extendedFeatureEdgeMesh/extendedFeatureEdgeMesh.H
+++ b/src/edgeMesh/extendedFeatureEdgeMesh/extendedFeatureEdgeMesh.H
@@ -93,6 +93,8 @@ public:
         NONFEATURE  // Not a feature point
     };
 
+    static const Foam::NamedEnum<pointStatus, 4> pointStatusNames_;
+
     enum edgeStatus
     {
         EXTERNAL,   // "Convex" edge
@@ -104,6 +106,9 @@ public:
                     // surfaceFeatures)
     };
 
+    static const Foam::NamedEnum<edgeStatus, 6> edgeStatusNames_;
+
+
 private:
 
     // Static data
@@ -155,6 +160,10 @@ private:
         //  (only valid for 0..nonFeatureStart_-1)
         labelListList featurePointNormals_;
 
+        //- Indices of feature edges attached to feature points. The edges are
+        //  ordered so that they can be circulated.
+        labelListList featurePointEdges_;
+
         //- Feature edges which are on the boundary between regions
         labelList regionEdges_;
 
@@ -202,6 +211,7 @@ public:
         //- Number of possible feature edge types (i.e. number of slices)
         static label nEdgeTypes;
 
+
     // Constructors
 
         //- Construct (read) given an IOobject
@@ -260,6 +270,7 @@ public:
             const vectorField& edgeDirections,
             const labelListList& edgeNormals,
             const labelListList& featurePointNormals,
+            const labelListList& featurePointEdges,
             const labelList& regionEdges
         );
 
@@ -381,6 +392,11 @@ public:
             //- Return the normal vectors for a given feature point
             inline vectorField featurePointNormals(label ptI) const;
 
+            //- Return the edge labels for a given feature point. Edges are
+            //  ordered by the faces that they share. The edge labels
+            //  correspond to the entry in edges().
+            inline const labelListList& featurePointEdges() const;
+
             //- Return the feature edges which are on the boundary between
             //  regions
             inline const labelList& regionEdges() const;
diff --git a/src/edgeMesh/extendedFeatureEdgeMesh/extendedFeatureEdgeMeshI.H b/src/edgeMesh/extendedFeatureEdgeMesh/extendedFeatureEdgeMeshI.H
index 62b0cc08ca..3138da65f8 100644
--- a/src/edgeMesh/extendedFeatureEdgeMesh/extendedFeatureEdgeMeshI.H
+++ b/src/edgeMesh/extendedFeatureEdgeMesh/extendedFeatureEdgeMeshI.H
@@ -115,7 +115,7 @@ inline Foam::vector Foam::extendedFeatureEdgeMesh::edgeDirection
     }
     else
     {
-        FatalErrorIn("Foam::extendedFeatureEdgeMesh::edgedirection")
+        FatalErrorIn("Foam::extendedFeatureEdgeMesh::edgeDirection")
             << "Requested ptI " << ptI << " is not a point on the requested "
             << "edgeI " << edgeI << ". edgeI start and end: "
             << e.start() << " " << e.end()
@@ -191,6 +191,13 @@ inline Foam::vectorField Foam::extendedFeatureEdgeMesh::featurePointNormals
 }
 
 
+inline const Foam::labelListList&
+Foam::extendedFeatureEdgeMesh::featurePointEdges() const
+{
+    return featurePointEdges_;
+}
+
+
 inline const Foam::labelList& Foam::extendedFeatureEdgeMesh::regionEdges() const
 {
     return regionEdges_;
diff --git a/src/edgeMesh/extendedFeatureEdgeMesh/extendedFeatureEdgeMeshTemplates.C b/src/edgeMesh/extendedFeatureEdgeMesh/extendedFeatureEdgeMeshTemplates.C
index ac7eb3ef11..63cef912b1 100644
--- a/src/edgeMesh/extendedFeatureEdgeMesh/extendedFeatureEdgeMeshTemplates.C
+++ b/src/edgeMesh/extendedFeatureEdgeMesh/extendedFeatureEdgeMeshTemplates.C
@@ -43,6 +43,7 @@ void Foam::extendedFeatureEdgeMesh::sortPointsAndEdges
     const edgeList& sFeatEds(surf.edges());
     const labelListList& edgeFaces = surf.edgeFaces();
     const vectorField& faceNormals = surf.faceNormals();
+    const labelListList& pointEdges = surf.pointEdges();
 
     // Extract and reorder the data from surfaceFeatures
 
@@ -51,6 +52,7 @@ void Foam::extendedFeatureEdgeMesh::sortPointsAndEdges
     // Filling the extendedFeatureEdgeMesh with the raw geometrical data.
 
     label nFeatEds = featureEdges.size();
+    label nFeatPts = featurePoints.size();
 
     DynamicList<point> tmpPts;
     edgeList eds(nFeatEds);
@@ -59,6 +61,14 @@ void Foam::extendedFeatureEdgeMesh::sortPointsAndEdges
     labelListList edgeNormals(nFeatEds);
     DynamicList<label> regionEdges;
 
+    // Keep track of the ordered feature point feature edges
+    labelListList featurePointFeatureEdges(nFeatPts);
+    forAll(featurePointFeatureEdges, pI)
+    {
+        featurePointFeatureEdges[pI] =
+            labelList(pointEdges[featurePoints[pI]].size(), -1);
+    }
+
     // Mapping between old and new indices, there is entry in the map for each
     // of surf.localPoints, -1 means that this point hasn't been used (yet),
     // >= 0 corresponds to the index
@@ -82,7 +92,6 @@ void Foam::extendedFeatureEdgeMesh::sortPointsAndEdges
     // All feature points have been added
     nonFeatureStart_ = tmpPts.size();
 
-
     PackedBoolList isRegionFeatureEdge(regionFeatureEdges);
 
     forAll(featureEdges, i)
@@ -147,8 +156,43 @@ void Foam::extendedFeatureEdgeMesh::sortPointsAndEdges
         {
             regionEdges.append(i);
         }
+
+        forAll(featurePointFeatureEdges, pI)
+        {
+            const labelList& fpfEdges = pointEdges[featurePoints[pI]];
+
+            labelList& fpfe = featurePointFeatureEdges[pI];
+
+            forAll(fpfEdges, eI)
+            {
+                if (sFEI == fpfEdges[eI])
+                {
+                    fpfe[eI] = i;
+                }
+            }
+        }
     }
 
+    forAll(featurePointFeatureEdges, pI)
+    {
+        const labelList& fpfe = featurePointFeatureEdges[pI];
+
+        DynamicList<label> newFeatureEdges(fpfe.size());
+
+        forAll(fpfe, eI)
+        {
+            const label edgeIndex = fpfe[eI];
+
+            if (edgeIndex != -1)
+            {
+                newFeatureEdges.append(edgeIndex);
+            }
+        }
+
+        featurePointFeatureEdges[pI] = newFeatureEdges;
+    }
+
+
     // Reorder the edges by classification
 
     List<DynamicList<label> > allEds(nEdgeTypes);
@@ -222,6 +266,11 @@ void Foam::extendedFeatureEdgeMesh::sortPointsAndEdges
     inplaceReorder(edMap, edgeNormals);
     inplaceRenumber(edMap, regionEdges);
 
+    forAll(featurePointFeatureEdges, pI)
+    {
+        inplaceRenumber(edMap, featurePointFeatureEdges[pI]);
+    }
+
     pointField pts(tmpPts);
 
     // Initialise the edgeMesh
@@ -301,6 +350,7 @@ void Foam::extendedFeatureEdgeMesh::sortPointsAndEdges
     }
 
     inplaceReorder(ptMap, pts);
+    inplaceReorder(ptMap, featurePointFeatureEdges);
 
     forAll(eds, i)
     {
@@ -311,6 +361,7 @@ void Foam::extendedFeatureEdgeMesh::sortPointsAndEdges
     // renumbered edges
     reset(xferMove(pts), xferMove(eds));
 
+
     // Generate the featurePointNormals
 
     labelListList featurePointNormals(nonFeatureStart_);
@@ -319,7 +370,7 @@ void Foam::extendedFeatureEdgeMesh::sortPointsAndEdges
     {
         DynamicList<label> tmpFtPtNorms;
 
-        const labelList& ptEds = pointEdges()[i];
+        const labelList& ptEds = edgeMesh::pointEdges()[i];
 
         forAll(ptEds, j)
         {
@@ -359,6 +410,7 @@ void Foam::extendedFeatureEdgeMesh::sortPointsAndEdges
     }
 
     featurePointNormals_ = featurePointNormals;
+    featurePointEdges_ = featurePointFeatureEdges;
 }
 
 
diff --git a/src/finiteVolume/interpolation/interpolation/interpolationPointMVC/pointMVCWeight.C b/src/finiteVolume/interpolation/interpolation/interpolationPointMVC/pointMVCWeight.C
index 39ea30b0c3..6c6a6c0c53 100644
--- a/src/finiteVolume/interpolation/interpolation/interpolationPointMVC/pointMVCWeight.C
+++ b/src/finiteVolume/interpolation/interpolation/interpolationPointMVC/pointMVCWeight.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -28,10 +28,7 @@ License
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-int Foam::pointMVCWeight::debug
-(
-    debug::debugSwitch("pointMVCWeight", 0)
-);
+defineDebugSwitchWithName(Foam::pointMVCWeight, "pointMVCWeight", 0);
 
 Foam::scalar Foam::pointMVCWeight::tol(SMALL);
 
diff --git a/src/lagrangian/intermediate/submodels/CloudFunctionObjects/ParticleCollector/ParticleCollector.C b/src/lagrangian/intermediate/submodels/CloudFunctionObjects/ParticleCollector/ParticleCollector.C
index 06f836a3d5..f1dc7c4ba0 100644
--- a/src/lagrangian/intermediate/submodels/CloudFunctionObjects/ParticleCollector/ParticleCollector.C
+++ b/src/lagrangian/intermediate/submodels/CloudFunctionObjects/ParticleCollector/ParticleCollector.C
@@ -138,7 +138,7 @@ void Foam::ParticleCollector<CloudType>::initConcentricCircles()
 
     radius_ = this->coeffDict().lookup("radius");
     nSector_ = readLabel(this->coeffDict().lookup("nSector"));
- 
+
     label nS = nSector_;
 
     vector refDir;
@@ -406,7 +406,7 @@ void Foam::ParticleCollector<CloudType>::write()
 
     Field<scalar> faceMassTotal(mass_.size());
     Field<scalar> faceMassFlowRate(massFlowRate_.size());
-    
+
     forAll(faces_, faceI)
     {
         scalarList allProcMass(Pstream::nProcs());
diff --git a/src/lagrangian/intermediate/submodels/CloudFunctionObjects/ParticleCollector/ParticleCollector.H b/src/lagrangian/intermediate/submodels/CloudFunctionObjects/ParticleCollector/ParticleCollector.H
index 283246cfec..29bb8ff95b 100644
--- a/src/lagrangian/intermediate/submodels/CloudFunctionObjects/ParticleCollector/ParticleCollector.H
+++ b/src/lagrangian/intermediate/submodels/CloudFunctionObjects/ParticleCollector/ParticleCollector.H
@@ -169,14 +169,14 @@ private:
         //- Collect parcels in polygon collectors
         label collectParcelPolygon
         (
-            const point& position,  
+            const point& position,
             const vector& U
         ) const;
 
         //- Collect parcels in concentric circle collectors
         label collectParcelConcentricCircles
         (
-            const point& position,  
+            const point& position,
             const vector& U
         ) const;
 
diff --git a/src/meshTools/AMIInterpolation/patches/cyclic/cyclicAMIPolyPatch/cyclicAMIPolyPatch.C b/src/meshTools/AMIInterpolation/patches/cyclic/cyclicAMIPolyPatch/cyclicAMIPolyPatch.C
index cd8f992236..49ba94fda2 100644
--- a/src/meshTools/AMIInterpolation/patches/cyclic/cyclicAMIPolyPatch/cyclicAMIPolyPatch.C
+++ b/src/meshTools/AMIInterpolation/patches/cyclic/cyclicAMIPolyPatch/cyclicAMIPolyPatch.C
@@ -120,21 +120,21 @@ void Foam::cyclicAMIPolyPatch::calcTransforms
     const vectorField& half1Areas
 )
 {
-    if (transform_ != neighbPatch().transform_)
+    if (transform() != neighbPatch().transform())
     {
         FatalErrorIn("cyclicAMIPolyPatch::calcTransforms()")
             << "Patch " << name()
-            << " has transform type " << transformTypeNames[transform_]
+            << " has transform type " << transformTypeNames[transform()]
             << ", neighbour patch " << nbrPatchName_
             << " has transform type "
-            << neighbPatch().transformTypeNames[neighbPatch().transform_]
+            << neighbPatch().transformTypeNames[neighbPatch().transform()]
             << exit(FatalError);
     }
 
 
     // Calculate transformation tensors
 
-    switch (transform_)
+    switch (transform())
     {
         case ROTATIONAL:
         {
@@ -371,13 +371,13 @@ Foam::cyclicAMIPolyPatch::cyclicAMIPolyPatch
     const label start,
     const label index,
     const polyBoundaryMesh& bm,
-    const word& patchType
+    const word& patchType,
+    const transformType transform
 )
 :
-    coupledPolyPatch(name, size, start, index, bm, patchType),
+    coupledPolyPatch(name, size, start, index, bm, patchType, transform),
     nbrPatchName_(word::null),
     nbrPatchID_(-1),
-    transform_(UNKNOWN),
     rotationAxis_(vector::zero),
     rotationCentre_(point::zero),
     separationVector_(vector::zero),
@@ -403,7 +403,6 @@ Foam::cyclicAMIPolyPatch::cyclicAMIPolyPatch
     coupledPolyPatch(name, dict, index, bm, patchType),
     nbrPatchName_(dict.lookup("neighbourPatch")),
     nbrPatchID_(-1),
-    transform_(UNKNOWN),
     rotationAxis_(vector::zero),
     rotationCentre_(point::zero),
     separationVector_(vector::zero),
@@ -429,46 +428,42 @@ Foam::cyclicAMIPolyPatch::cyclicAMIPolyPatch
             << exit(FatalIOError);
     }
 
-    if (dict.found("transform"))
+    switch (transform())
     {
-        transform_ = transformTypeNames.read(dict.lookup("transform"));
-        switch (transform_)
+        case ROTATIONAL:
         {
-            case ROTATIONAL:
-            {
-                dict.lookup("rotationAxis") >> rotationAxis_;
-                dict.lookup("rotationCentre") >> rotationCentre_;
+            dict.lookup("rotationAxis") >> rotationAxis_;
+            dict.lookup("rotationCentre") >> rotationCentre_;
 
-                scalar magRot = mag(rotationAxis_);
-                if (magRot < SMALL)
-                {
-                    FatalIOErrorIn
-                    (
-                        "cyclicAMIPolyPatch::cyclicAMIPolyPatch"
-                        "("
-                            "const word&, "
-                            "const dictionary&, "
-                            "const label, "
-                            "const polyBoundaryMesh&"
-                        ")",
-                        dict
-                    )   << "Illegal rotationAxis " << rotationAxis_ << endl
-                        << "Please supply a non-zero vector."
-                        << exit(FatalIOError);
-                }
-                rotationAxis_ /= magRot;
+            scalar magRot = mag(rotationAxis_);
+            if (magRot < SMALL)
+            {
+                FatalIOErrorIn
+                (
+                    "cyclicAMIPolyPatch::cyclicAMIPolyPatch"
+                    "("
+                        "const word&, "
+                        "const dictionary&, "
+                        "const label, "
+                        "const polyBoundaryMesh&"
+                    ")",
+                    dict
+                )   << "Illegal rotationAxis " << rotationAxis_ << endl
+                    << "Please supply a non-zero vector."
+                    << exit(FatalIOError);
+            }
+            rotationAxis_ /= magRot;
 
-                break;
-            }
-            case TRANSLATIONAL:
-            {
-                dict.lookup("separationVector") >> separationVector_;
-                break;
-            }
-            default:
-            {
-                // no additional info required
-            }
+            break;
+        }
+        case TRANSLATIONAL:
+        {
+            dict.lookup("separationVector") >> separationVector_;
+            break;
+        }
+        default:
+        {
+            // no additional info required
         }
     }
 
@@ -486,7 +481,6 @@ Foam::cyclicAMIPolyPatch::cyclicAMIPolyPatch
     coupledPolyPatch(pp, bm),
     nbrPatchName_(pp.nbrPatchName_),
     nbrPatchID_(-1),
-    transform_(pp.transform_),
     rotationAxis_(pp.rotationAxis_),
     rotationCentre_(pp.rotationCentre_),
     separationVector_(pp.separationVector_),
@@ -513,7 +507,6 @@ Foam::cyclicAMIPolyPatch::cyclicAMIPolyPatch
     coupledPolyPatch(pp, bm, index, newSize, newStart),
     nbrPatchName_(nbrPatchName),
     nbrPatchID_(-1),
-    transform_(pp.transform_),
     rotationAxis_(pp.rotationAxis_),
     rotationCentre_(pp.rotationCentre_),
     separationVector_(pp.separationVector_),
@@ -554,7 +547,6 @@ Foam::cyclicAMIPolyPatch::cyclicAMIPolyPatch
     coupledPolyPatch(pp, bm, index, mapAddressing, newStart),
     nbrPatchName_(pp.nbrPatchName_),
     nbrPatchID_(-1),
-    transform_(pp.transform_),
     rotationAxis_(pp.rotationAxis_),
     rotationCentre_(pp.rotationCentre_),
     separationVector_(pp.separationVector_),
@@ -672,7 +664,7 @@ void Foam::cyclicAMIPolyPatch::transformPosition(pointField& l) const
 {
     if (!parallel())
     {
-        if (transform_ == ROTATIONAL)
+        if (transform() == ROTATIONAL)
         {
             l = Foam::transform(forwardT(), l - rotationCentre_)
               + rotationCentre_;
@@ -718,7 +710,7 @@ void Foam::cyclicAMIPolyPatch::transformPosition
           : forwardT()[faceI]
         );
 
-        if (transform_ == ROTATIONAL)
+        if (transform() == ROTATIONAL)
         {
             l = Foam::transform(T, l - rotationCentre_) + rotationCentre_;
         }
@@ -796,12 +788,10 @@ void Foam::cyclicAMIPolyPatch::write(Ostream& os) const
     os.writeKeyword("neighbourPatch") << nbrPatchName_
         << token::END_STATEMENT << nl;
 
-    switch (transform_)
+    switch (transform())
     {
         case ROTATIONAL:
         {
-            os.writeKeyword("transform") << transformTypeNames[transform_]
-                << token::END_STATEMENT << nl;
             os.writeKeyword("rotationAxis") << rotationAxis_
                 << token::END_STATEMENT << nl;
             os.writeKeyword("rotationCentre") << rotationCentre_
@@ -810,16 +800,12 @@ void Foam::cyclicAMIPolyPatch::write(Ostream& os) const
         }
         case TRANSLATIONAL:
         {
-            os.writeKeyword("transform") << transformTypeNames[transform_]
-                << token::END_STATEMENT << nl;
             os.writeKeyword("separationVector") << separationVector_
                 << token::END_STATEMENT << nl;
             break;
         }
         case NOORDERING:
         {
-            os.writeKeyword("transform") << transformTypeNames[transform_]
-                << token::END_STATEMENT << nl;
             break;
         }
         default:
diff --git a/src/meshTools/AMIInterpolation/patches/cyclic/cyclicAMIPolyPatch/cyclicAMIPolyPatch.H b/src/meshTools/AMIInterpolation/patches/cyclic/cyclicAMIPolyPatch/cyclicAMIPolyPatch.H
index b1f420318e..b63747abfd 100644
--- a/src/meshTools/AMIInterpolation/patches/cyclic/cyclicAMIPolyPatch/cyclicAMIPolyPatch.H
+++ b/src/meshTools/AMIInterpolation/patches/cyclic/cyclicAMIPolyPatch/cyclicAMIPolyPatch.H
@@ -66,10 +66,6 @@ private:
 
         // Transformations
 
-            //- Type of transformation - rotational or translational
-            transformType transform_;
-
-
             // For rotation
 
                 //- Axis of rotation for rotational cyclics
@@ -161,7 +157,8 @@ public:
             const label start,
             const label index,
             const polyBoundaryMesh& bm,
-            const word& patchType
+            const word& patchType,
+            const transformType transform = UNKNOWN
         );
 
         //- Construct from dictionary
@@ -290,9 +287,6 @@ public:
 
             // Transformations
 
-                //- Type of transform
-                inline transformType transform() const;
-
                 //- Axis of rotation for rotational cyclic AMI
                 inline const vector& rotationAxis() const;
 
diff --git a/src/meshTools/AMIInterpolation/patches/cyclic/cyclicAMIPolyPatch/cyclicAMIPolyPatchI.H b/src/meshTools/AMIInterpolation/patches/cyclic/cyclicAMIPolyPatch/cyclicAMIPolyPatchI.H
index 3f3c2a4755..88d2ac02b6 100644
--- a/src/meshTools/AMIInterpolation/patches/cyclic/cyclicAMIPolyPatch/cyclicAMIPolyPatchI.H
+++ b/src/meshTools/AMIInterpolation/patches/cyclic/cyclicAMIPolyPatch/cyclicAMIPolyPatchI.H
@@ -39,13 +39,6 @@ Foam::cyclicAMIPolyPatch::neighbPatch() const
 }
 
 
-inline Foam::coupledPolyPatch::transformType
-Foam::cyclicAMIPolyPatch::transform() const
-{
-    return transform_;
-}
-
-
 inline const Foam::vector& Foam::cyclicAMIPolyPatch::rotationAxis() const
 {
     return rotationAxis_;
diff --git a/src/meshTools/algorithms/PointEdgeWave/PointEdgeWave.C b/src/meshTools/algorithms/PointEdgeWave/PointEdgeWave.C
index 4400b0365d..72ffa9b2c7 100644
--- a/src/meshTools/algorithms/PointEdgeWave/PointEdgeWave.C
+++ b/src/meshTools/algorithms/PointEdgeWave/PointEdgeWave.C
@@ -115,6 +115,7 @@ void Foam::PointEdgeWave<Type, TrackingData>::transform
             "PointEdgeWave<Type, TrackingData>::transform"
             "(const tensorField&, List<Type>&)"
         )   << "Non-uniform transformation on patch " << patch.name()
+            << " of type " << patch.type()
             << " not supported for point fields"
             << abort(FatalError);
 
diff --git a/src/meshTools/algorithms/PointEdgeWave/PointEdgeWave.H b/src/meshTools/algorithms/PointEdgeWave/PointEdgeWave.H
index 5c1a32cc87..592c24fb7b 100644
--- a/src/meshTools/algorithms/PointEdgeWave/PointEdgeWave.H
+++ b/src/meshTools/algorithms/PointEdgeWave/PointEdgeWave.H
@@ -26,10 +26,10 @@ Class
 
 Description
     Wave propagation of information through grid. Every iteration
-    information goes through one layer of edges. Templated on information
-    that is transferred.
+    information goes through one layer of edges.
 
     Templated on information that is transferred.
+
     Handles parallel and cyclics. Only parallel reasonably tested. Cyclics
     hardly tested.
 
diff --git a/src/meshTools/searchableSurface/searchableBox.C b/src/meshTools/searchableSurface/searchableBox.C
index 7f439ea4ae..6a41b103fa 100644
--- a/src/meshTools/searchableSurface/searchableBox.C
+++ b/src/meshTools/searchableSurface/searchableBox.C
@@ -232,9 +232,10 @@ const Foam::wordList& Foam::searchableBox::regions() const
 }
 
 
-Foam::pointField Foam::searchableBox::coordinates() const
+Foam::tmp<Foam::pointField> Foam::searchableBox::coordinates() const
 {
-    pointField ctrs(6);
+    tmp<pointField> tCtrs = tmp<pointField>(new pointField(6));
+    pointField& ctrs = tCtrs();
 
     const pointField pts(treeBoundBox::points());
     const faceList& fcs = treeBoundBox::faces;
@@ -243,7 +244,14 @@ Foam::pointField Foam::searchableBox::coordinates() const
     {
         ctrs[i] = fcs[i].centre(pts);
     }
-    return ctrs;
+
+    return tCtrs;
+}
+
+
+Foam::tmp<Foam::pointField> Foam::searchableBox::points() const
+{
+    return treeBoundBox::points();
 }
 
 
diff --git a/src/meshTools/searchableSurface/searchableBox.H b/src/meshTools/searchableSurface/searchableBox.H
index 2ddc860d16..9e33384c0d 100644
--- a/src/meshTools/searchableSurface/searchableBox.H
+++ b/src/meshTools/searchableSurface/searchableBox.H
@@ -127,7 +127,10 @@ public:
 
         //- Get representative set of element coordinates
         //  Usually the element centres (should be of length size()).
-        virtual pointField coordinates() const;
+        virtual tmp<pointField> coordinates() const;
+
+        //- Get the points that define the surface.
+        virtual tmp<pointField> points() const;
 
         // Does any part of the surface overlap the supplied bound box?
         virtual bool overlaps(const boundBox& bb) const
diff --git a/src/meshTools/searchableSurface/searchableCylinder.C b/src/meshTools/searchableSurface/searchableCylinder.C
index 2fc7032f2b..6e925365d8 100644
--- a/src/meshTools/searchableSurface/searchableCylinder.C
+++ b/src/meshTools/searchableSurface/searchableCylinder.C
@@ -39,11 +39,23 @@ addToRunTimeSelectionTable(searchableSurface, searchableCylinder, dict);
 
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 
-Foam::pointField Foam::searchableCylinder::coordinates() const
+Foam::tmp<Foam::pointField> Foam::searchableCylinder::coordinates() const
 {
-    pointField ctrs(1, 0.5*(point1_ + point2_));
+    tmp<pointField> tCtrs(new pointField(1, 0.5*(point1_ + point2_)));
 
-    return ctrs;
+    return tCtrs;
+}
+
+
+Foam::tmp<Foam::pointField> Foam::searchableCylinder::points() const
+{
+    tmp<pointField> tPts(new pointField(2));
+    pointField& pts = tPts();
+
+    pts[0] = point1_;
+    pts[1] = point2_;
+
+    return tPts;
 }
 
 
diff --git a/src/meshTools/searchableSurface/searchableCylinder.H b/src/meshTools/searchableSurface/searchableCylinder.H
index d2941c31d5..409ac0dbf5 100644
--- a/src/meshTools/searchableSurface/searchableCylinder.H
+++ b/src/meshTools/searchableSurface/searchableCylinder.H
@@ -152,7 +152,10 @@ public:
 
         //- Get representative set of element coordinates
         //  Usually the element centres (should be of length size()).
-        virtual pointField coordinates() const;
+        virtual tmp<pointField> coordinates() const;
+
+        //- Get the points that define the surface.
+        virtual tmp<pointField> points() const;
 
         //- Does any part of the surface overlap the supplied bound box?
         virtual bool overlaps(const boundBox& bb) const
diff --git a/src/meshTools/searchableSurface/searchablePlane.H b/src/meshTools/searchableSurface/searchablePlane.H
index 380435e6c1..5a2ef08242 100644
--- a/src/meshTools/searchableSurface/searchablePlane.H
+++ b/src/meshTools/searchableSurface/searchablePlane.H
@@ -124,10 +124,16 @@ public:
 
         //- Get representative set of element coordinates
         //  Usually the element centres (should be of length size()).
-        virtual pointField coordinates() const
+        virtual tmp<pointField> coordinates() const
         {
-            //notImplemented("searchablePlane::coordinates()")
-            return pointField(1, refPoint());
+            tmp<pointField> tCtrs(new pointField(1, refPoint()));
+            return tCtrs;
+        }
+
+        //- Get the points that define the surface.
+        virtual tmp<pointField> points() const
+        {
+            return coordinates();
         }
 
         //- Does any part of the surface overlap the supplied bound box?
diff --git a/src/meshTools/searchableSurface/searchablePlate.H b/src/meshTools/searchableSurface/searchablePlate.H
index 3c4a0ae9fd..97774e587f 100644
--- a/src/meshTools/searchableSurface/searchablePlate.H
+++ b/src/meshTools/searchableSurface/searchablePlate.H
@@ -144,20 +144,52 @@ public:
 
         //- Get representative set of element coordinates
         //  Usually the element centres (should be of length size()).
-        virtual pointField coordinates() const
+        virtual tmp<pointField> coordinates() const
         {
-            return pointField(1, origin_);
+            tmp<pointField> tCtrs(new pointField(1, origin_ + 0.5*span_));
+            return tCtrs;
+        }
+
+        //- Get the points that define the surface.
+        virtual tmp<pointField> points() const
+        {
+            tmp<pointField> tPts(new pointField(4));
+            pointField& pts = tPts();
+
+            pts[0] = origin_;
+            pts[2] = origin_ + span_;
+
+            if (span_.x() < span_.y() && span_.x() < span_.z())
+            {
+                pts[1] = origin_ + point(0, span_.y(), 0);
+                pts[3] = origin_ + point(0, 0, span_.z());
+            }
+            else if (span_.y() < span_.z())
+            {
+                pts[1] = origin_ + point(span_.x(), 0, 0);
+                pts[3] = origin_ + point(0, 0, span_.z());
+            }
+            else
+            {
+                pts[1] = origin_ + point(span_.x(), 0, 0);
+                pts[3] = origin_ + point(0, span_.y(), 0);
+            }
+
+            return tPts;
         }
 
         //- Does any part of the surface overlap the supplied bound box?
         virtual bool overlaps(const boundBox& bb) const
         {
-            notImplemented
+            return
             (
-                "searchablePlate::overlaps(const boundBox&) const"
+                (origin_.x() + span_.x()) >= bb.min().x()
+             && origin_.x() <= bb.max().x()
+             && (origin_.y() + span_.y()) >= bb.min().y()
+             && origin_.y() <= bb.max().y()
+             && (origin_.z() + span_.z()) >= bb.min().z()
+             && origin_.z() <= bb.max().z()
             );
-
-            return false;
         }
 
 
diff --git a/src/meshTools/searchableSurface/searchableSphere.C b/src/meshTools/searchableSurface/searchableSphere.C
index 8e0a00a739..88d665ea14 100644
--- a/src/meshTools/searchableSurface/searchableSphere.C
+++ b/src/meshTools/searchableSurface/searchableSphere.C
@@ -167,6 +167,12 @@ Foam::searchableSphere::~searchableSphere()
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
+bool Foam::searchableSphere::overlaps(const boundBox& bb) const
+{
+    return bb.overlaps(centre_, sqr(radius_));
+}
+
+
 const Foam::wordList& Foam::searchableSphere::regions() const
 {
     if (regions_.empty())
diff --git a/src/meshTools/searchableSurface/searchableSphere.H b/src/meshTools/searchableSurface/searchableSphere.H
index 5b546fcbe3..187541c156 100644
--- a/src/meshTools/searchableSurface/searchableSphere.H
+++ b/src/meshTools/searchableSurface/searchableSphere.H
@@ -133,21 +133,20 @@ public:
 
         //- Get representative set of element coordinates
         //  Usually the element centres (should be of length size()).
-        virtual pointField coordinates() const
+        virtual tmp<pointField> coordinates() const
         {
-            return pointField(1, centre_);
+            tmp<pointField> tCtrs(new pointField(1, centre_));
+            return tCtrs;
+        }
+
+        //- Get the points that define the surface.
+        virtual tmp<pointField> points() const
+        {
+            return coordinates();
         }
 
         //- Does any part of the surface overlap the supplied bound box?
-        virtual bool overlaps(const boundBox& bb) const
-        {
-            notImplemented
-            (
-                "searchableSphere::overlaps(const boundBox&) const"
-            );
-
-            return false;
-        }
+        virtual bool overlaps(const boundBox& bb) const;
 
 
         // Multiple point queries.
diff --git a/src/meshTools/searchableSurface/searchableSurface.H b/src/meshTools/searchableSurface/searchableSurface.H
index 94713fbf38..baeb970844 100644
--- a/src/meshTools/searchableSurface/searchableSurface.H
+++ b/src/meshTools/searchableSurface/searchableSurface.H
@@ -206,7 +206,10 @@ public:
 
         //- Get representative set of element coordinates
         //  Usually the element centres (should be of length size()).
-        virtual pointField coordinates() const = 0;
+        virtual tmp<pointField> coordinates() const = 0;
+
+        //- Get the points that define the surface.
+        virtual tmp<pointField> points() const = 0;
 
         //- Does any part of the surface overlap the supplied bound box?
         virtual bool overlaps(const boundBox& bb) const = 0;
diff --git a/src/meshTools/searchableSurface/searchableSurfaceCollection.C b/src/meshTools/searchableSurface/searchableSurfaceCollection.C
index 91115688b2..db1133b9ee 100644
--- a/src/meshTools/searchableSurface/searchableSurfaceCollection.C
+++ b/src/meshTools/searchableSurface/searchableSurfaceCollection.C
@@ -325,10 +325,11 @@ Foam::label Foam::searchableSurfaceCollection::size() const
 }
 
 
-Foam::pointField Foam::searchableSurfaceCollection::coordinates() const
+Foam::tmp<Foam::pointField>
+Foam::searchableSurfaceCollection::coordinates() const
 {
-    // Get overall size
-    pointField coords(size());
+    tmp<pointField> tCtrs = tmp<pointField>(new pointField(size()));
+    pointField& ctrs = tCtrs();
 
     // Append individual coordinates
     label coordI = 0;
@@ -339,7 +340,7 @@ Foam::pointField Foam::searchableSurfaceCollection::coordinates() const
 
         forAll(subCoords, i)
         {
-            coords[coordI++] = transform_[surfI].globalPosition
+            ctrs[coordI++] = transform_[surfI].globalPosition
             (
                 cmptMultiply
                 (
@@ -350,7 +351,45 @@ Foam::pointField Foam::searchableSurfaceCollection::coordinates() const
         }
     }
 
-    return coords;
+    return tCtrs;
+}
+
+
+Foam::tmp<Foam::pointField>
+Foam::searchableSurfaceCollection::points() const
+{
+    // Get overall size
+    label nPoints = 0;
+
+    forAll(subGeom_, surfI)
+    {
+        nPoints += subGeom_[surfI].points()().size();
+    }
+
+    tmp<pointField> tPts(new pointField(nPoints));
+    pointField& pts = tPts();
+
+    // Append individual coordinates
+    nPoints = 0;
+
+    forAll(subGeom_, surfI)
+    {
+        const pointField subCoords = subGeom_[surfI].points();
+
+        forAll(subCoords, i)
+        {
+            pts[nPoints++] = transform_[surfI].globalPosition
+            (
+                cmptMultiply
+                (
+                    subCoords[i],
+                    scale_[surfI]
+                )
+            );
+        }
+    }
+
+    return tPts;
 }
 
 
diff --git a/src/meshTools/searchableSurface/searchableSurfaceCollection.H b/src/meshTools/searchableSurface/searchableSurfaceCollection.H
index 7c592ca348..b93acdb745 100644
--- a/src/meshTools/searchableSurface/searchableSurfaceCollection.H
+++ b/src/meshTools/searchableSurface/searchableSurfaceCollection.H
@@ -174,7 +174,10 @@ public:
 
         //- Get representative set of element coordinates
         //  Usually the element centres (should be of length size()).
-        virtual pointField coordinates() const;
+        virtual tmp<pointField> coordinates() const;
+
+        //- Get the points that define the surface.
+        virtual tmp<pointField> points() const;
 
         //- Does any part of the surface overlap the supplied bound box?
         virtual bool overlaps(const boundBox& bb) const
diff --git a/src/meshTools/searchableSurface/searchableSurfaceWithGaps.H b/src/meshTools/searchableSurface/searchableSurfaceWithGaps.H
index a57e8740ec..0e3b6625bf 100644
--- a/src/meshTools/searchableSurface/searchableSurfaceWithGaps.H
+++ b/src/meshTools/searchableSurface/searchableSurfaceWithGaps.H
@@ -54,7 +54,7 @@ namespace Foam
 // Forward declaration of classes
 
 /*---------------------------------------------------------------------------*\
-                           Class searchableSurfaceWithGaps Declaration
+                 Class searchableSurfaceWithGaps Declaration
 \*---------------------------------------------------------------------------*/
 
 class searchableSurfaceWithGaps
@@ -151,11 +151,17 @@ public:
 
         //- Get representative set of element coordinates
         //  Usually the element centres (should be of length size()).
-        virtual pointField coordinates() const
+        virtual tmp<pointField> coordinates() const
         {
             return surface().coordinates();
         }
 
+        //- Get the points that define the surface.
+        virtual tmp<pointField> points() const
+        {
+            return surface().points();
+        }
+
         //- Does any part of the surface overlap the supplied bound box?
         //  Note: use perturbed surface? Since uses boundbox of points and
         //        not actual intersection chosen to use unperturbed surface.
diff --git a/src/meshTools/searchableSurface/searchableSurfaces.C b/src/meshTools/searchableSurface/searchableSurfaces.C
index 653d708e49..0995847fb4 100644
--- a/src/meshTools/searchableSurface/searchableSurfaces.C
+++ b/src/meshTools/searchableSurface/searchableSurfaces.C
@@ -846,7 +846,7 @@ void Foam::searchableSurfaces::writeStats
         {
             const triSurfaceMesh& ts = dynamic_cast<const triSurfaceMesh&>(s);
             Info<< "        edges     : " << ts.nEdges() << nl
-                << "        points    : " << ts.points().size() << nl;
+                << "        points    : " << ts.points()().size() << nl;
         }
         Info<< "        bounds    : " << s.bounds() << nl
             << "        closed    : " << Switch(s.hasVolumeType()) << endl;
diff --git a/src/meshTools/searchableSurface/triSurfaceMesh.C b/src/meshTools/searchableSurface/triSurfaceMesh.C
index 2508cdb919..4e42f5d3ad 100644
--- a/src/meshTools/searchableSurface/triSurfaceMesh.C
+++ b/src/meshTools/searchableSurface/triSurfaceMesh.C
@@ -148,7 +148,7 @@ bool Foam::triSurfaceMesh::isSurfaceClosed() const
     // Construct pointFaces. Let's hope surface has compact point
     // numbering ...
     labelListList pointFaces;
-    invertManyToMany(points().size(), *this, pointFaces);
+    invertManyToMany(points()().size(), *this, pointFaces);
 
     // Loop over all faces surrounding point. Count edges emanating from point.
     // Every edge should be used by two faces exactly.
@@ -288,7 +288,7 @@ void Foam::triSurfaceMesh::calcBounds(boundBox& bb, label& nPoints) const
 
     const triSurface& s = static_cast<const triSurface&>(*this);
 
-    PackedBoolList pointIsUsed(points().size());
+    PackedBoolList pointIsUsed(points()().size());
 
     nPoints = 0;
     bb = boundBox::invertedBox;
@@ -302,8 +302,8 @@ void Foam::triSurfaceMesh::calcBounds(boundBox& bb, label& nPoints) const
             label pointI = f[fp];
             if (pointIsUsed.set(pointI, 1u))
             {
-                bb.min() = ::Foam::min(bb.min(), points()[pointI]);
-                bb.max() = ::Foam::max(bb.max(), points()[pointI]);
+                bb.min() = ::Foam::min(bb.min(), points()()[pointI]);
+                bb.max() = ::Foam::max(bb.max(), points()()[pointI]);
                 nPoints++;
             }
         }
@@ -487,14 +487,25 @@ void Foam::triSurfaceMesh::clearOut()
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
-Foam::pointField Foam::triSurfaceMesh::coordinates() const
+Foam::tmp<Foam::pointField> Foam::triSurfaceMesh::coordinates() const
 {
+    tmp<pointField> tPts(new pointField(8));
+    pointField& pt = tPts();
+
     // Use copy to calculate face centres so they don't get stored
-    return PrimitivePatch<triSurface::FaceType, SubList, const pointField&>
+    pt = PrimitivePatch<triSurface::FaceType, SubList, const pointField&>
     (
         SubList<triSurface::FaceType>(*this, triSurface::size()),
         triSurface::points()
     ).faceCentres();
+
+    return tPts;
+}
+
+
+Foam::tmp<Foam::pointField> Foam::triSurfaceMesh::points() const
+{
+    return triSurface::points();
 }
 
 
@@ -526,12 +537,12 @@ Foam::triSurfaceMesh::tree() const
         label nPoints;
         calcBounds(bb, nPoints);
 
-        if (nPoints != points().size())
+        if (nPoints != points()().size())
         {
             WarningIn("triSurfaceMesh::tree() const")
                 << "Surface " << searchableSurface::name()
                 << " does not have compact point numbering."
-                << " Of " << points().size() << " only " << nPoints
+                << " Of " << points()().size() << " only " << nPoints
                 << " are used. This might give problems in some routines."
                 << endl;
         }
diff --git a/src/meshTools/searchableSurface/triSurfaceMesh.H b/src/meshTools/searchableSurface/triSurfaceMesh.H
index aa462e2554..f27df49d7c 100644
--- a/src/meshTools/searchableSurface/triSurfaceMesh.H
+++ b/src/meshTools/searchableSurface/triSurfaceMesh.H
@@ -199,7 +199,10 @@ public:
 
             //- Get representative set of element coordinates
             //  Usually the element centres (should be of length size()).
-            virtual pointField coordinates() const;
+            virtual tmp<pointField> coordinates() const;
+
+            //- Get the points that define the surface.
+            virtual tmp<pointField> points() const;
 
             // Does any part of the surface overlap the supplied bound box?
             virtual bool overlaps(const boundBox& bb) const;
diff --git a/src/parallel/decompose/Allwmake b/src/parallel/decompose/Allwmake
index 9d0acbd618..5cea1fbd5e 100755
--- a/src/parallel/decompose/Allwmake
+++ b/src/parallel/decompose/Allwmake
@@ -44,7 +44,18 @@ wmakeLnInclude decompositionMethods
 if [ -n "$SCOTCH_ARCH_PATH" ]
 then
     wmake $makeType scotchDecomp
-    [ -d "$FOAM_LIBBIN/$FOAM_MPI" ] && wmakeMpiLib ptscotchDecomp
+
+    if [ -d "$FOAM_LIBBIN/$FOAM_MPI" ]
+    then
+        #- Bit of a hack: ptscotch 6 requires scotch linked as well as. Can be
+        #  removed once ptscotch declares dependency on scotch itself.
+        if [ "$SCOTCH_VERSION" = "scotch_6.0.0" ]
+        then
+            export LINK_FLAGS="-lscotch"
+        fi
+
+        wmakeMpiLib ptscotchDecomp
+    fi
 else
     echo
     echo "Skipping scotchDecomp (ptscotchDecomp)"
diff --git a/src/parallel/decompose/decompositionMethods/hierarchGeomDecomp/hierarchGeomDecomp.C b/src/parallel/decompose/decompositionMethods/hierarchGeomDecomp/hierarchGeomDecomp.C
index 1098dfd828..9928f39f47 100644
--- a/src/parallel/decompose/decompositionMethods/hierarchGeomDecomp/hierarchGeomDecomp.C
+++ b/src/parallel/decompose/decompositionMethods/hierarchGeomDecomp/hierarchGeomDecomp.C
@@ -230,7 +230,7 @@ void Foam::hierarchGeomDecomp::findBinary
         if (returnReduce(hasNotChanged, andOp<bool>()))
         {
             WarningIn("hierarchGeomDecomp::findBinary(..)")
-                << "unable to find desired deomposition split, making do!"
+                << "unable to find desired decomposition split, making do!"
                 << endl;
             break;
         }
diff --git a/src/parallel/decompose/ptscotchDecomp/Make/options b/src/parallel/decompose/ptscotchDecomp/Make/options
index d4e551bcac..acdebd8976 100644
--- a/src/parallel/decompose/ptscotchDecomp/Make/options
+++ b/src/parallel/decompose/ptscotchDecomp/Make/options
@@ -9,4 +9,4 @@ EXE_INC = \
     -I../decompositionMethods/lnInclude
 
 LIB_LIBS = \
-    -L$(SCOTCH_ROOT)/lib -L$(FOAM_EXT_LIBBIN)/$(FOAM_MPI) -lptscotch -lptscotcherrexit -lscotch -lrt
+    -L$(SCOTCH_ROOT)/lib -L$(FOAM_EXT_LIBBIN)/$(FOAM_MPI) -lptscotch -lptscotcherrexit ${LINK_FLAGS} -lrt
diff --git a/src/postProcessing/functionObjects/utilities/pressureTools/pressureTools.H b/src/postProcessing/functionObjects/utilities/pressureTools/pressureTools.H
index f54375926c..11f490429d 100644
--- a/src/postProcessing/functionObjects/utilities/pressureTools/pressureTools.H
+++ b/src/postProcessing/functionObjects/utilities/pressureTools/pressureTools.H
@@ -69,7 +69,7 @@ Description
 
     The modes of operation are:
     \table
-        Mode                        | calcTotal | calcCoeff  
+        Mode                        | calcTotal | calcCoeff
         static pressure             | no        | no
         total pressure              | yes       | no
         pressure coefficient        | no        | yes
diff --git a/src/regionModels/surfaceFilmModels/derivedFvPatchFields/inclinedFilmNusseltHeight/inclinedFilmNusseltHeightFvPatchScalarField.C b/src/regionModels/surfaceFilmModels/derivedFvPatchFields/inclinedFilmNusseltHeight/inclinedFilmNusseltHeightFvPatchScalarField.C
index b36832a1d3..617af63382 100644
--- a/src/regionModels/surfaceFilmModels/derivedFvPatchFields/inclinedFilmNusseltHeight/inclinedFilmNusseltHeightFvPatchScalarField.C
+++ b/src/regionModels/surfaceFilmModels/derivedFvPatchFields/inclinedFilmNusseltHeight/inclinedFilmNusseltHeightFvPatchScalarField.C
@@ -158,7 +158,7 @@ void Foam::inclinedFilmNusseltHeightFvPatchScalarField::updateCoeffs()
     const volScalarField& rho = film.rho();
     const scalarField rhop(rho.boundaryField()[patchI].patchInternalField());
 
-    const scalarField Re(max(G, 0.0)/mup);
+    const scalarField Re(max(G, scalar(0.0))/mup);
 
     // TODO: currently re-evaluating the entire gTan field to return this patch
     const scalarField gTan(film.gTan()().boundaryField()[patchI] & n);
diff --git a/src/regionModels/surfaceFilmModels/derivedFvPatchFields/inclinedFilmNusseltHeight/inclinedFilmNusseltHeightFvPatchScalarField.H b/src/regionModels/surfaceFilmModels/derivedFvPatchFields/inclinedFilmNusseltHeight/inclinedFilmNusseltHeightFvPatchScalarField.H
index cb9f999237..7be767718d 100644
--- a/src/regionModels/surfaceFilmModels/derivedFvPatchFields/inclinedFilmNusseltHeight/inclinedFilmNusseltHeightFvPatchScalarField.H
+++ b/src/regionModels/surfaceFilmModels/derivedFvPatchFields/inclinedFilmNusseltHeight/inclinedFilmNusseltHeightFvPatchScalarField.H
@@ -89,7 +89,7 @@ public:
             const dictionary&
         );
 
-        //- Construct by mapping given 
+        //- Construct by mapping given
         // inclinedFilmNusseltHeightFvPatchScalarField onto a new patch
         inclinedFilmNusseltHeightFvPatchScalarField
         (
diff --git a/src/regionModels/surfaceFilmModels/derivedFvPatchFields/inclinedFilmNusseltInletVelocity/inclinedFilmNusseltInletVelocityFvPatchVectorField.C b/src/regionModels/surfaceFilmModels/derivedFvPatchFields/inclinedFilmNusseltInletVelocity/inclinedFilmNusseltInletVelocityFvPatchVectorField.C
index 7f21d9a2e4..923a559dfa 100644
--- a/src/regionModels/surfaceFilmModels/derivedFvPatchFields/inclinedFilmNusseltInletVelocity/inclinedFilmNusseltInletVelocityFvPatchVectorField.C
+++ b/src/regionModels/surfaceFilmModels/derivedFvPatchFields/inclinedFilmNusseltInletVelocity/inclinedFilmNusseltInletVelocityFvPatchVectorField.C
@@ -158,7 +158,7 @@ void Foam::inclinedFilmNusseltInletVelocityFvPatchVectorField::updateCoeffs()
     const volScalarField& rho = film.rho();
     const scalarField rhop(rho.boundaryField()[patchI].patchInternalField());
 
-    const scalarField Re(max(G, 0.0)/mup);
+    const scalarField Re(max(G, scalar(0.0))/mup);
 
     // TODO: currently re-evaluating the entire gTan field to return this patch
     const scalarField gTan(film.gTan()().boundaryField()[patchI] & n);
diff --git a/src/thermophysicalModels/radiationModels/radiationModel/radiationModel/radiationModelNew.C b/src/thermophysicalModels/radiationModels/radiationModel/radiationModel/radiationModelNew.C
index 9a95b0c88f..0a4dd3730c 100644
--- a/src/thermophysicalModels/radiationModels/radiationModel/radiationModel/radiationModelNew.C
+++ b/src/thermophysicalModels/radiationModels/radiationModel/radiationModel/radiationModelNew.C
@@ -53,7 +53,7 @@ Foam::radiation::radiationModel::New
         Info<< "Radiation model not active: radiationProperties not found"
             << endl;
     }
-    
+
     Info<< "Selecting radiationModel " << modelType << endl;
 
     TConstructorTable::iterator cstrIter =
diff --git a/src/turbulenceModels/compressible/RAS/v2f/v2f.C b/src/turbulenceModels/compressible/RAS/v2f/v2f.C
index 0fb834ac49..36e04932d7 100644
--- a/src/turbulenceModels/compressible/RAS/v2f/v2f.C
+++ b/src/turbulenceModels/compressible/RAS/v2f/v2f.C
@@ -407,7 +407,8 @@ void v2f::correct()
         1.0/T*((C1_ - N)*v2_ - 2.0/3.0*k_*(C1_ - 1.0))
     );
 
-    tmp<volScalarField> Ceps1 = 1.4*(1.0 + 0.05*min(sqrt(k_/v2_), 100.0));
+    tmp<volScalarField> Ceps1 =
+        1.4*(1.0 + 0.05*min(sqrt(k_/v2_), scalar(100.0)));
 
     // Update epsilon (and possibly G) at the wall
     epsilon_.boundaryField().updateCoeffs();
diff --git a/src/turbulenceModels/incompressible/RAS/v2f/v2f.C b/src/turbulenceModels/incompressible/RAS/v2f/v2f.C
index b8d20d2624..642dc819bf 100644
--- a/src/turbulenceModels/incompressible/RAS/v2f/v2f.C
+++ b/src/turbulenceModels/incompressible/RAS/v2f/v2f.C
@@ -374,7 +374,8 @@ void v2f::correct()
     );
 
 
-    tmp<volScalarField> Ceps1 = 1.4*(1.0 + 0.05*min(sqrt(k_/v2_), 100.0));
+    tmp<volScalarField> Ceps1 =
+        1.4*(1.0 + 0.05*min(sqrt(k_/v2_), scalar(100.0)));
 
     // Update epsilon (and possibly G) at the wall
     epsilon_.boundaryField().updateCoeffs();
diff --git a/tutorials/mesh/cvMesh/blob/Allclean b/tutorials/mesh/cvMesh/blob/Allclean
index 4a8e3bf4d9..3b8eb25810 100755
--- a/tutorials/mesh/cvMesh/blob/Allclean
+++ b/tutorials/mesh/cvMesh/blob/Allclean
@@ -6,4 +6,9 @@ cd ${0%/*} || exit 1    # run from this directory
 
 cleanCase
 
+rm -rf constant/cellAlignments > /dev/null 2>&1
+rm -rf constant/targetCellSize > /dev/null 2>&1
+rm -rf constant/internalDelaunayVertices > /dev/null 2>&1
+
+
 # ----------------------------------------------------------------- end-of-file
diff --git a/tutorials/mesh/cvMesh/blob/Allrun b/tutorials/mesh/cvMesh/blob/Allrun
index 860857ec95..ab12a6cbd5 100755
--- a/tutorials/mesh/cvMesh/blob/Allrun
+++ b/tutorials/mesh/cvMesh/blob/Allrun
@@ -4,10 +4,8 @@ cd ${0%/*} || exit 1    # run from this directory
 # Source tutorial run functions
 . $WM_PROJECT_DIR/bin/tools/RunFunctions
 
-runApplication blockMesh
 runApplication cvMesh
-#runApplication collapseEdges 1e-10 180 -overwrite
-runApplication snappyHexMesh -overwrite
-runApplication checkMesh -constant -allGeometry -allTopology
+runApplication collapseEdges -latestTime -collapseFaces
+runApplication checkMesh -latestTime -allGeometry -allTopology
 
 # ----------------------------------------------------------------- end-of-file
diff --git a/tutorials/mesh/cvMesh/blob/Allrun-parallel b/tutorials/mesh/cvMesh/blob/Allrun-parallel
index ce7e704980..253294de1f 100755
--- a/tutorials/mesh/cvMesh/blob/Allrun-parallel
+++ b/tutorials/mesh/cvMesh/blob/Allrun-parallel
@@ -5,30 +5,15 @@ cd ${0%/*} || exit 1    # run from this directory
 . $WM_PROJECT_DIR/bin/tools/RunFunctions
 
 # Get the number of processors to run on from system/decomposeParDict
-nProc=`grep numberOfSubdomains system/decomposeParDict \
-     | sed s/"numberOfSubdomains *\(.*\);"/"\1"/`
+nProc=$(getNumberOfProcessors)
 
 runApplication blockMesh
 runApplication decomposePar
 
-for dir in processor*
-do
-    if [[ -d $dir ]]
-    then
-        cp -r $dir/constant/polyMesh $dir/constant/polyMesh_background
-    fi
-done
-
 runParallel cvMesh $nProc
+runParallel collapseEdges $nProc -latestTime -collapseFaces
+runParallel checkMesh $nProc -latestTime -allTopology -allGeometry
 
-runApplication reconstructParMesh -constant -mergeTol 1e-10
-runParallel checkMesh $nProc -constant -allGeometry -allTopology
-
-# To run from the same background mesh as before
-# for dir in processor*;
-# do
-#     rm -r $dir/constant/polyMesh
-#     cp -r $dir/constant/polyMesh_background $dir/constant/polyMesh
-# done
+runApplication reconstructParMesh -latestTime
 
 # ----------------------------------------------------------------- end-of-file
diff --git a/tutorials/mesh/cvMesh/blob/constant/polyMesh/boundary b/tutorials/mesh/cvMesh/blob/constant/polyMesh/boundary
index cc9c4f8342..69a2a888d4 100644
--- a/tutorials/mesh/cvMesh/blob/constant/polyMesh/boundary
+++ b/tutorials/mesh/cvMesh/blob/constant/polyMesh/boundary
@@ -8,7 +8,7 @@
 FoamFile
 {
     version     2.0;
-    format      binary;
+    format      ascii;
     class       polyBoundaryMesh;
     location    "constant/polyMesh";
     object      boundary;
diff --git a/tutorials/mesh/cvMesh/blob/system/collapseDict b/tutorials/mesh/cvMesh/blob/system/collapseDict
new file mode 100644
index 0000000000..f340ced2b5
--- /dev/null
+++ b/tutorials/mesh/cvMesh/blob/system/collapseDict
@@ -0,0 +1,54 @@
+/*--------------------------------*- 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;
+
+    root            "";
+    case            "";
+    instance        "";
+    local           "";
+
+    class           dictionary;
+    object          collapseDict;
+}
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+collapseEdgesCoeffs
+{
+    minimumEdgeLength   1e-4;
+    maximumMergeAngle   180;
+    reductionFactor     0.5;
+}
+
+
+collapseFacesCoeffs
+{
+    initialFaceLengthFactor                 0.5;
+    reductionFactor                         0.5;
+
+    allowEarlyCollapseToPoint               on;
+    allowEarlyCollapseCoeff                 0.2;
+    guardFraction                           0.1;
+    maxCollapseFaceToPointSideLengthCoeff   0.3;
+}
+
+
+meshQualityCoeffs
+{
+    #include                    "meshQualityDict";
+    maximumIterations           30;
+    maximumSmoothingIterations  1;
+    maxPointErrorCount          5;
+}
+
+
+// ************************************************************************* //
diff --git a/tutorials/mesh/cvMesh/blob/system/controlDict b/tutorials/mesh/cvMesh/blob/system/controlDict
index ca09d8971c..e941da7036 100644
--- a/tutorials/mesh/cvMesh/blob/system/controlDict
+++ b/tutorials/mesh/cvMesh/blob/system/controlDict
@@ -34,11 +34,11 @@ deltaT          1;
 
 writeControl    timeStep;
 
-writeInterval   1000;
+writeInterval   80;
 
 purgeWrite      0;
 
-writeFormat     binary;//ascii;
+writeFormat     ascii;
 
 writePrecision  12;
 
diff --git a/tutorials/mesh/cvMesh/blob/system/cvMeshDict b/tutorials/mesh/cvMesh/blob/system/cvMeshDict
index af0db03508..eda52324f5 100644
--- a/tutorials/mesh/cvMesh/blob/system/cvMeshDict
+++ b/tutorials/mesh/cvMesh/blob/system/cvMeshDict
@@ -86,7 +86,9 @@ surfaceConformation
 
     surfaceSearchDistanceCoeff  5;
 
-    maxSurfaceProtrusionCoeff   0.1;
+    nearBoundaryDistanceCoeff   5;
+
+    maxSurfaceProtrusionCoeff   0.001;
 
     maxQuadAngle 125;
 
@@ -96,34 +98,15 @@ surfaceConformation
 
     conformationControls
     {
-        initial
-        {
-            edgeSearchDistCoeff             5;
-            surfacePtReplaceDistCoeff       0.5;
-            surfacePtExclusionDistanceCoeff 0.5;
-        }
-
-        iteration
-        {
-            edgeSearchDistCoeff         1.5;
-            surfacePtReplaceDistCoeff   0.7;
-        }
+        edgeSearchDistCoeff             5;
+        surfacePtReplaceDistCoeff       0.5;
+        surfacePtExclusionDistanceCoeff 0.5;
 
         maxIterations 15;
 
         iterationToInitialHitRatioLimit 0.0001;
     }
 
-    coarseConformationControls
-    {
-        $conformationControls;
-    }
-
-    fineConformationControls
-    {
-        $conformationControls;
-    }
-
     geometryToConformTo
     {
         blob.stl
@@ -140,37 +123,36 @@ surfaceConformation
 
 motionControl
 {
-    defaultCellSize     0.04;
+    defaultCellSize     0.1;
 
-    // Assign a priority to all requests for cell sizes, the highest overrules.
-    defaultPriority     0;
-
-    cellSizeControlGeometry
+    shapeControlFunctions
     {
         blob.stl
         {
-            priority            1;
-            mode                bothSides;
+            type                    searchableSurfaceControl;
+            priority                1;
+            mode                    bothSides;
 
             surfaceCellSizeFunction uniformValue;
             uniformValueCoeffs
             {
-                surfaceCellSize 0.04;
+                surfaceCellSize     $defaultCellSize;
             }
 
-            cellSizeFunction        uniformDistance;
-            uniformDistanceCoeffs
-            {
-                distance        0.1;
-            }
-            linearDistanceCoeffs
-            {
-                distanceCellSize        $defaultCellSize;
-                distance                0.1;
-            }
+            cellSizeFunction        uniform;
+            uniformCoeffs
+            {}
         }
     }
 
+    maxRefinementIterations 1;
+
+    cellAspectRatioControl
+    {
+        aspectRatio                 1.0;
+        aspectRatioDirection        (1 0 0);
+    }
+
     relaxationModel     adaptiveLinear;
 
     adaptiveLinearCoeffs
@@ -183,7 +165,7 @@ motionControl
 
     timeChecks                  no;
 
-    maxLoadUnbalance            0.05;
+    maxLoadUnbalance            0.5;
 
     alignmentSearchSpokes       24;
 
@@ -215,18 +197,9 @@ motionControl
 
 polyMeshFiltering
 {
-    writeTetDualMesh                        false;
-    filterSizeCoeff                         0.2;
-    mergeClosenessCoeff                     1e-3;
-    edgeMergeAngle                          45;
-    continueFilteringOnBadInitialPolyMesh   true;
-    filterErrorReductionCoeff               0.5;
-    filterCountSkipThreshold                4;
-    surfaceStepFaceAngle                    80;
-    maxCollapseIterations                   25;
-    maxConsecutiveEqualFaceSets             5;
-    edgeCollapseGuardFraction               0.1;
-    maxCollapseFaceToPointSideLengthCoeff   0.35;
+    filterEdges                 on;
+    filterFaces                 off;
+    writeTetDualMesh            false;
 }
 
 
diff --git a/tutorials/mesh/cvMesh/blob/system/decomposeParDict b/tutorials/mesh/cvMesh/blob/system/decomposeParDict
index 58cbdde811..3d3806e873 100644
--- a/tutorials/mesh/cvMesh/blob/system/decomposeParDict
+++ b/tutorials/mesh/cvMesh/blob/system/decomposeParDict
@@ -15,10 +15,10 @@ FoamFile
 }
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-numberOfSubdomains 8;
+numberOfSubdomains 2;
 
-//method          scotch;
- method          ptscotch;
+method          scotch;
+//method          ptscotch;
 // method          hierarchical;
 
 simpleCoeffs
@@ -29,7 +29,7 @@ simpleCoeffs
 
 hierarchicalCoeffs
 {
-    n               ( 2 2 2 );
+    n               ( 2 1 1 );
     delta           0.001;
     order           xyz;
 }
diff --git a/tutorials/mesh/cvMesh/flange/Allclean b/tutorials/mesh/cvMesh/flange/Allclean
index 926f4a12b9..dc1ee49a8f 100755
--- a/tutorials/mesh/cvMesh/flange/Allclean
+++ b/tutorials/mesh/cvMesh/flange/Allclean
@@ -4,8 +4,10 @@ cd ${0%/*} || exit 1    # run from this directory
 # Source tutorial run functions
 . $WM_PROJECT_DIR/bin/tools/CleanFunctions
 
-rm -rf constant/extendedFeatureEdgeMesh flange > /dev/null 2>&1
-rm -r constant/ccx constant/ccy constant/ccz  > /dev/null 2>&1
+rm -rf constant/extendedFeatureEdgeMesh > /dev/null 2>&1
+rm -r constant/ccx constant/ccy constant/ccz > /dev/null 2>&1
+rm -r constant/internalDelaunayVertices constant/targetCellSize > /dev/null 2>&1
+rm -r 0/ccx 0/ccy 0/ccz > /dev/null 2>&1
 
 cleanCase
 
diff --git a/tutorials/mesh/cvMesh/flange/Allrun b/tutorials/mesh/cvMesh/flange/Allrun
index d79a0bb185..8e16ed1b00 100755
--- a/tutorials/mesh/cvMesh/flange/Allrun
+++ b/tutorials/mesh/cvMesh/flange/Allrun
@@ -4,10 +4,6 @@ cd ${0%/*} || exit 1    # run from this directory
 # Source tutorial run functions
 . $WM_PROJECT_DIR/bin/tools/RunFunctions
 
-# Get the number of processors to run on from system/decomposeParDict
-nProc=`grep numberOfSubdomains system/decomposeParDict \
-     | sed s/"numberOfSubdomains *\(.*\);"/"\1"/`
-
 runApplication surfaceFeatureExtract
 
 # Create tight-fitting background mesh
@@ -16,25 +12,8 @@ runApplication topoSet -dict system/topoSetDict-background
 mv log.topoSet log.topoSet.background
 runApplication subsetMesh -cellSet background -patch walls -overwrite
 
-runApplication decomposePar
-
-# Backup initial background mesh on each processor
-for dir in processor*
-do
-    if [[ -d $dir ]]
-    then
-        cp -r $dir/constant/polyMesh $dir/constant/polyMesh_background
-    fi
-done
-
-runParallel cvMesh $nProc
-#runParallel snappyHexMesh $nProc
-
-runApplication reconstructParMesh -constant -mergeTol 1e-6
-
-runApplication topoSet -dict system/topoSetDict-slices
-mv log.topoSet log.topoSet.slices
-runApplication writeCellCentres -constant
-runParallel checkMesh $nProc -constant -allGeometry -allTopology
+runApplication cvMesh
+runApplication collapseEdges -latestTime -collapseFaces
+runApplication checkMesh -latestTime -allGeometry -allTopology
 
 # ----------------------------------------------------------------- end-of-file
diff --git a/tutorials/mesh/cvMesh/flange/Allrun-parallel b/tutorials/mesh/cvMesh/flange/Allrun-parallel
new file mode 100755
index 0000000000..f5bedb8935
--- /dev/null
+++ b/tutorials/mesh/cvMesh/flange/Allrun-parallel
@@ -0,0 +1,26 @@
+#!/bin/sh
+cd ${0%/*} || exit 1    # run from this directory
+
+# Source tutorial run functions
+. $WM_PROJECT_DIR/bin/tools/RunFunctions
+
+# Get the number of processors to run on from system/decomposeParDict
+nProc=$(getNumberOfProcessors)
+
+runApplication surfaceFeatureExtract
+
+# Create tight-fitting background mesh
+runApplication blockMesh
+runApplication topoSet -dict system/topoSetDict-background
+mv log.topoSet log.topoSet.background
+runApplication subsetMesh background -patch walls -overwrite
+
+runApplication decomposePar
+
+runParallel cvMesh $nProc
+runParallel collapseEdges $nProc -latestTime -collapseFaces
+runParallel checkMesh $nProc -latestTime -allTopology -allGeometry
+
+runApplication reconstructParMesh -latestTime
+
+# ----------------------------------------------------------------- end-of-file
diff --git a/tutorials/mesh/cvMesh/flange/constant/polyMesh/blockMeshDict b/tutorials/mesh/cvMesh/flange/constant/polyMesh/blockMeshDict
index e04b7a4041..81d15816e3 100644
--- a/tutorials/mesh/cvMesh/flange/constant/polyMesh/blockMeshDict
+++ b/tutorials/mesh/cvMesh/flange/constant/polyMesh/blockMeshDict
@@ -21,7 +21,7 @@ xmax  0.0265;
 ymin -0.028;
 ymax  0.023;
 zmin -0.024;
-zmax  0.0025;
+zmax  0.01;
 
 vertices
 (
diff --git a/tutorials/mesh/cvMesh/flange/constant/polyMesh/boundary b/tutorials/mesh/cvMesh/flange/constant/polyMesh/boundary
index 939aa87f62..efe6bfe832 100644
--- a/tutorials/mesh/cvMesh/flange/constant/polyMesh/boundary
+++ b/tutorials/mesh/cvMesh/flange/constant/polyMesh/boundary
@@ -8,44 +8,20 @@
 FoamFile
 {
     version     2.0;
-    format      binary;
+    format      ascii;
     class       polyBoundaryMesh;
     location    "constant/polyMesh";
     object      boundary;
 }
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-5
+1
 (
-    flange.obj_patch1
+    walls
     {
         type            wall;
-        nFaces          24684;
-        startFace       193547;
-    }
-    flange.obj_patch2
-    {
-        type            wall;
-        nFaces          1674;
-        startFace       218231;
-    }
-    flange.obj_patch3
-    {
-        type            wall;
-        nFaces          438;
-        startFace       219905;
-    }
-    flange.obj_patch4
-    {
-        type            wall;
-        nFaces          3595;
-        startFace       220343;
-    }
-    cvMesh_defaultPatch
-    {
-        type            wall;
-        nFaces          0;
-        startFace       223938;
+        nFaces          126;
+        startFace       207;
     }
 )
 
diff --git a/tutorials/mesh/cvMesh/flange/constant/triSurface/flange.eMesh b/tutorials/mesh/cvMesh/flange/constant/triSurface/flange.eMesh
deleted file mode 100644
index b21ffb616f..0000000000
--- a/tutorials/mesh/cvMesh/flange/constant/triSurface/flange.eMesh
+++ /dev/null
@@ -1,224 +0,0 @@
-/*--------------------------------*- 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      binary;
-    class       featureEdgeMesh;
-    location    "constant/triSurface";
-    object      flange.eMesh;
-}
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-
-// points:
-
-777
-(9��v��z?���Q�~?R���Q��9��v��z?���Q�~�R���Q��9��v��z?���Q�~?;�O��nb?9��v��z����Q�~?R���Q��9��v��z����Q�~�R���Q��9��v��z����Q�~?;�O��nb?9��v��z?����Mb`?�p��I���9��v��z?����Mb`?9�`��_�9��v��z�����Mb`?�p��I���9��v��z�����Mb`?9�`��_�9��v��z?����Mb`?R���Q��9��v��z?����Mb`?;�O��nb?9��v��z�����Mb`?R���Q��9��v��z�����Mb`?;�O��nb?9��v��z?���Q�~?�!� Ɛ�9�D9�/Q?A���%ɼ��ZI���9��v��z?���Q�~?x}�8\a�9��v��z����Q�~?�!� Ɛ�9�D9�/Q�A���%ɼ��ZI���9��v��z����Q�~?x}�8\a��+�xd?A���%ɼ�l����S�.��b?A���%ɼ���E�d�B�?����Mb`?�l������]D��?����Mb`?���5&��P_�J:�?����Mb`?�vLݕ����ॊ��?����Mb`?#<��GЎ�6��r~/�?����Mb`?�Zd;����(���?����Mb`?O��������Q���?����Mb`?/$�^��S�.��b?A���%ɼ|�5Z���(��?����Mb`?�n�2 ���E�[T�?����Mb`?�l����}X���?����Mb`?e��n���jO�9���?����Mb`?�q����ŜV��A�?����Mb`?�vLݕ���PIBǓ?����Mb`?0��K�ώ���(��?����Mb`?I>��B��}X���?����Mb`?d��I�y�jO�9���?����Mb`?���G��t�ŜV��A�?����Mb`?��Y ͚p��PIBǓ?����Mb`?�
�)�Ml�6��r~/�?����Mb`?9��v��j���]D��?����Mb`?��[v����ॊ��?����Mb`?�s�01Ll�P_�J:�?����Mb`?Au�~Қp���(���?����Mb`?3�-z�t���Q���?����Mb`?�iq!�y�S�.��b�A���%ɼ���E�+�xd�A���%ɼ�l������]D�������Mb`?���5&���d�B������Mb`?�l���񂿹�ॊ�������Mb`?#<��GЎ�P_�J:������Mb`?�vLݕ��6��r~/������Mb`?�Zd;����(��������Mb`?O��������Q��������Mb`?/$�^��S�.��b�A���%ɼ|�5Z��E�[T������Mb`?�l������(�������Mb`?�n�2 ��}X��������Mb`?e��n���jO�9��������Mb`?�q����ŜV��A������Mb`?�vLݕ���PIBǓ�����Mb`?0��K�ώ���(�������Mb`?I>��B��}X��������Mb`?d��I�y�jO�9��������Mb`?���G��t�ŜV��A������Mb`?��Y ͚p��PIBǓ�����Mb`?�
�)�Ml�6��r~/������Mb`?9��v��j���]D�������Mb`?��[v��P_�J:������Mb`?Au�~Қp���ॊ�������Mb`?�s�01Ll���(��������Mb`?3�-z�t���Q��������Mb`?�iq!�y�4���`[X?���Q�~�R���Q���x�޳�	?���Q�~�R���Q��Kx�h��g?���Q�~�R���Q���Y�oPq?���Q�~�R���Q��V���Ev?���Q�~�R���Q���x�޳�	?
-ףp=
-�?�p=
-ף��9�D9�/Q?
-ףp=
-�?W����e��a?
-ףp=
-�?���aN����Eݽ�j?
-ףp=
-�?��Z�#���O�|4�q?
-ףp=
-�?�(���G��H ���)v?
-ףp=
-�?)\���(��P�,�cy?
-ףp=
-�?�J���ʉ��Ɍ��^{?
-ףp=
-�?��ZI����$U��}|?
-ףp=
-�?����F�����i�|?
-ףp=
-�?�l�����ӿN\?�~�ucn>ލ�A���^tG9w?W?�~�ucn>"z����x�޳�	?���Q�~�;�O��nb?�O��X?���Q�~�;�O��nb?Kx�h��g?���Q�~�;�O��nb?�Y�oPq?���Q�~�;�O��nb?V���Ev?���Q�~�;�O��nb?9��v��z?���Q�~�;�O��nb?9�D9�/Q?
-ףp=
-�?!ȃ%c��x�޳�	?
-ףp=
-�?;�O��nb�e��a?
-ףp=
-�?���A#e���Eݽ�j?
-ףp=
-�?b��%��h�O�|4�q?
-ףp=
-�?��7דmn�H ���)v?
-ףp=
-�?��~j�ts��Ɍ��^{?
-ףp=
-�?jS�,
�|�P�,�cy?
-ףp=
-�?���0x��$U��}|?
-ףp=
-�?���r����ӿN\?�~�ucn>p���$�~��o=�1O?�G@
-��=ɰ�72�|��x�޳�	?/#�Z�>_�Q�{�4���`[X����Q�~�R���Q��Kx�h��g����Q�~�R���Q���Y�oPq����Q�~�R���Q��V���Ev����Q�~�R���Q��9�D9�/Q�
-ףp=
-�?W����e��a�
-ףp=
-�?���aN����Eݽ�j�
-ףp=
-�?��Z�#���O�|4�q�
-ףp=
-�?�(���G��H ���)v�
-ףp=
-�?)\���(���Ɍ��^{�
-ףp=
-�?��ZI���P�,�cy�
-ףp=
-�?�J���ʉ��$U��}|�
-ףp=
-�?����F�����i�|�
-ףp=
-�?�l�����ӿN\��~�ucn>ލ�A���^tG9w?W��~�ucn>"z����O��X����Q�~�;�O��nb?Kx�h��g����Q�~�;�O��nb?�Y�oPq����Q�~�;�O��nb?V���Ev����Q�~�;�O��nb?9��v��z����Q�~�;�O��nb?9�D9�/Q�
-ףp=
-�?!ȃ%c�e��a�
-ףp=
-�?���A#e���Eݽ�j�
-ףp=
-�?b��%��h�O�|4�q�
-ףp=
-�?��7דmn�H ���)v�
-ףp=
-�?��~j�ts�P�,�cy�
-ףp=
-�?���0x��Ɍ��^{�
-ףp=
-�?jS�,
�|��$U��}|�
-ףp=
-�?���r����ӿN\��~�ucn>p���$�~��o=�1O��G@
-��=ɰ�72�|��x�޳�	?9��v��z?�p=
-ף��9�D9�/Q?9��v��z?W����9�D9�/Q?����ސ�?W�����x�޳�	?����ސ�?�p=
-ף��e��a?9��v��z?���aN��e��a?����ސ�?���aN����Eݽ�j?9��v��z?��Z�#�����Eݽ�j?����ސ�?��Z�#���O�|4�q?9��v��z?�(���G��O�|4�q?����ސ�?�(���G��H ���)v?9��v��z?)\���(��H ���)v?����ސ�?)\���(��P�,�cy?9��v��z?�J���ʉ��Ɍ��^{?9��v��z?��ZI����Ɍ��^{?����ސ�?��ZI���P�,�cy?����ސ�?�J���ʉ��$U��}|?9��v��z?����F���$U��}|?����ސ�?����F�����i�|?9��v��z?�l���񂿠��i�|?����ސ�?�l����9�D9�/Q?9��v��z?��+�*c��x�޳�	?9��v��z?;�O��nb��x�޳�	?����ސ�?;�O��nb�9�D9�/Q?����ސ�?��+�*c�e��a?9��v��z?���A#e�e��a?����ސ�?���A#e���Eݽ�j?9��v��z?b��%��h���Eݽ�j?����ސ�?b��%��h�O�|4�q?9��v��z?��7דmn�O�|4�q?����ސ�?��7דmn�H ���)v?9��v��z?��~j�ts�H ���)v?����ސ�?��~j�ts��Ɍ��^{?9��v��z?jS�,
�|�P�,�cy?9��v��z?g@�n�0x�P�,�cy?����ސ�?g@�n�0x��Ɍ��^{?����ސ�?jS�,
�|��$U��}|?9��v��z?���r����$U��}|?����ސ�?���r���9�D9�/Q�9��v��z?W����9�D9�/Q�����ސ�?W����e��a�9��v��z?���aN��e��a�����ސ�?���aN����Eݽ�j�9��v��z?��Z�#�����Eݽ�j�����ސ�?��Z�#���O�|4�q�9��v��z?�(���G��O�|4�q�����ސ�?�(���G��H ���)v�9��v��z?)\���(��H ���)v�����ސ�?)\���(���Ɍ��^{�9��v��z?��ZI���P�,�cy�9��v��z?�J���ʉ�P�,�cy�����ސ�?�J���ʉ��Ɍ��^{�����ސ�?��ZI����$U��}|�9��v��z?����F���$U��}|�����ސ�?����F�����i�|�9��v��z?�l���񂿠��i�|�����ސ�?�l����9�D9�/Q�9��v��z?��+�*c�9�D9�/Q�����ސ�?��+�*c�e��a�9��v��z?���A#e�e��a�����ސ�?���A#e���Eݽ�j�9��v��z?b��%��h���Eݽ�j�����ސ�?b��%��h�O�|4�q�9��v��z?��7דmn�O�|4�q�����ސ�?��7דmn�H ���)v�9��v��z?��~j�ts�H ���)v�����ސ�?��~j�ts�P�,�cy�9��v��z?g@�n�0x��Ɍ��^{�9��v��z?jS�,
�|��Ɍ��^{�����ސ�?jS�,
�|�P�,�cy�����ސ�?g@�n�0x��$U��}|�9��v��z?���r����$U��}|�����ސ�?���r���7q�x�������Q�~�;�O��nb?�q �
-�����Q�~�;�O��nb?�{���G�?���Q�~����Q�:|��A��.��?���Q�~��l�����U�@�?���Q�~�e��/`s��>���?���Q�~�bS���"h���PS&��?���Q�~��8Bi�[��c�ߓ?���Q�~�e��h�O�6��r~/�?���Q�~�
\��W0�/��.��?���Q�~��

-��V?�(L�?�?���Q�~�?lm
-��B?�nEɧ�����Q�~����������S�����Q�~���X�)����{���G�����Q�~�����Ň��A��.������Q�~��l�����U�@�����Q�~�d�nm<3���>�������Q�~�>��F�ڏ���PS&������Q�~�2��8*7��	��g�꓿���Q�~����3
��6��r~/�����Q�~����^@Ԓ��q �
-�?���Q�~�;�O��nb?7q�x���?���Q�~�;�O��nb?e�gc�O?�4{@�:?R
Aʙ��u�B�FH?1�v��G?�7}�����
?��<?F�}TN?�����懿�x�޳�	?�P�?�bP?�������x�޳�	?���Q�~�㥛� �����G�@�V?���Q�~���Ŧ���*�"f?���Q�~��4�8EG���}�?w8p?���Q�~��ĘO�ő��賨��t?���Q�~�wT볹 ��獓¼�y?���Q�~�D9,h�����ڥ.�~?���Q�~�A�]��a��G����?���Q�~������%���kA0�?���Q�~��G��|����}8H��?���Q�~��l����6��r~/�?���Q�~����^@Ԓ����S�?���Q�~���X�)���>�H*��?���Q�~�*�8���H)2��#�?���Q�~��ƒf׽���nEɧ�?���Q�~���������G�@�V?���Q�~���5L��6��x�޳�	?���Q�~�����Mb0�*�"f?���Q�~����?VKE��}�?w8p?���Q�~��,��j�R��賨��t?���Q�~��K���]�獓¼�y?���Q�~�
-�J$��f�G����?���Q�~�� x|{w���ڥ.�~?���Q�~���q��kA0�?���Q�~�!�J�~����Av��?����Mb`?�l���񂿔N$�jf�?����Mb`?���3ڪ���&�XL�?����Mb`?qй6�E��?�+T퉔?����Mb`?>u�Rz���)�5�ٓ?����Mb`?��3S�����``�?����Mb`?+ժZ_��6��r~/�?����Mb`?��������@v͚S�?����Mb`?�
-���_���`����?����Mb`?�m��E�����`���?����Mb`?�i2�m�����BF��?����Mb`?V���E��S��.�?����Mb`?�I�F���^�G
��?����Mb`?�l���񂿔N$�jf�?���Q�~����3ڪ�����Av��?���Q�~��l�����&�XL�?���Q�~�qй6�E��?�+T퉔?���Q�~�>u�Rz���)�5�ٓ?���Q�~���3S�����``�?���Q�~�+ժZ_��6��r~/�?���Q�~���������@v͚S�?���Q�~��
-���_���`����?���Q�~��m��E�����`���?���Q�~��i2�m�����BF��?���Q�~�V���E��S��.�?���Q�~��I�F���^�G
��?���Q�~��l���񂿔N$�jf�?����Mb`?h<�y8���&�XL�?����Mb`?L*�I;�?�+T퉔?����Mb`?�,Rr�y|�)�5�ٓ?����Mb`?<��
\z���``�?����Mb`?�H��y�6��r~/�?����Mb`?�~j�t�x�@v͚S�?����Mb`?�|�y��`����?����Mb`?�ֈ`\z���`���?����Mb`?�CFQ�{|���BF��?����Mb`?�(���;�S��.�?����Mb`?v��g
9���N$�jf�?���Q�~�h<�y8���&�XL�?���Q�~�L*�I;�?�+T퉔?���Q�~��,Rr�y|�)�5�ٓ?���Q�~�<��
\z���``�?���Q�~��H��y�6��r~/�?���Q�~��~j�t�x�@v͚S�?���Q�~��|�y��`����?���Q�~��ֈ`\z���`���?���Q�~��CFQ�{|���BF��?���Q�~��(���;�S��.�?���Q�~�v��g
9��e�gc�O��4{@�:?R
Aʙ��u�B�FH�1�v��G?�7}�����
?��<�F�}TN?�����懿��G�@�V����Q�~���Ŧ���*�"f����Q�~��4�8EG���}�?w8p����Q�~��ĘO�ő��賨��t����Q�~�wT볹 ��獓¼�y����Q�~�D9,h���G��������Q�~������%����ڥ.�~����Q�~�A�]��a���kA0�����Q�~��G��|����}8H������Q�~��l����>�H*������Q�~�*�8���H)2��#�����Q�~��ƒf׽����G�@�V����Q�~���5L��6�*�"f����Q�~����?VKE��}�?w8p����Q�~��,��j�R��賨��t����Q�~��K���]�獓¼�y����Q�~�
-�J$��f���ڥ.�~����Q�~���q�G��������Q�~�� x|{w��kA0�����Q�~�!�J�~��N$�jf������Mb`?���3ڪ�����Av�������Mb`?�l�����&�XL������Mb`?qй6�E��?�+T퉔�����Mb`?>u�Rz���)�5�ٓ�����Mb`?��3S�����``������Mb`?+ժZ_��6��r~/������Mb`?��������@v͚S������Mb`?�
-���_���`���������Mb`?�m��E�����`��������Mb`?�i2�m�����BF�������Mb`?V���E��S��.�����Mb`?�I�F���^�G
�������Mb`?�l���񂿾��Av������Q�~��l���񂿔N$�jf�����Q�~����3ڪ���&�XL�����Q�~�qй6�E��?�+T퉔����Q�~�>u�Rz���)�5�ٓ����Q�~���3S�����``�����Q�~�+ժZ_��6��r~/�����Q�~���������@v͚S�����Q�~��
-���_���`��������Q�~��m��E�����`�������Q�~��i2�m�����BF������Q�~�V���E��S��.񍿸��Q�~��I�F���^�G
������Q�~��l���񂿔N$�jf������Mb`?h<�y8���&�XL������Mb`?L*�I;�?�+T퉔�����Mb`?�,Rr�y|�)�5�ٓ�����Mb`?<��
\z���``������Mb`?�H��y�6��r~/������Mb`?�~j�t�x�@v͚S������Mb`?�|�y��`���������Mb`?�ֈ`\z���`��������Mb`?�CFQ�{|���BF�������Mb`?�(���;�S��.�����Mb`?v��g
9���N$�jf�����Q�~�h<�y8���&�XL�����Q�~�L*�I;�?�+T퉔����Q�~��,Rr�y|�)�5�ٓ����Q�~�<��
\z���``�����Q�~��H��y�6��r~/�����Q�~��~j�t�x�@v͚S�����Q�~��|�y��`��������Q�~��ֈ`\z���`�������Q�~��CFQ�{|���BF������Q�~��(���;�S��.񍿸��Q�~�v��g
9��6��r~/�����Q�~�
\��W0��(L�?�����Q�~�?lm
-��B?/��.������Q�~��

-��V?�{���G�?���Q�~�����Ň��U�@�?���Q�~�d�nm<3���>���?���Q�~�>��F�ڏ���PS&��?���Q�~�2��8*7��	��g��?���Q�~����3
���{���G�����Q�~����Q�:|��U�@�����Q�~�e��/`s��>�������Q�~�bS���"h���PS&������Q�~��8Bi�[��c�ߓ����Q�~�e��h�O�9�D9�/Q?���R�)\���(�������O?C��N9?)\���(���4�_�H?l
��+G?)\���(��q?t�I<?n�U1FN?)\���(���x�޳�	?����MbP?)\���(�������O?C��N9�)\���(���4�_�H?l
��+G�)\���(��q?t�I<?n�U1FN�)\���(���x�޳�	?����MbP�)\���(��6��r~/�?����Mb`?���^@Ԓ����S�?����Mb`?��X�)���>�H*��?����Mb`?*�8���H)2��#�?����Mb`?�ƒf׽���nEɧ�?����Mb`?�������A��.��?����Mb`?�l�����{���G�?����Mb`?����Ň��U�@�?����Mb`?d�nm<3���>���?����Mb`?>��F�ڏ���PS&��?����Mb`?2��8*7��	��g��?����Mb`?���3
���{���G�?����Mb`?���Q�:|��U�@�?����Mb`?e��/`s��>���?����Mb`?bS���"h���PS&��?����Mb`?�8Bi�[��c�ߓ?����Mb`?e��h�O�6��r~/�?����Mb`?
\��W0��(L�?�?����Mb`??lm
-��B?�q �
-�?����Mb`?;�O��nb?7q�x���?����Mb`?;�O��nb?/��.��?����Mb`?�

-��V?�����O�C��N9?)\���(��9�D9�/Q����R�)\���(���4�_�H�l
��+G?)\���(��q?t�I<�n�U1FN?)\���(�������O�C��N9�)\���(���4�_�H�l
��+G�)\���(��q?t�I<�n�U1FN�)\���(�����S������Mb`?��X�)���6��r~/������Mb`?���^@Ԓ�>�H*�������Mb`?*�8���H)2��#������Mb`?�ƒf׽���nEɧ������Mb`?�������{���G������Mb`?����Ň��A��.�������Mb`?�l�����U�@������Mb`?d�nm<3���>��������Mb`?>��F�ڏ���PS&�������Mb`?2��8*7��	��g�꓿����Mb`?���3
���{���G������Mb`?���Q�:|��U�@������Mb`?e��/`s��>��������Mb`?bS���"h���PS&�������Mb`?�8Bi�[��c�ߓ�����Mb`?e��h�O�6��r~/������Mb`?
\��W0��(L�?������Mb`??lm
-��B?�q �
-������Mb`?;�O��nb?/��.�������Mb`?�

-��V?7q�x��������Mb`?;�O��nb?��8sY�i?)\���(��)\���(���(ȶ�
p?)\���(��עh[͊�H�5�Ēq?)\���(���~��󉿣(ȶ�
p?)\���(���џG�+v���8sY�i?)\���(����~j�ts�H�5�Ēq?)\���(��5�ع��w��(ȶ�
p�)\���(��עh[͊���8sY�i�)\���(��)\���(��H�5�Ēq�)\���(���~�����8sY�i�)\���(����~j�ts��(ȶ�
p�)\���(���џG�+v�H�5�Ēq�)\���(��5�ع��w�9�D9�/Q?�'�1��q?R���Q���x�޳�	?;�O��nr?R���Q���x�޳�	?���Q�~?R���Q��4���`[X?���Q�~?R���Q��p�@�a?�E\cDp?R���Q��Kx�h��g?���Q�~?R���Q����sZ\�j?��Dwj?R���Q���Y�oPq?���Q�~?R���Q��c����r?g�NVɤȼR���Q��I�B�r?kܴ|��R?R���Q��mH�A8p?m�$�<b?R���Q��V���Ev?���Q�~?R���Q��9��v��z?��
-{��<R���Q��9��v��z?���S�k?R���Q��9��v��z?��~j�ts?R���Q��9��v��z?J+�y?R���Q���x�޳�	?;�O��nr�R���Q��9�D9�/Q?�'�1��q�R���Q��p�@�a?�E\cDp�R���Q����sZ\�j?��Dwj�R���Q��I�B�r?kܴ|��R�R���Q��mH�A8p?m�$�<b�R���Q��9��v��z?����Mb`�R���Q��9��v��z?���S�k�R���Q��9��v��z?��~j�ts�R���Q��9��v��z?J+�y�R���Q���x�޳�	?�Q��둿㥛� �����G�@�V?�Q��둿��Ŧ���*�"f?�Q��둿�4�8EG���}�?w8p?�Q��둿�ĘO�ő��賨��t?�Q��둿wT볹 ��獓¼�y?�Q��둿D9,h�����ڥ.�~?�Q��둿A�]��a��G����?�Q��둿�����%���kA0�?�Q��둿�G��|����}8H��?�Q��둿�l����9�D9�/Q?)\���(����2d���9�����	?)\���(��g��j+�����y�/]?)\���(��<f�2�}���B����b?)\���(��3Y��I݄��+�xd?)\���(���l����dN�R�Cs?)\���(���� �����4���t?)\���(����ZI���행���u?)\���(����LLb��\>���v?)\���(���l���񂿆x�޳�	?)\���(��%u���Yh)Q��Q?)\���(���ˤ<�卿"��R��`?)\���(��S��.Q��_v�d�X?
-ףp=
-�?����}Ӓ��x�޳�	?
-ףp=
-�?�l���񒿐�_!Rg?
-ףp=
-�?�)�����n���p?
-ףp=
-�?F$
--����#��H�u?
-ףp=
-�?�d��F���
-F%uz?
-ףp=
-�?��8h����r��{�?
-ףp=
-�?�D
-
-(y����Y�� ?
-ףp=
-�?�
N�⍿�r��h��?
-ףp=
-�?<ۤ������Z�?
-ףp=
-�?�l����e�gc�O?�4{@�:�R
Aʙ��u�B�FH?1�v��G��7}�����
?��<?F�}TN������懿�x�޳�	?�P�?�bP��������O��X?���Q�~?;�O��nb?�x�޳�	?���Q�~?;�O��nb?Kx�h��g?���Q�~?;�O��nb?�Y�oPq?���Q�~?;�O��nb?V���Ev?���Q�~?;�O��nb?9��v��z?���S�k?;�O��nb?9��v��z?��~j�ts?;�O��nb?9��v��z?J+�y?;�O��nb?��G�@�V?�Q��둿��5L��6��x�޳�	?�Q��둿����Mb0�*�"f?�Q��둿���?VKE��}�?w8p?�Q��둿�,��j�R��賨��t?�Q��둿�K���]�獓¼�y?�Q��둿
-�J$��f�G����?�Q��둿� x|{w���ڥ.�~?�Q��둿��q��kA0�?�Q��둿!�J�~�9�����	?)\���(��_�Q�{�9�D9�/Q?)\���(��ò>�߹|���y�/]?)\���(����\���~��B����b?)\���(����������4���t?)\���(��jS�,
�|�dN�R�Cs?)\���(��B�]�gFz�행���u?)\���(��j���<���Yh)Q��Q?)\���(�������o��x�޳�	?)\���(��ŏ1w-!o�"��R��`?)\���(���ò�_$q��x�޳�	?
-ףp=
-�?_v�d�X?
-ףp=
-�?�A�p�-���_!Rg?
-ףp=
-�?	m�ze<�n���p?
-ףp=
-�?i,�lVN�#��H�u?
-ףp=
-�?�}�ϕ�Z��
-F%uz?
-ףp=
-�?. ��Ld���Y�� ?
-ףp=
-�?���{�p���r��{�?
-ףp=
-�?2(��W�v��r��h��?
-ףp=
-�?���bc~�9�D9�/Q��'�1��q?R���Q��4���`[X����Q�~?R���Q��p�@�a��E\cDp?R���Q��Kx�h��g����Q�~?R���Q����sZ\�j���Dwj?R���Q���Y�oPq����Q�~?R���Q��I�B�r�kܴ|��R?R���Q��c����r�g�NVɤȼR���Q��mH�A8p�m�$�<b?R���Q��V���Ev����Q�~?R���Q��9��v��z���
-{��<R���Q��9��v��z����S�k?R���Q��9��v��z���~j�ts?R���Q��9��v��z�J+�y?R���Q��9�D9�/Q��'�1��q�R���Q��p�@�a��E\cDp�R���Q����sZ\�j���Dwj�R���Q��I�B�r�kܴ|��R�R���Q��mH�A8p�m�$�<b�R���Q��9��v��z�����Mb`�R���Q��9��v��z����S�k�R���Q��9��v��z���~j�ts�R���Q��9��v��z�J+�y�R���Q����G�@�V��Q��둿��Ŧ���*�"f��Q��둿�4�8EG���}�?w8p��Q��둿�ĘO�ő��賨��t��Q��둿wT볹 ��獓¼�y��Q��둿D9,h���G������Q��둿�����%����ڥ.�~��Q��둿A�]��a���kA0���Q��둿�G��|����}8H����Q��둿�l����9�D9�/Q�)\���(����2d�����y�/]�)\���(��<f�2�}���B����b�)\���(��3Y��I݄��+�xd�)\���(���l������4���t�)\���(����ZI���dN�R�Cs�)\���(���� ���행���u�)\���(����LLb��\>���v�)\���(���l����Yh)Q��Q�)\���(���ˤ<�卿"��R��`�)\���(��S��.Q��_v�d�X�
-ףp=
-�?����}Ӓ���_!Rg�
-ףp=
-�?�)�����n���p�
-ףp=
-�?F$
--����#��H�u�
-ףp=
-�?�d��F���
-F%uz�
-ףp=
-�?��8h����Y�� �
-ףp=
-�?�
N�⍿��r��{��
-ףp=
-�?�D
-
-(y���r��h���
-ףp=
-�?<ۤ������Z��
-ףp=
-�?�l����e�gc�O��4{@�:�R
Aʙ��u�B�FH�1�v��G��7}�����
?��<�F�}TN������懿�O��X����Q�~?;�O��nb?Kx�h��g����Q�~?;�O��nb?�Y�oPq����Q�~?;�O��nb?V���Ev����Q�~?;�O��nb?9��v��z����S�k?;�O��nb?9��v��z���~j�ts?;�O��nb?9��v��z�J+�y?;�O��nb?��G�@�V��Q��둿��5L��6�*�"f��Q��둿���?VKE��}�?w8p��Q��둿�,��j�R��賨��t��Q��둿�K���]�獓¼�y��Q��둿
-�J$��f���ڥ.�~��Q��둿��q�G������Q��둿� x|{w��kA0���Q��둿!�J�~�9�D9�/Q�)\���(��ò>�߹|���y�/]�)\���(����\���~��B����b�)\���(��������dN�R�Cs�)\���(��B�]�gFz���4���t�)\���(��jS�,
�|�행���u�)\���(��j���<���Yh)Q��Q�)\���(�������o�"��R��`�)\���(���ò�_$q�_v�d�X�
-ףp=
-�?�A�p�-���_!Rg�
-ףp=
-�?	m�ze<�n���p�
-ףp=
-�?i,�lVN�#��H�u�
-ףp=
-�?�}�ϕ�Z��
-F%uz�
-ףp=
-�?. ��Ld���r��{��
-ףp=
-�?2(��W�v���Y�� �
-ףp=
-�?���{�p��r��h���
-ףp=
-�?���bc~�9��v��z?���Q�~?yf��}4?9��v��z����Q�~?<r��C��9��v��z����Q�~? &�B���9��v��z?���Q�~?<r��C��9��v��z?���Q�~? &�B���9��v��z����Q�~?yf��}4?�B����b?9��v��z?���<݄���y�/]?9��v��z?����}���+�xd?9��v��z?�l�����B����b�9��v��z?A�5q����y�/]�9��v��z?+����~��+�xd�9��v��z?�l����9�D9�/Q?9��v��z?��ZI����x�޳�	?9��v��z?�������x�޳�	?9��v��z?���k�{�9�D9�/Q?9��v��z?jS�,
�|���y�/]?9��v��z?+����~�9�D9�/Q�9��v��z?��ZI�����y�/]�9��v��z?����}��9�D9�/Q�9��v��z?jS�,
�|��B����b?9��v��z?A�5q���B����b�9��v��z?���<݄��}�֤�b?k�/�.�o?)\���(��^H��0~j?T�j�
-j?)\���(��^H��0~j?T�j�
-j�)\���(���}�֤�b?k�/�.�o�)\���(��^H��0~j�T�j�
-j?)\���(���}�֤�b�k�/�.�o?)\���(���}�֤�b�k�/�.�o�)\���(��^H��0~j�T�j�
-j�)\���(����Ц4��?����Mb`?�N�j憿��D��?����Mb`?�l�������piF�?����Mb`?6K-���9��v��z?����Mb`?f�B,c��9��v��z?����Mb`?6��"ѕ��~���Y�?����Mb`?��������Ц4��?����Mb`?�;��}����piF�?����Mb`?�7�ޛ�l�9��v��z?����Mb`?����c<?�~���Y�?����Mb`?�����u���D�������Mb`?�l������Ц4�������Mb`?�N�j憿���piF������Mb`?6K-���9��v��z�����Mb`?f�B,c��9��v��z�����Mb`?6��"ѕ��~���Y������Mb`?��������Ц4�������Mb`?�;��}����piF������Mb`?�7�ޛ�l�9��v��z�����Mb`?����c<?�~���Y������Mb`?�����u�$��=h,p?���6Meb?)\���(��$��=h,p?���6Meb�)\���(��$��=h,p����6Meb?)\���(��$��=h,p����6Meb�)\���(��9��v��z?���S�k?�p{�}鐿9��v��z?��~j�ts?~[��ݐ�9��v��z?J+�y?�>��ѐ�Yh)Q��Q?�Q��둿�ˤ<�卿�x�޳�	?�Q��둿%u���"��R��`?�Q��둿S��.Q����8sY�i?�Q��둿)\���(���(ȶ�
p?�Q��둿עh[͊�H�5�Ēq?�Q��둿�~�����4���t?�Q��둿��ZI���dN�R�Cs?�Q��둿�� ���행���u?�Q��둿��LLb��\>���v?�Q��둿�l����9��v��z?���S�k?�CmFA`�9��v��z?��~j�ts?ҍ���`�9��v��z?J+�y?ħJ���`��x�޳�	?�Q��둿ŏ1w-!o�Yh)Q��Q?�Q��둿�����o�"��R��`?�Q��둿�ò�_$q���8sY�i?�Q��둿��~j�ts��(ȶ�
p?�Q��둿�џG�+v�H�5�Ēq?�Q��둿5�ع��w�dN�R�Cs?�Q��둿B�]�gFz���4���t?�Q��둿jS�,
�|�행���u?�Q��둿j���<���9��v��z����S�k?�p{�}鐿9��v��z���~j�ts?~[��ݐ�9��v��z�J+�y?�>��ѐ�Yh)Q��Q��Q��둿�ˤ<�卿"��R��`��Q��둿S��.Q����8sY�i��Q��둿)\���(���(ȶ�
p��Q��둿עh[͊�H�5�Ēq��Q��둿�~���dN�R�Cs��Q��둿�� �����4���t��Q��둿��ZI���행���u��Q��둿��LLb��\>���v��Q��둿�l����9��v��z����S�k?�CmFA`�9��v��z���~j�ts?ҍ���`�9��v��z�J+�y?ħJ���`�Yh)Q��Q��Q��둿�����o�"��R��`��Q��둿�ò�_$q���8sY�i��Q��둿��~j�ts��(ȶ�
p��Q��둿�џG�+v�H�5�Ēq��Q��둿5�ع��w���4���t��Q��둿jS�,
�|�dN�R�Cs��Q��둿B�]�gFz�행���u��Q��둿j���<����(�m~
r?�ބYR?)\���(��c����r?���R�)\���(���x�޳�	?D]�|nr?)\���(��0�+!XS?�Dd���q?)\���(���(�m~
r?�ބYR�)\���(��0�+!XS?�Dd���q�)\���(���x�޳�	?D]�|nr�)\���(���(�m~
r��ބYR?)\���(��c����r����R�)\���(��0�+!XS��Dd���q?)\���(���(�m~
r��ބYR�)\���(��0�+!XS��Dd���q�)\���(���x�޳�	?���Q�~?C�	�Q���O��X?���Q�~?��cF�4��Kx�h��g?���Q�~?1X�Bߒ��Y�oPq?���Q�~?0n��.W��V���Ev?���Q�~?������O��X?���Q�~?{�Fy�0?�x�޳�	?���Q�~?����7?Kx�h��g?���Q�~?C�U��h��Y�oPq?���Q�~?w�hOC�V���Ev?���Q�~?vnڌ�U��O��X����Q�~?��cF�4��Kx�h��g����Q�~?1X�Bߒ��Y�oPq����Q�~?0n��.W��V���Ev����Q�~?������O��X����Q�~?{�Fy�0?Kx�h��g����Q�~?C�U��h��Y�oPq����Q�~?w�hOC�V���Ev����Q�~?vnڌ�U�)
-
-// edges:
-
-788
-(JKLJMLNM
NOPPQQRRSSTUVTUVWWXY[\\]]^^__`abcadcedfeghhfigXijkjKmmnnooppqOrqsrtsutvwwuxvyxz/|[}|~}~�b����������������y8���������������������������������������������
����






	
	

-

-









































 

!
 
"
!
#
"
$
#
%
$
&
%
'
&
(
'
)
(

)

*
*
+
+
,
,
-
-
.
.
/
/
0
0
1
1
2
2
3
3
4
4

��`���5
6
5
7
6
�7
��A
A
B
B
�K
L
M
K
N
M
O
N
P
O
Q
P
R
Q
S
R
T
S
U
T
V
U
W
V
X
Y
Y
Z
Z
[
[
\
\
]
]
^
^
_
_
`
`
a
a
b
b
c
c
d
L
e
e
f
f
g
g
h
h
i
i
j
j
k
k
l
l
m
m
n
n
o
o
W
p
X
q
p
r
q
s
r
t
s
u
t
v
u
w
v
x
w
y
x
z
y
d
z
{
|
��}
����~
~


�
�
�
�
�
�
���
�
�
�
�
�
�
�
�
�
{
|
}
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�

-�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�

�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�

-�
�

-�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�

�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�


		
-
-
�
  �
!""�
#!�
#$%&$�
&'(())**++,-.,-.//�
01�
0231245367864895:;;<<==9>�
?>@?7AABB@C:DCEDFEFG�
HGIHJIKJLMMKNLON�
PPQQRRSTUU�
VTWVX�
YX�
Y�
ZZ[[\\]]^_`^_`aabcdcede
ffgghhij
kjlkilmmnnooppqrsqrsttOuvuwvSwxy�
xyzzW%{{||�
}'~}~���������b���������������������������������������������YZZ{z{������������������������������������������������������������������������������������������������
�









�
8
�9
8
:
9
;
:
<
;
=
>
>
<
?
=
@
?
�C
C
D
D
E
E
F
F
G
H
I
G
H
I
J
J
@
��������������
-���������������������������	��	
�������������������������������������������������������������������������������������	������������������������������������������������������������������������
�
� ! "!#"#$$%%&&''(()*+,)+,-.*-./0123453467167089::;;<<==>>5?9@?A@BACBDC2EFGGDHFEIIHlk�l������������������������������������������������������������������������)
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-
-// ************************************************************************* //
diff --git a/tutorials/mesh/cvMesh/flange/system/collapseDict b/tutorials/mesh/cvMesh/flange/system/collapseDict
new file mode 100644
index 0000000000..9034677ca9
--- /dev/null
+++ b/tutorials/mesh/cvMesh/flange/system/collapseDict
@@ -0,0 +1,52 @@
+/*--------------------------------*- 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;
+
+    root            "";
+    case            "";
+    instance        "";
+    local           "";
+
+    class           dictionary;
+    object          collapseDict;
+}
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+collapseEdgesCoeffs
+{
+    minimumEdgeLength   1e-6;
+    maximumMergeAngle   180;
+    reductionFactor     0.5;
+}
+
+collapseFacesCoeffs
+{
+    initialFaceLengthFactor                 0.5;
+    reductionFactor                         0.5;
+
+    allowEarlyCollapseToPoint               on;
+    allowEarlyCollapseCoeff                 0.2;
+    guardFraction                           0.1;
+    maxCollapseFaceToPointSideLengthCoeff   0.3;
+}
+
+meshQualityCoeffs
+{
+    #include                    "meshQualityDict";
+    maximumIterations           30;
+    maximumSmoothingIterations  1;
+    maxPointErrorCount          5;
+}
+
+
+// ************************************************************************* //
diff --git a/tutorials/mesh/cvMesh/flange/system/controlDict b/tutorials/mesh/cvMesh/flange/system/controlDict
index 66a4bab34e..213488e4d8 100644
--- a/tutorials/mesh/cvMesh/flange/system/controlDict
+++ b/tutorials/mesh/cvMesh/flange/system/controlDict
@@ -22,23 +22,25 @@ FoamFile
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
+application     cvMesh;
+
 startFrom       startTime;
 
 startTime       0;
 
 stopAt          endTime;
 
-endTime         0;
+endTime         100;
 
 deltaT          1;
 
 writeControl    timeStep;
 
-writeInterval   1000;
+writeInterval   10;
 
 purgeWrite      0;
 
-writeFormat     binary; //ascii;
+writeFormat     ascii;
 
 writePrecision  10;
 
diff --git a/tutorials/mesh/cvMesh/flange/system/cvMeshDict b/tutorials/mesh/cvMesh/flange/system/cvMeshDict
index e0dace7c28..ea769c8152 100644
--- a/tutorials/mesh/cvMesh/flange/system/cvMeshDict
+++ b/tutorials/mesh/cvMesh/flange/system/cvMeshDict
@@ -45,52 +45,35 @@ backgroundMeshDecomposition
 
 surfaceConformation
 {
-    locationInMesh (0 0 0);
+    locationInMesh                      (0 0 0);
 
-    pointPairDistanceCoeff      0.1;
+    pointPairDistanceCoeff              0.1;
 
     mixedFeaturePointPPDistanceCoeff    5.0;
 
-    featurePointExclusionDistanceCoeff  0.65;
+    featurePointExclusionDistanceCoeff  0.7;
 
-    featureEdgeExclusionDistanceCoeff   0.8;
+    featureEdgeExclusionDistanceCoeff   0.7;
 
-    surfaceSearchDistanceCoeff  3;
+    surfaceSearchDistanceCoeff          5;
 
-    maxSurfaceProtrusionCoeff   0.1;
+    maxSurfaceProtrusionCoeff           0.1;
 
-    maxQuadAngle 125;
+    maxQuadAngle                        125;
 
     surfaceConformationRebuildFrequency 10;
 
+    specialiseFeaturePoints             on;
+
     conformationControls
     {
-        initial
-        {
-            edgeSearchDistCoeff         5;
-            surfacePtReplaceDistCoeff   0.5;
-            surfacePtExclusionDistanceCoeff 0.5;
-        }
+        edgeSearchDistCoeff             5;
+        surfacePtReplaceDistCoeff       0.5;
+        surfacePtExclusionDistanceCoeff 0.5;
 
-        iteration
-        {
-            edgeSearchDistCoeff         2;
-            surfacePtReplaceDistCoeff   0.5;
-        }
+        maxIterations                   15;
 
-        maxIterations 15;
-
-        iterationToInitialHitRatioLimit 0.001;
-    }
-
-    coarseConformationControls
-    {
-        $conformationControls;
-    }
-
-    fineConformationControls
-    {
-        $conformationControls;
+        iterationToInitialHitRatioLimit 0.0001;
     }
 
     geometryToConformTo
@@ -134,30 +117,30 @@ motionControl
 {
     defaultCellSize     0.001;
 
-    // Assign a priority to all requests for cell sizes, the highest overrules.
-    defaultPriority     0;
-
-    cellSizeControlGeometry
+    shapeControlFunctions
     {
         flange.obj
         {
-            priority            1;
-            mode                inside;
+            type                    searchableSurfaceControl;
+            priority                1;
+            mode                    inside;
             surfaceCellSizeFunction uniformValue;
             uniformValueCoeffs
             {
-                surfaceCellSize     0.0005;
+                surfaceCellSize     $defaultCellSize;
             }
 
-            cellSizeFunction    linearDistance;
-            linearDistanceCoeffs
-            {
-                distanceCellSize    $defaultCellSize;
-                distance            0.004;
-            }
+            cellSizeFunction        uniform;
+            uniformCoeffs{}
         }
     }
 
+    cellAspectRatioControl
+    {
+        aspectRatio                 1.0;
+        aspectRatioDirection        (0 0 0);
+    }
+
     relaxationModel     adaptiveLinear;
 
     adaptiveLinearCoeffs
@@ -170,7 +153,7 @@ motionControl
 
     timeChecks                  no;
 
-    maxLoadUnbalance            0.05;
+    maxLoadUnbalance            0.2;
 
     alignmentSearchSpokes       36;
 
@@ -202,18 +185,9 @@ motionControl
 
 polyMeshFiltering
 {
-    writeTetDualMesh                        false;
-    filterSizeCoeff                         0.2;
-    mergeClosenessCoeff                     1e-9;
-    continueFilteringOnBadInitialPolyMesh   true;
-    filterErrorReductionCoeff               0.5;
-    filterCountSkipThreshold                4;
-    maxCollapseIterations                   25;
-    maxConsecutiveEqualFaceSets             5;
-    surfaceStepFaceAngle                    90;
-    edgeCollapseGuardFraction               0.0;    //0.3;
-    maxCollapseFaceToPointSideLengthCoeff   0.35;
-    edgeMergeAngle                          30;
+    filterEdges                 on;
+    filterFaces                 off;
+    writeTetDualMesh            false;
 }
 
 
@@ -222,4 +196,5 @@ meshQualityControls
     #include "meshQualityDict"
 }
 
+
 // ************************************************************************* //
diff --git a/tutorials/mesh/cvMesh/flange/system/decomposeParDict b/tutorials/mesh/cvMesh/flange/system/decomposeParDict
index f54d913bac..afb5d8a226 100644
--- a/tutorials/mesh/cvMesh/flange/system/decomposeParDict
+++ b/tutorials/mesh/cvMesh/flange/system/decomposeParDict
@@ -15,14 +15,14 @@ FoamFile
 }
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-numberOfSubdomains 4;
+numberOfSubdomains 8;
 
-method          scotch;
-//method          hierarchical;
+//method          scotch;
+method          hierarchical;
 
 simpleCoeffs
 {
-    n               ( 2 2 1 );
+    n               ( 2 2 2 );
     delta           0.001;
 }
 
diff --git a/tutorials/mesh/cvMesh/flange/system/fvSchemes b/tutorials/mesh/cvMesh/flange/system/fvSchemes
index 2e5c55b28b..046181f357 100644
--- a/tutorials/mesh/cvMesh/flange/system/fvSchemes
+++ b/tutorials/mesh/cvMesh/flange/system/fvSchemes
@@ -22,7 +22,7 @@ ddtSchemes
 
 gradSchemes
 {
-    default         none;
+    default         Gauss linear;
 }
 
 divSchemes
@@ -33,6 +33,7 @@ divSchemes
 laplacianSchemes
 {
     default         none;
+    laplacian(nn)   Gauss linear corrected;
 }
 
 interpolationSchemes
@@ -42,7 +43,7 @@ interpolationSchemes
 
 snGradSchemes
 {
-    default         none;
+    default         corrected;
 }
 
 fluxRequired
diff --git a/tutorials/mesh/cvMesh/flange/system/fvSolution b/tutorials/mesh/cvMesh/flange/system/fvSolution
index 740eb61a4b..6368c12298 100644
--- a/tutorials/mesh/cvMesh/flange/system/fvSolution
+++ b/tutorials/mesh/cvMesh/flange/system/fvSolution
@@ -17,6 +17,13 @@ FoamFile
 
 solvers
 {
+    nn
+    {
+        solver          PCG;
+        preconditioner  DIC;
+        tolerance       1e-06;
+        relTol          0;
+    }
 }
 
 // ************************************************************************* //
diff --git a/tutorials/mesh/cvMesh/flange/system/meshQualityDict b/tutorials/mesh/cvMesh/flange/system/meshQualityDict
index 1b83e2bd87..4a182cc0b5 100644
--- a/tutorials/mesh/cvMesh/flange/system/meshQualityDict
+++ b/tutorials/mesh/cvMesh/flange/system/meshQualityDict
@@ -23,7 +23,7 @@ FoamFile
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 //- Maximum non-orthogonality allowed. Set to 180 to disable.
-maxNonOrtho         65;
+maxNonOrtho         45;
 
 //- Max skewness allowed. Set to <0 to disable.
 maxBoundarySkewness 50;
diff --git a/tutorials/mesh/cvMesh/flange/system/surfaceFeatureExtractDict b/tutorials/mesh/cvMesh/flange/system/surfaceFeatureExtractDict
index ca6dfb9e7c..520df11958 100644
--- a/tutorials/mesh/cvMesh/flange/system/surfaceFeatureExtractDict
+++ b/tutorials/mesh/cvMesh/flange/system/surfaceFeatureExtractDict
@@ -24,7 +24,7 @@ flange.obj
         // than includedAngle as features
         // - 0  : selects no edges
         // - 180: selects all edges
-        includedAngle   155;
+        includedAngle   100;
     }
 
 
diff --git a/tutorials/mesh/cvMesh/simpleShapes/Allrun b/tutorials/mesh/cvMesh/simpleShapes/Allrun
index 4c2ecc9473..90634c33c1 100755
--- a/tutorials/mesh/cvMesh/simpleShapes/Allrun
+++ b/tutorials/mesh/cvMesh/simpleShapes/Allrun
@@ -30,12 +30,8 @@ runApplication surfaceOrient \
     constant/triSurface/domain_clean_orient.stl
 mv log.surfaceOrient log.surfaceOrient.domain
 
-runApplication surfaceFeatureExtract
-mv log.surfaceFeatureExtract log.surfaceFeatureExtract.coneAndSphere_clean
-
 unset FOAM_SIGFPE
 runApplication surfaceFeatureExtract
-mv log.surfaceFeatureExtract log.surfaceFeatureExtract.domain
 
 # Generate aligned points (in constant/internalDelaunayVertices) and a
 # mesh from that.
diff --git a/tutorials/mesh/cvMesh/simpleShapes/constant/triSurface/domain.stl b/tutorials/mesh/cvMesh/simpleShapes/constant/triSurface/domain.stl
index b51c052914..5650ed2001 100644
--- a/tutorials/mesh/cvMesh/simpleShapes/constant/triSurface/domain.stl
+++ b/tutorials/mesh/cvMesh/simpleShapes/constant/triSurface/domain.stl
@@ -83,4 +83,4 @@ solid ascii
    vertex 1.3 -0.9 1
   endloop
  endfacet
-end solid
+endsolid
diff --git a/tutorials/mesh/cvMesh/simpleShapes/system/collapseDict b/tutorials/mesh/cvMesh/simpleShapes/system/collapseDict
new file mode 100644
index 0000000000..9034677ca9
--- /dev/null
+++ b/tutorials/mesh/cvMesh/simpleShapes/system/collapseDict
@@ -0,0 +1,52 @@
+/*--------------------------------*- 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;
+
+    root            "";
+    case            "";
+    instance        "";
+    local           "";
+
+    class           dictionary;
+    object          collapseDict;
+}
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+collapseEdgesCoeffs
+{
+    minimumEdgeLength   1e-6;
+    maximumMergeAngle   180;
+    reductionFactor     0.5;
+}
+
+collapseFacesCoeffs
+{
+    initialFaceLengthFactor                 0.5;
+    reductionFactor                         0.5;
+
+    allowEarlyCollapseToPoint               on;
+    allowEarlyCollapseCoeff                 0.2;
+    guardFraction                           0.1;
+    maxCollapseFaceToPointSideLengthCoeff   0.3;
+}
+
+meshQualityCoeffs
+{
+    #include                    "meshQualityDict";
+    maximumIterations           30;
+    maximumSmoothingIterations  1;
+    maxPointErrorCount          5;
+}
+
+
+// ************************************************************************* //
diff --git a/tutorials/mesh/cvMesh/simpleShapes/system/controlDict b/tutorials/mesh/cvMesh/simpleShapes/system/controlDict
index 05271d052b..8bbced6c67 100644
--- a/tutorials/mesh/cvMesh/simpleShapes/system/controlDict
+++ b/tutorials/mesh/cvMesh/simpleShapes/system/controlDict
@@ -34,7 +34,7 @@ deltaT          1;
 
 writeControl    timeStep;
 
-writeInterval   1000;   //10 to see the meshing steps
+writeInterval   80;   // 10 to see the meshing steps
 
 purgeWrite      0;
 
diff --git a/tutorials/mesh/cvMesh/simpleShapes/system/cvMeshDict b/tutorials/mesh/cvMesh/simpleShapes/system/cvMeshDict
index 26952c55ce..99379e62c9 100644
--- a/tutorials/mesh/cvMesh/simpleShapes/system/cvMeshDict
+++ b/tutorials/mesh/cvMesh/simpleShapes/system/cvMeshDict
@@ -96,12 +96,12 @@ surfaceConformation
     // Distance to a feature point within which surface and edge
     // conformation points are excluded - fraction of the local target
     // cell size
-    featurePointExclusionDistanceCoeff  0.4;
+    featurePointExclusionDistanceCoeff  0.6;
 
     // Distance to an existing feature edge conformation location
     // within which other edge conformation location are excluded -
     // fraction of the local target cell size
-    featureEdgeExclusionDistanceCoeff   0.2;
+    featureEdgeExclusionDistanceCoeff   0.6;
 
     // Optimisation: do not check for surface intersection (of dual edges)
     // for points near to surface.
@@ -120,35 +120,27 @@ surfaceConformation
     // Frequency to redo surface conformation (expensive).
     surfaceConformationRebuildFrequency 10;
 
+    // Specialised feature point handling
+    specialiseFeaturePoints on;
+
     // Initial and intermediate controls
     conformationControls
     {
-        // Initial conformation
-        initial
-        {
-            // We've got a point poking through the surface. Don't do any
-            // surface conformation if near feature edge (since feature edge
-            // conformation should have priority)
+        // We've got a point poking through the surface. Don't do any
+        // surface conformation if near feature edge (since feature edge
+        // conformation should have priority)
 
-            // distance to search for near feature edges
-            edgeSearchDistCoeff         1.1;
+        // distance to search for near feature edges
+        edgeSearchDistCoeff         2;
 
-            // Proximity to a feature edge where a surface hit is
-            //  not created, only the edge conformation is created
-            // - fraction of the local target cell size. Coarse
-            // conformation, initial protrusion tests.
-            surfacePtReplaceDistCoeff   0.5;
+        // Proximity to a feature edge where a surface hit is
+        //  not created, only the edge conformation is created
+        // - fraction of the local target cell size. Coarse
+        // conformation, initial protrusion tests.
+        surfacePtReplaceDistCoeff   0.5;
 
 
-            surfacePtExclusionDistanceCoeff 0.5;
-        }
-
-        // Same for iterations
-        iteration
-        {
-            edgeSearchDistCoeff         1.25;
-            surfacePtReplaceDistCoeff   0.7;
-        }
+        surfacePtExclusionDistanceCoeff 0.5;
 
         // Stop either at maxIterations or if the number of surface pokes
         // is very small (iterationToInitialHitRatioLimit * initial number)
@@ -159,16 +151,6 @@ surfaceConformation
         iterationToInitialHitRatioLimit 0.001;
     }
 
-    coarseConformationControls
-    {
-        $conformationControls;
-    }
-
-    fineConformationControls
-    {
-        $conformationControls;
-    }
-
     // Geometry to mesh to
     geometryToConformTo
     {
@@ -257,11 +239,47 @@ motionControl
     // Absolute cell size of back ground mesh. This is the maximum cell size.
     defaultCellSize     0.1;
 
-    // Assign a priority to all requests for cell sizes, the highest overrules.
-    defaultPriority     0;
-
-    cellSizeControlGeometry
+    shapeControlFunctions
     {
+        coneAndSphere
+        {
+            type                searchableSurfaceControl;
+            priority            1;
+            mode                bothSides;
+
+            surfaceCellSizeFunction uniformValue;
+            uniformValueCoeffs
+            {
+                surfaceCellSize 0.075;
+            }
+
+            cellSizeFunction        uniform;
+            uniformCoeffs
+            {}
+        }
+
+        domain
+        {
+            type                searchableSurfaceControl;
+            priority            1;
+            mode                bothSides;
+
+            surfaceCellSizeFunction uniformValue;
+            uniformValueCoeffs
+            {
+                surfaceCellSize $defaultCellSize;
+            }
+
+            cellSizeFunction        uniform;
+            uniformCoeffs
+            {}
+        }
+    }
+
+    cellAspectRatioControl
+    {
+        aspectRatio                 1.0;
+        aspectRatioDirection        (0 0 0);
     }
 
     // Underrelaxation for point motion. Simulated annealing: starts off at 1
@@ -280,7 +298,7 @@ motionControl
     objOutput                   no;
 
     // Timing and memory usage.
-    timeChecks                  yes;
+    timeChecks                  no;
 
     // Number of rays in plane parallel to nearest surface. Used to detect
     // next closest surfaces. Used to work out alignment (three vectors)
@@ -341,101 +359,13 @@ motionControl
 // Do not change. See cvControls.H
 polyMeshFiltering
 {
-    // Upper limit on the size of faces to be filtered.
-    // fraction of the local target cell size
-    filterSizeCoeff                         0.2;
-
-    // Upper limit on how close two dual vertices can be before
-    // being merged, fraction of the local target cell size
-    mergeClosenessCoeff                     1e-9;
-
-    // To not filter: set maxNonOrtho to 1 (so check fails) and then
-    // set continueFilteringOnBadInitialPolyMesh to false.
-    continueFilteringOnBadInitialPolyMesh   true;
-
-    // When a face is "bad", what fraction should the filterSizeCoeff be
-    // reduced by.  Recursive, so for a filterCount value of fC, the
-    // filterSizeCoeff is reduced by pow(filterErrorReductionCoeff, fC)
-    filterErrorReductionCoeff               0.5;
-
-    // Maximum number of filterCount applications before a face
-    // is not attempted to be filtered
-    filterCountSkipThreshold                4;
-
-    // Maximum number of permissible iterations of the face collapse
-    // algorithm.  The value to choose will be related the maximum number
-    // of points on a face that is to be collapsed and how many faces
-    // around it need to be collapsed.
-    maxCollapseIterations                   25;
-
-    // Maximum number of times an to allow an equal faceSet to be
-    // returned from the face quality assessment before stopping iterations
-    // to break an infinitie loop.
-    maxConsecutiveEqualFaceSets             5;
-    // Remove little steps (almost perp to surface) by collapsing face.
-    surfaceStepFaceAngle                    80;
-    // Do not collapse face to edge if should become edges
-    edgeCollapseGuardFraction               0.3;
-    // Only collapse face to point if high aspect ratio
-    maxCollapseFaceToPointSideLengthCoeff   0.35;
-
-    // Write the tet-dual mesh for post-processing
-    writeTetDualMesh                        yes;
+    filterEdges                 on;
+    filterFaces                 on;
+    writeTetDualMesh            false;
 }
 
 
-// Generic mesh quality settings. At any undoable phase these determine
-// where to undo. Same as in snappyHexMeshDict
-meshQualityControls
-{
-    //- Maximum non-orthogonality allowed. Set to 180 to disable.
-    maxNonOrtho 65;
-
-    //- Max skewness allowed. Set to <0 to disable.
-    maxBoundarySkewness 50;
-    maxInternalSkewness 10;
-
-    //- Max concaveness allowed. Is angle (in degrees) below which concavity
-    //  is allowed. 0 is straight face, <0 would be convex face.
-    //  Set to 180 to disable.
-    maxConcave 80;
-
-    //- Minimum pyramid volume. Is absolute volume of cell pyramid.
-    //  Set to a sensible fraction of the smallest cell volume expected.
-    //  Set to very negative number (e.g. -1E30) to disable.
-    minVol -1E30;
-
-    //- Minimum quality of the tet formed by the
-    //  variable base point minimum decomposition triangles and
-    //  the cell centre (so not face-centre decomposition).
-    //  This has to be a positive number for tracking
-    //  to work. Set to very negative number (e.g. -1E30) to
-    //  disable.
-    //     <0 = inside out tet,
-    //      0 = flat tet
-    //      1 = regular tet
-    minTetQuality 1e-30;
-
-    //- Minimum absolute face area. Set to <0 to disable.
-    minArea -1;
-
-    //- Minimum face twist. Set to <-1 to disable. dot product of face normal
-    //- and face centre triangles normal
-    minTwist 0.001;
-
-    //- minimum normalised cell determinant
-    //- 1 = hex, <= 0 = folded or flattened illegal cell
-    minDeterminant 0.001;
-
-    //- minFaceWeight (0 -> 0.5)
-    minFaceWeight 0.02;
-
-    //- minVolRatio (0 -> 1)
-    minVolRatio 0.01;
-
-    //must be >0 for Fluent compatibility
-    minTriangleTwist -1;
-}
+#include "meshQualityDict";
 
 
 // ************************************************************************* //
diff --git a/tutorials/mesh/cvMesh/simpleShapes/system/meshQualityDict b/tutorials/mesh/cvMesh/simpleShapes/system/meshQualityDict
new file mode 100644
index 0000000000..1b83e2bd87
--- /dev/null
+++ b/tutorials/mesh/cvMesh/simpleShapes/system/meshQualityDict
@@ -0,0 +1,73 @@
+/*--------------------------------*- 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;
+
+    root            "";
+    case            "";
+    instance        "";
+    local           "";
+
+    class           dictionary;
+    object          meshQualityDict;
+}
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+//- Maximum non-orthogonality allowed. Set to 180 to disable.
+maxNonOrtho         65;
+
+//- Max skewness allowed. Set to <0 to disable.
+maxBoundarySkewness 50;
+maxInternalSkewness 10;
+
+//- Max concaveness allowed. Is angle (in degrees) below which concavity
+//  is allowed. 0 is straight face, <0 would be convex face.
+//  Set to 180 to disable.
+maxConcave          80;
+
+//- Minimum quality of the tet formed by the face-centre
+//  and variable base point minimum decomposition triangles and
+//  the cell centre. This has to be a positive number for tracking
+//  to work. Set to very negative number (e.g. -1E30) to
+//  disable.
+//     <0 = inside out tet,
+//      0 = flat tet
+//      1 = regular tet
+minTetQuality       1e-30;
+
+//- Minimum pyramid volume. Is absolute volume of cell pyramid.
+//  Set to a sensible fraction of the smallest cell volume expected.
+//  Set to very negative number (e.g. -1E30) to disable.
+minVol              0;
+
+//- Minimum face area. Set to <0 to disable.
+minArea             -1;
+
+//- Minimum face twist. Set to <-1 to disable. dot product of face normal
+//- and face centre triangles normal
+minTwist            0.001;
+
+//- minimum normalised cell determinant
+//- 1 = hex, <= 0 = folded or flattened illegal cell
+minDeterminant      0.001;
+
+//- minFaceWeight (0 -> 0.5)
+minFaceWeight       0.02;
+
+//- minVolRatio (0 -> 1)
+minVolRatio         0.01;
+
+//must be >0 for Fluent compatibility
+minTriangleTwist    -1;
+
+
+// ************************************************************************* //
diff --git a/wmake/rules/General/CGAL b/wmake/rules/General/CGAL
index cfb02d716a..167a420ab6 100644
--- a/wmake/rules/General/CGAL
+++ b/wmake/rules/General/CGAL
@@ -7,4 +7,5 @@ CGAL_INC = \
 
 CGAL_LIBS = \
     -L$(MPFR_ARCH_PATH)/lib \
+    -L$(GMP_ARCH_PATH)/lib \
     -L$(BOOST_ARCH_PATH)/lib