From 063936cfe00692d1a3c425f83992d8427a85b46b Mon Sep 17 00:00:00 2001
From: andy <a.heather@opencfd.co.uk>
Date: Wed, 22 Oct 2008 16:13:37 +0100
Subject: [PATCH 01/16] bugfix: multiple edge gradings per block

---
 .../mesh/generation/blockMesh/blockPoints.C   | 228 +++++++-----------
 1 file changed, 86 insertions(+), 142 deletions(-)

diff --git a/applications/utilities/mesh/generation/blockMesh/blockPoints.C b/applications/utilities/mesh/generation/blockMesh/blockPoints.C
index 0cb024215d..2fecb21bf5 100644
--- a/applications/utilities/mesh/generation/blockMesh/blockPoints.C
+++ b/applications/utilities/mesh/generation/blockMesh/blockPoints.C
@@ -41,23 +41,23 @@ namespace Foam
 void block::blockPoints()
 {
     // set local variables for mesh specification
-    label ni = blockDef_.n().x();
-    label nj = blockDef_.n().y();
-    label nk = blockDef_.n().z();
+    const label ni = blockDef_.n().x();
+    const label nj = blockDef_.n().y();
+    const label nk = blockDef_.n().z();
 
-    point start = blockDef_.points()[blockDef_.blockShape()[0]];
-    point xEnd = blockDef_.points()[blockDef_.blockShape()[1]];
-    point xyEnd = blockDef_.points()[blockDef_.blockShape()[2]];
-    point yEnd = blockDef_.points()[blockDef_.blockShape()[3]];
+    const point p000 = blockDef_.points()[blockDef_.blockShape()[0]];
+    const point p100 = blockDef_.points()[blockDef_.blockShape()[1]];
+    const point p110 = blockDef_.points()[blockDef_.blockShape()[2]];
+    const point p010 = blockDef_.points()[blockDef_.blockShape()[3]];
 
-    point zEnd = blockDef_.points()[blockDef_.blockShape()[4]];
-    point xzEnd = blockDef_.points()[blockDef_.blockShape()[5]];
-    point xyzEnd = blockDef_.points()[blockDef_.blockShape()[6]];
-    point yzEnd = blockDef_.points()[blockDef_.blockShape()[7]];
+    const point p001 = blockDef_.points()[blockDef_.blockShape()[4]];
+    const point p101 = blockDef_.points()[blockDef_.blockShape()[5]];
+    const point p111 = blockDef_.points()[blockDef_.blockShape()[6]];
+    const point p011 = blockDef_.points()[blockDef_.blockShape()[7]];
 
-    // set reference to the list of edge point and weighting factors
-    const List<List<point> >& edgePoints = blockDef_.blockEdgePoints();
-    const scalarListList& edgeWeights = blockDef_.blockEdgeWeights();
+    // list of edge point and weighting factors
+    const List<List<point> >& p = blockDef_.blockEdgePoints();
+    const scalarListList& w = blockDef_.blockEdgeWeights();
 
     // generate vertices
 
@@ -69,193 +69,138 @@ void block::blockPoints()
             {
                 label vertexNo = vtxLabel(i, j, k);
 
-                vector edgex1 = start*(1.0 - edgeWeights[0][i])
-                      + xEnd*edgeWeights[0][i];
+                // points on edges
+                vector edgex1 = p000 + (p100 - p000)*w[0][i];
+                vector edgex2 = p010 + (p110 - p010)*w[1][i];
+                vector edgex3 = p011 + (p111 - p011)*w[2][i];
+                vector edgex4 = p001 + (p101 - p001)*w[3][i];
 
-                vector edgex2 = yEnd*(1.0 - edgeWeights[1][i])
-                      + xyEnd*edgeWeights[1][i];
+                vector edgey1 = p000 + (p010 - p000)*w[4][j];
+                vector edgey2 = p100 + (p110 - p100)*w[5][j];
+                vector edgey3 = p101 + (p111 - p101)*w[6][j];
+                vector edgey4 = p001 + (p011 - p001)*w[7][j];
 
-                vector edgex3 = yzEnd*(1.0 - edgeWeights[2][i])
-                      + xyzEnd*edgeWeights[2][i];
-
-                vector edgex4 = zEnd*(1.0 - edgeWeights[3][i])
-                      + xzEnd*edgeWeights[3][i];
-
-
-
-                vector edgey1 = start*(1.0 - edgeWeights[4][j])
-                      + yEnd*edgeWeights[4][j];
-
-                vector edgey2 = xEnd*(1.0 - edgeWeights[5][j])
-                      + xyEnd*edgeWeights[5][j];
-
-                vector edgey3 = xzEnd*(1.0 - edgeWeights[6][j])
-                      + xyzEnd*edgeWeights[6][j];
-
-                vector edgey4 = zEnd*(1.0 - edgeWeights[7][j])
-                      + yzEnd*edgeWeights[7][j];
-
-
-
-                vector edgez1 = start*(1.0 - edgeWeights[8][k])
-                      + zEnd*edgeWeights[8][k];
-
-                vector edgez2 = xEnd*(1.0 - edgeWeights[9][k])
-                      + xzEnd*edgeWeights[9][k];
-
-                vector edgez3 = xyEnd*(1.0 - edgeWeights[10][k])
-                      + xyzEnd*edgeWeights[10][k];
-
-                vector edgez4 = yEnd*(1.0 - edgeWeights[11][k])
-                      + yzEnd*edgeWeights[11][k];
+                vector edgez1 = p000 + (p001 - p000)*w[8][k];
+                vector edgez2 = p100 + (p101 - p100)*w[9][k];
+                vector edgez3 = p110 + (p111 - p110)*w[10][k];
+                vector edgez4 = p010 + (p011 - p010)*w[11][k];
 
                 // calculate the importance factors for all edges
                 // x - direction
                 scalar impx1 =
                 (
-                    (1.0 - edgeWeights[0][i])
-                        *(1.0 - edgeWeights[4][j])
-                        *(1.0 - edgeWeights[8][k])
-                  + edgeWeights[0][i]
-                        *(1.0 - edgeWeights[5][j])
-                        *(1.0 - edgeWeights[9][k])
+                    (1.0 - w[0][i])*(1.0 - w[4][j])*(1.0 - w[8][k])
+                  + w[0][i]*(1.0 - w[5][j])*(1.0 - w[9][k])
                 );
 
                 scalar impx2 =
                 (
-                    (1.0 - edgeWeights[1][i])
-                        *edgeWeights[4][j]
-                        *(1.0 - edgeWeights[11][k])
-                  + edgeWeights[1][i]
-                        *edgeWeights[5][j]
-                        *(1.0 - edgeWeights[10][k])
+                    (1.0 - w[1][i])*w[4][j]*(1.0 - w[11][k])
+                  + w[1][i]*w[5][j]*(1.0 - w[10][k])
                 );
 
-               scalar impx3 =
-               (
-                   (1.0 - edgeWeights[2][i])
-                       *edgeWeights[7][j]
-                       *edgeWeights[11][k]
-                 + edgeWeights[2][i]
-                       *edgeWeights[6][j]
-                       *edgeWeights[10][k]
-               );
+                scalar impx3 =
+                (
+                     (1.0 - w[2][i])*w[7][j]*w[11][k]
+                   + w[2][i]*w[6][j]*w[10][k]
+                );
 
 
-               scalar impx4 =
-               (
-                   (1.0 - edgeWeights[3][i])
-                       *(1.0 - edgeWeights[7][j])
-                       *edgeWeights[8][k]
-                 + edgeWeights[3][i]
-                       *(1.0 - edgeWeights[6][j])
-                       *edgeWeights[9][k]
-               );
+                scalar impx4 =
+                (
+                    (1.0 - w[3][i])*(1.0 - w[7][j])*w[8][k]
+                  + w[3][i]*(1.0 - w[6][j])*w[9][k]
+                );
 
+                scalar magImpx = impx1 + impx2 + impx3 + impx4;
+                impx1 /= magImpx;
+                impx2 /= magImpx;
+                impx3 /= magImpx;
+                impx4 /= magImpx;
 
 
                 // y - direction
                 scalar impy1 =
                 (
-                    (1.0 - edgeWeights[4][j])
-                        *(1.0 - edgeWeights[0][i])
-                        *(1.0 - edgeWeights[8][k])
-                  + edgeWeights[4][j]
-                        *(1.0 - edgeWeights[1][i])
-                        *(1.0 - edgeWeights[11][k])
+                    (1.0 - w[4][j])*(1.0 - w[0][i])*(1.0 - w[8][k])
+                  + w[4][j]*(1.0 - w[1][i])*(1.0 - w[11][k])
                 );
 
                 scalar impy2 =
                 (
-                    (1.0 - edgeWeights[5][j])
-                        *edgeWeights[0][i]
-                        *(1.0 - edgeWeights[9][k])
-                  + edgeWeights[5][j]
-                        *edgeWeights[1][i]
-                        *(1.0 - edgeWeights[10][k])
+                    (1.0 - w[5][j])*w[0][i]*(1.0 - w[9][k])
+                  + w[5][j]*w[1][i]*(1.0 - w[10][k])
                 );
 
                 scalar impy3 =
                 (
-                    (1.0 - edgeWeights[6][j])
-                        *edgeWeights[3][i]
-                        *edgeWeights[9][k]
-                  + edgeWeights[6][j]
-                        *edgeWeights[2][i]
-                        *edgeWeights[10][k]
+                    (1.0 - w[6][j])*w[3][i]*w[9][k]
+                  + w[6][j]*w[2][i]*w[10][k]
                 );
 
                 scalar impy4 =
                 (
-                    (1.0 - edgeWeights[7][j])
-                        *(1.0 - edgeWeights[3][i])
-                        *edgeWeights[8][k]
-                  + edgeWeights[7][j]
-                        *(1.0 - edgeWeights[2][i])
-                        *edgeWeights[11][k]
+                    (1.0 - w[7][j])*(1.0 - w[3][i])*w[8][k]
+                  + w[7][j]*(1.0 - w[2][i])*w[11][k]
                 );
 
+                scalar magImpy = impy1 + impy2 + impy3 + impy4;
+                impy1 /= magImpy;
+                impy2 /= magImpy;
+                impy3 /= magImpy;
+                impy4 /= magImpy;
 
 
                 // z - direction
                 scalar impz1 =
                 (
-                    (1.0 - edgeWeights[8][k])
-                        *(1.0 - edgeWeights[0][i])
-                        *(1.0 - edgeWeights[4][j])
-                  + edgeWeights[8][k]
-                        *(1.0 - edgeWeights[3][i])
-                        *(1.0 - edgeWeights[7][j])
+                    (1.0 - w[8][k])*(1.0 - w[0][i])*(1.0 - w[4][j])
+                  + w[8][k]*(1.0 - w[3][i])*(1.0 - w[7][j])
                 );
 
                 scalar impz2 =
                 (
-                    (1.0 - edgeWeights[9][k])
-                        *edgeWeights[0][i]
-                        *(1.0 - edgeWeights[5][j])
-                  + edgeWeights[9][k]
-                        *edgeWeights[3][i]
-                        *(1.0 - edgeWeights[6][j])
+                    (1.0 - w[9][k])*w[0][i]*(1.0 - w[5][j])
+                  + w[9][k]*w[3][i]*(1.0 - w[6][j])
                 );
 
                 scalar impz3 =
                 (
-                    (1.0 - edgeWeights[10][k])
-                        *edgeWeights[1][i]
-                        *edgeWeights[5][j]
-                  + edgeWeights[10][k]
-                        *edgeWeights[2][i]
-                        *edgeWeights[6][j]
+                    (1.0 - w[10][k])*w[1][i]*w[5][j]
+                  + w[10][k]*w[2][i]*w[6][j]
                 );
 
                 scalar impz4 =
                 (
-                    (1.0 - edgeWeights[11][k])
-                        *(1.0 - edgeWeights[1][i])
-                        *edgeWeights[4][j]
-                  + edgeWeights[11][k]
-                        *(1.0 - edgeWeights[2][i])
-                        *edgeWeights[7][j]
+                    (1.0 - w[11][k])*(1.0 - w[1][i])*w[4][j]
+                  + w[11][k]*(1.0 - w[2][i])*w[7][j]
                 );
 
+                scalar magImpz = impz1 + impz2 + impz3 + impz4;
+                impz1 /= magImpz;
+                impz2 /= magImpz;
+                impz3 /= magImpz;
+                impz4 /= magImpz;
+
                 // calculate the correction vectors
-                vector corx1 = impx1*(edgePoints[0][i] - edgex1);
-                vector corx2 = impx2*(edgePoints[1][i] - edgex2);
-                vector corx3 = impx3*(edgePoints[2][i] - edgex3);
-                vector corx4 = impx4*(edgePoints[3][i] - edgex4);
+                vector corx1 = impx1*(p[0][i] - edgex1);
+                vector corx2 = impx2*(p[1][i] - edgex2);
+                vector corx3 = impx3*(p[2][i] - edgex3);
+                vector corx4 = impx4*(p[3][i] - edgex4);
 
-                vector cory1 = impy1*(edgePoints[4][j] - edgey1);
-                vector cory2 = impy2*(edgePoints[5][j] - edgey2);
-                vector cory3 = impy3*(edgePoints[6][j] - edgey3);
-                vector cory4 = impy4*(edgePoints[7][j] - edgey4);
+                vector cory1 = impy1*(p[4][j] - edgey1);
+                vector cory2 = impy2*(p[5][j] - edgey2);
+                vector cory3 = impy3*(p[6][j] - edgey3);
+                vector cory4 = impy4*(p[7][j] - edgey4);
 
-                vector corz1 = impz1*(edgePoints[8][k] - edgez1);
-                vector corz2 = impz2*(edgePoints[9][k] - edgez2);
-                vector corz3 = impz3*(edgePoints[10][k] - edgez3);
-                vector corz4 = impz4*(edgePoints[11][k] - edgez4);
+                vector corz1 = impz1*(p[8][k] - edgez1);
+                vector corz2 = impz2*(p[9][k] - edgez2);
+                vector corz3 = impz3*(p[10][k] - edgez3);
+                vector corz4 = impz4*(p[11][k] - edgez4);
 
 
                 // multiply by the importance factor
+
                 // x - direction
                 edgex1 *= impx1;
                 edgex2 *= impx2;
@@ -285,7 +230,6 @@ void block::blockPoints()
                 vertices_[vertexNo] += corx1 + corx2 + corx3 + corx4;
                 vertices_[vertexNo] += cory1 + cory2 + cory3 + cory4;
                 vertices_[vertexNo] += corz1 + corz2 + corz3 + corz4;
-
             }
         }
     }

From 9ea84ab62e58a97f674be76d87932c2d995c3001 Mon Sep 17 00:00:00 2001
From: andy <a.heather@opencfd.co.uk>
Date: Thu, 23 Oct 2008 16:59:27 +0100
Subject: [PATCH 02/16] added error msg when sampling patch is not found

---
 .../directMappedFixedValueFvPatchField.C               | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/src/finiteVolume/fields/fvPatchFields/derived/directMappedFixedValue/directMappedFixedValueFvPatchField.C b/src/finiteVolume/fields/fvPatchFields/derived/directMappedFixedValue/directMappedFixedValueFvPatchField.C
index 279e72a0c5..ab3af1717e 100644
--- a/src/finiteVolume/fields/fvPatchFields/derived/directMappedFixedValue/directMappedFixedValueFvPatchField.C
+++ b/src/finiteVolume/fields/fvPatchFields/derived/directMappedFixedValue/directMappedFixedValueFvPatchField.C
@@ -234,6 +234,16 @@ void directMappedFixedValueFvPatchField<Type>::updateCoeffs()
                  (
                     mpp.samplePatch()
                  );
+            if (patchID < 0)
+            {
+                FatalErrorIn
+                (
+                    "void directMappedFixedValueFvPatchField<Type>::"
+                    "updateCoeffs()"
+                )<< "Unable to find sample patch " << mpp.samplePatch()
+                 << " for patch " << this->patch().name() << nl
+                 << abort(FatalError);
+            }
             typedef GeometricField<Type, fvPatchField, volMesh> fieldType;
             const word& fieldName = this->dimensionedInternalField().name();
             const fieldType& sendField =

From 1fb786eb6af47737f0ab2bbee5670f3acfcf7bd1 Mon Sep 17 00:00:00 2001
From: mattijs <mattijs@hunt.opencfd.co.uk>
Date: Thu, 30 Oct 2008 15:40:31 +0000
Subject: [PATCH 03/16] removed transfer; delegate to List instead

---
 src/OpenFOAM/fields/Fields/Field/Field.C | 14 --------------
 src/OpenFOAM/fields/Fields/Field/Field.H |  6 ------
 2 files changed, 20 deletions(-)

diff --git a/src/OpenFOAM/fields/Fields/Field/Field.C b/src/OpenFOAM/fields/Fields/Field/Field.C
index 994f8ee630..c906bcbf55 100644
--- a/src/OpenFOAM/fields/Fields/Field/Field.C
+++ b/src/OpenFOAM/fields/Fields/Field/Field.C
@@ -575,20 +575,6 @@ void Field<Type>::replace
 }
 
 
-template<class Type>
-void Field<Type>::transfer(Field<Type>& f)
-{
-    List<Type>::transfer(f);
-}
-
-
-template<class Type>
-void Field<Type>::transfer(List<Type>& lst)
-{
-    List<Type>::transfer(lst);
-}
-
-
 template<class Type>
 tmp<Field<Type> > Field<Type>::T() const
 {
diff --git a/src/OpenFOAM/fields/Fields/Field/Field.H b/src/OpenFOAM/fields/Fields/Field/Field.H
index 8e168cb0ac..1b372925e3 100644
--- a/src/OpenFOAM/fields/Fields/Field/Field.H
+++ b/src/OpenFOAM/fields/Fields/Field/Field.H
@@ -297,12 +297,6 @@ public:
         //- Replace a component field of the field
         void replace(const direction, const cmptType&);
 
-        //- Transfer the contents of the argument Field into this Field
-        void transfer(Field<Type>&);
-
-        //- Transfer the contents of the argument List into this Field
-        void transfer(List<Type>&);
-
         //- Return the field transpose (only defined for second rank tensors)
         tmp<Field<Type> > T() const;
 

From ded4f0b2a4be7a2e1e7433360f637845b69587d2 Mon Sep 17 00:00:00 2001
From: andy <a.heather@opencfd.co.uk>
Date: Thu, 30 Oct 2008 18:49:14 +0000
Subject: [PATCH 04/16] added option to set reference by point

---
 .../general/findRefCell/findRefCell.C         | 59 ++++++++++++++++++-
 .../general/findRefCell/findRefCell.H         |  3 +-
 .../fvMatrices/fvMatrix/fvMatrix.C            |  2 +-
 3 files changed, 59 insertions(+), 5 deletions(-)

diff --git a/src/finiteVolume/cfdTools/general/findRefCell/findRefCell.C b/src/finiteVolume/cfdTools/general/findRefCell/findRefCell.C
index 00ce11355a..321eeba6a8 100644
--- a/src/finiteVolume/cfdTools/general/findRefCell/findRefCell.C
+++ b/src/finiteVolume/cfdTools/general/findRefCell/findRefCell.C
@@ -33,15 +33,68 @@ void Foam::setRefCell
     const volScalarField& field,
     const dictionary& dict,
     label& refCelli,
-    scalar& refValue
+    scalar& refValue,
+    bool forceReference
 )
 {
-    if (field.needReference())
+    if (field.needReference() || forceReference)
     {
         word refCellName = field.name() + "RefCell";
+        word refPointName = field.name() + "RefPoint";
+
         word refValueName = field.name() + "RefValue";
 
-        refCelli = readLabel(dict.lookup(refCellName));
+        if (dict.found(refCellName))
+        {
+            if (Pstream::master())
+            {
+                refCelli = readLabel(dict.lookup(refCellName));
+            }
+            else
+            {
+                refCelli = -1;
+            }
+        }
+        else if (dict.found(refPointName))
+        {
+            point refPointi(dict.lookup(refPointName));
+            refCelli = field.mesh().findCell(refPointi);
+            label hasRef = (refCelli >= 0 ? 1 : 0);
+            label sumHasRef = returnReduce<label>(hasRef, sumOp<label>());
+            if (sumHasRef != 1)
+            {
+                FatalErrorIn
+                (
+                    "void Foam::setRefCell"
+                     "("
+                     "    const volScalarField&,"
+                     "    const dictionary&,"
+                     "    label& scalar&,"
+                     "    bool"
+                     ")"
+                )
+                  << "Unable to set reference cell for field " << field.name()
+                  << nl << "    Reference point " << refPointName
+                  << " found on multiple domains" << nl << abort(FatalError);
+            }
+        }
+        else
+        {
+            FatalErrorIn
+            (
+                "void Foam::setRefCell"
+                 "("
+                 "    const volScalarField&,"
+                 "    const dictionary&,"
+                 "    label& scalar&,"
+                 "    bool"
+                 ")"
+            )
+              << "Unable to set reference cell for field" << field.name() << nl
+              << "    Please supply either " << refCellName
+              << " or " << refPointName << nl << abort(FatalError);
+        }
+
         refValue = readScalar(dict.lookup(refValueName));
     }
 }
diff --git a/src/finiteVolume/cfdTools/general/findRefCell/findRefCell.H b/src/finiteVolume/cfdTools/general/findRefCell/findRefCell.H
index 724f44ed17..db9858ce27 100644
--- a/src/finiteVolume/cfdTools/general/findRefCell/findRefCell.H
+++ b/src/finiteVolume/cfdTools/general/findRefCell/findRefCell.H
@@ -52,7 +52,8 @@ void setRefCell
     const volScalarField& field,
     const dictionary& dict,
     label& refCelli,
-    scalar& refValue
+    scalar& refValue,
+    bool forceReference = false
 );
 
 }
diff --git a/src/finiteVolume/fvMatrices/fvMatrix/fvMatrix.C b/src/finiteVolume/fvMatrices/fvMatrix/fvMatrix.C
index 9dab83d168..b8698eb177 100644
--- a/src/finiteVolume/fvMatrices/fvMatrix/fvMatrix.C
+++ b/src/finiteVolume/fvMatrices/fvMatrix/fvMatrix.C
@@ -483,7 +483,7 @@ void Foam::fvMatrix<Type>::setReference
 {
     if (psi_.needReference() || forceReference)
     {
-        if (Pstream::master())
+        if (cell >= 0)
         {
             source()[cell] += diag()[cell]*value;
             diag()[cell] += diag()[cell];

From 380e3192c5f5108c943a7083e7df986fb976e2b7 Mon Sep 17 00:00:00 2001
From: mattijs <mattijs@hunt.opencfd.co.uk>
Date: Fri, 31 Oct 2008 18:04:26 +0000
Subject: [PATCH 05/16] ulist argument

---
 src/OpenFOAM/containers/Lists/SortableList/SortableList.C | 2 +-
 src/OpenFOAM/containers/Lists/SortableList/SortableList.H | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/OpenFOAM/containers/Lists/SortableList/SortableList.C b/src/OpenFOAM/containers/Lists/SortableList/SortableList.C
index 7ebfa9de9e..9eaf99c801 100644
--- a/src/OpenFOAM/containers/Lists/SortableList/SortableList.C
+++ b/src/OpenFOAM/containers/Lists/SortableList/SortableList.C
@@ -32,7 +32,7 @@ License
 
 // Construct from List
 template <class Type>
-Foam::SortableList<Type>::SortableList(const List<Type>& values)
+Foam::SortableList<Type>::SortableList(const UList<Type>& values)
 :
     List<Type>(values),
     indices_(values.size())
diff --git a/src/OpenFOAM/containers/Lists/SortableList/SortableList.H b/src/OpenFOAM/containers/Lists/SortableList/SortableList.H
index 1a5272e5b7..305da6e32e 100644
--- a/src/OpenFOAM/containers/Lists/SortableList/SortableList.H
+++ b/src/OpenFOAM/containers/Lists/SortableList/SortableList.H
@@ -88,7 +88,7 @@ public:
 
         //- Construct from List, sorting the elements.
         //  Starts with indices set to index in argument
-        explicit SortableList(const List<Type>&);
+        explicit SortableList(const UList<Type>&);
 
         //- Construct from tranferred List, sorting the elements.
         //  Starts with indices set to index in argument

From 012cbab02c755c7e3f84a70fbaca3297b11adbb4 Mon Sep 17 00:00:00 2001
From: mattijs <mattijs@hunt.opencfd.co.uk>
Date: Fri, 31 Oct 2008 18:04:42 +0000
Subject: [PATCH 06/16] debug message

---
 src/OpenFOAM/meshes/primitiveMesh/primitiveMeshPointFaces.C | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/src/OpenFOAM/meshes/primitiveMesh/primitiveMeshPointFaces.C b/src/OpenFOAM/meshes/primitiveMesh/primitiveMeshPointFaces.C
index dc8d865f59..b7a90375b7 100644
--- a/src/OpenFOAM/meshes/primitiveMesh/primitiveMeshPointFaces.C
+++ b/src/OpenFOAM/meshes/primitiveMesh/primitiveMeshPointFaces.C
@@ -38,6 +38,11 @@ const labelListList& primitiveMesh::pointFaces() const
 {
     if (!pfPtr_)
     {
+        if (debug)
+        {
+            Pout<< "primitiveMesh::pointFaces() : "
+                << "calculating pointFaces" << endl;
+        }
         // Invert faces()
         pfPtr_ = new labelListList(nPoints());
         invertManyToMany(nPoints(), faces(), *pfPtr_);

From 99500b1fa83ae74a11bfc4ffe9ca6114331e150b Mon Sep 17 00:00:00 2001
From: mattijs <mattijs@hunt.opencfd.co.uk>
Date: Tue, 4 Nov 2008 14:47:36 +0000
Subject: [PATCH 07/16] updated for new functionality

---
 applications/utilities/surface/surfaceSubset/surfaceSubsetDict | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/applications/utilities/surface/surfaceSubset/surfaceSubsetDict b/applications/utilities/surface/surfaceSubset/surfaceSubsetDict
index 70879af6f4..83f5399b44 100644
--- a/applications/utilities/surface/surfaceSubset/surfaceSubsetDict
+++ b/applications/utilities/surface/surfaceSubset/surfaceSubsetDict
@@ -42,4 +42,7 @@ surface
 // Extend selection with edge neighbours
 addFaceNeighbours no;
 
+// Invert selection
+invertSelection false;
+
 // ************************************************************************* //

From 593db180ce82395fcd4a088802fc7c32004a1a59 Mon Sep 17 00:00:00 2001
From: mattijs <mattijs@hunt.opencfd.co.uk>
Date: Tue, 4 Nov 2008 14:47:48 +0000
Subject: [PATCH 08/16] added verbosity option

---
 .../surface/surfaceCheck/surfaceCheck.C       | 34 +++++++++++--------
 1 file changed, 19 insertions(+), 15 deletions(-)

diff --git a/applications/utilities/surface/surfaceCheck/surfaceCheck.C b/applications/utilities/surface/surfaceCheck/surfaceCheck.C
index 3506b05de7..2cd26f757e 100644
--- a/applications/utilities/surface/surfaceCheck/surfaceCheck.C
+++ b/applications/utilities/surface/surfaceCheck/surfaceCheck.C
@@ -36,7 +36,7 @@ License
 using namespace Foam;
 
 // Does face use valid vertices?
-bool validTri(const triSurface& surf, const label faceI)
+bool validTri(const bool verbose, const triSurface& surf, const label faceI)
 {
     // Simple check on indices ok.
 
@@ -49,20 +49,21 @@ bool validTri(const triSurface& surf, const label faceI)
      || (f[2] < 0) || (f[2] >= surf.points().size())
     )
     {
-        //WarningIn("validTri(const triSurface&, const label)")
-        //    << "triangle " << faceI << " vertices " << f
-        //    << " uses point indices outside point range 0.."
-        //    << surf.points().size()-1 << endl;
+        WarningIn("validTri(const triSurface&, const label)")
+            << "triangle " << faceI << " vertices " << f
+            << " uses point indices outside point range 0.."
+            << surf.points().size()-1 << endl;
 
         return false;
     }
 
     if ((f[0] == f[1]) || (f[0] == f[2]) || (f[1] == f[2]))
     {
-        //WarningIn("validTri(const triSurface&, const label)")
-        //    << "triangle " << faceI
-        //    << " uses non-unique vertices " << f
-        //    << endl;
+        WarningIn("validTri(const triSurface&, const label)")
+            << "triangle " << faceI
+            << " uses non-unique vertices " << f
+            << " coords:" << f.points(surf.points())
+            << endl;
         return false;
     }
 
@@ -91,11 +92,12 @@ bool validTri(const triSurface& surf, const label faceI)
          && ((f[2] == nbrF[0]) || (f[2] == nbrF[1]) || (f[2] == nbrF[2]))
         )
         {
-            //WarningIn("validTri(const triSurface&, const label)")
-            //    << "triangle " << faceI << " vertices " << f
-            //    << " has the same vertices as triangle " << nbrFaceI
-            //    << " vertices " << nbrF
-            //    << endl;
+            WarningIn("validTri(const triSurface&, const label)")
+                << "triangle " << faceI << " vertices " << f
+                << " has the same vertices as triangle " << nbrFaceI
+                << " vertices " << nbrF
+                << " coords:" << f.points(surf.points())
+                << endl;
 
             return false;
         }
@@ -170,9 +172,11 @@ int main(int argc, char *argv[])
     argList::validArgs.clear();
     argList::validArgs.append("surface file");
     argList::validOptions.insert("noSelfIntersection", "");
+    argList::validOptions.insert("verbose", "");
     argList args(argc, argv);
 
     bool checkSelfIntersection = !args.options().found("noSelfIntersection");
+    bool verbose = args.options().found("verbose");
 
     fileName surfFileName(args.additionalArgs()[0]);
     Pout<< "Reading surface from " << surfFileName << " ..." << nl << endl;
@@ -232,7 +236,7 @@ int main(int argc, char *argv[])
 
         forAll(surf, faceI)
         {
-            if (!validTri(surf, faceI))
+            if (!validTri(verbose, surf, faceI))
             {
                 illegalFaces.append(faceI);
             }

From c8d4ea0e43358b8c27e2fdb9cdd88d02abe22893 Mon Sep 17 00:00:00 2001
From: mattijs <mattijs@hunt.opencfd.co.uk>
Date: Wed, 5 Nov 2008 13:48:52 +0000
Subject: [PATCH 09/16] isosurfaces

---
 src/sampling/Make/files                       |    1 +
 .../distanceSurface/distanceSurface.C         |  317 +++
 .../distanceSurface/distanceSurface.H         |  234 ++
 .../distanceSurfaceTemplates.C                |   83 +
 .../sampledSurface/isoSurface/isoSurface.C    | 1994 +++++++++++++++--
 .../sampledSurface/isoSurface/isoSurface.H    |  252 ++-
 .../isoSurface/isoSurfaceTemplates.C          |  292 ---
 .../isoSurface/sampledIsoSurface.C            |   72 +-
 .../isoSurface/sampledIsoSurface.H            |   10 +-
 9 files changed, 2667 insertions(+), 588 deletions(-)
 create mode 100644 src/sampling/sampledSurface/distanceSurface/distanceSurface.C
 create mode 100644 src/sampling/sampledSurface/distanceSurface/distanceSurface.H
 create mode 100644 src/sampling/sampledSurface/distanceSurface/distanceSurfaceTemplates.C
 delete mode 100644 src/sampling/sampledSurface/isoSurface/isoSurfaceTemplates.C

diff --git a/src/sampling/Make/files b/src/sampling/Make/files
index f17e7222bd..bbc77a3dde 100644
--- a/src/sampling/Make/files
+++ b/src/sampling/Make/files
@@ -24,6 +24,7 @@ sampledSurface/patch/sampledPatch.C
 sampledSurface/plane/sampledPlane.C
 sampledSurface/isoSurface/isoSurface.C
 sampledSurface/isoSurface/sampledIsoSurface.C
+sampledSurface/distanceSurface/distanceSurface.C
 sampledSurface/sampledSurface/sampledSurface.C
 sampledSurface/sampledSurfaces/sampledSurfaces.C
 sampledSurface/sampledSurfacesFunctionObject/sampledSurfacesFunctionObject.C
diff --git a/src/sampling/sampledSurface/distanceSurface/distanceSurface.C b/src/sampling/sampledSurface/distanceSurface/distanceSurface.C
new file mode 100644
index 0000000000..66cfac6fb5
--- /dev/null
+++ b/src/sampling/sampledSurface/distanceSurface/distanceSurface.C
@@ -0,0 +1,317 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+\*---------------------------------------------------------------------------*/
+
+#include "distanceSurface.H"
+#include "dictionary.H"
+#include "volFields.H"
+#include "volPointInterpolation.H"
+#include "addToRunTimeSelectionTable.H"
+#include "fvMesh.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(distanceSurface, 0);
+    addToRunTimeSelectionTable(sampledSurface, distanceSurface, word);
+}
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+void Foam::distanceSurface::createGeometry() const
+{
+    // Clear any stored topo
+    facesPtr_.clear();
+
+    // Distance to cell centres
+    scalarField cellDistance(mesh().nCells());
+    {
+        List<pointIndexHit> nearest;
+        surfPtr_().findNearest
+        (
+            mesh().cellCentres(),
+            scalarField(mesh().nCells(), GREAT),
+            nearest
+        );
+        forAll(cellDistance, cellI)
+        {
+            cellDistance[cellI] = Foam::mag
+            (
+                nearest[cellI].hitPoint()
+              - mesh().cellCentres()[cellI]
+            );
+        }
+    }
+
+    // Distance to points
+    scalarField pointDistance(mesh().nPoints());
+    {
+        List<pointIndexHit> nearest;
+        surfPtr_().findNearest
+        (
+            mesh().points(),
+            scalarField(mesh().nPoints(), GREAT),
+            nearest
+        );
+        forAll(pointDistance, pointI)
+        {
+            pointDistance[pointI] = Foam::mag
+            (
+                nearest[pointI].hitPoint()
+              - mesh().points()[pointI]
+            );
+        }
+    }
+
+    //- Direct from cell field and point field.
+    const isoSurface iso
+    (
+        mesh(),
+        cellDistance,
+        pointDistance,
+        distance_,
+        regularise_
+    );
+
+    ////- From point field and interpolated cell.
+    //scalarField cellAvg(mesh().nCells(), scalar(0.0));
+    //labelField nPointCells(mesh().nCells(), 0);
+    //{
+    //    for (label pointI = 0; pointI < mesh().nPoints(); pointI++)
+    //    {
+    //        const labelList& pCells = mesh().pointCells(pointI);
+    //
+    //        forAll(pCells, i)
+    //        {
+    //            label cellI = pCells[i];
+    //
+    //            cellAvg[cellI] += pointDistance[pointI];
+    //            nPointCells[cellI]++;
+    //        }
+    //    }
+    //}
+    //forAll(cellAvg, cellI)
+    //{
+    //    cellAvg[cellI] /= nPointCells[cellI];
+    //}
+    //
+    //const isoSurface iso
+    //(
+    //    mesh(),
+    //    cellAvg,
+    //    pointDistance,
+    //    distance_,
+    //    regularise_
+    //);
+
+
+    const_cast<distanceSurface&>(*this).triSurface::operator=(iso);
+    meshCells_ = iso.meshCells();
+
+    if (debug)
+    {
+        print(Pout);
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::distanceSurface::distanceSurface
+(
+    const word& name,
+    const polyMesh& mesh,
+    const dictionary& dict
+)
+:
+    sampledSurface(name, mesh, dict),
+    surfPtr_
+    (
+        searchableSurface::New
+        (
+            dict.lookup("surfaceType"),
+            IOobject
+            (
+                dict.lookupOrDefault("surfaceName", name),  // name
+                mesh.time().constant(),                     // directory
+                "triSurface",                               // instance
+                mesh.time(),                                // registry
+                IOobject::MUST_READ,
+                IOobject::NO_WRITE
+            ),
+            dict
+        )
+    ),
+    distance_(readScalar(dict.lookup("distance"))),
+    regularise_(dict.lookupOrDefault("regularise", true)),
+    zoneName_(word::null),
+    facesPtr_(NULL),
+    storedTimeIndex_(-1),
+    meshCells_(0)
+{
+//    label zoneId = -1;
+//    if (dict.readIfPresent("zone", zoneName_))
+//    {
+//        zoneId = mesh.cellZones().findZoneID(zoneName_);
+//        if (debug && zoneId < 0)
+//        {
+//            Info<< "cellZone \"" << zoneName_
+//                << "\" not found - using entire mesh"
+//                << endl;
+//        }
+//    }
+    correct(true);
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::distanceSurface::~distanceSurface()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+void Foam::distanceSurface::correct(const bool meshChanged)
+{
+    // Only change of mesh changes plane - zone restriction gets lost
+    if (meshChanged)
+    {
+        createGeometry();
+    }
+}
+
+
+Foam::tmp<Foam::scalarField>
+Foam::distanceSurface::sample
+(
+    const volScalarField& vField
+) const
+{
+    return sampleField(vField);
+}
+
+
+Foam::tmp<Foam::vectorField>
+Foam::distanceSurface::sample
+(
+    const volVectorField& vField
+) const
+{
+    return sampleField(vField);
+}
+
+
+Foam::tmp<Foam::sphericalTensorField>
+Foam::distanceSurface::sample
+(
+    const volSphericalTensorField& vField
+) const
+{
+    return sampleField(vField);
+}
+
+
+Foam::tmp<Foam::symmTensorField>
+Foam::distanceSurface::sample
+(
+    const volSymmTensorField& vField
+) const
+{
+    return sampleField(vField);
+}
+
+
+Foam::tmp<Foam::tensorField>
+Foam::distanceSurface::sample
+(
+    const volTensorField& vField
+) const
+{
+    return sampleField(vField);
+}
+
+
+Foam::tmp<Foam::scalarField>
+Foam::distanceSurface::interpolate
+(
+    const interpolation<scalar>& interpolator
+) const
+{
+    return interpolateField(interpolator);
+}
+
+
+Foam::tmp<Foam::vectorField>
+Foam::distanceSurface::interpolate
+(
+    const interpolation<vector>& interpolator
+) const
+{
+    return interpolateField(interpolator);
+}
+
+Foam::tmp<Foam::sphericalTensorField>
+Foam::distanceSurface::interpolate
+(
+    const interpolation<sphericalTensor>& interpolator
+) const
+{
+    return interpolateField(interpolator);
+}
+
+
+Foam::tmp<Foam::symmTensorField>
+Foam::distanceSurface::interpolate
+(
+    const interpolation<symmTensor>& interpolator
+) const
+{
+    return interpolateField(interpolator);
+}
+
+
+Foam::tmp<Foam::tensorField>
+Foam::distanceSurface::interpolate
+(
+    const interpolation<tensor>& interpolator
+) const
+{
+    return interpolateField(interpolator);
+}
+
+
+void Foam::distanceSurface::print(Ostream& os) const
+{
+    os  << "distanceSurface: " << name() << " :"
+        << "  surface:" << surfPtr_().name()
+        << "  distance:" << distance_
+        << "  faces:" << faces().size()
+        << "  points:" << points().size();
+}
+
+
+// ************************************************************************* //
diff --git a/src/sampling/sampledSurface/distanceSurface/distanceSurface.H b/src/sampling/sampledSurface/distanceSurface/distanceSurface.H
new file mode 100644
index 0000000000..bb7290c5d8
--- /dev/null
+++ b/src/sampling/sampledSurface/distanceSurface/distanceSurface.H
@@ -0,0 +1,234 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Class
+    Foam::distanceSurface
+
+Description
+    A sampledSurface defined by a distance to a surface.
+
+SourceFiles
+    distanceSurface.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef distanceSurface_H
+#define distanceSurface_H
+
+#include "sampledSurface.H"
+#include "triSurface.H"
+#include "searchableSurface.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                       Class distanceSurface Declaration
+\*---------------------------------------------------------------------------*/
+
+class distanceSurface
+:
+    public sampledSurface,
+    public triSurface
+{
+    // Private data
+
+        //- Surface
+        const autoPtr<searchableSurface> surfPtr_;
+
+        //- distance value
+        const scalar distance_;
+
+        //- Whether to coarsen
+        const Switch regularise_;
+
+        //- zone name (if restricted to zones)
+        word zoneName_;
+
+        //- triangles converted to faceList
+        mutable autoPtr<faceList> facesPtr_;
+
+
+        // Recreated for every isoSurface
+
+            //- Time at last call
+            mutable label storedTimeIndex_;
+
+            //- For every triangle the original cell in mesh
+            mutable labelList meshCells_;
+
+
+    // Private Member Functions
+
+        //- Create iso surface (if time has changed)
+        void createGeometry() const;
+
+        //- sample field on faces
+        template <class Type>
+        tmp<Field<Type> > sampleField
+        (
+            const GeometricField<Type, fvPatchField, volMesh>& vField
+        ) const;
+
+
+        template <class Type>
+        tmp<Field<Type> >
+        interpolateField(const interpolation<Type>&) const;
+
+
+public:
+
+    //- Runtime type information
+    TypeName("distanceSurface");
+
+
+    // Constructors
+
+        //- Construct from dictionary
+        distanceSurface
+        (
+            const word& name,
+            const polyMesh& mesh,
+            const dictionary& dict
+        );
+
+
+    // Destructor
+
+        virtual ~distanceSurface();
+
+
+    // Member Functions
+
+        //- Points of surface
+        virtual const pointField& points() const
+        {
+            return triSurface::points();
+        }
+
+        //- Faces of surface
+        virtual const faceList& faces() const
+        {
+            if (!facesPtr_.valid())
+            {
+                const triSurface& s = *this;
+
+                facesPtr_.reset(new faceList(s.size()));
+
+                forAll(s, i)
+                {
+                    facesPtr_()[i] = s[i].triFaceFace();
+                }
+            }
+            return facesPtr_;
+        }
+
+
+        //- Correct for mesh movement and/or field changes
+        virtual void correct(const bool meshChanged);
+
+
+        //- sample field on surface
+        virtual tmp<scalarField> sample
+        (
+            const volScalarField&
+        ) const;
+
+        //- sample field on surface
+        virtual tmp<vectorField> sample
+        (
+            const volVectorField&
+        ) const;
+
+        //- sample field on surface
+        virtual tmp<sphericalTensorField> sample
+        (
+            const volSphericalTensorField&
+        ) const;
+
+        //- sample field on surface
+        virtual tmp<symmTensorField> sample
+        (
+            const volSymmTensorField&
+        ) const;
+
+        //- sample field on surface
+        virtual tmp<tensorField> sample
+        (
+            const volTensorField&
+        ) const;
+
+
+        //- interpolate field on surface
+        virtual tmp<scalarField> interpolate
+        (
+            const interpolation<scalar>&
+        ) const;
+
+        //- interpolate field on surface
+        virtual tmp<vectorField> interpolate
+        (
+            const interpolation<vector>&
+        ) const;
+
+        //- interpolate field on surface
+        virtual tmp<sphericalTensorField> interpolate
+        (
+            const interpolation<sphericalTensor>&
+        ) const;
+
+        //- interpolate field on surface
+        virtual tmp<symmTensorField> interpolate
+        (
+            const interpolation<symmTensor>&
+        ) const;
+
+        //- interpolate field on surface
+        virtual tmp<tensorField> interpolate
+        (
+            const interpolation<tensor>&
+        ) const;
+
+        //- Write
+        virtual void print(Ostream&) const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+#   include "distanceSurfaceTemplates.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/sampling/sampledSurface/distanceSurface/distanceSurfaceTemplates.C b/src/sampling/sampledSurface/distanceSurface/distanceSurfaceTemplates.C
new file mode 100644
index 0000000000..ce983c7f5f
--- /dev/null
+++ b/src/sampling/sampledSurface/distanceSurface/distanceSurfaceTemplates.C
@@ -0,0 +1,83 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+\*---------------------------------------------------------------------------*/
+
+#include "distanceSurface.H"
+#include "isoSurface.H"
+#include "volFieldsFwd.H"
+#include "pointFields.H"
+#include "volPointInterpolation.H"
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+template <class Type>
+Foam::tmp<Foam::Field<Type> >
+Foam::distanceSurface::sampleField
+(
+    const GeometricField<Type, fvPatchField, volMesh>& vField
+) const
+{
+    return tmp<Field<Type> >(new Field<Type>(vField, meshCells_));
+}
+
+
+template <class Type>
+Foam::tmp<Foam::Field<Type> >
+Foam::distanceSurface::interpolateField
+(
+    const interpolation<Type>& interpolator
+) const
+{
+    // One value per point
+    tmp<Field<Type> > tvalues(new Field<Type>(points().size()));
+    Field<Type>& values = tvalues();
+
+    boolList pointDone(points().size(), false);
+
+    forAll(faces(), cutFaceI)
+    {
+        const face& f = faces()[cutFaceI];
+
+        forAll(f, faceVertI)
+        {
+            label pointI = f[faceVertI];
+
+            if (!pointDone[pointI])
+            {
+                values[pointI] = interpolator.interpolate
+                (
+                    points()[pointI],
+                    meshCells_[cutFaceI]
+                );
+                pointDone[pointI] = true;
+            }
+        }
+    }
+
+    return tvalues;
+}
+
+
+// ************************************************************************* //
diff --git a/src/sampling/sampledSurface/isoSurface/isoSurface.C b/src/sampling/sampledSurface/isoSurface/isoSurface.C
index 45be2c1334..9a60ab84ad 100644
--- a/src/sampling/sampledSurface/isoSurface/isoSurface.C
+++ b/src/sampling/sampledSurface/isoSurface/isoSurface.C
@@ -24,12 +24,13 @@ License
 
 \*---------------------------------------------------------------------------*/
 
+#include "Field.H"
 #include "isoSurface.H"
 #include "dictionary.H"
 #include "polyMesh.H"
-#include "volFields.H"
 #include "mergePoints.H"
 #include "tetMatcher.H"
+#include "syncTools.H"
 
 #include "addToRunTimeSelectionTable.H"
 
@@ -42,250 +43,1831 @@ namespace Foam
 
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 
+Foam::scalar Foam::isoSurface::isoFraction
+(
+    const scalar s0,
+    const scalar s1
+) const
+{
+    scalar d = s1-s0;
+
+    if (mag(d) > VSMALL)
+    {
+        return (iso_-s0)/d;
+    }
+    else
+    {
+        return -1.0;
+    }
+}
+
+
+//Foam::List<Foam::triFace> Foam::isoSurface::triangulate(const face& f) const
+//{
+//    faceList triFaces(f.nTriangles(mesh_.points()));
+//    label triFaceI = 0;
+//    f.triangles(mesh_.points(), triFaceI, triFaces);
+//
+//    List<triFace> tris(triFaces.size());
+//    forAll(triFaces, i)
+//    {
+//        tris[i][0] = triFaces[i][0];
+//        tris[i][1] = triFaces[i][1];
+//        tris[i][2] = triFaces[i][2];
+//    }
+//    return tris;
+//}
+
+
+Foam::isoSurface::cellCutType Foam::isoSurface::calcCutType
+(
+    const PackedList<1>& isTet,
+    const scalarField& cellValues,
+    const scalarField& pointValues,
+    const label cellI
+) const
+{
+    const cell& cFaces = mesh_.cells()[cellI];
+
+    if (isTet.get(cellI) == 1)
+    {
+        forAll(cFaces, cFaceI)
+        {
+            const face& f = mesh_.faces()[cFaces[cFaceI]];
+
+            for (label fp = 1; fp < f.size() - 1; fp++)
+            {
+                triFace tri(f[0], f[fp], f[f.fcIndex(fp)]);
+
+                bool aLower = (pointValues[tri[0]] < iso_);
+                bool bLower = (pointValues[tri[1]] < iso_);
+                bool cLower = (pointValues[tri[2]] < iso_);
+
+                if (aLower == bLower && aLower == cLower)
+                {}
+                else
+                {
+                    return CUT;
+                }
+            }
+        }
+        return NOTCUT;
+    }
+    else
+    {
+        bool cellLower = (cellValues[cellI] < iso_);
+
+        // First check if there is any cut in cell
+        bool edgeCut = false;
+
+        forAll(cFaces, cFaceI)
+        {
+            const face& f = mesh_.faces()[cFaces[cFaceI]];
+
+            // Check pyramids cut
+            forAll(f, fp)
+            {
+                if ((pointValues[f[fp]] < iso_) != cellLower)
+                {
+                    edgeCut = true;
+                    break;
+                }
+            }
+
+            if (edgeCut)
+            {
+                break;
+            }
+
+            for (label fp = 1; fp < f.size() - 1; fp++)
+            {
+                triFace tri(f[0], f[fp], f[f.fcIndex(fp)]);
+            //List<triFace> tris(triangulate(f));
+            //forAll(tris, i)
+            //{
+            //    const triFace& tri = tris[i];
+
+                bool aLower = (pointValues[tri[0]] < iso_);
+                bool bLower = (pointValues[tri[1]] < iso_);
+                bool cLower = (pointValues[tri[2]] < iso_);
+
+                if (aLower == bLower && aLower == cLower)
+                {}
+                else
+                {
+                    edgeCut = true;
+                    break;
+                }
+            }
+
+            if (edgeCut)
+            {
+                break;
+            }
+        }
+
+        if (edgeCut)
+        {
+            // Count actual cuts (expensive since addressing needed)
+            // Note: not needed if you don't want to preserve maxima/minima
+            // centred around cellcentre. In that case just always return CUT
+
+            const labelList& cPoints = mesh_.cellPoints(cellI);
+
+            label nPyrCuts = 0;
+
+            forAll(cPoints, i)
+            {
+                if ((pointValues[cPoints[i]] < iso_) != cellLower)
+                {
+                    nPyrCuts++;
+                }
+            }
+
+            if (nPyrCuts == cPoints.size())
+            {
+                return SPHERE;
+            }
+            else
+            {
+                return CUT;
+            }
+        }
+        else
+        {
+            return NOTCUT;
+        }
+    }
+}
+
+
+// Return the two common points between two triangles
+Foam::labelPair Foam::isoSurface::findCommonPoints
+(
+    const labelledTri& tri0,
+    const labelledTri& tri1
+)
+{
+    labelPair common(-1, -1);
+
+    label fp0 = 0;
+    label fp1 = findIndex(tri1, tri0[fp0]);
+
+    if (fp1 == -1)
+    {
+        fp0 = 1;
+        fp1 = findIndex(tri1, tri0[fp0]);
+    }
+
+    if (fp1 != -1)
+    {
+        // So tri0[fp0] is tri1[fp1]
+
+        // Find next common point
+        label fp0p1 = tri0.fcIndex(fp0);
+        label fp1p1 = tri1.fcIndex(fp1);
+        label fp1m1 = tri1.rcIndex(fp1);
+
+        if (tri0[fp0p1] == tri1[fp1p1] || tri0[fp0p1] == tri1[fp1m1])
+        {
+            common[0] = tri0[fp0];
+            common[1] = tri0[fp0p1];
+        }
+    }
+    return common;
+}
+
+
+// Caculate centre of surface.
+Foam::point Foam::isoSurface::calcCentre(const triSurface& s)
+{
+    vector sum = vector::zero;
+
+    forAll(s, i)
+    {
+        sum += s[i].centre(s.points());
+    }
+    return sum/s.size();
+}
+
+
+// Replace surface (localPoints, localTris) with single point. Returns
+// point. Destructs arguments.
+Foam::pointIndexHit Foam::isoSurface::collapseSurface
+(
+    pointField& localPoints,
+    DynamicList<labelledTri, 64>& localTris
+)
+{
+    pointIndexHit info(false, vector::zero, localTris.size());
+
+    if (localTris.size() == 0)
+    {}
+    else if (localTris.size() == 1)
+    {
+        const labelledTri& tri = localTris[0];
+        info.setPoint(tri.centre(localPoints));
+        info.setHit();
+    }
+    else if (localTris.size() == 2)
+    {
+        // Check if the two triangles share an edge.
+        const labelledTri& tri0 = localTris[0];
+        const labelledTri& tri1 = localTris[0];
+
+        labelPair shared = findCommonPoints(tri0, tri1);
+
+        if (shared[0] != -1)
+        {
+            info.setPoint
+            (
+                0.5
+              * (
+                    tri0.centre(localPoints)
+                  + tri1.centre(localPoints)
+                )
+            );
+            info.setHit();
+        }
+    }
+    else
+    {
+        // Check if single region. Rare situation.
+        triSurface surf
+        (
+            localTris,
+            geometricSurfacePatchList(0),
+            localPoints,
+            true
+        );
+        localTris.clearStorage();
+
+        labelList faceZone;
+        label nZones = surf.markZones
+        (
+            boolList(surf.nEdges(), false),
+            faceZone
+        );
+
+        if (nZones == 1)
+        {
+            info.setPoint(calcCentre(surf));
+            info.setHit();
+        }
+    }
+
+    return info;
+}
+
+
+void Foam::isoSurface::calcSnappedCc
+(
+    const PackedList<1>& isTet,
+    const scalarField& cVals,
+    const scalarField& pVals,
+    const List<cellCutType>& cellCutType,
+
+    DynamicList<point>& snappedPoints,
+    labelList& snappedCc
+) const
+{
+    const pointField& cc = mesh_.cellCentres();
+    const pointField& pts = mesh_.points();
+
+    snappedCc.setSize(mesh_.nCells());
+    snappedCc = -1;
+
+    // Work arrays
+    DynamicList<point, 64> localPoints(64);
+    DynamicList<labelledTri, 64> localTris(64);
+    Map<label> pointToLocal(64);
+
+    forAll(mesh_.cells(), cellI)
+    {
+        if (cellCutType[cellI] == CUT && isTet.get(cellI) == 0)
+        {
+            scalar cVal = cVals[cellI];
+
+            const cell& cFaces = mesh_.cells()[cellI];
+
+            localPoints.clear();
+            localTris.clear();
+            pointToLocal.clear();
+
+            // Create points for all intersections close to cell centre
+            // (i.e. from pyramid edges)
+
+            forAll(cFaces, cFaceI)
+            {
+                const face& f = mesh_.faces()[cFaces[cFaceI]];
+
+                forAll(f, fp)
+                {
+                    label pointI = f[fp];
+
+                    scalar s = isoFraction(cVal, pVals[pointI]);
+
+                    if (s >= 0.0 && s <= 0.5)
+                    {
+                        if (pointToLocal.insert(pointI, localPoints.size()))
+                        {
+                            localPoints.append((1.0-s)*cc[cellI]+s*pts[pointI]);
+                        }
+                    }
+                }
+            }
+
+            if (localPoints.size() == 0)
+            {
+                // No near intersections
+            }
+            else if (localPoints.size() == 1)
+            {
+                // No need for any analysis.
+                snappedCc[cellI] = snappedPoints.size();
+                snappedPoints.append(localPoints[0]);
+
+                //Pout<< "cell:" << cellI
+                //    << " at " << mesh_.cellCentres()[cellI]
+                //    << " collapsing " << localPoints
+                //    << " intersections down to "
+                //    << snappedPoints[snappedCc[cellI]] << endl;
+            }
+            else if (localPoints.size() == 2)
+            {
+                //? No need for any analysis.???
+                snappedCc[cellI] = snappedPoints.size();
+                snappedPoints.append(0.5*(localPoints[0]+localPoints[1]));
+
+                //Pout<< "cell:" << cellI
+                //    << " at " << mesh_.cellCentres()[cellI]
+                //    << " collapsing " << localPoints
+                //    << " intersections down to "
+                //    << snappedPoints[snappedCc[cellI]] << endl;
+            }
+            else
+            {
+                // Need to analyse 
+                forAll(cFaces, cFaceI)
+                {
+                    const face& f = mesh_.faces()[cFaces[cFaceI]];
+
+                    // Do a tetrahedrisation. Each face to cc becomes pyr.
+                    // Each pyr gets split into tets by diagonalisation
+                    // of face.
+
+                    for (label fp = 1; fp < f.size() - 1; fp++)
+                    {
+                        triFace tri(f[0], f[fp], f[f.fcIndex(fp)]);
+                    //List<triFace> tris(triangulate(f));
+                    //forAll(tris, i)
+                    //{
+                    //    const triFace& tri = tris[i];
+
+                        // Get fractions for the three edges to cell centre
+                        FixedList<scalar, 3> s(3);
+                        s[0] = isoFraction(cVal, pVals[tri[0]]);
+                        s[1] = isoFraction(cVal, pVals[tri[1]]);
+                        s[2] = isoFraction(cVal, pVals[tri[2]]);
+
+                        if
+                        (
+                            (s[0] >= 0.0 && s[0] <= 0.5)
+                         && (s[1] >= 0.0 && s[1] <= 0.5)
+                         && (s[2] >= 0.0 && s[2] <= 0.5)
+                        )
+                        {
+                            localTris.append
+                            (
+                                labelledTri
+                                (
+                                    pointToLocal[tri[0]],
+                                    pointToLocal[tri[1]],
+                                    pointToLocal[tri[2]],
+                                    0
+                                )
+                            );
+                        }
+                    }
+                }
+
+                pointField surfPoints;
+                surfPoints.transfer(localPoints);
+                pointIndexHit info = collapseSurface(surfPoints, localTris);
+
+                if (info.hit())
+                {
+                    snappedCc[cellI] = snappedPoints.size();
+                    snappedPoints.append(info.hitPoint());
+
+                    //Pout<< "cell:" << cellI
+                    //    << " at " << mesh_.cellCentres()[cellI]
+                    //    << " collapsing " << surfPoints
+                    //    << " intersections down to "
+                    //    << snappedPoints[snappedCc[cellI]] << endl;
+                }
+            }
+        }
+    }
+}
+
+
+// Generate triangles for face connected to pointI
+void Foam::isoSurface::genPointTris
+(
+    const scalarField& cellValues,
+    const scalarField& pointValues,
+    const label pointI,
+    const face& f,
+    const label cellI,
+    DynamicList<point, 64>& localTriPoints
+) const
+{
+    const pointField& cc = mesh_.cellCentres();
+    const pointField& pts = mesh_.points();
+
+    for (label fp = 1; fp < f.size() - 1; fp++)
+    {
+        triFace tri(f[0], f[fp], f[f.fcIndex(fp)]);
+    //List<triFace> tris(triangulate(f));
+    //forAll(tris, i)
+    //{
+    //    const triFace& tri = tris[i];
+
+        label index = findIndex(tri, pointI);
+
+        if (index == -1)
+        {
+            continue;
+        }
+
+        // Tet between index..index-1, index..index+1, index..cc
+        label b = tri[tri.fcIndex(index)];
+        label c = tri[tri.rcIndex(index)];
+
+        // Get fractions for the three edges emanating from point
+        FixedList<scalar, 3> s(3);
+        s[0] = isoFraction(pointValues[pointI], pointValues[b]);
+        s[1] = isoFraction(pointValues[pointI], pointValues[c]);
+        s[2] = isoFraction(pointValues[pointI], cellValues[cellI]);
+
+        if
+        (
+            (s[0] >= 0.0 && s[0] <= 0.5)
+         && (s[1] >= 0.0 && s[1] <= 0.5)
+         && (s[2] >= 0.0 && s[2] <= 0.5)
+        )
+        {
+            localTriPoints.append((1.0-s[0])*pts[pointI] + s[0]*pts[b]);
+            localTriPoints.append((1.0-s[1])*pts[pointI] + s[1]*pts[c]);
+            localTriPoints.append((1.0-s[2])*pts[pointI] + s[2]*cc[cellI]);
+        }
+    }
+}
+
+
+// Generate triangle for tet connected to pointI
+void Foam::isoSurface::genPointTris
+(
+    const scalarField& pointValues,
+    const label pointI,
+    const label cellI,
+    DynamicList<point, 64>& localTriPoints
+) const
+{
+    const pointField& pts = mesh_.points();
+    const cell& cFaces = mesh_.cells()[cellI];
+
+    FixedList<label, 4> tet;
+
+    label face0 = cFaces[0];
+    const face& f0 = mesh_.faces()[face0];
+
+    if (mesh_.faceOwner()[face0] != cellI)
+    {
+        tet[0] = f0[0];
+        tet[1] = f0[1];
+        tet[2] = f0[2];
+    }
+    else
+    {
+        tet[0] = f0[0];
+        tet[1] = f0[2];
+        tet[2] = f0[1];
+    }
+
+    // Find the point on the next face that is not on f0
+    const face& f1 = mesh_.faces()[cFaces[1]];
+
+    forAll(f1, fp)
+    {
+        label p1 = f1[fp];
+
+        if (p1 != tet[0] && p1 != tet[1] && p1 != tet[2])
+        {
+            tet[3] = p1;
+            break;
+        }
+    }
+
+
+    // Get the index of pointI
+
+    label i0 = findIndex(tet, pointI);
+    label i1 = tet.fcIndex(i0);
+    label i2 = tet.fcIndex(i1);
+    label i3 = tet.fcIndex(i2);
+
+    // Get fractions for the three edges emanating from point
+    FixedList<scalar, 3> s(3);
+    s[0] = isoFraction(pointValues[pointI], pointValues[tet[i1]]);
+    s[1] = isoFraction(pointValues[pointI], pointValues[tet[i2]]);
+    s[2] = isoFraction(pointValues[pointI], pointValues[tet[i3]]);
+
+    if
+    (
+        (s[0] >= 0.0 && s[0] <= 0.5)
+     && (s[1] >= 0.0 && s[1] <= 0.5)
+     && (s[2] >= 0.0 && s[2] <= 0.5)
+    )
+    {
+        localTriPoints.append((1.0-s[0])*pts[pointI] + s[0]*pts[tet[i1]]);
+        localTriPoints.append((1.0-s[1])*pts[pointI] + s[1]*pts[tet[i2]]);
+        localTriPoints.append((1.0-s[2])*pts[pointI] + s[2]*pts[tet[i3]]);
+    }
+}
+
+
+void Foam::isoSurface::calcSnappedPoint
+(
+    const PackedList<1>& isBoundaryPoint,
+    const PackedList<1>& isTet,
+    const scalarField& cVals,
+    const scalarField& pVals,
+    const List<cellCutType>& cellCutType,
+
+    DynamicList<point>& snappedPoints,
+    labelList& snappedPoint
+) const
+{
+    const point greatPoint(VGREAT, VGREAT, VGREAT);
+    pointField collapsedPoint(mesh_.nPoints(), greatPoint);
+
+
+    // Work arrays
+    DynamicList<point, 64> localTriPoints(100);
+    labelHashSet localPointCells(100);
+
+    forAll(mesh_.pointFaces(), pointI)
+    {
+        if (isBoundaryPoint.get(pointI) == 1)
+        {
+            continue;
+        }
+
+        const labelList& pFaces = mesh_.pointFaces()[pointI];
+
+        bool anyCut = false;
+
+        forAll(pFaces, i)
+        {
+            label faceI = pFaces[i];
+
+            if
+            (
+                cellCutType[mesh_.faceOwner()[faceI]] == CUT
+             || (
+                    mesh_.isInternalFace(faceI)
+                 && cellCutType[mesh_.faceNeighbour()[faceI]] == CUT
+                )
+            )
+            {
+                anyCut = true;
+                break;
+            }
+        }
+
+        if (!anyCut)
+        {
+            continue;
+        }
+
+
+        localPointCells.clear();
+        localTriPoints.clear();
+
+        forAll(pFaces, pFaceI)
+        {
+            label faceI = pFaces[pFaceI];
+            const face& f = mesh_.faces()[faceI];
+            label own = mesh_.faceOwner()[faceI];
+
+            // Triangulate around f[0] on owner side
+            if (isTet.get(own) == 1)
+            {
+                if (localPointCells.insert(own))
+                {
+                    genPointTris(pVals, pointI, own, localTriPoints);
+                }
+            }
+            else
+            {
+                genPointTris(cVals, pVals, pointI, f, own, localTriPoints);
+            }
+
+            if (mesh_.isInternalFace(faceI))
+            {
+                label nei = mesh_.faceNeighbour()[faceI];
+
+                if (isTet.get(nei) == 1)
+                {
+                    if (localPointCells.insert(nei))
+                    {
+                        genPointTris(pVals, pointI, nei, localTriPoints);
+                    }
+                }
+                else
+                {
+                    genPointTris(cVals, pVals, pointI, f, nei, localTriPoints);
+                }
+            }
+        }
+
+        if (localTriPoints.size() == 0)
+        {
+            // No near intersections
+        }
+        else if (localTriPoints.size() == 3)
+        {
+            // Single triangle. No need for any analysis. Average points.
+            pointField points;
+            points.transfer(localTriPoints);
+            collapsedPoint[pointI] = sum(points)/points.size();
+
+            //Pout<< "    point:" << pointI
+            //    << " replacing coord:" << mesh_.points()[pointI]
+            //    << " by average:" << collapsedPoint[pointI] << endl;
+        }
+        else
+        {
+            // Convert points into triSurface.
+
+            // Merge points and compact out non-valid triangles
+            labelList triMap;               // merged to unmerged triangle
+            labelList triPointReverseMap;   // unmerged to merged point
+            triSurface surf
+            (
+                stitchTriPoints
+                (
+                    false,                  // do not check for duplicate tris
+                    localTriPoints,
+                    triPointReverseMap,  
+                    triMap
+                )
+            );
+
+            labelList faceZone;
+            label nZones = surf.markZones
+            (
+                boolList(surf.nEdges(), false),
+                faceZone
+            );
+
+            if (nZones == 1)
+            {
+                collapsedPoint[pointI] = calcCentre(surf);
+                //Pout<< "    point:" << pointI << " nZones:" << nZones
+                //    << " replacing coord:" << mesh_.points()[pointI]
+                //    << " by average:" << collapsedPoint[pointI] << endl;
+            }
+        }
+    }
+
+    syncTools::syncPointList
+    (
+        mesh_,
+        collapsedPoint,
+        minEqOp<point>(),
+        greatPoint,
+        true                // are coordinates so separate
+    );
+
+    snappedPoint.setSize(mesh_.nPoints());
+    snappedPoint = -1;
+
+    forAll(collapsedPoint, pointI)
+    {
+        if (collapsedPoint[pointI] != greatPoint)
+        {
+            snappedPoint[pointI] = snappedPoints.size();
+            snappedPoints.append(collapsedPoint[pointI]);
+        }
+    }
+}
+
+
+Foam::point Foam::isoSurface::generatePoint
+(
+    const DynamicList<point>& snappedPoints,
+
+    const scalar s0,
+    const point& p0,
+    const label p0Index,
+
+    const scalar s1,
+    const point& p1,
+    const label p1Index
+) const
+{
+    scalar d = s1-s0;
+
+    if (mag(d) > VSMALL)
+    {
+        scalar s = (iso_-s0)/d;
+
+        if (s >= 0.5 && s <= 1 && p1Index != -1)
+        {
+            return snappedPoints[p1Index];
+        }
+        else if (s >= 0.0 && s <= 0.5 && p0Index != -1)
+        {
+            return snappedPoints[p0Index];
+        }
+        else
+        {
+            return s*p1 + (1.0-s)*p0;
+        }
+    }
+    else
+    {
+        scalar s = 0.4999;
+
+        return s*p1 + (1.0-s)*p0;
+    }
+}
+
+
+void Foam::isoSurface::generateTriPoints
+(
+    const DynamicList<point>& snapped,
+
+    const scalar s0,
+    const point& p0,
+    const label p0Index,
+
+    const scalar s1,
+    const point& p1,
+    const label p1Index,
+
+    const scalar s2,
+    const point& p2,
+    const label p2Index,
+
+    const scalar s3,
+    const point& p3,
+    const label p3Index,
+
+    DynamicList<point>& points
+) const
+{
+    int triIndex = 0;
+    if (s0 < iso_)
+    {
+        triIndex |= 1;
+    }
+    if (s1 < iso_)
+    {
+        triIndex |= 2;
+    }
+    if (s2 < iso_)
+    {
+        triIndex |= 4;
+    }
+    if (s3 < iso_)
+    {
+        triIndex |= 8;
+    }
+
+    /* Form the vertices of the triangles for each case */
+    switch (triIndex)
+    {
+        case 0x00:
+        case 0x0F:
+        break;
+
+        case 0x0E:
+        case 0x01:
+            points.append(generatePoint(snapped,s0,p0,p0Index,s1,p1,p1Index));
+            points.append(generatePoint(snapped,s0,p0,p0Index,s2,p2,p2Index));
+            points.append(generatePoint(snapped,s0,p0,p0Index,s3,p3,p3Index));
+        break;
+
+        case 0x0D:
+        case 0x02:
+            points.append(generatePoint(snapped,s1,p1,p1Index,s0,p0,p0Index));
+            points.append(generatePoint(snapped,s1,p1,p1Index,s3,p3,p3Index));
+            points.append(generatePoint(snapped,s1,p1,p1Index,s2,p2,p2Index));
+        break;
+
+        case 0x0C:
+        case 0x03:
+        {
+            point tp1 = generatePoint(snapped,s0,p0,p0Index,s2,p2,p2Index);
+            point tp2 = generatePoint(snapped,s1,p1,p1Index,s3,p3,p3Index);
+
+            points.append(generatePoint(snapped,s0,p0,p0Index,s3,p3,p3Index));
+            points.append(tp1);
+            points.append(tp2);
+            points.append(tp2);
+            points.append(generatePoint(snapped,s1,p1,p1Index,s2,p2,p2Index));
+            points.append(tp1);
+        }
+        break;
+
+        case 0x0B:
+        case 0x04:
+        {
+            points.append(generatePoint(snapped,s2,p2,p2Index,s0,p0,p0Index));
+            points.append(generatePoint(snapped,s2,p2,p2Index,s1,p1,p1Index));
+            points.append(generatePoint(snapped,s2,p2,p2Index,s3,p3,p3Index));
+        }
+        break;
+
+        case 0x0A:
+        case 0x05:
+        {
+            point tp0 = generatePoint(snapped,s0,p0,p0Index,s1,p1,p1Index);
+            point tp1 = generatePoint(snapped,s2,p2,p2Index,s3,p3,p3Index);
+
+            points.append(tp0);
+            points.append(tp1);
+            points.append(generatePoint(snapped,s0,p0,p0Index,s3,p3,p3Index));
+            points.append(tp0);
+            points.append(generatePoint(snapped,s1,p1,p1Index,s2,p2,p2Index));
+            points.append(tp1);
+        }
+        break;
+
+        case 0x09:
+        case 0x06:
+        {
+            point tp0 = generatePoint(snapped,s0,p0,p0Index,s1,p1,p1Index);
+            point tp1 = generatePoint(snapped,s2,p2,p2Index,s3,p3,p3Index);
+
+            points.append(tp0);
+            points.append(generatePoint(snapped,s1,p1,p1Index,s3,p3,p3Index));
+            points.append(tp1);
+            points.append(tp0);
+            points.append(generatePoint(snapped,s0,p0,p0Index,s2,p2,p2Index));
+            points.append(tp1);
+        }
+        break;
+
+        case 0x07:
+        case 0x08:
+            points.append(generatePoint(snapped,s3,p3,p3Index,s0,p0,p0Index));
+            points.append(generatePoint(snapped,s3,p3,p3Index,s2,p2,p2Index));
+            points.append(generatePoint(snapped,s3,p3,p3Index,s1,p1,p1Index));
+        break;
+    }
+}
+
+
+Foam::triSurface Foam::isoSurface::stitchTriPoints
+(
+    const bool checkDuplicates,
+    const List<point>& triPoints,
+    labelList& triPointReverseMap,  // unmerged to merged point
+    labelList& triMap               // merged to unmerged triangle
+) const
+{
+    label nTris = triPoints.size()/3;
+
+    if ((triPoints.size() % 3) != 0)
+    {
+        FatalErrorIn("isoSurface::stitchTriPoints(..)")
+            << "Problem: number of points " << triPoints.size()
+            << " not a multiple of 3." << abort(FatalError);
+    }
+
+    pointField newPoints;
+    mergePoints
+    (
+        triPoints,
+        mergeDistance_,
+        false,
+        triPointReverseMap,
+        newPoints
+    );
+
+    // Check that enough merged.
+    if (debug)
+    {
+        pointField newNewPoints;
+        labelList oldToNew;
+        bool hasMerged = mergePoints
+        (
+            newPoints,
+            mergeDistance_,
+            true,
+            oldToNew,
+            newNewPoints
+        );
+
+        if (hasMerged)
+        {
+            FatalErrorIn("isoSurface::stitchTriPoints(..)")
+                << "Merged points contain duplicates"
+                << " when merging with distance " << mergeDistance_ << endl
+                << "merged:" << newPoints.size() << " re-merged:"
+                << newNewPoints.size()
+                << abort(FatalError);
+        }
+    }
+
+
+    List<labelledTri> tris;
+    {
+        DynamicList<labelledTri> dynTris(nTris);
+        label rawPointI = 0;
+        DynamicList<label> newToOldTri(nTris);
+
+        for (label oldTriI = 0; oldTriI < nTris; oldTriI++)
+        {
+            labelledTri tri
+            (
+                triPointReverseMap[rawPointI],
+                triPointReverseMap[rawPointI+1],
+                triPointReverseMap[rawPointI+2],
+                0
+            );
+            rawPointI += 3;
+
+            if ((tri[0] != tri[1]) && (tri[0] != tri[2]) && (tri[1] != tri[2]))
+            {
+                newToOldTri.append(oldTriI);
+                dynTris.append(tri);
+            }
+        }
+
+        triMap.transfer(newToOldTri.shrink());
+        tris.transfer(dynTris.shrink());
+    }
+
+
+    // Use face centres to determine 'flat hole' situation (see RMT paper).
+    // Two unconnected triangles get connected because (some of) the edges
+    // separating them get collapsed. Below only checks for duplicate triangles,
+    // not non-manifold edge connectivity.
+    if (checkDuplicates)
+    {
+        if (debug)
+        {
+            Pout<< "isoSurface : merged from " << nTris
+                << " down to " << tris.size() << " triangles." << endl;
+        }
+
+        pointField centres(tris.size());
+        forAll(tris, triI)
+        {
+            centres[triI] = tris[triI].centre(newPoints);
+        }
+
+        pointField mergedCentres;
+        labelList oldToMerged;
+        bool hasMerged = mergePoints
+        (
+            centres,
+            mergeDistance_,
+            false,
+            oldToMerged,
+            mergedCentres
+        );
+
+        if (debug)
+        {
+            Pout<< "isoSurface : detected "
+                << centres.size()-mergedCentres.size()
+                << " duplicate triangles." << endl;
+        }
+
+        if (hasMerged)
+        {
+            // Filter out duplicates.
+            label newTriI = 0;
+            DynamicList<label> newToOldTri(tris.size());
+            labelList newToMaster(mergedCentres.size(), -1);
+            forAll(tris, triI)
+            {
+                label mergedI = oldToMerged[triI];
+
+                if (newToMaster[mergedI] == -1)
+                {
+                    newToMaster[mergedI] = triI;
+                    newToOldTri.append(triMap[triI]);
+                    tris[newTriI++] = tris[triI];
+                }
+            }
+
+            triMap.transfer(newToOldTri.shrink());
+            tris.setSize(newTriI);
+        }
+    }
+
+    return triSurface(tris, geometricSurfacePatchList(0), newPoints, true);
+}
+
+
+// Does face use valid vertices?
+bool Foam::isoSurface::validTri(const triSurface& surf, const label faceI)
+{
+    // Simple check on indices ok.
+
+    const labelledTri& f = surf[faceI];
+
+    if
+    (
+        (f[0] < 0) || (f[0] >= surf.points().size())
+     || (f[1] < 0) || (f[1] >= surf.points().size())
+     || (f[2] < 0) || (f[2] >= surf.points().size())
+    )
+    {
+        WarningIn("validTri(const triSurface&, const label)")
+            << "triangle " << faceI << " vertices " << f
+            << " uses point indices outside point range 0.."
+            << surf.points().size()-1 << endl;
+
+        return false;
+    }
+
+    if ((f[0] == f[1]) || (f[0] == f[2]) || (f[1] == f[2]))
+    {
+        WarningIn("validTri(const triSurface&, const label)")
+            << "triangle " << faceI
+            << " uses non-unique vertices " << f
+            << endl;
+        return false;
+    }
+
+    // duplicate triangle check
+
+    const labelList& fFaces = surf.faceFaces()[faceI];
+
+    // Check if faceNeighbours use same points as this face.
+    // Note: discards normal information - sides of baffle are merged.
+    forAll(fFaces, i)
+    {
+        label nbrFaceI = fFaces[i];
+
+        if (nbrFaceI <= faceI)
+        {
+            // lower numbered faces already checked
+            continue;
+        }
+
+        const labelledTri& nbrF = surf[nbrFaceI];
+
+        if
+        (
+            ((f[0] == nbrF[0]) || (f[0] == nbrF[1]) || (f[0] == nbrF[2]))
+         && ((f[1] == nbrF[0]) || (f[1] == nbrF[1]) || (f[1] == nbrF[2]))
+         && ((f[2] == nbrF[0]) || (f[2] == nbrF[1]) || (f[2] == nbrF[2]))
+        )
+        {
+            WarningIn("validTri(const triSurface&, const label)")
+                << "triangle " << faceI << " vertices " << f
+                << " has the same vertices as triangle " << nbrFaceI
+                << " vertices " << nbrF
+                << endl;
+
+            return false;
+        }
+    }
+    return true;
+}
+
+
+void Foam::isoSurface::calcAddressing
+(
+    const triSurface& surf,
+    List<FixedList<label, 3> >& faceEdges,
+    labelList& edgeFace0,
+    labelList& edgeFace1,
+    Map<labelList>& edgeFacesRest
+) const
+{
+    const pointField& points = surf.points();
+
+    pointField edgeCentres(3*surf.size());
+    label edgeI = 0;
+    forAll(surf, triI)
+    {
+        const labelledTri& tri = surf[triI];
+        edgeCentres[edgeI++] = 0.5*(points[tri[0]]+points[tri[1]]);
+        edgeCentres[edgeI++] = 0.5*(points[tri[1]]+points[tri[2]]);
+        edgeCentres[edgeI++] = 0.5*(points[tri[2]]+points[tri[0]]);
+    }
+
+    pointField mergedCentres;
+    labelList oldToMerged;
+    bool hasMerged = mergePoints
+    (
+        edgeCentres,
+        mergeDistance_,
+        false,
+        oldToMerged,
+        mergedCentres
+    );
+
+    if (debug)
+    {
+        Pout<< "isoSurface : detected "
+            << mergedCentres.size()
+            << " edges on " << surf.size() << " triangles." << endl;
+    }
+
+    if (!hasMerged)
+    {
+        return;
+    }
+
+
+    // Determine faceEdges
+    faceEdges.setSize(surf.size());
+    edgeI = 0;
+    forAll(surf, triI)
+    {
+        faceEdges[triI][0] = oldToMerged[edgeI++];
+        faceEdges[triI][1] = oldToMerged[edgeI++];
+        faceEdges[triI][2] = oldToMerged[edgeI++];
+    }
+    
+
+    // Determine edgeFaces
+    edgeFace0.setSize(mergedCentres.size());
+    edgeFace0 = -1;
+    edgeFace1.setSize(mergedCentres.size());
+    edgeFace1 = -1;
+    edgeFacesRest.clear();
+
+    forAll(oldToMerged, oldEdgeI)
+    {
+        label triI = oldEdgeI / 3;
+        label edgeI = oldToMerged[oldEdgeI];
+
+        if (edgeFace0[edgeI] == -1)
+        {
+            edgeFace0[edgeI] = triI;
+        }
+        else if (edgeFace1[edgeI] == -1)
+        {
+            edgeFace1[edgeI] = triI;
+        }
+        else
+        {
+            //WarningIn("orientSurface(triSurface&)")
+            //    << "Edge " << edgeI << " with centre " << mergedCentres[edgeI]
+            //    << " used by more than two triangles: " << edgeFace0[edgeI]
+            //    << ", "
+            //    << edgeFace1[edgeI] << " and " << triI << endl;
+            Map<labelList>::iterator iter = edgeFacesRest.find(edgeI);
+
+            if (iter != edgeFacesRest.end())
+            {
+                labelList& eFaces = iter();
+                label sz = eFaces.size();
+                eFaces.setSize(sz+1);
+                eFaces[sz] = triI;
+            }
+            else
+            {
+                edgeFacesRest.insert(edgeI, labelList(1, triI));
+            }
+        }
+    }
+}
+
+
+void Foam::isoSurface::walkOrientation
+(
+    const triSurface& surf,
+    const List<FixedList<label, 3> >& faceEdges,
+    const labelList& edgeFace0,
+    const labelList& edgeFace1,
+    const label seedTriI,
+    labelList& flipState
+)
+{
+    // Do walk for consistent orientation.
+    DynamicList<label> changedFaces(surf.size());
+
+    changedFaces.append(seedTriI);
+
+    while (changedFaces.size() > 0)
+    {
+        DynamicList<label> newChangedFaces(changedFaces.size());
+
+        forAll(changedFaces, i)
+        {
+            label triI = changedFaces[i];
+            const labelledTri& tri = surf[triI];
+            const FixedList<label, 3>& fEdges = faceEdges[triI];
+
+            forAll(fEdges, fp)
+            {
+                label edgeI = fEdges[fp];
+    
+                // my points:
+                label p0 = tri[fp];
+                label p1 = tri[tri.fcIndex(fp)];
+
+                label nbrI =
+                (
+                    edgeFace0[edgeI] != triI
+                  ? edgeFace0[edgeI]
+                  : edgeFace1[edgeI]
+                );
+
+                if (nbrI != -1 && flipState[nbrI] == -1)
+                {
+                    const labelledTri& nbrTri = surf[nbrI];
+
+                    // nbr points
+                    label nbrFp = findIndex(nbrTri, p0);
+                    label nbrP1 = nbrTri[nbrTri.rcIndex(nbrFp)];
+
+                    bool sameOrientation = (p1 == nbrP1);
+
+                    if (flipState[triI] == 0)
+                    {
+                        flipState[nbrI] = (sameOrientation ? 0 : 1);
+                    }
+                    else
+                    {
+                        flipState[nbrI] = (sameOrientation ? 1 : 0);
+                    }
+                    newChangedFaces.append(nbrI);
+                }
+            }
+        }
+
+        changedFaces.transfer(newChangedFaces);
+    }
+}    
+
+
+void Foam::isoSurface::orientSurface
+(
+    triSurface& surf,
+    const List<FixedList<label, 3> >& faceEdges,
+    const labelList& edgeFace0,
+    const labelList& edgeFace1,
+    const Map<labelList>& edgeFacesRest
+)
+{
+    // -1 : unvisited
+    //  0 : leave as is
+    //  1 : flip
+    labelList flipState(surf.size(), -1);
+
+    label seedTriI = 0;
+
+    while (true)
+    {
+        // Find first unvisited triangle
+        for
+        (
+            ;
+            seedTriI < surf.size() && flipState[seedTriI] != -1; 
+            seedTriI++
+        )
+        {}
+
+        if (seedTriI == surf.size())
+        {
+            break;
+        }
+
+        // Note: Determine orientation of seedTriI?
+        // for now assume it is ok
+        flipState[seedTriI] = 0;
+
+        walkOrientation
+        (
+            surf,
+            faceEdges,
+            edgeFace0,
+            edgeFace1,
+            seedTriI,
+            flipState
+        );
+    }
+
+    // Do actual flipping
+    surf.clearOut();
+    forAll(surf, triI)
+    {
+        if (flipState[triI] == 1)
+        {
+            labelledTri tri(surf[triI]);
+
+            surf[triI][0] = tri[0];
+            surf[triI][1] = tri[2];
+            surf[triI][2] = tri[1];
+        }
+        else if (flipState[triI] == -1)
+        {
+            FatalErrorIn("isoSurface::orientSurface(triSurface&, const label)")
+                << "problem" << abort(FatalError);
+        }
+    }
+}
+
+
+// Checks if triangle is connected through edgeI only.
+bool Foam::isoSurface::danglingTriangle
+(
+    const FixedList<label, 3>& fEdges,
+    const labelList& edgeFace1
+)
+{
+    label nOpen = 0;
+    forAll(fEdges, i)
+    {
+        if (edgeFace1[fEdges[i]] == -1)
+        {
+            nOpen++;
+        }
+    }
+
+    if (nOpen == 1 || nOpen == 2 || nOpen == 3)
+    {
+        return true;
+    }
+    else
+    {
+        return false;
+    }
+}
+
+
+// Mark triangles to keep. Returns number of dangling triangles.
+Foam::label Foam::isoSurface::markDanglingTriangles
+(
+    const List<FixedList<label, 3> >& faceEdges,
+    const labelList& edgeFace0,
+    const labelList& edgeFace1,
+    const Map<labelList>& edgeFacesRest,
+    boolList& keepTriangles
+)
+{
+    keepTriangles.setSize(faceEdges.size());
+    keepTriangles = true;
+
+    label nDangling = 0;
+
+    // Remove any dangling triangles
+    forAllConstIter(Map<labelList>,  edgeFacesRest, iter)
+    {
+        // These are all the non-manifold edges. Filter out all triangles
+        // with only one connected edge (= this edge)
+
+        label edgeI = iter.key();
+        const labelList& otherEdgeFaces = iter();
+
+        // Remove all dangling triangles
+        if (danglingTriangle(faceEdges[edgeFace0[edgeI]], edgeFace1))
+        {
+            keepTriangles[edgeFace0[edgeI]] = false;
+            nDangling++;
+        }
+        if (danglingTriangle(faceEdges[edgeFace1[edgeI]], edgeFace1))
+        {
+            keepTriangles[edgeFace1[edgeI]] = false;
+            nDangling++;
+        }
+        forAll(otherEdgeFaces, i)
+        {
+            label triI = otherEdgeFaces[i];
+            if (danglingTriangle(faceEdges[triI], edgeFace1))
+            {
+                keepTriangles[triI] = false;
+                nDangling++;
+            }
+        }
+    }
+    return nDangling;
+}
+
+
+Foam::triSurface Foam::isoSurface::subsetMesh
+(
+    const triSurface& s,
+    const labelList& newToOldFaces,
+    labelList& newToOldPoints
+)
+{
+    const boolList include
+    (
+        createWithValues<boolList>
+        (
+            s.size(),
+            false,
+            newToOldFaces,
+            true
+        )
+    );
+
+    newToOldPoints.setSize(s.points().size());
+    labelList oldToNewPoints(s.points().size(), -1);
+    {
+        label pointI = 0;
+
+        forAll(include, oldFacei)
+        {
+            if (include[oldFacei])
+            {
+                // Renumber labels for triangle
+                const labelledTri& tri = s[oldFacei];
+
+                forAll(tri, fp)
+                {
+                    label oldPointI = tri[fp];
+
+                    if (oldToNewPoints[oldPointI] == -1)
+                    {
+                        oldToNewPoints[oldPointI] = pointI;
+                        newToOldPoints[pointI++] = oldPointI;
+                    }
+                }
+            }
+        }
+        newToOldPoints.setSize(pointI);
+    }
+
+    // Extract points
+    pointField newPoints(newToOldPoints.size());
+    forAll(newToOldPoints, i)
+    {
+        newPoints[i] = s.points()[newToOldPoints[i]];
+    }
+    // Extract faces
+    List<labelledTri> newTriangles(newToOldFaces.size());
+
+    forAll(newToOldFaces, i)
+    {
+        // Get old vertex labels
+        const labelledTri& tri = s[newToOldFaces[i]];
+
+        newTriangles[i][0] = oldToNewPoints[tri[0]];
+        newTriangles[i][1] = oldToNewPoints[tri[1]];
+        newTriangles[i][2] = oldToNewPoints[tri[2]];
+        newTriangles[i].region() = tri.region();
+    }
+
+    // Reuse storage.
+    return triSurface(newTriangles, s.patches(), newPoints, true);
+}
+
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
 Foam::isoSurface::isoSurface
 (
     const polyMesh& mesh,
-    const scalarField& cellValues,
-    const scalarField& pointValues,
-    const scalar iso
+    const scalarField& cVals,
+    const scalarField& pVals,
+    const scalar iso,
+    const bool regularise,
+    const scalar mergeTol
 )
 :
     mesh_(mesh),
-    cellValues_(cellValues),
-    pointValues_(pointValues),
-    iso_(iso)
+    iso_(iso),
+    mergeDistance_(mergeTol*mag(mesh.bounds().max()-mesh.bounds().min()))
 {
-    const pointField& cellCentres = mesh.cellCentres();
-
-    tetMatcher tet;
-
-    DynamicList<point> triPoints;
-    DynamicList<label> triMeshCells;
-
-    forAll(mesh.cells(), cellI)
+    // Determine if cell is tet
+    PackedList<1> isTet(mesh_.nCells());
     {
-        label oldNPoints = triPoints.size();
+        tetMatcher tet;
 
-        const cell& cFaces = mesh.cells()[cellI];
-
-        if (tet.isA(mesh, cellI))
+        forAll(isTet, cellI)
         {
-            // For tets don't do cell-centre decomposition, just use the
-            // tet points and values
-
-            const face& f0 = mesh.faces()[cFaces[0]];
-
-            // Get the other point
-            const face& f1 = mesh.faces()[cFaces[1]];
-            label oppositeI = -1;
-            forAll(f1, fp)
+            if (tet.isA(mesh_, cellI))
             {
-                oppositeI = f1[fp];
-
-                if (findIndex(f0, oppositeI) == -1)
-                {
-                    break;
-                }
+                isTet.set(cellI, 1);
             }
-
-            vertexInterp
-            (
-                iso,
-                pointValues[f0[0]],
-                pointValues[f0[1]],
-                pointValues[f0[2]],
-                pointValues[oppositeI],
-
-                mesh.points()[f0[0]],
-                mesh.points()[f0[1]],
-                mesh.points()[f0[2]],
-                mesh.points()[oppositeI],
-
-                triPoints
-            );
         }
-        else
+    }
+
+    // Determine if point is on boundary. Points on boundaries are never
+    // snapped. Coupled boundaries are handled explicitly so not marked here.
+    PackedList<1> isBoundaryPoint(mesh_.nPoints());
+    const polyBoundaryMesh& patches = mesh_.boundaryMesh();
+    forAll(patches, patchI)
+    {
+        const polyPatch& pp = patches[patchI];
+
+        if (!pp.coupled())
         {
-            const cell& cFaces = mesh.cells()[cellI];
-
-            forAll(cFaces, cFaceI)
+            label faceI = pp.start();
+            forAll(pp, i)
             {
-                label faceI = cFaces[cFaceI];
-                const face& f = mesh.faces()[faceI];
+                const face& f = mesh_.faces()[faceI++];
 
-                // Do a tetrahedrisation. Each face to cc becomes pyr.
-                // Each pyr gets split into two tets by diagionalisation
-                // of face. So
-                // - f[0], f[1], f[2], cc
-                // - f[0], f[2], f[3], cc
-
-                for(label fp = 1; fp < f.size() - 1; fp++)
+                forAll(f, fp)
                 {
-                    vertexInterp
-                    (
-                        iso,
-                        pointValues[f[0]],
-                        pointValues[f[fp]],
-                        pointValues[f[f.fcIndex(fp)]],
-                        cellValues[cellI],
-
-                        mesh.points()[f[0]],
-                        mesh.points()[f[fp]],
-                        mesh.points()[f[f.fcIndex(fp)]],
-                        cellCentres[cellI],
-
-                        triPoints
-                    );
+                    isBoundaryPoint.set(f[fp], 1);
                 }
             }
         }
+    }
 
 
-        // Every three triPoints is a cell
-        label nCells = (triPoints.size()-oldNPoints)/3;
-        for (label i = 0; i < nCells; i++)
+    // Determine if any cut through cell
+
+    List<cellCutType> cellCutType(mesh_.nCells());
+    label nCutCells = 0;
+    forAll(mesh_.cells(), cellI)
+    {
+        cellCutType[cellI] = calcCutType(isTet, cVals, pVals, cellI);
+
+        if (cellCutType[cellI] == CUT)
         {
-            triMeshCells.append(cellI);
+            nCutCells++;
+        }
+    }
+
+    if (debug)
+    {
+        Pout<< "isoSurface : detected " << nCutCells
+            << " candidate cut cells." << endl;
+    }
+
+    DynamicList<point> snappedPoints(nCutCells);
+
+    // Per cc -1 or a point inside snappedPoints.
+    labelList snappedCc;
+    if (regularise)
+    {
+        calcSnappedCc
+        (
+            isTet,
+            cVals,
+            pVals,
+            cellCutType,
+            snappedPoints,
+            snappedCc
+        );
+    }
+    else
+    {
+        snappedCc.setSize(mesh_.nCells());
+        snappedCc = -1;
+    }
+
+    if (debug)
+    {
+        Pout<< "isoSurface : shifted " << snappedPoints.size()
+            << " cell centres to intersection." << endl;
+    }
+
+    label nCellSnaps = snappedPoints.size();
+
+    // Per point -1 or a point inside snappedPoints.
+    labelList snappedPoint;
+    if (regularise)
+    {
+        calcSnappedPoint
+        (
+            isBoundaryPoint,
+            isTet,
+            cVals,
+            pVals,
+            cellCutType,
+            snappedPoints,
+            snappedPoint
+        );
+    }
+    else
+    {
+        snappedPoint.setSize(mesh_.nPoints());
+        snappedPoint = -1;
+    }
+
+    if (debug)
+    {
+        Pout<< "isoSurface : shifted " << snappedPoints.size()-nCellSnaps
+            << " vertices to intersection." << endl;
+    }
+
+
+
+    DynamicList<point> triPoints(nCutCells);
+    DynamicList<label> triMeshCells(nCutCells);
+
+    forAll(mesh_.cells(), cellI)
+    {
+        if (cellCutType[cellI] != NOTCUT)
+        {
+            label oldNPoints = triPoints.size();
+
+            const cell& cFaces = mesh_.cells()[cellI];
+
+            if (isTet.get(cellI) == 1)
+            {
+                // For tets don't do cell-centre decomposition, just use the
+                // tet points and values
+
+                const face& f0 = mesh_.faces()[cFaces[0]];
+
+                // Get the other point
+                const face& f1 = mesh_.faces()[cFaces[1]];
+                label oppositeI = -1;
+                forAll(f1, fp)
+                {
+                    oppositeI = f1[fp];
+
+                    if (findIndex(f0, oppositeI) == -1)
+                    {
+                        break;
+                    }
+                }
+
+                generateTriPoints
+                (
+                    snappedPoints,
+                    pVals[f0[0]],
+                    mesh_.points()[f0[0]],
+                    snappedPoint[f0[0]],
+
+                    pVals[f0[1]],
+                    mesh_.points()[f0[1]],
+                    snappedPoint[f0[1]],
+
+                    pVals[f0[2]],
+                    mesh_.points()[f0[2]],
+                    snappedPoint[f0[2]],
+
+                    pVals[oppositeI],
+                    mesh_.points()[oppositeI],
+                    snappedPoint[oppositeI],
+
+                    triPoints
+                );
+            }
+            else
+            {
+                const cell& cFaces = mesh_.cells()[cellI];
+
+                forAll(cFaces, cFaceI)
+                {
+                    label faceI = cFaces[cFaceI];
+                    const face& f = mesh_.faces()[faceI];
+
+                    for (label fp = 1; fp < f.size() - 1; fp++)
+                    {
+                        triFace tri(f[0], f[fp], f[f.fcIndex(fp)]);
+                    //List<triFace> tris(triangulate(f));
+                    //forAll(tris, i)
+                    //{
+                    //    const triFace& tri = tris[i];
+
+
+                        generateTriPoints
+                        (
+                            snappedPoints,
+
+                            pVals[tri[0]],
+                            mesh_.points()[tri[0]],
+                            snappedPoint[tri[0]],
+
+                            pVals[tri[1]],
+                            mesh_.points()[tri[1]],
+                            snappedPoint[tri[1]],
+
+                            pVals[tri[2]],
+                            mesh_.points()[tri[2]],
+                            snappedPoint[tri[2]],
+
+                            cVals[cellI],
+                            mesh_.cellCentres()[cellI],
+                            snappedCc[cellI],
+
+                            triPoints
+                        );
+                    }
+                }
+            }
+
+
+            // Every three triPoints is a cell
+            label nCells = (triPoints.size()-oldNPoints)/3;
+            for (label i = 0; i < nCells; i++)
+            {
+                triMeshCells.append(cellI);
+            }
         }
     }
 
     triPoints.shrink();
     triMeshCells.shrink();
-    meshCells_.transfer(triMeshCells);
 
-    pointField newPoints;
-    mergePoints(triPoints, SMALL, false, triPointMergeMap_, newPoints);
-
-    DynamicList<labelledTri> tris(meshCells_.size());
-    forAll(meshCells_, triI)
+    if (debug)
     {
-        tris.append
-        (
-            labelledTri
-            (
-                triPointMergeMap_[3*triI],
-                triPointMergeMap_[3*triI+1],
-                triPointMergeMap_[3*triI+2],
-                0
-            )
-        );
+        Pout<< "isoSurface : generated " << triMeshCells.size()
+            << " unmerged triangles." << endl;
     }
 
-    //- 1.5.x:
-    //tris.shrink();
-    //triSurface::operator=
-    //(
-    //    triSurface(tris, geometricSurfacePatchList(0), newPoints)
-    //);
-
+    // Merge points and compact out non-valid triangles
+    labelList triMap;           // merged to unmerged triangle
     triSurface::operator=
     (
-        triSurface(tris, geometricSurfacePatchList(0), newPoints, true)
+        stitchTriPoints
+        (
+            true,               // check for duplicate tris
+            triPoints,
+            triPointMergeMap_,  // unmerged to merged point
+            triMap
+        )
     );
+
+    if (debug)
+    {
+        Pout<< "isoSurface : generated " << triMap.size()
+            << " merged triangles." << endl;
+    }
+
+    meshCells_.setSize(triMap.size());
+    forAll(triMap, i)
+    {
+        meshCells_[i] = triMeshCells[triMap[i]];
+    }
+
+    if (debug)
+    {
+        Pout<< "isoSurface : checking " << size()
+            << " triangles for validity." << endl;
+
+        forAll(*this, triI)
+        {
+            // Copied from surfaceCheck
+            validTri(*this, triI);
+        }
+    }
+
+
+    List<FixedList<label, 3> > faceEdges;
+    labelList edgeFace0, edgeFace1;
+    Map<labelList> edgeFacesRest;
+
+
+    while (true)
+    {
+        // Calculate addressing
+        calcAddressing(*this, faceEdges, edgeFace0, edgeFace1, edgeFacesRest);
+
+        // See if any dangling triangles
+        boolList keepTriangles;
+        label nDangling = markDanglingTriangles
+        (
+            faceEdges,
+            edgeFace0,
+            edgeFace1,
+            edgeFacesRest,
+            keepTriangles
+        );
+
+        if (debug)
+        {
+            Pout<< "isoSurface : detected " << nDangling
+                << " dangling triangles." << endl;
+        }
+
+        if (nDangling == 0)
+        {
+            break;
+        }
+
+        // Create face map (new to old)
+        labelList subsetTriMap(findIndices(keepTriangles, true));
+
+        labelList subsetPointMap;
+        triSurface::operator=
+        (
+            subsetMesh
+            (
+                *this,
+                subsetTriMap,
+                subsetPointMap
+            )
+        );
+        meshCells_ = labelField(meshCells_, subsetTriMap);
+        triPointMergeMap_ = labelField(triPointMergeMap_, subsetPointMap);
+    }
+
+    orientSurface(*this, faceEdges, edgeFace0, edgeFace1, edgeFacesRest);
 }
 
 
-// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
-
-//Foam::tmp<Foam::scalarField>
-//Foam::isoSurface::sample
-//(
-//    const volScalarField& vField
-//) const
-//{
-//    return sampleField(vField);
-//}
-//
-//
-//Foam::tmp<Foam::vectorField>
-//Foam::isoSurface::sample
-//(
-//    const volVectorField& vField
-//) const
-//{
-//    return sampleField(vField);
-//}
-//
-//Foam::tmp<Foam::sphericalTensorField>
-//Foam::isoSurface::sample
-//(
-//    const volSphericalTensorField& vField
-//) const
-//{
-//    return sampleField(vField);
-//}
-//
-//
-//Foam::tmp<Foam::symmTensorField>
-//Foam::isoSurface::sample
-//(
-//    const volSymmTensorField& vField
-//) const
-//{
-//    return sampleField(vField);
-//}
-//
-//
-//Foam::tmp<Foam::tensorField>
-//Foam::isoSurface::sample
-//(
-//    const volTensorField& vField
-//) const
-//{
-//    return sampleField(vField);
-//}
-//
-//
-//Foam::tmp<Foam::scalarField>
-//Foam::isoSurface::interpolate
-//(
-//    const interpolation<scalar>& interpolator
-//) const
-//{
-//    return interpolateField(interpolator);
-//}
-//
-//
-//Foam::tmp<Foam::vectorField>
-//Foam::isoSurface::interpolate
-//(
-//    const interpolation<vector>& interpolator
-//) const
-//{
-//    return interpolateField(interpolator);
-//}
-//
-//Foam::tmp<Foam::sphericalTensorField>
-//Foam::isoSurface::interpolate
-//(
-//    const interpolation<sphericalTensor>& interpolator
-//) const
-//{
-//    return interpolateField(interpolator);
-//}
-//
-//
-//Foam::tmp<Foam::symmTensorField>
-//Foam::isoSurface::interpolate
-//(
-//    const interpolation<symmTensor>& interpolator
-//) const
-//{
-//    return interpolateField(interpolator);
-//}
-//
-//
-//Foam::tmp<Foam::tensorField>
-//Foam::isoSurface::interpolate
-//(
-//    const interpolation<tensor>& interpolator
-//) const
-//{
-//    return interpolateField(interpolator);
-//}
-
-
 // ************************************************************************* //
diff --git a/src/sampling/sampledSurface/isoSurface/isoSurface.H b/src/sampling/sampledSurface/isoSurface/isoSurface.H
index ddd6854909..d696d40048 100644
--- a/src/sampling/sampledSurface/isoSurface/isoSurface.H
+++ b/src/sampling/sampledSurface/isoSurface/isoSurface.H
@@ -28,6 +28,19 @@ Class
 Description
     A surface formed by the iso value.
     After "Polygonising A Scalar Field Using Tetrahedrons", Paul Bourke
+    and
+    "Regularised Marching Tetrahedra: improved iso-surface extraction",
+    G.M. Treece, R.W. Prager and A.H. Gee.
+
+    Note:
+    - in parallel the regularisation (coarsening) always takes place
+    and slightly different surfaces will be created compared to non-parallel.
+    The surface will still be continuous though!
+    - does tets without using cell centres/cell values. Not tested.
+    - regularisation can create duplicate triangles/non-manifold surfaces.
+    Current handling of those is bit ad-hoc for now and not perfect.
+    Uses geometric merge.
+    - does not do 2D correctly, creates non-flat iso surface.
 
 SourceFiles
     isoSurface.C
@@ -38,6 +51,9 @@ SourceFiles
 #define isoSurface_H
 
 #include "triSurface.H"
+#include "labelPair.H"
+#include "pointIndexHit.H"
+#include "PackedList.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -56,18 +72,30 @@ class isoSurface
 {
     // Private data
 
+        enum segmentCutType
+        {
+            NEARFIRST,      // intersection close to e.first()
+            NEARSECOND,     //  ,,                   e.second()
+            NOTNEAR         // no intersection
+        };
+
+        enum cellCutType
+        {
+            NOTCUT,     // not cut
+            SPHERE,     // all edges to cell centre cut
+            CUT         // normal cut
+        };
+
+
         //- Reference to mesh
         const polyMesh& mesh_;
 
-        //- Reference to cell values
-        const scalarField& cellValues_;
-
-        //- Reference to point values
-        const scalarField& pointValues_;
-
         //- Isosurface value
         const scalar iso_;
 
+        //- When to merge points
+        const scalar mergeDistance_;
+
 
         //- For every triangle the original cell in mesh
         labelList meshCells_;
@@ -78,33 +106,180 @@ class isoSurface
 
     // Private Member Functions
 
-        template<class T>
-        static T vertexInterp
+        //- Get location of iso value as fraction inbetween s0,s1
+        scalar isoFraction
         (
-            const scalar iso,
-            const T& p0,
-            const T& p1,
             const scalar s0,
             const scalar s1
-        );
+        ) const;
 
-        template<class T>
-        static void vertexInterp
+        //List<triFace> triangulate(const face& f) const;
+
+        //- Determine whether cell is cut
+        cellCutType calcCutType
         (
-            const scalar iso,
-            const scalar s0,
-            const scalar s1,
-            const scalar s2,
-            const scalar s3,
+            const PackedList<1>&,
+            const scalarField& cellValues,
+            const scalarField& pointValues,
+            const label
+        ) const;
 
-            const T& p0,
-            const T& p1,
-            const T& p2,
-            const T& p3,
-
-            DynamicList<T>& points
+        static labelPair findCommonPoints
+        (
+            const labelledTri&,
+            const labelledTri&
         );
 
+        static point calcCentre(const triSurface&);
+
+        static pointIndexHit collapseSurface
+        (
+            pointField& localPoints,
+            DynamicList<labelledTri, 64>& localTris
+        );
+
+        //- Determine per cc whether all near cuts can be snapped to single
+        //  point.
+        void calcSnappedCc
+        (
+            const PackedList<1>& isTet,
+            const scalarField& cVals,
+            const scalarField& pVals,
+            const List<cellCutType>& cellCutType,
+            DynamicList<point>& triPoints,
+            labelList& snappedCc
+        ) const;
+
+        //- Generate triangles for face connected to pointI
+        void genPointTris
+        (
+            const scalarField& cellValues,
+            const scalarField& pointValues,
+            const label pointI,
+            const face& f,
+            const label cellI,
+            DynamicList<point, 64>& localTriPoints
+        ) const;
+
+        //- Generate triangles for tet connected to pointI
+        void genPointTris
+        (
+            const scalarField& pointValues,
+            const label pointI,
+            const label cellI,
+            DynamicList<point, 64>& localTriPoints
+        ) const;
+
+        //- Determine per point whether all near cuts can be snapped to single
+        //  point.
+        void calcSnappedPoint
+        (
+            const PackedList<1>& isBoundaryPoint,
+            const PackedList<1>& isTet,
+            const scalarField& cVals,
+            const scalarField& pVals,
+            const List<cellCutType>& cellCutType,
+            DynamicList<point>& triPoints,
+            labelList& snappedPoint
+        ) const;
+
+        //- Generate single point by interpolation or snapping
+        point generatePoint
+        (
+            const DynamicList<point>& snappedPoints,
+            const scalar s0,
+            const point& p0,
+            const label p0Index,
+            const scalar s1,
+            const point& p1,
+            const label p1Index
+        ) const;
+
+        void generateTriPoints
+        (
+            const DynamicList<point>& snapped,
+            const scalar s0,
+            const point& p0,
+            const label p0Index,
+            const scalar s1,
+            const point& p1,
+            const label p1Index,
+            const scalar s2,
+            const point& p2,
+            const label p2Index,
+            const scalar s3,
+            const point& p3,
+            const label p3Index,
+            DynamicList<point>& points
+        ) const;
+
+        triSurface stitchTriPoints
+        (
+            const bool checkDuplicates,
+            const List<point>& triPoints,
+            labelList& triPointReverseMap,  // unmerged to merged point
+            labelList& triMap               // merged to unmerged triangle
+        ) const;
+
+        //- Check single triangle for (topological) validity
+        static bool validTri(const triSurface&, const label);
+
+        //- Determine edge-face addressing
+        void calcAddressing
+        (
+            const triSurface& surf,
+            List<FixedList<label, 3> >& faceEdges,
+            labelList& edgeFace0,
+            labelList& edgeFace1,
+            Map<labelList>& edgeFacesRest
+        ) const;
+
+        //- Determine orientation
+        static void walkOrientation
+        (
+            const triSurface& surf,
+            const List<FixedList<label, 3> >& faceEdges,
+            const labelList& edgeFace0,
+            const labelList& edgeFace1,
+            const label seedTriI,
+            labelList& flipState
+        );
+
+        //- Orient surface
+        static void orientSurface
+        (
+            triSurface&,
+            const List<FixedList<label, 3> >& faceEdges,
+            const labelList& edgeFace0,
+            const labelList& edgeFace1,
+            const Map<labelList>& edgeFacesRest
+        );
+
+        //- Is triangle (given by 3 edges) not fully connected?
+        static bool danglingTriangle
+        (
+            const FixedList<label, 3>& fEdges,
+            const labelList& edgeFace1
+        );
+
+        //- Mark all non-fully connected triangles
+        static label markDanglingTriangles
+        (
+            const List<FixedList<label, 3> >& faceEdges,
+            const labelList& edgeFace0,
+            const labelList& edgeFace1,
+            const Map<labelList>& edgeFacesRest,
+            boolList& keepTriangles
+        );
+
+        static triSurface subsetMesh
+        (
+            const triSurface& s,
+            const labelList& newToOldFaces,
+            labelList& newToOldPoints
+        );
+
+
 public:
 
     //- Runtime type information
@@ -119,7 +294,9 @@ public:
             const polyMesh& mesh,
             const scalarField& cellValues,
             const scalarField& pointValues,
-            const scalar iso
+            const scalar iso,
+            const bool regularise,
+            const scalar mergeTol = 1E-6    // fraction of bounding box
         );
 
 
@@ -136,23 +313,6 @@ public:
         {
             return triPointMergeMap_;
         }
-
-
-        //- sample field on faces
-        template <class Type>
-        tmp<Field<Type> > sample
-        (
-            const Field<Type>& sampleCellValues
-        ) const;
-
-        //- interpolate field to points
-        template <class Type>
-        tmp<Field<Type> >
-        interpolate
-        (
-            const Field<Type>& sampleCellValues,
-            const Field<Type>& samplePointValues
-        ) const;
 };
 
 
@@ -162,12 +322,6 @@ public:
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-#ifdef NoRepository
-#   include "isoSurfaceTemplates.C"
-#endif
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
 #endif
 
 // ************************************************************************* //
diff --git a/src/sampling/sampledSurface/isoSurface/isoSurfaceTemplates.C b/src/sampling/sampledSurface/isoSurface/isoSurfaceTemplates.C
deleted file mode 100644
index e1500ca6e5..0000000000
--- a/src/sampling/sampledSurface/isoSurface/isoSurfaceTemplates.C
+++ /dev/null
@@ -1,292 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software; you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by the
-    Free Software Foundation; either version 2 of the License, or (at your
-    option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM; if not, write to the Free Software Foundation,
-    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
-
-\*---------------------------------------------------------------------------*/
-
-#include "isoSurface.H"
-#include "polyMesh.H"
-#include "tetMatcher.H"
-
-// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
-
-template<class Type>
-Type Foam::isoSurface::vertexInterp
-(
-    const scalar iso,
-    const Type& p0,
-    const Type& p1,
-    const scalar s0,
-    const scalar s1
-)
-{
-    scalar d = s1-s0;
-
-    if (mag(d) > VSMALL)
-    {
-        return (iso-s0)/d*p1 + (s1-iso)/d*p0;
-    }
-    else
-    {
-        return 0.5*(p0+p1);
-    }
-}
-
-
-// After "Polygonising A Scalar Field Using Tetrahedrons"
-// by Paul Bourke
-// Get value consistent with uncompacted triangle points.
-// Given tet corner sample values s0..s3 interpolate the corresponding
-// values p0..p3 to construct the surface corresponding to sample value iso.
-template<class Type>
-void Foam::isoSurface::vertexInterp
-(
-    const scalar iso,
-    const scalar s0,
-    const scalar s1,
-    const scalar s2,
-    const scalar s3,
-
-    const Type& p0,
-    const Type& p1,
-    const Type& p2,
-    const Type& p3,
-
-    DynamicList<Type>& points
-)
-{
-    int triIndex = 0;
-    if (s0 < iso)
-    {
-        triIndex |= 1;
-    }
-    if (s1 < iso)
-    {
-        triIndex |= 2;
-    }
-    if (s2 < iso)
-    {
-        triIndex |= 4;
-    }
-    if (s3 < iso)
-    {
-        triIndex |= 8;
-    }
-
-    /* Form the vertices of the triangles for each case */
-    switch (triIndex)
-    {
-        case 0x00:
-        case 0x0F:
-        break;
-
-        case 0x0E:
-        case 0x01:
-            points.append(vertexInterp(iso,p0,p1,s0,s1));
-            points.append(vertexInterp(iso,p0,p2,s0,s2));
-            points.append(vertexInterp(iso,p0,p3,s0,s3));
-        break;
-
-        case 0x0D:
-        case 0x02:
-            points.append(vertexInterp(iso,p1,p0,s1,s0));
-            points.append(vertexInterp(iso,p1,p3,s1,s3));
-            points.append(vertexInterp(iso,p1,p2,s1,s2));
-        break;
-
-        case 0x0C:
-        case 0x03:
-        {
-            const Type tp1 = vertexInterp(iso,p0,p2,s0,s2);
-            const Type tp2 = vertexInterp(iso,p1,p3,s1,s3);
-
-            points.append(vertexInterp(iso,p0,p3,s0,s3));
-            points.append(tp1);
-            points.append(tp2);
-            points.append(tp2);
-            points.append(vertexInterp(iso,p1,p2,s1,s2));
-            points.append(tp1);
-        }
-        break;
-
-        case 0x0B:
-        case 0x04:
-        {
-            points.append(vertexInterp(iso,p2,p0,s2,s0));
-            points.append(vertexInterp(iso,p2,p1,s2,s1));
-            points.append(vertexInterp(iso,p2,p3,s2,s3));
-        }
-        break;
-
-        case 0x0A:
-        case 0x05:
-        {
-            const Type tp0 = vertexInterp(iso,p0,p1,s0,s1);
-            const Type tp1 = vertexInterp(iso,p2,p3,s2,s3);
-
-            points.append(tp0);
-            points.append(tp1);
-            points.append(vertexInterp(iso,p0,p3,s0,s3));
-            points.append(tp0);
-            points.append(vertexInterp(iso,p1,p2,s1,s2));
-            points.append(tp1);
-        }
-        break;
-
-        case 0x09:
-        case 0x06:
-        {
-            const Type tp0 = vertexInterp(iso,p0,p1,s0,s1);
-            const Type tp1 = vertexInterp(iso,p2,p3,s2,s3);
-
-            points.append(tp0);
-            points.append(vertexInterp(iso,p1,p3,s1,s3));
-            points.append(tp1);
-            points.append(tp0);
-            points.append(vertexInterp(iso,p0,p2,s0,s2));
-            points.append(tp1);
-        }
-        break;
-
-        case 0x07:
-        case 0x08:
-            points.append(vertexInterp(iso,p3,p0,s3,s0));
-            points.append(vertexInterp(iso,p3,p2,s3,s2));
-            points.append(vertexInterp(iso,p3,p1,s3,s1));
-        break;
-    }
-}
-
-
-template <class Type>
-Foam::tmp<Foam::Field<Type> >
-Foam::isoSurface::sample(const Field<Type>& vField) const
-{
-    return tmp<Field<Type> >(new Field<Type>(vField, meshCells()));
-}
-
-
-template <class Type>
-Foam::tmp<Foam::Field<Type> >
-Foam::isoSurface::interpolate
-(
-    const Field<Type>& sampleCellValues,
-    const Field<Type>& samplePointValues
-) const
-{
-    tetMatcher tet;
-
-    DynamicList<Type> triValues;
-
-    // Note: in same order as construction of triSurface
-    label oldCellI = -1;
-    forAll(meshCells_, triI)
-    {
-        label cellI = meshCells_[triI];
-
-        if (cellI != oldCellI)
-        {
-            oldCellI = cellI;
-
-            const cell& cFaces = mesh_.cells()[cellI];
-
-            if (tet.isA(mesh_, cellI))
-            {
-                // For tets don't do cell-centre decomposition, just use the
-                // tet points and values
-
-                const face& f0 = mesh_.faces()[cFaces[0]];
-
-                // Get the other point
-                const face& f1 = mesh_.faces()[cFaces[1]];
-                label oppositeI = -1;
-                forAll(f1, fp)
-                {
-                    oppositeI = f1[fp];
-
-                    if (findIndex(f0, oppositeI) == -1)
-                    {
-                        break;
-                    }
-                }
-
-                vertexInterp
-                (
-                    iso_,
-                    pointValues_[f0[0]],
-                    pointValues_[f0[1]],
-                    pointValues_[f0[2]],
-                    pointValues_[oppositeI],
-
-                    samplePointValues[f0[0]],
-                    samplePointValues[f0[1]],
-                    samplePointValues[f0[2]],
-                    samplePointValues[oppositeI],
-
-                    triValues
-                );
-            }
-            else
-            {
-                forAll(cFaces, cFaceI)
-                {
-                    label faceI = cFaces[cFaceI];
-                    const face& f = mesh_.faces()[faceI];
-
-                    for(label fp = 1; fp < f.size() - 1; fp++)
-                    {
-                        vertexInterp
-                        (
-                            iso_,
-                            pointValues_[f[0]],
-                            pointValues_[f[fp]],
-                            pointValues_[f[f.fcIndex(fp)]],
-                            cellValues_[cellI],
-
-                            samplePointValues[f[0]],
-                            samplePointValues[f[fp]],
-                            samplePointValues[f[f.fcIndex(fp)]],
-                            sampleCellValues[cellI],
-
-                            triValues
-                        );
-                    }
-                }
-            }
-        }
-    }
-
-    // One value per point
-    tmp<Field<Type> > tvalues(new Field<Type>(points().size()));
-    Field<Type>& values = tvalues();
-
-    forAll(triValues, i)
-    {
-        values[triPointMergeMap_[i]] = triValues[i];
-    }
-
-    return tvalues;
-}
-
-
-// ************************************************************************* //
diff --git a/src/sampling/sampledSurface/isoSurface/sampledIsoSurface.C b/src/sampling/sampledSurface/isoSurface/sampledIsoSurface.C
index a5ad5dc0ed..d068b51120 100644
--- a/src/sampling/sampledSurface/isoSurface/sampledIsoSurface.C
+++ b/src/sampling/sampledSurface/isoSurface/sampledIsoSurface.C
@@ -106,48 +106,49 @@ void Foam::sampledIsoSurface::createGeometry() const
         );
 
         //- Direct from cell field and point field. Gives bad continuity.
-        //const isoSurface iso
-        //(
-        //    fvm,
-        //    cellFld.internalField(),
-        //    pointFld().internalField(),
-        //    isoVal_
-        //);
-
-        //- From point field and interpolated cell.
-        scalarField cellAvg(fvm.nCells(), scalar(0.0));
-        labelField nPointCells(fvm.nCells(), 0);
-        {
-            for (label pointI = 0; pointI < fvm.nPoints(); pointI++)
-            {
-                const labelList& pCells = fvm.pointCells(pointI);
-
-                forAll(pCells, i)
-                {
-                    label cellI = pCells[i];
-
-                    cellAvg[cellI] += pointFld().internalField()[pointI];
-                    nPointCells[cellI]++;
-                }
-            }
-        }
-        forAll(cellAvg, cellI)
-        {
-            cellAvg[cellI] /= nPointCells[cellI];
-        }
-
         const isoSurface iso
         (
             fvm,
-            cellAvg,
+            cellFld.internalField(),
             pointFld().internalField(),
-            isoVal_
+            isoVal_,
+            regularise_
         );
 
+        ////- From point field and interpolated cell.
+        //scalarField cellAvg(fvm.nCells(), scalar(0.0));
+        //labelField nPointCells(fvm.nCells(), 0);
+        //{
+        //    for (label pointI = 0; pointI < fvm.nPoints(); pointI++)
+        //    {
+        //        const labelList& pCells = fvm.pointCells(pointI);
+        //
+        //        forAll(pCells, i)
+        //        {
+        //            label cellI = pCells[i];
+        //
+        //            cellAvg[cellI] += pointFld().internalField()[pointI];
+        //            nPointCells[cellI]++;
+        //        }
+        //    }
+        //}
+        //forAll(cellAvg, cellI)
+        //{
+        //    cellAvg[cellI] /= nPointCells[cellI];
+        //}
+        //
+        //const isoSurface iso
+        //(
+        //    fvm,
+        //    cellAvg,
+        //    pointFld().internalField(),
+        //    isoVal_,
+        //    regularise_
+        //);
+
 
         const_cast<sampledIsoSurface&>(*this).triSurface::operator=(iso);
         meshCells_ = iso.meshCells();
-        triPointMergeMap_ = iso.triPointMergeMap();
 
         if (debug)
         {
@@ -155,7 +156,6 @@ void Foam::sampledIsoSurface::createGeometry() const
                 << nl
                 << "    isoField       : " << isoField_ << nl
                 << "    isoValue       : " << isoVal_ << nl
-                << "    unmerged points: " << triPointMergeMap_.size() << nl
                 << "    points         : " << points().size() << nl
                 << "    tris           : " << triSurface::size() << nl
                 << "    cut cells      : " << meshCells_.size() << endl;
@@ -176,11 +176,11 @@ Foam::sampledIsoSurface::sampledIsoSurface
     sampledSurface(name, mesh, dict),
     isoField_(dict.lookup("isoField")),
     isoVal_(readScalar(dict.lookup("isoValue"))),
+    regularise_(dict.lookupOrDefault("regularise", true)),
     zoneName_(word::null),
     facesPtr_(NULL),
     storedTimeIndex_(-1),
-    meshCells_(0),
-    triPointMergeMap_(0)
+    meshCells_(0)
 {
 //    label zoneId = -1;
 //    if (dict.readIfPresent("zone", zoneName_))
diff --git a/src/sampling/sampledSurface/isoSurface/sampledIsoSurface.H b/src/sampling/sampledSurface/isoSurface/sampledIsoSurface.H
index a55cb6641a..e4213dbbde 100644
--- a/src/sampling/sampledSurface/isoSurface/sampledIsoSurface.H
+++ b/src/sampling/sampledSurface/isoSurface/sampledIsoSurface.H
@@ -58,10 +58,13 @@ class sampledIsoSurface
     // Private data
 
         //- Field to get isoSurface of
-        word isoField_;
+        const word isoField_;
 
         //- iso value
-        scalar isoVal_;
+        const scalar isoVal_;
+
+        //- Whether to coarse
+        const Switch regularise_;
 
         //- zone name (if restricted to zones)
         word zoneName_;
@@ -78,9 +81,6 @@ class sampledIsoSurface
             //- For every triangle the original cell in mesh
             mutable labelList meshCells_;
 
-            //- For every unmerged triangle point the point in the triSurface
-            mutable labelList triPointMergeMap_;
-
 
     // Private Member Functions
 

From 81bd77b8ade58be84486319bd4612df1c00fdfae Mon Sep 17 00:00:00 2001
From: mattijs <mattijs@hunt.opencfd.co.uk>
Date: Wed, 5 Nov 2008 15:38:27 +0000
Subject: [PATCH 10/16] remove meshCutSurface

---
 src/finiteVolume/Make/files                   |   11 -
 .../edgeCuts/cellDecompCuts.H                 |  161 ---
 .../edgeCuts/cellDecompIsoSurfaceCuts.C       |  267 -----
 .../edgeCuts/cellDecompIsoSurfaceCuts.H       |  101 --
 .../edgeCuts/faceDecompCuts.H                 |  200 ---
 .../edgeCuts/faceDecompIsoSurfaceCuts.C       |  342 ------
 .../edgeCuts/faceDecompIsoSurfaceCuts.H       |  102 --
 .../fvMeshCutSurface/edgeCuts/meshEdgeCuts.C  |  109 --
 .../fvMeshCutSurface/edgeCuts/meshEdgeCuts.H  |  161 ---
 .../fvMeshCutSurface/meshCut/cellAddressing.C |  132 --
 .../fvMeshCutSurface/meshCut/cellAddressing.H |  145 ---
 .../fvMeshCutSurface/meshCut/meshCutSurface.C | 1068 -----------------
 .../fvMeshCutSurface/meshCut/meshCutSurface.H |  209 ----
 .../meshCut/meshCutSurfaceInterpolate.C       |  174 ---
 .../fvMeshCutSurface/tetEdges/centreEdge.H    |  187 ---
 .../fvMeshCutSurface/tetEdges/diagonalEdge.H  |  199 ---
 .../fvMeshCutSurface/tetEdges/faceEdge.H      |  186 ---
 .../fvMeshCutSurface/tetEdges/pyramidEdge.H   |  185 ---
 18 files changed, 3939 deletions(-)
 delete mode 100644 src/finiteVolume/fvMesh/fvMeshCutSurface/edgeCuts/cellDecompCuts.H
 delete mode 100644 src/finiteVolume/fvMesh/fvMeshCutSurface/edgeCuts/cellDecompIsoSurfaceCuts.C
 delete mode 100644 src/finiteVolume/fvMesh/fvMeshCutSurface/edgeCuts/cellDecompIsoSurfaceCuts.H
 delete mode 100644 src/finiteVolume/fvMesh/fvMeshCutSurface/edgeCuts/faceDecompCuts.H
 delete mode 100644 src/finiteVolume/fvMesh/fvMeshCutSurface/edgeCuts/faceDecompIsoSurfaceCuts.C
 delete mode 100644 src/finiteVolume/fvMesh/fvMeshCutSurface/edgeCuts/faceDecompIsoSurfaceCuts.H
 delete mode 100644 src/finiteVolume/fvMesh/fvMeshCutSurface/edgeCuts/meshEdgeCuts.C
 delete mode 100644 src/finiteVolume/fvMesh/fvMeshCutSurface/edgeCuts/meshEdgeCuts.H
 delete mode 100644 src/finiteVolume/fvMesh/fvMeshCutSurface/meshCut/cellAddressing.C
 delete mode 100644 src/finiteVolume/fvMesh/fvMeshCutSurface/meshCut/cellAddressing.H
 delete mode 100644 src/finiteVolume/fvMesh/fvMeshCutSurface/meshCut/meshCutSurface.C
 delete mode 100644 src/finiteVolume/fvMesh/fvMeshCutSurface/meshCut/meshCutSurface.H
 delete mode 100644 src/finiteVolume/fvMesh/fvMeshCutSurface/meshCut/meshCutSurfaceInterpolate.C
 delete mode 100644 src/finiteVolume/fvMesh/fvMeshCutSurface/tetEdges/centreEdge.H
 delete mode 100644 src/finiteVolume/fvMesh/fvMeshCutSurface/tetEdges/diagonalEdge.H
 delete mode 100644 src/finiteVolume/fvMesh/fvMeshCutSurface/tetEdges/faceEdge.H
 delete mode 100644 src/finiteVolume/fvMesh/fvMeshCutSurface/tetEdges/pyramidEdge.H

diff --git a/src/finiteVolume/Make/files b/src/finiteVolume/Make/files
index 2f301c0406..199daec554 100644
--- a/src/finiteVolume/Make/files
+++ b/src/finiteVolume/Make/files
@@ -297,15 +297,4 @@ cfdTools/general/SRF/SRFModel/SRFModel/newSRFModel.C
 cfdTools/general/SRF/SRFModel/rpm/rpm.C
 cfdTools/general/SRF/derivedFvPatchFields/SRFVelocityFvPatchVectorField/SRFVelocityFvPatchVectorField.C
 
-fvMeshCutSurface = fvMesh/fvMeshCutSurface
-
-meshCut = $(fvMeshCutSurface)/meshCut
-$(meshCut)/meshCutSurface.C
-$(meshCut)/cellAddressing.C
-
-edgeCuts = $(fvMeshCutSurface)/edgeCuts
-$(edgeCuts)/meshEdgeCuts.C
-$(edgeCuts)/faceDecompIsoSurfaceCuts.C
-$(edgeCuts)/cellDecompIsoSurfaceCuts.C
-
 LIB = $(FOAM_LIBBIN)/libfiniteVolume
diff --git a/src/finiteVolume/fvMesh/fvMeshCutSurface/edgeCuts/cellDecompCuts.H b/src/finiteVolume/fvMesh/fvMeshCutSurface/edgeCuts/cellDecompCuts.H
deleted file mode 100644
index a1cc320e8f..0000000000
--- a/src/finiteVolume/fvMesh/fvMeshCutSurface/edgeCuts/cellDecompCuts.H
+++ /dev/null
@@ -1,161 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software; you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by the
-    Free Software Foundation; either version 2 of the License, or (at your
-    option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM; if not, write to the Free Software Foundation,
-    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
-
-Class
-    Foam::cellDecompCuts
-
-Description
-    Container for cuts of edges of (implicit) tet decomposition.
-    Used to collect data for meshCut.
-
-    As much as possible, cuts are defined using mesh information:
-      - cut (exactly) through mesh vertex
-      - cut (exactly) through cell centre
-
-      - cut through mesh edge. Both edge label and position on edge given.
-
-      - cut through tet pyramidEdge (edge between vertex and cell centre).
-        Edge and position on edge given.
-
-      - cut through diagonalEdge (edge between vertices of a face)
-        Edge and position on edge given.
-
-SourceFiles
-
-\*---------------------------------------------------------------------------*/
-
-#ifndef cellDecompCuts_H
-#define cellDecompCuts_H
-
-#include "meshEdgeCuts.H"
-#include "pyramidEdge.H"
-#include "diagonalEdge.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-namespace Foam
-{
-
-// Forward declaration of classes
-
-/*---------------------------------------------------------------------------*\
-                           Class cellDecompCuts Declaration
-\*---------------------------------------------------------------------------*/
-
-class cellDecompCuts
-:
-    public meshEdgeCuts
-{
-
-protected:
-
-        labelList meshCellCentres_;
-
-        List<pyramidEdge> pyrEdges_;
-        scalarField pyrEdgeWeights_;
-
-        List<diagonalEdge> diagEdges_;
-        scalarField diagEdgeWeights_;
-
-    // Private Member Functions
-
-
-public:
-
-    // Constructors
-
-        //- Construct from components
-        cellDecompCuts
-        (
-            const primitiveMesh& mesh,
-            const labelList& cells,
-
-            const labelList& meshVerts,
-            const labelList& meshCellCentres,
-
-            const labelList& meshEdges,
-            const scalarField& meshEdgeWeights,
-
-            const List<pyramidEdge>& pyrEdges,
-            const scalarField& pyrEdgeWeights,
-
-            const List<diagonalEdge>& diagEdges,
-            const scalarField& diagEdgeWeights
-        )
-        :
-            meshEdgeCuts(mesh, cells, meshVerts, meshEdges, meshEdgeWeights),
-            meshCellCentres_(meshCellCentres),
-            pyrEdges_(pyrEdges),
-            pyrEdgeWeights_(pyrEdgeWeights),
-            diagEdges_(diagEdges),
-            diagEdgeWeights_(diagEdgeWeights)
-        {}
-
-
-    // Member Functions
-
-        const labelList& meshCellCentres() const
-        {
-            return meshCellCentres_;
-        }
-
-        const List<pyramidEdge>& pyrEdges() const
-        {
-            return pyrEdges_;
-        }
-
-        const scalarField& pyrEdgeWeights() const
-        {
-            return pyrEdgeWeights_;
-        }
-
-        const List<diagonalEdge>& diagEdges() const
-        {
-            return diagEdges_;
-        }
-
-        const scalarField& diagEdgeWeights() const
-        {
-            return diagEdgeWeights_;
-        }
-
-        label size() const
-        {
-            return
-                meshEdgeCuts::size() + meshCellCentres_.size()
-              + pyrEdges_.size() + diagEdges_.size();
-        }
-
-};
-
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#endif
-
-// ************************************************************************* //
diff --git a/src/finiteVolume/fvMesh/fvMeshCutSurface/edgeCuts/cellDecompIsoSurfaceCuts.C b/src/finiteVolume/fvMesh/fvMeshCutSurface/edgeCuts/cellDecompIsoSurfaceCuts.C
deleted file mode 100644
index 1f8f7d6d1f..0000000000
--- a/src/finiteVolume/fvMesh/fvMeshCutSurface/edgeCuts/cellDecompIsoSurfaceCuts.C
+++ /dev/null
@@ -1,267 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software; you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by the
-    Free Software Foundation; either version 2 of the License, or (at your
-    option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM; if not, write to the Free Software Foundation,
-    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
-
-Description
-
-\*---------------------------------------------------------------------------*/
-
-#include "cellDecompIsoSurfaceCuts.H"
-#include "volPointInterpolation.H"
-
-// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
-
-void Foam::cellDecompIsoSurfaceCuts::constructEdgeCuts
-(
-    const volScalarField& volField,
-    const pointScalarField& ptField,
-    const scalar isoVal,
-    const scalar tol
-)
-{
-    const primitiveMesh& mesh = volField.mesh();
-
-    // Intermediate storage for labels of cut edges and cut points
-    label nBFaces = mesh.nFaces() - mesh.nInternalFaces();
-
-    labelHashSet cutCells(nBFaces);
-    labelHashSet cutVerts(nBFaces);
-    labelHashSet cutCellCentres(nBFaces);
-
-    DynamicList<label> meshCutEdges(nBFaces);
-    DynamicList<scalar> meshEdgeWeights(nBFaces);
-
-    DynamicList<pyramidEdge> cutPyrEdges(nBFaces);
-    DynamicList<scalar> pyrEdgeWeights(nBFaces);
-
-    DynamicList<diagonalEdge> cutDiagEdges(nBFaces);
-    DynamicList<scalar> diagEdgeWeights(nBFaces);
-
-
-    // Walk over faces
-    forAll(mesh.faces(), faceI)
-    {
-        const face& f = mesh.faces()[faceI];
-
-        label ownerI = mesh.faceOwner()[faceI];
-        label neighbourI = -1;
-        if (mesh.isInternalFace(faceI))
-        {
-            neighbourI = mesh.faceNeighbour()[faceI];
-        }
-
-        scalar weight;
-
-        //
-        // Check face diagonal. Simple triangulation from f[0]
-        //
-
-        for(label fp = 2; fp < f.size() - 1; fp++)
-        {
-            if (crosses(isoVal, ptField[f[0]], ptField[f[fp]], weight))
-            {
-                mark(ownerI, cutCells);
-                if (neighbourI != -1)
-                {
-                    mark(neighbourI, cutCells);
-                }
-
-                if (weight < tol)
-                {
-                    mark(f[0], cutVerts);
-                }
-                else if (weight > 1-tol)
-                {
-                    mark(f[fp], cutVerts);
-                }
-                else
-                {
-                    cutDiagEdges.append(diagonalEdge(faceI, 0, fp));
-                    diagEdgeWeights.append(weight);
-                }
-            }
-        }
-    }
-    
-
-    // Walk over all mesh points
-    forAll(mesh.points(), pointI)
-    {
-        const labelList& myCells = mesh.pointCells()[pointI];
-
-        forAll(myCells, myCellI)
-        {
-            label cellI = myCells[myCellI];
-
-            //
-            // Check pyramid edge crossing
-            //
-
-            scalar weight;
-
-            if (crosses(isoVal, ptField[pointI], volField[cellI], weight))
-            {
-                mark(cellI, cutCells);
-
-                if (weight < tol)
-                {
-                    mark(pointI, cutVerts);
-                }
-                else if (weight > 1-tol)
-                {
-                    mark(cellI, cutCellCentres);
-                }
-                else
-                {
-                    cutPyrEdges.append(pyramidEdge(pointI, cellI));
-                    pyrEdgeWeights.append(weight);
-                }
-            }
-        }
-    }            
-
-
-    // Walk over all mesh edges
-    forAll(mesh.edges(), edgeI)
-    {
-        const edge& e = mesh.edges()[edgeI];
-
-        scalar weight;
-
-        if (crosses(isoVal, ptField[e.start()], ptField[e.end()], weight))
-        {
-            mark(mesh.edgeCells()[edgeI], cutCells);
-
-            if (weight < tol)
-            {
-                mark(e.start(), cutVerts);
-            }
-            else if (weight > 1-tol)
-            {
-                mark(e.end(), cutVerts);
-            }
-            else
-            {
-                meshCutEdges.append(edgeI);
-                meshEdgeWeights.append(weight);
-            }
-        }
-    }
-
-    meshCutEdges.shrink();
-    meshEdgeWeights.shrink();
-
-    cutPyrEdges.shrink();
-    pyrEdgeWeights.shrink();
-
-    cutDiagEdges.shrink();
-    diagEdgeWeights.shrink();
-
-
-    // Tranfer lists to cellDecompCuts
-
-    cells_ = cutCells.toc();
-
-    meshVerts_ = cutVerts.toc();
-    meshCellCentres_ = cutCellCentres.toc();
-
-    meshEdges_.transfer(meshCutEdges);
-    meshEdgeWeights_.transfer(meshEdgeWeights);
-
-    pyrEdges_.transfer(cutPyrEdges);
-    pyrEdgeWeights_.transfer(pyrEdgeWeights);
-
-    diagEdges_.transfer(cutDiagEdges);
-    diagEdgeWeights_.transfer(diagEdgeWeights);
-}
-
-
-// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
-
-Foam::cellDecompIsoSurfaceCuts::cellDecompIsoSurfaceCuts
-(
-    const volScalarField& volField,
-    const pointScalarField& ptField,
-    const scalar isoVal,
-    const scalar tol
-)
-:
-    cellDecompCuts
-    (
-        volField.mesh(),
-        labelList(),
-
-        labelList(),            // mesh vertices
-        labelList(),            // mesh cell centres
-
-        labelList(),            // mesh edges
-        scalarField(),
-
-        List<pyramidEdge>(),    // pyramid edges
-        scalarField(),
-
-        List<diagonalEdge>(),   // face diagonal edges
-        scalarField()
-    )
-{
-    constructEdgeCuts(volField, ptField, isoVal, tol);
-}
-
-
-// Construct from interpolator and field (does interpolation)
-Foam::cellDecompIsoSurfaceCuts::cellDecompIsoSurfaceCuts
-(
-    const volScalarField& volField,
-    const volPointInterpolation& pInterp,
-    const scalar isoVal,
-    const scalar tol
-)
-:
-    cellDecompCuts
-    (
-        volField.mesh(),
-        labelList(),
-
-        labelList(),            // mesh vertices
-        labelList(),            // mesh cell centres
-
-        labelList(),            // mesh edges
-        scalarField(),
-
-        List<pyramidEdge>(),    // pyramid edges
-        scalarField(),
-
-        List<diagonalEdge>(),   // face diagonal edges
-        scalarField()
-    )
-{
-    // Get field on vertices
-    tmp<pointScalarField> tptField = pInterp.interpolate(volField);
-    const pointScalarField& ptField = tptField();
-
-
-    constructEdgeCuts(volField, ptField, isoVal, tol);
-}
-
-
-// ************************************************************************* //
diff --git a/src/finiteVolume/fvMesh/fvMeshCutSurface/edgeCuts/cellDecompIsoSurfaceCuts.H b/src/finiteVolume/fvMesh/fvMeshCutSurface/edgeCuts/cellDecompIsoSurfaceCuts.H
deleted file mode 100644
index f7ee4d2b11..0000000000
--- a/src/finiteVolume/fvMesh/fvMeshCutSurface/edgeCuts/cellDecompIsoSurfaceCuts.H
+++ /dev/null
@@ -1,101 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software; you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by the
-    Free Software Foundation; either version 2 of the License, or (at your
-    option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM; if not, write to the Free Software Foundation,
-    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
-
-Class
-    Foam::cellDecompIsoSurfaceCuts
-
-Description
-    cellCuts resulting from isoSurface reconstruction on cellDecomp tet mesh
-
-SourceFiles
-    cellDecompIsoSurfaceCuts.C
-
-\*---------------------------------------------------------------------------*/
-
-#ifndef cellDecompIsoSurfaceCuts_H
-#define cellDecompIsoSurfaceCuts_H
-
-#include "cellDecompCuts.H"
-#include "volFields.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-namespace Foam
-{
-
-// Forward declaration of classes
-class volPointInterpolation;
-
-/*---------------------------------------------------------------------------*\
-                           Class cellDecompIsoSurfaceCuts Declaration
-\*---------------------------------------------------------------------------*/
-
-class cellDecompIsoSurfaceCuts
-:
-    public cellDecompCuts
-{
-    // Private Member Functions
-
-        //- Do all the hard work: determine edge crossings
-        void constructEdgeCuts
-        (
-            const volScalarField&,
-            const pointScalarField&,
-            const scalar,
-            const scalar
-        );
-
-public:
-
-    // Constructors
-
-        //- Construct from field on cells and field on vertices
-        cellDecompIsoSurfaceCuts
-        (
-            const volScalarField&,
-            const pointScalarField&,
-            const scalar isoValue,
-            const scalar tol
-        );
-
-        //- Construct from interpolator and field (does interpolation)
-        cellDecompIsoSurfaceCuts
-        (
-            const volScalarField&,
-            const volPointInterpolation&,
-            const scalar isoValue,
-            const scalar tol
-        );
-};
-
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#endif
-
-// ************************************************************************* //
diff --git a/src/finiteVolume/fvMesh/fvMeshCutSurface/edgeCuts/faceDecompCuts.H b/src/finiteVolume/fvMesh/fvMeshCutSurface/edgeCuts/faceDecompCuts.H
deleted file mode 100644
index c5f374e051..0000000000
--- a/src/finiteVolume/fvMesh/fvMeshCutSurface/edgeCuts/faceDecompCuts.H
+++ /dev/null
@@ -1,200 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software; you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by the
-    Free Software Foundation; either version 2 of the License, or (at your
-    option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM; if not, write to the Free Software Foundation,
-    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
-
-Class
-    Foam::faceDecompCuts
-
-Description
-    Container for cuts of edges of (implicit) tet decomposition. Used to
-    collect data for meshCut. As much as possible cuts are defined using
-    mesh information:
-
-    - cut (exactly) through mesh vertex
-    -   ,,              ,,       cell centre
-    -   ,,              ,,       face centre
-
-    - cut through mesh edge. Both edge label and position on edge given.
-
-    - cut through tet pyramidEdge (edge between vertex and cell centre).
-      Edge and position on edge given.
-    - cut through tet faceEdge (edge between vertex and face centre).
-      Edge and position on edge given.
-    - cut through tet centreEdge (edge between face centre and cell centre).
-      Edge and position on edge given.
-
-SourceFiles
-
-\*---------------------------------------------------------------------------*/
-
-#ifndef faceDecompCuts_H
-#define faceDecompCuts_H
-
-#include "meshEdgeCuts.H"
-#include "pyramidEdge.H"
-#include "faceEdge.H"
-#include "centreEdge.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-namespace Foam
-{
-
-// Forward declaration of classes
-
-/*---------------------------------------------------------------------------*\
-                           Class faceDecompCuts Declaration
-\*---------------------------------------------------------------------------*/
-
-class faceDecompCuts
-:
-    public meshEdgeCuts
-{
-
-protected:
-
-        //- List of faces whose centre is exactly cut
-        labelList meshFaceCentres_;
-
-        //- List of cells whose centre is exactly cut
-        labelList meshCellCentres_;
-
-        //- List of pyramid edge descriptions
-        List<pyramidEdge> pyrEdges_;
-
-        //- For each pyramid edge description the position of the cut
-        scalarField pyrEdgeWeights_;
-
-        //- List of face edge descriptions
-        List<faceEdge> faceEdges_;
-
-        //- For each face edge description the position of the cut
-        scalarField faceEdgeWeights_;
-
-        //- List of centre edge descriptions
-        List<centreEdge> centreEdges_;
-
-        //- For each centre edge description the position of the cut
-        scalarField centreEdgeWeights_;
-
-public:
-
-    // Constructors
-
-        //- Construct from components
-        faceDecompCuts
-        (
-            const primitiveMesh& mesh,
-            const labelList& cells,
-
-            const labelList& meshVerts,
-            const labelList& meshFaceCentres,
-            const labelList& meshCellCentres,
-
-            const labelList& meshEdges,
-            const scalarField& meshEdgeWeights,
-
-            const List<pyramidEdge>& pyrEdges,
-            const scalarField& pyrEdgeWeights,
-
-            const List<faceEdge>& faceEdges,
-            const scalarField& faceEdgeWeights,
-
-            const List<centreEdge>& centreEdges,
-            const scalarField& centreEdgeWeights
-        )
-        :
-            meshEdgeCuts(mesh, cells, meshVerts, meshEdges, meshEdgeWeights),
-            meshFaceCentres_(meshFaceCentres),
-            meshCellCentres_(meshCellCentres),
-            pyrEdges_(pyrEdges),
-            pyrEdgeWeights_(pyrEdgeWeights),
-            faceEdges_(faceEdges),
-            faceEdgeWeights_(faceEdgeWeights),
-            centreEdges_(centreEdges),
-            centreEdgeWeights_(centreEdgeWeights)
-        {}
-
-
-    // Member Functions
-
-        const labelList& meshFaceCentres() const
-        {
-            return meshFaceCentres_;
-        }
-
-        const labelList& meshCellCentres() const
-        {
-            return meshCellCentres_;
-        }
-
-        const List<pyramidEdge>& pyrEdges() const
-        {
-            return pyrEdges_;
-        }
-
-        const scalarField& pyrEdgeWeights() const
-        {
-            return pyrEdgeWeights_;
-        }
-
-        const List<centreEdge>& centreEdges() const
-        {
-            return centreEdges_;
-        }
-
-        const scalarField& centreEdgeWeights() const
-        {
-            return centreEdgeWeights_;
-        }
-
-        const List<faceEdge>& faceEdges() const
-        {
-            return faceEdges_;
-        }
-
-        const scalarField& faceEdgeWeights() const
-        {
-            return faceEdgeWeights_;
-        }
-
-        label size() const
-        {
-            return
-                meshEdgeCuts::size()
-              + meshFaceCentres_.size() + meshCellCentres_.size()
-              + pyrEdges_.size() + centreEdges_.size() + faceEdges_.size();       
-        }
-
-};
-
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#endif
-
-// ************************************************************************* //
diff --git a/src/finiteVolume/fvMesh/fvMeshCutSurface/edgeCuts/faceDecompIsoSurfaceCuts.C b/src/finiteVolume/fvMesh/fvMeshCutSurface/edgeCuts/faceDecompIsoSurfaceCuts.C
deleted file mode 100644
index 6f2ad0a8f1..0000000000
--- a/src/finiteVolume/fvMesh/fvMeshCutSurface/edgeCuts/faceDecompIsoSurfaceCuts.C
+++ /dev/null
@@ -1,342 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software; you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by the
-    Free Software Foundation; either version 2 of the License, or (at your
-    option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM; if not, write to the Free Software Foundation,
-    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
-
-Description
-
-\*---------------------------------------------------------------------------*/
-
-#include "faceDecompIsoSurfaceCuts.H"
-#include "volPointInterpolation.H"
-
-// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
-
-void Foam::faceDecompIsoSurfaceCuts::constructEdgeCuts
-(
-    const volScalarField& volField,
-    const pointScalarField& ptField,
-    const scalar isoVal,
-    const scalar tol
-)
-{
-    const primitiveMesh& mesh = volField.mesh();
-
-    // Intermediate storage for labels of cut edges and cut points
-    label nBFaces = mesh.nFaces() - mesh.nInternalFaces();
-
-    labelHashSet cutCells(nBFaces);
-    labelHashSet cutVerts(nBFaces);
-    labelHashSet cutFaceCentres(nBFaces);
-    labelHashSet cutCellCentres(nBFaces);
-
-    DynamicList<label> meshCutEdges(nBFaces);
-    DynamicList<scalar> meshEdgeWeights(nBFaces);
-
-    DynamicList<pyramidEdge> cutPyrEdges(nBFaces);
-    DynamicList<scalar> pyrEdgeWeights(nBFaces);
-
-    DynamicList<faceEdge> cutFaceEdges(nBFaces);
-    DynamicList<scalar> faceEdgeWeights(nBFaces);
-
-    DynamicList<centreEdge> cutCentreEdges(nBFaces);
-    DynamicList<scalar> centreEdgeWeights(nBFaces);
-
-
-    // Walk over faces
-    forAll(mesh.faces(), faceI)
-    {
-        const face& f = mesh.faces()[faceI];
-
-        // Face centre value
-        scalar fcVal = 0;
-
-        forAll(f, fp)
-        {
-            fcVal += ptField[f[fp]];
-        }
-        fcVal /= f.size();
-
-
-        label ownerI = mesh.faceOwner()[faceI];
-        label neighbourI = -1;
-        if (mesh.isInternalFace(faceI))
-        {
-            neighbourI = mesh.faceNeighbour()[faceI];
-        }
-
-        scalar weight;
-
-        //
-        // Check faceCentre-cellCentre crossing for owner and neigbour
-        //
-
-        if (crosses(isoVal, fcVal, volField[ownerI], weight))
-        {
-            mark(ownerI, cutCells);
-
-            if (weight < tol)
-            {
-                mark(faceI, cutFaceCentres);
-            }
-            else if (weight > 1-tol)
-            {
-                mark(ownerI, cutCellCentres);
-            }
-            else
-            {
-                cutCentreEdges.append(centreEdge(faceI, true));
-                centreEdgeWeights.append(weight);
-            }
-        }
-
-        if (neighbourI != -1)
-        {
-            if (crosses(isoVal, fcVal, volField[neighbourI], weight))
-            {
-                mark(neighbourI, cutCells);
-
-                if (weight < tol)
-                {
-                    mark(faceI, cutFaceCentres);
-                }
-                else if (weight > 1-tol)
-                {
-                    mark(neighbourI, cutCellCentres);
-                }
-                else
-                {
-                    cutCentreEdges.append(centreEdge(faceI, false));
-                    centreEdgeWeights.append(weight);
-                }
-            }
-        }
-
-
-        forAll(f, fp)
-        {
-            //
-            // Check face internal (faceEdge) edge crossing
-            //
-
-            if (crosses(isoVal, ptField[f[fp]], fcVal, weight))
-            {
-                mark(ownerI, cutCells);
-                if (neighbourI != -1)
-                {
-                    mark(neighbourI, cutCells);
-                }
-
-                if (weight < tol)
-                {
-                    mark(f[fp], cutVerts);
-                }
-                else if (weight > 1-tol)
-                {
-                    mark(faceI, cutFaceCentres);
-                }
-                else
-                {
-                    cutFaceEdges.append(faceEdge(faceI, fp));
-                    faceEdgeWeights.append(weight);
-                }
-            }
-        }
-    }
-    
-
-    // Walk over all mesh points
-    forAll(mesh.points(), pointI)
-    {
-        const labelList& myCells = mesh.pointCells()[pointI];
-
-        forAll(myCells, myCellI)
-        {
-            label cellI = myCells[myCellI];
-
-            //
-            // Check pyramid edge crossing
-            //
-
-            scalar weight;
-
-            if (crosses(isoVal, ptField[pointI], volField[cellI], weight))
-            {
-                mark(cellI, cutCells);
-
-                if (weight < tol)
-                {
-                    mark(pointI, cutVerts);
-                }
-                else if (weight > 1-tol)
-                {
-                    mark(cellI, cutCellCentres);
-                }
-                else
-                {
-                    cutPyrEdges.append(pyramidEdge(pointI, cellI));
-                    pyrEdgeWeights.append(weight);
-                }
-            }
-        }
-    }            
-
-
-    // Walk over all mesh edges
-    forAll(mesh.edges(), edgeI)
-    {
-        const edge& e = mesh.edges()[edgeI];
-
-        scalar weight;
-
-        if (crosses(isoVal, ptField[e.start()], ptField[e.end()], weight))
-        {
-            mark(mesh.edgeCells()[edgeI], cutCells);
-
-            if (weight < tol)
-            {
-                mark(e.start(), cutVerts);
-            }
-            else if (weight > 1-tol)
-            {
-                mark(e.end(), cutVerts);
-            }
-            else
-            {
-                meshCutEdges.append(edgeI);
-                meshEdgeWeights.append(weight);
-            }
-        }
-    }
-
-    meshCutEdges.shrink();
-    meshEdgeWeights.shrink();
-
-    cutPyrEdges.shrink();
-    pyrEdgeWeights.shrink();
-
-    cutFaceEdges.shrink();
-    faceEdgeWeights.shrink();
-
-    cutCentreEdges.shrink();
-    centreEdgeWeights.shrink();
-
-
-
-    // Tranfer lists to faceDecompCuts
-
-    cells_ = cutCells.toc();
-    meshVerts_ = cutVerts.toc();
-    meshFaceCentres_ = cutFaceCentres.toc();
-    meshCellCentres_ = cutCellCentres.toc();
-
-    meshEdges_.transfer(meshCutEdges);
-    meshEdgeWeights_.transfer(meshEdgeWeights);
-
-    pyrEdges_.transfer(cutPyrEdges);
-    pyrEdgeWeights_.transfer(pyrEdgeWeights);
-
-    faceEdges_.transfer(cutFaceEdges);
-    faceEdgeWeights_.transfer(faceEdgeWeights);
-
-    centreEdges_.transfer(cutCentreEdges);
-    centreEdgeWeights_.transfer(centreEdgeWeights);
-}
-
-
-// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
-
-Foam::faceDecompIsoSurfaceCuts::faceDecompIsoSurfaceCuts
-(
-    const volScalarField& volField,
-    const pointScalarField& ptField,
-    const scalar isoVal,
-    const scalar tol
-)
-:
-    faceDecompCuts
-    (
-        volField.mesh(),
-        labelList(),
-
-        labelList(),
-        labelList(),
-        labelList(),
-
-        labelList(),            // mesh edges
-        scalarField(),
-
-        List<pyramidEdge>(),    // pyramid edges
-        scalarField(),
-
-        List<faceEdge>(),       // face edges
-        scalarField(),
-
-        List<centreEdge>(),     // cell centre edges
-        scalarField()
-    )
-{
-    constructEdgeCuts(volField, ptField, isoVal, tol);
-}
-
-
-// Construct from interpolator and field (does interpolation)
-Foam::faceDecompIsoSurfaceCuts::faceDecompIsoSurfaceCuts
-(
-    const volScalarField& volField,
-    const volPointInterpolation& pInterp,
-    const scalar isoVal,
-    const scalar tol
-)
-:
-    faceDecompCuts
-    (
-        volField.mesh(),
-        labelList(),
-
-        labelList(),
-        labelList(),
-        labelList(),
-
-        labelList(),            // mesh edges
-        scalarField(),
-
-        List<pyramidEdge>(),    // pyramid edges
-        scalarField(),
-
-        List<faceEdge>(),       // face edges
-        scalarField(),
-
-        List<centreEdge>(),     // cell centre edges
-        scalarField()
-    )
-{
-    // Get field on vertices
-    tmp<pointScalarField> tptField = pInterp.interpolate(volField);
-    const pointScalarField& ptField = tptField();
-
-
-    constructEdgeCuts(volField, ptField, isoVal, tol);
-}
-
-
-// ************************************************************************* //
diff --git a/src/finiteVolume/fvMesh/fvMeshCutSurface/edgeCuts/faceDecompIsoSurfaceCuts.H b/src/finiteVolume/fvMesh/fvMeshCutSurface/edgeCuts/faceDecompIsoSurfaceCuts.H
deleted file mode 100644
index d845de2b4f..0000000000
--- a/src/finiteVolume/fvMesh/fvMeshCutSurface/edgeCuts/faceDecompIsoSurfaceCuts.H
+++ /dev/null
@@ -1,102 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software; you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by the
-    Free Software Foundation; either version 2 of the License, or (at your
-    option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM; if not, write to the Free Software Foundation,
-    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
-
-Class
-    Foam::faceDecompIsoSurfaceCuts
-
-Description
-    List of triangles based on isoSurface reconstruction on faceDecomp mesh.
-
-SourceFiles
-    faceDecompIsoSurfaceCuts.C
-
-\*---------------------------------------------------------------------------*/
-
-#ifndef faceDecompIsoSurfaceCuts_H
-#define faceDecompIsoSurfaceCuts_H
-
-#include "faceDecompCuts.H"
-#include "labelHashSet.H"
-#include "volFields.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-namespace Foam
-{
-
-// Forward declaration of classes
-class volPointInterpolation;
-
-/*---------------------------------------------------------------------------*\
-                           Class faceDecompIsoSurfaceCuts Declaration
-\*---------------------------------------------------------------------------*/
-
-class faceDecompIsoSurfaceCuts
-:
-    public faceDecompCuts
-{
-    // Private Member Functions
-
-        //- Do all the hard work: determine edge crossings
-        void constructEdgeCuts
-        (
-            const volScalarField&,
-            const pointScalarField&,
-            const scalar isoVal,
-            const scalar tol
-        );
-
-public:
-
-    // Constructors
-
-        //- Construct from field on cells and field on vertices
-        faceDecompIsoSurfaceCuts
-        (
-            const volScalarField&,
-            const pointScalarField&,
-            const scalar isoVal,
-            const scalar tol
-        );
-
-        //- Construct from interpolator and field (does interpolation)
-        faceDecompIsoSurfaceCuts
-        (
-            const volScalarField&,
-            const volPointInterpolation&,
-            const scalar isoVal,
-            const scalar tol
-        );
-};
-
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#endif
-
-// ************************************************************************* //
diff --git a/src/finiteVolume/fvMesh/fvMeshCutSurface/edgeCuts/meshEdgeCuts.C b/src/finiteVolume/fvMesh/fvMeshCutSurface/edgeCuts/meshEdgeCuts.C
deleted file mode 100644
index 752aee07ff..0000000000
--- a/src/finiteVolume/fvMesh/fvMeshCutSurface/edgeCuts/meshEdgeCuts.C
+++ /dev/null
@@ -1,109 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software; you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by the
-    Free Software Foundation; either version 2 of the License, or (at your
-    option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM; if not, write to the Free Software Foundation,
-    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
-
-Description
-
-\*---------------------------------------------------------------------------*/
-
-#include "meshEdgeCuts.H"
-
-// * * * * * * * * * * * * * Private Static Functions  * * * * * * * * * * * //
-
-void Foam::meshEdgeCuts::mark(const label elem, labelHashSet& markedElems)
-{
-    labelHashSet::const_iterator iter = markedElems.find(elem);
-
-    if (iter == markedElems.end())
-    {
-        markedElems.insert(elem);
-    }
-}
-
-
-void Foam::meshEdgeCuts::mark
-(
-    const labelList& elems,
-    labelHashSet& markedElems
-)
-{
-    forAll(elems, elemI)
-    {
-        mark(elems[elemI], markedElems);
-    }
-}
-
-
-bool Foam::meshEdgeCuts::crosses
-(
-    const scalar isoVal,
-    const scalar val0,
-    const scalar val1,
-    scalar& weight
-)
-{
-    if
-    ( 
-        ((val0 <= isoVal) && (val1 >= isoVal))
-     || ((val1 <= isoVal) && (val0 >= isoVal))
-    )
-    {
-        if (val0 == val1)
-        {
-            return false;
-        }
-        else
-        {
-            weight = (isoVal - val0)/((val1 - val0) + VSMALL);
-
-            return true;
-        }
-    }
-    else
-    {
-        return false;
-    }
-}
-
-
-// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
-
-// Construct from components
-Foam::meshEdgeCuts::meshEdgeCuts
-(
-    const primitiveMesh& mesh,
-    const labelList& cells,
-    const labelList& meshVerts,
-    const labelList& meshEdges,
-    const scalarField& meshEdgeWeights
-)
-:
-    mesh_(mesh),
-    cells_(cells),
-    meshVerts_(meshVerts),
-    meshEdges_(meshEdges),
-    meshEdgeWeights_(meshEdgeWeights)
-{}
-
-
-// ************************************************************************* //
diff --git a/src/finiteVolume/fvMesh/fvMeshCutSurface/edgeCuts/meshEdgeCuts.H b/src/finiteVolume/fvMesh/fvMeshCutSurface/edgeCuts/meshEdgeCuts.H
deleted file mode 100644
index dab50b77e7..0000000000
--- a/src/finiteVolume/fvMesh/fvMeshCutSurface/edgeCuts/meshEdgeCuts.H
+++ /dev/null
@@ -1,161 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software; you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by the
-    Free Software Foundation; either version 2 of the License, or (at your
-    option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM; if not, write to the Free Software Foundation,
-    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
-
-Class
-    Foam::meshEdgeCuts
-
-Description
-    Container for cuts of edges of mesh. Cuts either exactly through existing 
-    vertices or through edges.
-
-SourceFiles
-
-\*---------------------------------------------------------------------------*/
-
-#ifndef meshEdgeCuts_H
-#define meshEdgeCuts_H
-
-#include "labelList.H"
-#include "labelHashSet.H"
-#include "scalarField.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-namespace Foam
-{
-
-// Forward declaration of classes
-class primitiveMesh;
-
-/*---------------------------------------------------------------------------*\
-                           Class meshEdgeCuts Declaration
-\*---------------------------------------------------------------------------*/
-
-class meshEdgeCuts
-{
-    // Private data
-
-        const primitiveMesh& mesh_;
-
-    // Private Member Functions
-
-        //- Disallow default bitwise copy construct
-        meshEdgeCuts(const meshEdgeCuts&);
-
-        //- Disallow default bitwise assignment
-        void operator=(const meshEdgeCuts&);
-
-
-protected:
-
-        //- List of cells containing the cuts
-        labelList cells_;
-
-        //- Points exactly cut by cuts
-        labelList meshVerts_;
-
-        //- List of edge labels cut
-        labelList meshEdges_;
-
-        //- Positions on edges
-        scalarField meshEdgeWeights_;
-
-
-    // Protected Static Functions
-
-        //- Mark element in a hashSet
-        static void mark(const label elem, labelHashSet& markedElems);
-
-        //- Mark list of elements in a hashSet
-        static void mark(const labelList& elems, labelHashSet& markedElems);
-
-        //- Return true and set weight if linear interpolation between
-        //  val0 and val1 crosses isoVal. weight=1 if isoVal==val1
-        static bool crosses
-        (
-            const scalar isoVal,
-            const scalar val0,
-            const scalar val1,
-            scalar& weight
-        );
-
-public:
-
-    // Constructors
-
-        //- Construct from components
-        meshEdgeCuts
-        (
-            const primitiveMesh& mesh,
-            const labelList& cells,
-            const labelList& meshVerts,
-            const labelList& meshEdges,
-            const scalarField& meshEdgeWeights
-        );
-
-
-    // Member Functions
-
-        const primitiveMesh& mesh() const
-        {
-            return mesh_;
-        }
-
-        const labelList& cells() const
-        {
-            return cells_;
-        }
-
-        const labelList& meshVerts() const
-        {
-            return meshVerts_;
-        }
-
-        const labelList& meshEdges() const
-        {
-            return meshEdges_;
-        }
-
-        const scalarField& meshEdgeWeights() const
-        {
-            return meshEdgeWeights_;
-        }
-
-        label size() const
-        {
-            return meshVerts_.size() + meshEdges_.size();
-        }
-
-};
-
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#endif
-
-// ************************************************************************* //
diff --git a/src/finiteVolume/fvMesh/fvMeshCutSurface/meshCut/cellAddressing.C b/src/finiteVolume/fvMesh/fvMeshCutSurface/meshCut/cellAddressing.C
deleted file mode 100644
index be1fbb99df..0000000000
--- a/src/finiteVolume/fvMesh/fvMeshCutSurface/meshCut/cellAddressing.C
+++ /dev/null
@@ -1,132 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software; you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by the
-    Free Software Foundation; either version 2 of the License, or (at your
-    option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM; if not, write to the Free Software Foundation,
-    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
-
-Description
-
-\*---------------------------------------------------------------------------*/
-
-#include "cellAddressing.H"
-#include "labelHashSet.H"
-#include "cellModel.H"
-
-
-// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
-
-Foam::labelList Foam::cellAddressing::makeIdentity(const label size)
-{
-    labelList result(size);
-    forAll(result, resultI)
-    {
-        result[resultI] = resultI;
-    }
-    return result;
-}
-
-
-Foam::label Foam::cellAddressing::findEdge(const edge& e)
-{
-    forAll(edges_, edgeI)
-    {
-        if (edges_[edgeI] == e)
-        {
-            return edgeI;
-        }
-    }
-    FatalErrorIn
-    (
-        "cellAddressing::findEdge(const edge&)"
-    )   << "Problem: cannot find edge " << e << " in edges " << edges_
-        << exit(FatalError);
-
-    return -1;
-}
-
-
-// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
-
-// Construct from components
-Foam::cellAddressing::cellAddressing(const Foam::cellModel& model)
-:
-    modelFaces_(model.modelFaces()),
-    edges_(model.edges(makeIdentity(model.nPoints()))),
-    edgeFaces_(model.nEdges()),
-    faceEdges_(model.nFaces()),
-    pointEdges_(model.nPoints())
-{
-    List<labelHashSet > dynEdgeFaces(edgeFaces_.size());
-
-    forAll(faceEdges_, faceI)
-    {
-        DynamicList<label> fEdges;
-
-        const face& f = modelFaces_[faceI];
-
-        forAll(f, fp)
-        {
-            label edgeI = findEdge(edge(f[fp], f[(fp+1)%f.size()]));
-
-            // Append to faceEdges
-            fEdges.append(edgeI);
-
-            // Append to edgefaces
-            labelHashSet& eFaces = dynEdgeFaces[edgeI];
-
-            if (!eFaces.found(faceI))
-            {
-                eFaces.insert(faceI);
-            }
-        }
-        fEdges.shrink();
-
-        // Copy into faceEdges_
-        faceEdges_[faceI].transfer(fEdges.shrink());
-    }
-
-    // Convert dynEdgeFaces into edgeFaces_
-
-    forAll(dynEdgeFaces, edgeI)
-    {
-        edgeFaces_[edgeI] = dynEdgeFaces[edgeI].toc();
-    }
-
-
-    // Convert edges_ into pointEdges
-    List<DynamicList<label> > dynPointEdges(model.nPoints());
-
-    forAll(edges_, edgeI)
-    {
-        const edge& e = edges_[edgeI];
-
-        dynPointEdges[e.start()].append(edgeI);
-        dynPointEdges[e.end()].append(edgeI);
-    }
-
-    forAll(dynPointEdges, pointI)
-    {
-        pointEdges_[pointI].transfer(dynPointEdges[pointI].shrink());
-    }
-}
-
-
-// ************************************************************************* //
diff --git a/src/finiteVolume/fvMesh/fvMeshCutSurface/meshCut/cellAddressing.H b/src/finiteVolume/fvMesh/fvMeshCutSurface/meshCut/cellAddressing.H
deleted file mode 100644
index d51937b4b4..0000000000
--- a/src/finiteVolume/fvMesh/fvMeshCutSurface/meshCut/cellAddressing.H
+++ /dev/null
@@ -1,145 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software; you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by the
-    Free Software Foundation; either version 2 of the License, or (at your
-    option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM; if not, write to the Free Software Foundation,
-    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
-
-Class
-    Foam::cellAddressing
-
-Description
-    Additional addressing for a cellModel. (cellModel themselves only
-    contain cell-points). Used in cellFeatures class.
-
-SourceFiles
-    cellAddressing.C
-
-\*---------------------------------------------------------------------------*/
-
-#ifndef cellAddressing_H
-#define cellAddressing_H
-
-#include "cellModel.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-namespace Foam
-{
-
-// Forward declaration of classes
-class cellModel;
-
-/*---------------------------------------------------------------------------*\
-                           Class cellAddressing Declaration
-\*---------------------------------------------------------------------------*/
-
-class cellAddressing
-{
-    // Private data
-
-        faceList modelFaces_;
-
-        edgeList edges_;
-
-        labelListList edgeFaces_;
-
-        labelListList faceEdges_;
-
-        labelListList pointEdges_;
-
-    // Private static functions        
-
-        static labelList makeIdentity(const label size);
-
-    // Private static functions        
-
-        label findEdge(const edge& e); 
-
-public:
-
-    // Constructors
-
-        //- Construct from components
-        cellAddressing(const cellModel& model);
-
-    // Destructor
-
-    // Member Functions
-
-        // Access
-
-            inline const faceList& modelFaces() const
-            {
-                return modelFaces_;
-            }
-
-            inline const edgeList& edges() const
-            {
-                return edges_;
-            }
-
-            inline const labelListList& edgeFaces() const
-            {
-                return edgeFaces_;
-            }
-
-            inline const labelListList& faceEdges() const
-            {
-                return faceEdges_;
-            }
-
-            inline const labelListList& pointEdges() const
-            {
-                return pointEdges_;
-            }
-
-
-        // Check
-
-        // Edit
-
-        // Write
-
-
-    // Member Operators
-
-    // Friend Functions
-
-    // Friend Operators
-
-    // IOstream Operators
-
-};
-
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-//#include "cellAddressingI.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#endif
-
-// ************************************************************************* //
diff --git a/src/finiteVolume/fvMesh/fvMeshCutSurface/meshCut/meshCutSurface.C b/src/finiteVolume/fvMesh/fvMeshCutSurface/meshCut/meshCutSurface.C
deleted file mode 100644
index 6d0017adcf..0000000000
--- a/src/finiteVolume/fvMesh/fvMeshCutSurface/meshCut/meshCutSurface.C
+++ /dev/null
@@ -1,1068 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software; you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by the
-    Free Software Foundation; either version 2 of the License, or (at your
-    option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM; if not, write to the Free Software Foundation,
-    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
-
-Description
-
-    Cuts tets resulting from tet decomposition. See Userguide,
-    'Cell shapes in the traditional mesh description'
-
-        f = face
-        fp = vertex of face
-        f[fp] = mesh vertex
-        fc = face centre
-        cc = cell centre
-
-    Caters for both types of decomposition:
-
-    cellDecomp: introduction of cellCentre. Faces get triangulated by
-    introducing diagonals.
-
-    faceDecomp: introduction of cellCentre and faceCentres.
-
-
-    Tet given by its 4 vertices:
-
-            faceDecomp                          cellDecomp
-            ----------                          ----------
-        0:  f[fp]                               f[fp]
-        1:  fc                                  f[0]
-        2:  f[fp+1]                             f[fp+1]
-        3:  cc                                  cc
-
-    Tet given by its 6 edges:
-
-            faceDecomp                          cellDecomp
-            ----------                          ----------
-        0:  fp-fc        (face edge)            fp-f0   (diagonal edge)
-        1:  fp-fp+1      ('real', mesh edge)    fp-fp+1 (mesh edge)
-        2:  fp-cc        (pyramid edge)         fp-cc   (pyramid edge)
-        3:  fc-cc        (centre edge)          f0-cc   (pyramid edge)
-        4:  fc-fp+1      (face edge)            f0-fp+1 (diagonal edge)
-        5:  fp+1 - cc    (pyramid edge)         fp+1-cc (pyramid edge)
-
-\*---------------------------------------------------------------------------*/
-
-#include "meshCutSurface.H"
-#include "faceDecompCuts.H"
-#include "cellDecompCuts.H"
-#include "primitiveMesh.H"
-#include "cellAddressing.H"
-#include "Map.H"
-#include "boolList.H"
-#include "cellModeller.H"
-#include "orientedSurface.H"
-#include "boundBox.H"
-
-// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
-
-// Symbolic names of tet vertices in faceDecomposition (replace FC by f[0] for
-// cellDecomposition)
-Foam::label Foam::meshCutSurface::FP0 = 0;
-Foam::label Foam::meshCutSurface::FC  = 1;
-Foam::label Foam::meshCutSurface::FP1 = 2;
-Foam::label Foam::meshCutSurface::CC  = 3;
-
-// Symbolic names of tet edges in faceDecomposition
-Foam::label Foam::meshCutSurface::FP0_FC  = 0;
-Foam::label Foam::meshCutSurface::FP0_FP1 = 1;
-Foam::label Foam::meshCutSurface::FP0_CC  = 2;
-Foam::label Foam::meshCutSurface::FC_CC   = 3;
-Foam::label Foam::meshCutSurface::FC_FP1  = 4;
-Foam::label Foam::meshCutSurface::FP1_CC  = 5;
-
-
-// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
-
-template<class T, class Hash>
-Foam::label Foam::meshCutSurface::find
-(
-    const HashTable<label, T, Hash>& table,
-    const T& key
-)
-{
-    typename HashTable<label, T, Hash>::const_iterator iter = table.find(key);
-
-    if (iter == table.end())
-    {
-        return -1;
-    }
-    else
-    {
-        return iter();
-    }
-}
-
-
-Foam::label Foam::meshCutSurface::findEdge
-(
-    const edgeList& edges,
-    const labelList& edgeLabels,
-    const edge& e
-)
-{
-    forAll(edgeLabels, edgeLabelI)
-    {
-        label edgeI = edgeLabels[edgeLabelI];
-
-        if (edges[edgeI] == e)
-        {
-            return edgeI;
-        }
-    }
-
-    forAll(edgeLabels, edgeLabelI)
-    {
-        label edgeI = edgeLabels[edgeLabelI];
-
-        Pout<< "edge:" << edgeI << " vertices:" << edges[edgeI] << endl;
-    }
-
-    FatalErrorIn
-    (
-        "meshCutSurface::findEdge(const edgeList&, const labelList&, const edge&)"
-    )   << "Can not find edge " << e << " among edge labels " << edgeLabels
-        << exit(FatalError);
-
-    return -1;
-}
-
-
-Foam::label Foam::meshCutSurface::findCutEdge
-(
-    const cellAddressing& model,
-    const labelList& tetEdgeCuts,
-    const label faceI,
-    const label cutEdgeI
-)
-{
-    const labelList& fEdges = model.faceEdges()[faceI];
-
-    forAll(fEdges, fEdgeI)
-    {
-       label edgeI = fEdges[fEdgeI];
-
-       if ((edgeI != cutEdgeI) && (tetEdgeCuts[edgeI] != -1))
-       {
-            return edgeI;
-       }
-    }
-    
-    FatalErrorIn
-    (
-        "meshCutSurface::findCutEdge(const cellAddressing&, const labelList&"
-        ", const label, const label)"
-    )   << "Problem: face " << faceI << " consists of edges " << fEdges
-        << " of which only one is cut"
-        << exit(FatalError);
-
-    return -1;
-}
-
-
-Foam::triSurface Foam::meshCutSurface::removeDuplicates(const triSurface& surf)
-{
-    boolList includeTri(surf.size(), true);
-
-    forAll(surf, triI)
-    {
-        const labelledTri& t = surf[triI];
-
-        const labelList& nbs = surf.faceFaces()[triI];
-
-        forAll(nbs, nbI)
-        {
-            if (nbs[nbI] <= triI)
-            {
-                // lower numbered faces already checked
-                continue;
-            }
-
-            const labelledTri& nb = surf[nbs[nbI]];
-
-            if
-            (
-                ((t[0] == nb[0]) || (t[0] == nb[1]) || (t[0] == nb[2]))
-             && ((t[1] == nb[0]) || (t[1] == nb[1]) || (t[1] == nb[2]))
-             && ((t[2] == nb[0]) || (t[2] == nb[1]) || (t[2] == nb[2]))
-            )
-            {
-                includeTri[nbs[nbI]] = false;
-            }
-        }
-    }
-
-    labelList pointMap, faceMap;
-
-    return surf.subsetMesh(includeTri, pointMap, faceMap);
-}
-
-
-void Foam::meshCutSurface::cutTet
-(
-    const cellAddressing& model,
-    const labelList& tetVertCuts,
-    const labelList& tetEdgeCuts,
-    const label cellI,
-
-    List<labelledTri>& tris,
-    label& triI
-)
-{
-    label nVertCuts = 0;
-    forAll(tetVertCuts, tetVertI)
-    {
-        if (tetVertCuts[tetVertI] != -1)
-        {
-            nVertCuts++;
-        }
-    }
-
-    label nEdgeCuts = 0;
-    forAll(tetEdgeCuts, tetEdgeI)
-    {
-        if (tetEdgeCuts[tetEdgeI] != -1)
-        {
-            nEdgeCuts++;
-        }
-    }
-
-    if (nVertCuts != 0)
-    {
-        // Cuts through vertices as well as edges. Handle separately.
-        cutTetThroughVerts
-        (
-            model,
-            tetVertCuts,
-            nVertCuts,
-            tetEdgeCuts,
-            nEdgeCuts,
-            cellI,
-
-            tris,
-            triI
-        );
-    }
-    else
-    {
-        // Cuts through edges. 'Simple' case.
-        cutTetThroughEdges
-        (
-            model,
-            tetEdgeCuts,
-            nEdgeCuts,
-            cellI,
-
-            tris,
-            triI
-        );
-    }
-}
-
-
-void Foam::meshCutSurface::cutTetThroughEdges
-(
-    const cellAddressing& model,
-    const labelList& tetEdgeCuts,
-    const label nEdgeCuts,
-    const label cellI,
-
-    List<labelledTri>& tris,
-    label& triI
-)
-{
-    if (nEdgeCuts < 3)
-    {
-        //Pout<< "Tet only cut by " << nEdgeCuts << endl;
-    }
-    else if (nEdgeCuts == 3)
-    {
-        label triVertI = 0;
-
-        labelledTri& tri = tris[triI++];
-
-        forAll(tetEdgeCuts, tetEdgeI)
-        {
-            if (tetEdgeCuts[tetEdgeI] != -1)
-            {
-                tri[triVertI++] = tetEdgeCuts[tetEdgeI];
-            }
-        }
-
-        //Pout<< "Triangle formed by vertices:" << tri << endl;
-        tri.region() = cellI;
-    }
-    else if (nEdgeCuts == 4)
-    {
-        // Find ordering of vertices
-
-        label edge0 = -1;
-        forAll(tetEdgeCuts, tetEdgeI)
-        {
-            if (tetEdgeCuts[tetEdgeI] != -1)
-            {
-                edge0 = tetEdgeI;
-
-                break;
-            }
-        }
-
-        const labelList& nbFaces = model.edgeFaces()[edge0];
-
-        // Find cut edges among faces using edge0
-        label edge1 = findCutEdge(model, tetEdgeCuts, nbFaces[0], edge0);
-        label edge2 = findCutEdge(model, tetEdgeCuts, nbFaces[1], edge0);
-
-        // Find the other edge
-        label edge3 = -1;
-        forAll(tetEdgeCuts, tetEdgeI)
-        {
-            if
-            (
-                (tetEdgeCuts[tetEdgeI] != -1)
-             && (tetEdgeI != edge0)
-             && (tetEdgeI != edge1)
-             && (tetEdgeI != edge2)
-            )
-            {
-                // Fourth cut edge
-                edge3 = tetEdgeI;
-
-                break;
-            }
-        }
-
-        //Pout<< "Triangle 1 formed by vertices:" << tri1 << endl;
-        tris[triI++] =
-            labelledTri
-            (
-                tetEdgeCuts[edge0],
-                tetEdgeCuts[edge1],
-                tetEdgeCuts[edge2],
-                cellI
-            );
-
-        //Pout<< "Triangle 2 formed by vertices:" << tri2 << endl;
-        tris[triI++] = 
-            labelledTri
-            (
-                tetEdgeCuts[edge1],
-                tetEdgeCuts[edge2],
-                tetEdgeCuts[edge3],
-                cellI
-            );
-
-    }
-    else
-    {
-        //FatalErrorIn("meshCutSurface::cutTet")
-        //    << "Cannot handle tets with " << nEdgeCuts << " edges cut"
-        //    << exit(FatalError);
-    }
-}
-
-
-void Foam::meshCutSurface::cutTetThroughVerts
-(
-    const cellAddressing& model,
-    const labelList& tetVertCuts,
-    const label nVertCuts,
-    const labelList& tetEdgeCuts,
-    const label nEdgeCuts,
-    const label cellI,
-
-    List<labelledTri>& tris,
-    label& triI
-)
-{
-    if (nVertCuts == 1)
-    {
-        if (nEdgeCuts == 1)
-        {
-            return;
-        }
-        else if (nEdgeCuts != 2)
-        {
-            // Illegal
-            return;
-        }
-        else    // nEdgeCuts == 2
-        {
-            // Find cut-edges not connected to cut-vertex.
-
-            // Triangle to fill.
-            labelledTri tri;
-            label triVertI = 0;
-
-            // Get label of vertex cut
-            label cutVertI = -1;
-
-            forAll(tetVertCuts, tetVertI)
-            {
-                if (tetVertCuts[tetVertI] != -1)
-                {
-                    tri[triVertI++] = tetVertCuts[tetVertI];
-
-                    cutVertI = tetVertI;
-
-                    break; 
-                }
-            }
-
-            // Mark all edges connected to the cut vertex
-            boolList connectedEdge(6, false);
-
-            const labelList& vEdges = model.pointEdges()[cutVertI];
-
-            forAll(vEdges, vEdgeI)
-            {
-                connectedEdge[vEdges[vEdgeI]] = true;
-            }
-
-            // Go through all edges and collect vertices from cut edges.
-            forAll(tetEdgeCuts, tetEdgeI)
-            {
-                if (tetEdgeCuts[tetEdgeI] != -1)
-                {
-                    // Cut edge.
-
-                    if (connectedEdge[tetEdgeI])
-                    {
-                        // Illegal
-                        return;
-                    }
-                    else
-                    {
-                        // Store edge cut vertex
-                        tri[triVertI++] = tetEdgeCuts[tetEdgeI];
-                    }
-                }
-            }
-
-
-            if (triVertI == 3)
-            {
-                // Collected all triVerts.
-                tri.region() = cellI;
-                tris[triI++] = tri;
-            }
-            else
-            {
-                // Illegal.
-            }
-        }
-    }
-    else if (nVertCuts == 2)
-    {
-        if (nEdgeCuts == 1)
-        {
-            // Only interesting if the cut edge is the one opposite the
-            // edge connecting the two cut vertices.
-
-            // Triangle to fill.
-            labelledTri tri;
-            label triVertI = 0;
-
-            // Get label of edge cut
-            label edgeI = -1;
-
-            forAll(tetEdgeCuts, tetEdgeI)
-            {
-                if (tetEdgeCuts[tetEdgeI] != -1)
-                {
-                    tri[triVertI++] = tetEdgeCuts[tetEdgeI];
-
-                    edgeI = tetEdgeI;
-
-                    break; 
-                }
-            }
-
-
-            // Find cut vertices which are not on edge edgeI.
-            const edge& e = model.edges()[edgeI];
-
-            forAll(tetVertCuts, tetVertI)
-            {
-                if
-                (
-                    (tetVertCuts[tetVertI] != -1)
-                 && (tetVertI != e.start())
-                 && (tetVertI != e.end())
-                )
-                {
-                    tri[triVertI++] = tetVertCuts[tetVertI];
-                }
-            }
-
-
-            if (triVertI == 3)
-            {
-                // Collected all triVerts.
-                //Pout<< "Triangle formed by vertices:" << tri << endl;
-                tri.region() = cellI;
-                tris[triI++] = tri;
-            }
-            else
-            {
-                // Illegal.
-            }
-        }
-        else    // nEdgeCuts != 1
-        {
-            // Illegal if 2 or more edges cut.
-        }   
-    }
-    else if (nVertCuts == 3)
-    {
-        if (nEdgeCuts == 0)
-        {
-            // Cut coincides with face. Form triangle out of cut vertices.
-
-            // Triangle to fill.
-            labelledTri tri;
-            label triVertI = 0;
-
-            forAll(tetVertCuts, tetVertI)
-            {
-                if (tetVertCuts[tetVertI] != -1)
-                {
-                    tri[triVertI++] = tetVertCuts[tetVertI];
-                }
-            }
-            tri.region() = cellI;
-            tris[triI++] = tri;
-        }
-        else    // nEdgeCuts != 0
-        {
-            // Illegal.
-        }
-    }
-    else // nVertCuts <= 0 || > 3
-    {
-        // Illegal.
-    }
-}
-
-
-// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
-
-// Construct from edge cuts. Is given edges and position on edge.
-//  - cuts.cells(): list of cells affected in any way by cutting.
-//  - cuts.meshVerts(): labels of mesh vertices that are cut
-//    (cut exactly through point
-//  - cuts.faceCentres(): face labels whose faceCentres are cut
-//  - cuts.cellCentres(): cell labels whose cellcentres are cut
-//  - cuts.meshEdges(): labels of mesh edges that are cut
-//  - cuts.pyrEdges(): pyramid edges cut
-//  - cuts.centreEdges(): face-cellCentre edges cut
-//  - cuts.faceEdges(): face-face edges cut
-Foam::meshCutSurface::meshCutSurface(const faceDecompCuts& cuts)
-:
-    triSurface()
-{
-    const primitiveMesh& mesh = cuts.mesh();
-
-    // Collect points and create reverse map from edge to new vertex.
-    pointField points(cuts.size());
-    label pointI = 0;
-
-    //
-    // Cuts through existing points
-    //
-
-    // Mesh vertices cut
-    Map<label> meshVertToVert(cuts.meshVerts().size()*2);
-
-    forAll(cuts.meshVerts(), cutVertI)
-    {
-        points[pointI++] = mesh.points()[cuts.meshVerts()[cutVertI]];
-
-        meshVertToVert.insert(cuts.meshVerts()[cutVertI], pointI - 1);
-    }
-
-    // Face centres cut
-    Map<label> faceCentreToVert(cuts.meshFaceCentres().size()*2);
-
-    forAll(cuts.meshFaceCentres(), cutFaceCentreI)
-    {
-        label faceI = cuts.meshFaceCentres()[cutFaceCentreI];
-
-        points[pointI++] = mesh.faceCentres()[faceI];
-
-        faceCentreToVert.insert(faceI, pointI - 1);
-    }
-
-    // Cell centres cut
-    Map<label> cellCentreToVert(cuts.meshCellCentres().size()*2);
-
-    forAll(cuts.meshCellCentres(), cutCellCentreI)
-    {
-        label cellI = cuts.meshCellCentres()[cutCellCentreI];
-
-        points[pointI++] = mesh.cellCentres()[cellI];
-
-        cellCentreToVert.insert(cellI, pointI - 1);
-    }
-
-
-    //
-    // Cuts through edges
-    //
-
-    // Cuts through existing (mesh) edges
-    Map<label> meshEdgeToVert(cuts.meshEdges().size()*2);
-
-    forAll(cuts.meshEdges(), meshCutSurfaceEdgeI)
-    {
-        label edgeI = cuts.meshEdges()[meshCutSurfaceEdgeI];
-
-        const edge& e = mesh.edges()[edgeI];
-
-        scalar weight = cuts.meshEdgeWeights()[meshCutSurfaceEdgeI];
-
-        points[pointI++] =
-            (1-weight)*mesh.points()[e.start()]
-          + weight*mesh.points()[e.end()];
-
-        meshEdgeToVert.insert(edgeI, pointI - 1);
-    }
-
-    // Cuts on tetDecomposition: Pyramid edges
-    HashTable<label, pyramidEdge, pyramidEdge::pyramidEdgeHash>
-        pyrEdgeToVert(cuts.pyrEdges().size()*2);
-
-    forAll(cuts.pyrEdges(), edgeI)
-    {
-        const pyramidEdge& e = cuts.pyrEdges()[edgeI];
-
-        points[pointI++] = e.coord(mesh, cuts.pyrEdgeWeights()[edgeI]);
-
-        pyrEdgeToVert.insert(e, pointI - 1);
-    }
-
-    // Cuts on tetDecomposition: Face-Cell centre edges
-    HashTable<label, centreEdge, centreEdge::centreEdgeHash>
-        centreEdgeToVert(cuts.centreEdges().size()*2);
-
-    forAll(cuts.centreEdges(), edgeI)
-    {
-        const centreEdge& e = cuts.centreEdges()[edgeI];
-
-        points[pointI++] = e.coord(mesh, cuts.centreEdgeWeights()[edgeI]);
-
-        centreEdgeToVert.insert(e, pointI - 1);
-    }
-
-    // Cuts on tetDecomposition: Face edges
-    HashTable<label, faceEdge, faceEdge::faceEdgeHash>
-        faceEdgeToVert(cuts.faceEdges().size()*2);
-
-    forAll(cuts.faceEdges(), edgeI)
-    {
-        const faceEdge& e = cuts.faceEdges()[edgeI];
-
-        points[pointI++] = e.coord(mesh, cuts.faceEdgeWeights()[edgeI]);
-
-        faceEdgeToVert.insert(e, pointI - 1);
-    }
-
-    if (pointI != points.size())
-    {
-        FatalErrorIn
-        (
-            "meshCutSurface::meshCutSurface(const faceDecompCuts& cuts)"
-        )   << "pointI:" << pointI << "  points.size():" << points.size()
-            << abort(FatalError);
-    }
-
-
-    // Generate tet model + additional addressing
-    const cellModel& tet = *(cellModeller::lookup("tet"));
-
-    cellAddressing tetPlus(tet);
-
-    // Tet edges cut. -1 if edge not cut, vertex label otherwise.
-    labelList tetEdgeCuts(6);
-
-    // Tet vertices cut. -1 if edge not cut, vertex label otherwise.
-    labelList tetVertCuts(4);
-
-    List<labelledTri> tris(2*cuts.size());
-    label triI = 0;
-
-    forAll(cuts.cells(), cutCellI)
-    {
-        label cellI = cuts.cells()[cutCellI];
-
-        tetVertCuts[CC] = find(cellCentreToVert, cellI);
-
-        const cell& cellFaces = mesh.cells()[cellI];
-
-        forAll(cellFaces, cellFaceI)
-        {
-            label faceI = cellFaces[cellFaceI];
-
-            tetVertCuts[FC] = find(faceCentreToVert, faceI);
-
-            bool isOwner = (mesh.faceOwner()[faceI] == cellI);
-
-            tetEdgeCuts[FC_CC] = find
-            (
-                centreEdgeToVert,
-                centreEdge(faceI, isOwner)
-            );
-
-            const face& f = mesh.faces()[faceI];
-
-            forAll(f, fp)
-            {
-                label fp1 = (fp+1) % f.size();
-
-                tetVertCuts[FP0] = find(meshVertToVert, f[fp]);
-                tetVertCuts[FP1] = find(meshVertToVert, f[fp1]);
-
-
-                tetEdgeCuts[FP0_FC] = find
-                (
-                    faceEdgeToVert,
-                    faceEdge(faceI, fp)
-                );
-
-
-                label edgeI = findEdge
-                (
-                    mesh.edges(),
-                    mesh.faceEdges()[faceI],
-                    edge(f[fp], f[fp1])
-                );
-                tetEdgeCuts[FP0_FP1] = find
-                (
-                    meshEdgeToVert,
-                    edgeI
-                );
-
-                tetEdgeCuts[FP0_CC] = find
-                (
-                    pyrEdgeToVert,
-                    pyramidEdge(f[fp], cellI)
-                );
-
-                tetEdgeCuts[FC_FP1] = find
-                (
-                    faceEdgeToVert,
-                    faceEdge(faceI, fp1)
-                );
-
-                tetEdgeCuts[FP1_CC] = find
-                (
-                    pyrEdgeToVert,
-                    pyramidEdge(f[fp1], cellI)
-                );
-
-
-                cutTet
-                (
-                    tetPlus,
-                    tetVertCuts,
-                    tetEdgeCuts,
-                    cellI,
-
-                    tris,
-                    triI
-                );
-            }
-        }
-    }
-
-    tris.setSize(triI);
-
-    // Get a point outside all of the surface (over all processors)
-    boundBox bb(points, true);
-
-    point outsidePt(1.5*bb.max() - 0.5*bb.min());
-
-    // Orient the surface after removing duplicate faces.
-    triSurface::operator=
-    (
-        orientedSurface
-        (
-            removeDuplicates
-            (
-                triSurface(tris, points)
-            ),
-            outsidePt
-        )
-    );
-}
-
-
-// Construct from edge cuts. Is given edges and position on edge.
-//  - cuts.cells(): list of cells affected in any way by cutting.
-//  - cuts.meshVerts(): labels of mesh vertices that are cut (cut exactly through
-//    point
-//  - cuts.cellCentres(): cell labels whose cellcentres are cut
-//  - cuts.meshEdges(): labels of mesh edges that are cut
-//  - cuts.pyrEdges(): pyramid edges cut
-//  - cuts.diagEdges(): diagonal edges cut
-Foam::meshCutSurface::meshCutSurface(const cellDecompCuts& cuts)
-:
-    triSurface()
-{
-    const primitiveMesh& mesh = cuts.mesh();
-
-    // Collect points and create reverse map from edge to new vertex.
-    pointField points(cuts.size());
-    label pointI = 0;
-
-    //
-    // Cuts through existing points
-    //
-
-    // Mesh vertices cut
-    Map<label> meshVertToVert(cuts.meshVerts().size()*2);
-
-    forAll(cuts.meshVerts(), cutVertI)
-    {
-        points[pointI++] = mesh.points()[cuts.meshVerts()[cutVertI]];
-
-        meshVertToVert.insert(cuts.meshVerts()[cutVertI], pointI - 1);
-    }
-
-    // Cell centres cut
-    Map<label> cellCentreToVert(cuts.meshCellCentres().size()*2);
-
-    forAll(cuts.meshCellCentres(), cutCellCentreI)
-    {
-        label cellI = cuts.meshCellCentres()[cutCellCentreI];
-
-        points[pointI++] = mesh.cellCentres()[cellI];
-
-        cellCentreToVert.insert(cellI, pointI - 1);
-    }
-
-
-    //
-    // Cuts through edges
-    //
-
-    // Cuts through existing (mesh) edges
-    Map<label> meshEdgeToVert(cuts.meshEdges().size()*2);
-
-    forAll(cuts.meshEdges(), meshCutSurfaceEdgeI)
-    {
-        label edgeI = cuts.meshEdges()[meshCutSurfaceEdgeI];
-
-        const edge& e = mesh.edges()[edgeI];
-
-        scalar weight = cuts.meshEdgeWeights()[meshCutSurfaceEdgeI];
-
-        points[pointI++] =
-            (1-weight)*mesh.points()[e.start()]
-          + weight*mesh.points()[e.end()];
-
-        meshEdgeToVert.insert(edgeI, pointI - 1);
-    }
-
-    // Cuts on tetDecomposition: Pyramid edges
-    HashTable<label, pyramidEdge, pyramidEdge::pyramidEdgeHash>
-        pyrEdgeToVert(cuts.pyrEdges().size()*2);
-
-    forAll(cuts.pyrEdges(), edgeI)
-    {
-        const pyramidEdge& e = cuts.pyrEdges()[edgeI];
-
-        points[pointI++] = e.coord(mesh, cuts.pyrEdgeWeights()[edgeI]);
-
-        pyrEdgeToVert.insert(e, pointI - 1);
-    }
-
-    // Cuts on tetDecomposition: diagonal edges
-    HashTable<label, diagonalEdge, diagonalEdge::diagonalEdgeHash>
-        diagEdgeToVert(cuts.diagEdges().size()*2);
-
-    forAll(cuts.diagEdges(), edgeI)
-    {
-        const diagonalEdge& e = cuts.diagEdges()[edgeI];
-
-        points[pointI++] = e.coord(mesh, cuts.diagEdgeWeights()[edgeI]);
-
-        diagEdgeToVert.insert(e, pointI - 1);
-    }
-
-
-
-    // Generate tet model + additional addressing
-    const cellModel& tet = *(cellModeller::lookup("tet"));
-
-    cellAddressing tetPlus(tet);
-
-    // Tet edges cut. -1 if edge not cut, vertex label otherwise.
-    labelList tetEdgeCuts(6);
-
-    // Tet vertices cut. -1 if edge not cut, vertex label otherwise.
-    labelList tetVertCuts(4);
-
-    List<labelledTri> tris(2*cuts.size());
-    label triI = 0;
-
-    forAll(cuts.cells(), cutCellI)
-    {
-        label cellI = cuts.cells()[cutCellI];
-
-        tetVertCuts[CC] = find(cellCentreToVert, cellI);
-
-        const cell& cellFaces = mesh.cells()[cellI];
-
-        forAll(cellFaces, cellFaceI)
-        {
-            label faceI = cellFaces[cellFaceI];
-
-            const face& f = mesh.faces()[faceI];
-
-            // Handle f0 separately
-            tetVertCuts[FC] = find(meshVertToVert, f[0]);
-            tetEdgeCuts[FC_CC] = find
-            (
-                pyrEdgeToVert,
-                pyramidEdge(f[0], cellI)
-            );
-
-            for (label fp = 1; fp < f.size()-1; fp++)
-            {
-                label fp1 = fp+1;
-
-                tetVertCuts[FP0] = find(meshVertToVert, f[fp]);
-                tetVertCuts[FP1] = find(meshVertToVert, f[fp1]);
-
-                tetEdgeCuts[FP0_FP1] = find
-                (
-                    meshEdgeToVert,
-                    findEdge
-                    (
-                        mesh.edges(),
-                        mesh.faceEdges()[faceI],
-                        edge(f[fp], f[fp1])
-                    )
-                );
-
-                if (fp == 1)
-                {
-                    // f[1] to f[0] is normal mesh edge
-                    tetEdgeCuts[FP0_FC] = find
-                    (
-                        meshEdgeToVert,
-                        findEdge
-                        (
-                            mesh.edges(),
-                            mesh.faceEdges()[faceI],
-                            edge(f[0], f[fp])
-                        )
-                    );
-                }
-                else
-                {
-                    // Diagonal cut
-                    tetEdgeCuts[FP0_FC] = find
-                    (
-                        diagEdgeToVert,
-                        diagonalEdge(faceI, 0, fp)
-                    );
-                }
-
-                if (fp1 == f.size()-1)
-                {
-                    // Last face vertex to f[0] -> normal mesh edge
-                    tetEdgeCuts[FC_FP1] = find
-                    (
-                        meshEdgeToVert,
-                        findEdge
-                        (
-                            mesh.edges(),
-                            mesh.faceEdges()[faceI],
-                            edge(f[0], f[fp1])
-                        )
-                    );
-                }
-                else
-                {
-                    tetEdgeCuts[FC_FP1] = find
-                    (
-                        diagEdgeToVert,
-                        diagonalEdge(faceI, 0, fp1)
-                    );
-                }
-
-                tetEdgeCuts[FP0_CC] = find
-                (
-                    pyrEdgeToVert,
-                    pyramidEdge(f[fp], cellI)
-                );
-
-                tetEdgeCuts[FP1_CC] = find
-                (
-                    pyrEdgeToVert,
-                    pyramidEdge(f[fp1], cellI)
-                );
-
-
-                cutTet
-                (
-                    tetPlus,
-                    tetVertCuts,
-                    tetEdgeCuts,
-                    cellI,
-
-                    tris,
-                    triI
-                );
-            }
-        }
-    }
-
-    tris.setSize(triI);
-
-    // Get a point outside all of the surface (over all processors)
-    boundBox bb(points, true);
-
-    point outsidePt(1.5*bb.max() - 0.5*bb.min());
-
-    // Orient the surface after removing duplicate faces.
-    triSurface::operator=
-    (
-        orientedSurface
-        (
-            removeDuplicates
-            (
-                triSurface(tris, points)
-            ),
-            outsidePt
-        )
-    );
-}
-
-
-// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
-
-
-// ************************************************************************* //
diff --git a/src/finiteVolume/fvMesh/fvMeshCutSurface/meshCut/meshCutSurface.H b/src/finiteVolume/fvMesh/fvMeshCutSurface/meshCut/meshCutSurface.H
deleted file mode 100644
index c5d92529ff..0000000000
--- a/src/finiteVolume/fvMesh/fvMeshCutSurface/meshCut/meshCutSurface.H
+++ /dev/null
@@ -1,209 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software; you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by the
-    Free Software Foundation; either version 2 of the License, or (at your
-    option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM; if not, write to the Free Software Foundation,
-    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
-
-Class
-    Foam::meshCutSurface
-
-Description
-    Description of surface resulting from cuts through mesh. Region on
-    labelledTris is the cell the triangle is resulting from.
-
-SourceFiles
-    meshCutSurface.C
-
-\*---------------------------------------------------------------------------*/
-
-#ifndef meshCutSurface_H
-#define meshCutSurface_H
-
-#include "labelList.H"
-#include "HashTable.H"
-#include "pointField.H"
-#include "triSurface.H"
-#include "boolList.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-namespace Foam
-{
-
-// Forward declaration of classes
-class primitiveMesh;
-class cellAddressing;
-class faceDecompCuts;
-class cellDecompCuts;
-
-/*---------------------------------------------------------------------------*\
-                           Class meshCutSurface Declaration
-\*---------------------------------------------------------------------------*/
-
-class meshCutSurface
-:
-    public triSurface
-{
-
-    // Static data members
-
-        //- Symbolic names of tet vertices
-        static label FP0;
-        static label FC;
-        static label FP1;
-        static label CC;
-
-        //- Symbolic names of tet edges
-        static label FP0_FC;
-        static label FP0_FP1;
-        static label FP0_CC;
-        static label FC_CC;
-        static label FC_FP1;
-        static label FP1_CC;
-
-
-    // Private Static Functions
-
-        //- Find key in hashtable. Returns value or -1 if not found
-        template<class T, class Hash>
-        static label find
-        (
-            const HashTable<label, T, Hash>& table,
-            const T& key
-        );
-
-        //- Find edge in subset edgeLabels of edges.
-        static label findEdge
-        (
-            const edgeList& edges,
-            const labelList& edgeLabels,
-            const edge& e
-        );
-
-        //- Find the other (i.e. not cutEdgeI) cut-edge on faceI of cell model
-        static label findCutEdge
-        (
-            const cellAddressing& model,
-            const labelList& tetEdgeCuts,
-            const label faceI,
-            const label cutEdgeI
-        );
-
-
-    // Private Member Functions
-
-        //- Remove duplicate faces (resulting from 3 meshVerts cut - is seen
-        //  from both sides)
-        static triSurface removeDuplicates(const triSurface& surf);
-
-
-public:
-
-        //- Generic tet cutting routine.
-        //  Generate triangles given the cut vertices and edges of the tet.
-        //  (Triangles can be incorrectly oriented)
-        void cutTet
-        (
-            const cellAddressing& model,
-            const labelList& tetVertCuts,
-            const labelList& tetEdgeCuts,
-            const label cellI,
-            List<labelledTri>& tris,
-            label& triI
-        );
-
-        //- Tet cutting when cuts are only through edges.
-        void cutTetThroughEdges
-        (
-            const cellAddressing& model,
-            const labelList& tetEdgeCuts,
-            const label nEdgeCuts,
-            const label cellI,
-            List<labelledTri>& tris,
-            label& triI
-        );
-
-        //- Tet cutting when cuts are through corner vertices (and possibly
-        //  edges)
-        void cutTetThroughVerts
-        (
-            const cellAddressing& model,
-            const labelList& tetVertCuts,
-            const label nVertCuts,
-            const labelList& tetEdgeCuts,
-            const label nEdgeCuts,
-            const label cellI,
-            List<labelledTri>& tris,
-            label& triI
-        );
-
-
-    // Static functions
-
-        //- Interpolate onto points given edge weights, cell centre values,
-        //  face centre values and vertex values
-        template <class T>
-        static tmp<Field<T> > interpolate
-        (
-            const faceDecompCuts& cuts,
-            const Field<T>& vField,
-            const Field<T>& fField,
-            const Field<T>& pField
-        );
-
-        //- Interpolate onto points given edge weights, cell centre values,
-        //  and vertex values
-        template <class T>
-        static tmp<Field<T> > interpolate
-        (
-            const cellDecompCuts& cuts,
-            const Field<T>& vField,
-            const Field<T>& pField
-        );
-
-
-    // Constructors
-
-        //- Construct from cuts on faceDecomp tet decomposition
-        //  (introduces cellcentres and facecentres)
-        meshCutSurface(const faceDecompCuts& cuts);
-
-        //- Construct from cuts on cellDecomp tet decomposition
-        //  (introduces cellcentres but not facecentres)
-        meshCutSurface(const cellDecompCuts& cuts);
-};
-
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#ifdef NoRepository
-#   include "meshCutSurfaceInterpolate.C"
-#endif
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#endif
-
-// ************************************************************************* //
diff --git a/src/finiteVolume/fvMesh/fvMeshCutSurface/meshCut/meshCutSurfaceInterpolate.C b/src/finiteVolume/fvMesh/fvMeshCutSurface/meshCut/meshCutSurfaceInterpolate.C
deleted file mode 100644
index 37327e0467..0000000000
--- a/src/finiteVolume/fvMesh/fvMeshCutSurface/meshCut/meshCutSurfaceInterpolate.C
+++ /dev/null
@@ -1,174 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software; you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by the
-    Free Software Foundation; either version 2 of the License, or (at your
-    option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM; if not, write to the Free Software Foundation,
-    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
-
-\*---------------------------------------------------------------------------*/
-
-#include "meshCutSurface.H"
-#include "pyramidEdge.H"
-#include "faceEdge.H"
-#include "centreEdge.H"
-#include "diagonalEdge.H"
-#include "faceDecompCuts.H"
-#include "cellDecompCuts.H"
-
-// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
-
-template <class T>
-Foam::tmp<Foam::Field<T> > Foam::meshCutSurface::interpolate
-(
-    const faceDecompCuts& cuts,
-    const Field<T>& vField,
-    const Field<T>& fField,
-    const Field<T>& pField
-)
-{
-    const primitiveMesh& mesh = cuts.mesh();
-
-    tmp<Field<T> > tvals(new Field<T>(cuts.size()));
-    Field<T>& vals = tvals();
-
-    label pointI = 0;
-
-    forAll(cuts.meshVerts(), cutVertI)
-    {
-        vals[pointI++] = pField[cuts.meshVerts()[cutVertI]];
-    }
-
-    forAll(cuts.meshFaceCentres(), cutFaceCentreI)
-    {
-        label faceI = cuts.meshFaceCentres()[cutFaceCentreI];
-
-        vals[pointI++] = fField[faceI];
-    }
-
-    forAll(cuts.meshCellCentres(), cutCellCentreI)
-    {
-        label cellI = cuts.meshCellCentres()[cutCellCentreI];
-
-        vals[pointI++] = vField[cellI];
-    }
-
-    forAll(cuts.meshEdges(), meshCutSurfaceEdgeI)
-    {
-        label edgeI = cuts.meshEdges()[meshCutSurfaceEdgeI];
-
-        const edge& e = mesh.edges()[edgeI];
-
-        scalar weight = cuts.meshEdgeWeights()[meshCutSurfaceEdgeI];
-
-        vals[pointI++] = weight*pField[e.start()] + (1-weight)*pField[e.end()];
-    }
-
-    forAll(cuts.pyrEdges(), edgeI)
-    {
-        const pyramidEdge& e = cuts.pyrEdges()[edgeI];
-
-        scalar weight = cuts.pyrEdgeWeights()[edgeI];
-
-        vals[pointI++] = e.interpolate(vField, pField, weight);
-    }
-
-    forAll(cuts.centreEdges(), edgeI)
-    {
-        const centreEdge& e = cuts.centreEdges()[edgeI];
-
-        scalar weight = cuts.centreEdgeWeights()[edgeI];
-
-        vals[pointI++] = e.interpolate(mesh, vField, fField, weight);
-    }
-
-    forAll(cuts.faceEdges(), edgeI)
-    {
-        const faceEdge& e = cuts.faceEdges()[edgeI];
-
-        scalar weight = cuts.faceEdgeWeights()[edgeI];
-
-        vals[pointI++] = e.interpolate(mesh, fField, pField, weight);
-    }
-
-    return tvals;
-}
-
-
-template <class T>
-Foam::tmp<Foam::Field<T> > Foam::meshCutSurface::interpolate
-(
-    const cellDecompCuts& cuts,
-    const Field<T>& vField,
-    const Field<T>& pField
-)
-{
-    const primitiveMesh& mesh = cuts.mesh();
-
-    tmp<Field<T> > tvals(new Field<T>(cuts.size()));
-    Field<T>& vals = tvals();
-
-    label pointI = 0;
-
-    forAll(cuts.meshVerts(), cutVertI)
-    {
-        vals[pointI++] = pField[cuts.meshVerts()[cutVertI]];
-    }
-
-    forAll(cuts.meshCellCentres(), cutCellCentreI)
-    {
-        label cellI = cuts.meshCellCentres()[cutCellCentreI];
-
-        vals[pointI++] = vField[cellI];
-    }
-
-    forAll(cuts.meshEdges(), meshCutSurfaceEdgeI)
-    {
-        label edgeI = cuts.meshEdges()[meshCutSurfaceEdgeI];
-
-        const edge& e = mesh.edges()[edgeI];
-
-        scalar weight = cuts.meshEdgeWeights()[meshCutSurfaceEdgeI];
-
-        vals[pointI++] = weight*pField[e.start()] + (1-weight)*pField[e.end()];
-    }
-
-    forAll(cuts.pyrEdges(), edgeI)
-    {
-        const pyramidEdge& e = cuts.pyrEdges()[edgeI];
-
-        scalar weight = cuts.pyrEdgeWeights()[edgeI];
-
-        vals[pointI++] = e.interpolate(vField, pField, weight);
-    }
-
-    forAll(cuts.diagEdges(), edgeI)
-    {
-        const diagonalEdge& e = cuts.diagEdges()[edgeI];
-
-        scalar weight = cuts.diagEdgeWeights()[edgeI];
-
-        vals[pointI++] = e.interpolate(mesh, pField, weight);
-    }
-
-    return tvals;
-}
-
-
-// ************************************************************************* //
diff --git a/src/finiteVolume/fvMesh/fvMeshCutSurface/tetEdges/centreEdge.H b/src/finiteVolume/fvMesh/fvMeshCutSurface/tetEdges/centreEdge.H
deleted file mode 100644
index a7646089e9..0000000000
--- a/src/finiteVolume/fvMesh/fvMeshCutSurface/tetEdges/centreEdge.H
+++ /dev/null
@@ -1,187 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software; you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by the
-    Free Software Foundation; either version 2 of the License, or (at your
-    option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM; if not, write to the Free Software Foundation,
-    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
-
-Class
-    Foam::centreEdge
-
-Description
-    Implicit description of faceCentre to cellCentre edge
-    (from tet decomposition).
-
-    Stores
-      - face label
-      - whether in owner or neighbour of face
-
-SourceFiles
-
-\*---------------------------------------------------------------------------*/
-
-#ifndef centreEdge_H
-#define centreEdge_H
-
-#include "label.H"
-#include "primitiveMesh.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-namespace Foam
-{
-
-// Forward declaration of classes
-
-/*---------------------------------------------------------------------------*\
-                           Class centreEdge Declaration
-\*---------------------------------------------------------------------------*/
-
-class centreEdge
-{
-    // Private data
-
-        //- face label
-        label faceLabel_;
-
-        //- is in owner or neighbour of face
-        bool inOwner_;
-
-public:
-
-    // Public classes
-
-        //- Hash function
-        class centreEdgeHash
-        {
-
-        public:
-
-            centreEdgeHash()
-            {}
-
-            //- simple hashing function of labels
-            label operator()(const centreEdge& ce, const label tableSize) const
-            {
-                return (ce.faceLabel() + ce.inOwner()) % tableSize;
-            }
-        };
-
-
-    // Constructors
-
-        //- Construct null
-        inline centreEdge()
-        :
-            faceLabel_(-1),
-            inOwner_(-1)
-        {}
-
-        //- Construct from components
-        inline centreEdge(const label faceLabel, const bool inOwner)
-        :
-            faceLabel_(faceLabel),
-            inOwner_(inOwner)
-        {}
-
-    // Member Functions
-
-        label faceLabel() const
-        {   
-            return faceLabel_;
-        }
-
-        bool inOwner() const
-        {   
-            return inOwner_;
-        }
-
-        template <class T>
-        T interpolate
-        (
-            const primitiveMesh& mesh,
-            const Field<T>& cellField,
-            const Field<T>& faceField,
-            const scalar weight
-        ) const
-        {
-            label cellI;
-            if (inOwner_)
-            {
-                cellI = mesh.faceOwner()[faceLabel_];
-            }
-            else
-            {
-                cellI = mesh.faceNeighbour()[faceLabel_];
-            }
-
-            return
-                (1-weight)*faceField[faceLabel_]
-              + weight*cellField[cellI];
-        }
-
-        point coord(const primitiveMesh& mesh, const scalar weight) const
-        {
-            return interpolate
-            (
-                mesh,
-                mesh.cellCentres(),
-                mesh.faceCentres(),
-                weight
-            );
-        }
-
-
-    // Member Operators
-
-        bool operator==(const centreEdge& ce) const
-        {
-            return
-                (faceLabel() == ce.faceLabel())
-             && (inOwner() == ce.inOwner());
-        }
-
-
-    // IOstream Operators
-
-        inline friend Ostream& operator<<(Ostream& os, const centreEdge& ce)
-        {
-            os  << token::BEGIN_LIST
-                << ce.faceLabel_ << token::SPACE
-                << ce.inOwner_
-                << token::END_LIST;
-
-            // Check state of Ostream
-            os.check("Ostream& operator<<(Ostream&, const centreEdge&)");
-
-            return os;
-        }
-};
-
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#endif
-
-// ************************************************************************* //
diff --git a/src/finiteVolume/fvMesh/fvMeshCutSurface/tetEdges/diagonalEdge.H b/src/finiteVolume/fvMesh/fvMeshCutSurface/tetEdges/diagonalEdge.H
deleted file mode 100644
index fed2e1d9f5..0000000000
--- a/src/finiteVolume/fvMesh/fvMeshCutSurface/tetEdges/diagonalEdge.H
+++ /dev/null
@@ -1,199 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software; you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by the
-    Free Software Foundation; either version 2 of the License, or (at your
-    option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM; if not, write to the Free Software Foundation,
-    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
-
-Class
-    Foam::diagonalEdge
-
-Description
-    Implicit description of diagonal edge (from tet decomposition).
-    Diangonal edge is edge between two vertices of same face.
-
-    Stores
-        - face label
-        - indices in face
-
-SourceFiles
-
-\*---------------------------------------------------------------------------*/
-
-#ifndef diagonalEdge_H
-#define diagonalEdge_H
-
-#include "label.H"
-#include "primitiveMesh.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-namespace Foam
-{
-
-/*---------------------------------------------------------------------------*\
-                           Class diagonalEdge Declaration
-\*---------------------------------------------------------------------------*/
-
-class diagonalEdge
-{
-    // Private data
-
-        //- face label
-        label faceLabel_;
-
-        //- index in face
-        label faceIndex0_;
-
-        //- index in face
-        label faceIndex1_;
-
-public:
-
-    // Public classes
-
-        //- Hash function
-        class diagonalEdgeHash
-        {
-
-        public:
-
-            diagonalEdgeHash()
-            {}
-
-            //- simple hashing function of labels. Commutative on face indices
-            //  since edge is same.
-            label operator()(const diagonalEdge& de, const label tableSize)
-                const
-            {
-                // Note: mag since multiply might overflow and produce
-                // negative numbers
-                return
-                    mag
-                    (
-                        de.faceLabel()
-                      + (de.faceLabel()*de.faceLabel())
-                      + de.faceIndex0() * de.faceIndex1()
-                      + (de.faceIndex0() + de.faceIndex1())
-                    )
-                  % tableSize;
-            }
-        };
-
-
-    // Constructors
-
-        //- Construct null
-        inline diagonalEdge()
-        :
-            faceLabel_(-1),
-            faceIndex0_(-1),
-            faceIndex1_(-1)
-        {}
-
-        //- Construct from components
-        inline diagonalEdge
-        (
-            const label faceLabel,
-            const label faceIndex0,
-            const label faceIndex1
-        )
-        :
-            faceLabel_(faceLabel),
-            faceIndex0_(faceIndex0),
-            faceIndex1_(faceIndex1)
-        {}
-
-    // Member Functions
-
-        label faceLabel() const
-        {   
-            return faceLabel_;
-        }
-
-        label faceIndex0() const
-        {   
-            return faceIndex0_;
-        }
-
-        label faceIndex1() const
-        {   
-            return faceIndex1_;
-        }
-
-        template <class T>
-        T interpolate
-        (
-            const primitiveMesh& mesh,
-            const Field<T>& vertField,
-            const scalar weight
-        ) const
-        {
-            const face& f = mesh.faces()[faceLabel_];
-
-            return
-                (1-weight)*vertField[f[faceIndex0_]]
-              + weight*vertField[f[faceIndex1_]];
-        }
-
-        point coord(const primitiveMesh& mesh, const scalar weight) const
-        {
-            return interpolate(mesh, mesh.points(), weight);
-        }
-
-
-    // Member Operators
-
-        bool operator==(const diagonalEdge& de) const
-        {
-            return
-                (faceLabel() == de.faceLabel())
-             && (faceIndex0() == de.faceIndex0())
-             && (faceIndex1() == de.faceIndex1());
-        }
-
-
-    // IOstream Operators
-
-        inline friend Ostream& operator<<(Ostream& os, const diagonalEdge& de)
-        {
-            os  << token::BEGIN_LIST
-                << de.faceLabel_ << token::SPACE
-                << de.faceIndex0_ << token::SPACE
-                << de.faceIndex1_
-                << token::END_LIST;
-
-            // Check state of Ostream
-            os.check("Ostream& operator<<(Ostream&, const diagonalEdge&)");
-
-            return os;
-        }
-};
-
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#endif
-
-// ************************************************************************* //
diff --git a/src/finiteVolume/fvMesh/fvMeshCutSurface/tetEdges/faceEdge.H b/src/finiteVolume/fvMesh/fvMeshCutSurface/tetEdges/faceEdge.H
deleted file mode 100644
index 6676862c7c..0000000000
--- a/src/finiteVolume/fvMesh/fvMeshCutSurface/tetEdges/faceEdge.H
+++ /dev/null
@@ -1,186 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software; you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by the
-    Free Software Foundation; either version 2 of the License, or (at your
-    option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM; if not, write to the Free Software Foundation,
-    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
-
-Class
-    Foam::faceEdge
-
-Description
-    Implicit description of face edge (from tet decomposition).
-    Face edge is edge between vertex of face and face centre.
-
-    Stores
-        - face label
-        - index in face (gives the mesh vertex)
-
-
-SourceFiles
-
-\*---------------------------------------------------------------------------*/
-
-#ifndef faceEdge_H
-#define faceEdge_H
-
-#include "label.H"
-#include "primitiveMesh.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-namespace Foam
-{
-
-// Forward declaration of classes
-
-/*---------------------------------------------------------------------------*\
-                           Class faceEdge Declaration
-\*---------------------------------------------------------------------------*/
-
-class faceEdge
-{
-    // Private data
-
-        //- face label
-        label faceLabel_;
-
-        //- index in face
-        label faceIndex_;
-
-public:
-
-    // Public classes
-
-        //- Hash function
-        class faceEdgeHash
-        {
-
-        public:
-
-            faceEdgeHash()
-            {}
-
-            //- simple hashing function of labels
-            label operator()(const faceEdge& fe, const label tableSize)
-                const
-            {
-                // Note: mag since multiply might overflow and produce
-                // negative numbers
-                return
-                    mag
-                    (
-                        fe.faceLabel()
-                      + (fe.faceLabel() * fe.faceLabel())
-                      + fe.faceIndex()
-                      + (fe.faceIndex() * fe.faceIndex())
-                    )
-                  % tableSize;
-            }
-        };
-
-
-    // Constructors
-
-        //- Construct null
-        inline faceEdge()
-        :
-            faceLabel_(-1),
-            faceIndex_(-1)
-        {}
-
-        //- Construct from components
-        inline faceEdge(const label faceLabel, const label faceIndex)
-        :
-            faceLabel_(faceLabel),
-            faceIndex_(faceIndex)
-        {}
-
-    // Member Functions
-
-        label faceLabel() const
-        {
-            return faceLabel_;
-        }
-
-        label faceIndex() const
-        {
-            return faceIndex_;
-        }
-
-        template <class T>
-        T interpolate
-        (
-            const primitiveMesh& mesh,
-            const Field<T>& faceField,
-            const Field<T>& vertField,
-            const scalar weight
-        ) const
-        {
-            const face& f = mesh.faces()[faceLabel_];
-
-            return
-                (1-weight)*vertField[f[faceIndex_]]
-              + weight*faceField[faceLabel_];
-        }
-
-
-        point coord(const primitiveMesh& mesh, const scalar weight) const
-        {
-            return interpolate(mesh, mesh.faceCentres(), mesh.points(), weight);
-        }
-
-
-    // Member Operators
-
-        bool operator==(const faceEdge& fe) const
-        {
-            return
-                (faceLabel() == fe.faceLabel())
-             && (faceIndex() == fe.faceIndex());
-        }
-
-
-    // IOstream Operators
-
-        inline friend Ostream& operator<<(Ostream& os, const faceEdge& fe)
-        {
-            os  << token::BEGIN_LIST
-                << fe.faceLabel_ << token::SPACE
-                << fe.faceIndex_
-                << token::END_LIST;
-
-            // Check state of Ostream
-            os.check("Ostream& operator<<(Ostream&, const faceEdge&)");
-
-            return os;
-        }
-};
-
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#endif
-
-// ************************************************************************* //
diff --git a/src/finiteVolume/fvMesh/fvMeshCutSurface/tetEdges/pyramidEdge.H b/src/finiteVolume/fvMesh/fvMeshCutSurface/tetEdges/pyramidEdge.H
deleted file mode 100644
index b05fc6d2ef..0000000000
--- a/src/finiteVolume/fvMesh/fvMeshCutSurface/tetEdges/pyramidEdge.H
+++ /dev/null
@@ -1,185 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software; you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by the
-    Free Software Foundation; either version 2 of the License, or (at your
-    option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM; if not, write to the Free Software Foundation,
-    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
-
-Class
-    Foam::pyramidEdge
-
-Description
-    Implicit description of pyramid edge (from tet decomposition).
-    Pyramid edge is edge between mesh vertex and cell centre.
-
-    Stores
-        - vertex label
-        - cell label
-
-SourceFiles
-
-\*---------------------------------------------------------------------------*/
-
-#ifndef pyramidEdge_H
-#define pyramidEdge_H
-
-#include "label.H"
-#include "primitiveMesh.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-namespace Foam
-{
-
-// Forward declaration of classes
-
-/*---------------------------------------------------------------------------*\
-                           Class pyramidEdge Declaration
-\*---------------------------------------------------------------------------*/
-
-class pyramidEdge
-{
-    // Private data
-
-        //- vertex label
-        label vertexLabel_;
-
-        //- cell label
-        label cellLabel_;
-
-public:
-
-    // Public classes
-
-        //- Hash function
-        class pyramidEdgeHash
-        {
-
-        public:
-
-            pyramidEdgeHash()
-            {}
-
-            //- simple hashing function of labels
-            label operator()(const pyramidEdge& pe, const label tableSize) const
-            {
-                // Note: mag since multiply might overflow and produce
-                // negative numbers
-                return
-                    mag
-                    (
-                        pe.vertexLabel()
-                      + (pe.vertexLabel() * pe.vertexLabel())
-                      + pe.cellLabel()
-                      + (pe.cellLabel() * pe.cellLabel())
-                    )
-                  % tableSize;
-            }
-        };
-
-
-    // Constructors
-
-        //- Construct null
-        inline pyramidEdge()
-        :
-            vertexLabel_(-1),
-            cellLabel_(-1)
-        {}
-
-        //- Construct from components
-        inline pyramidEdge
-        (
-            const label vertexLabel,
-            const label cellLabel
-        )
-        :
-            vertexLabel_(vertexLabel),
-            cellLabel_(cellLabel)
-        {}
-
-    // Member Functions
-
-        label vertexLabel() const
-        {   
-            return vertexLabel_;
-        }
-
-        label cellLabel() const
-        {   
-            return cellLabel_;
-        }
-
-        template <class T>
-        T interpolate
-        (
-            const Field<T>& cellField,
-            const Field<T>& vertField,
-            const scalar weight
-        ) const
-        {
-            return
-                (1-weight)*vertField[vertexLabel_]
-              + weight*cellField[cellLabel_];
-        }
-
-
-        point coord(const primitiveMesh& mesh, const scalar weight) const
-        {
-            return interpolate(mesh.cellCentres(), mesh.points(), weight);
-        }
-
-
-    // Member Operators
-
-        bool operator==(const pyramidEdge& pe) const
-        {
-            return
-                (vertexLabel() == pe.vertexLabel())
-             && (cellLabel() == pe.cellLabel());
-        }
-
-
-    // IOstream Operators
-
-        inline friend Ostream& operator<<(Ostream& os, const pyramidEdge& pe)
-        {
-            os  << token::BEGIN_LIST
-                << pe.vertexLabel_ << token::SPACE
-                << pe.cellLabel_
-                << token::END_LIST;
-
-            // Check state of Ostream
-            os.check("Ostream& operator<<(Ostream&, const pyramidEdge&)");
-
-            return os;
-        }
-};
-
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#endif
-
-// ************************************************************************* //

From 1538606f58791e3158fd2b5a50651484274e9f85 Mon Sep 17 00:00:00 2001
From: mattijs <mattijs@hunt.opencfd.co.uk>
Date: Fri, 7 Nov 2008 11:46:13 +0000
Subject: [PATCH 11/16] signed distance

---
 .../distanceSurface/distanceSurface.C         | 36 +++++++++++++++----
 .../distanceSurface/distanceSurface.H         |  3 ++
 2 files changed, 33 insertions(+), 6 deletions(-)

diff --git a/src/sampling/sampledSurface/distanceSurface/distanceSurface.C b/src/sampling/sampledSurface/distanceSurface/distanceSurface.C
index 66cfac6fb5..fca90949ca 100644
--- a/src/sampling/sampledSurface/distanceSurface/distanceSurface.C
+++ b/src/sampling/sampledSurface/distanceSurface/distanceSurface.C
@@ -56,13 +56,36 @@ void Foam::distanceSurface::createGeometry() const
             scalarField(mesh().nCells(), GREAT),
             nearest
         );
-        forAll(cellDistance, cellI)
+
+        if (signed_)
         {
-            cellDistance[cellI] = Foam::mag
-            (
-                nearest[cellI].hitPoint()
-              - mesh().cellCentres()[cellI]
-            );
+            vectorField normal;
+            surfPtr_().getNormal(nearest, normal);
+
+            forAll(cellDistance, cellI)
+            {
+                vector d(mesh().cellCentres()[cellI]-nearest[cellI].hitPoint());
+
+                if ((d&normal[cellI]) > 0)
+                {
+                    cellDistance[cellI] = Foam::mag(d);
+                }
+                else
+                {
+                    cellDistance[cellI] = -Foam::mag(d);
+                }
+            }
+        }
+        else
+        {
+            forAll(cellDistance, cellI)
+            {
+                cellDistance[cellI] = Foam::mag
+                (
+                    nearest[cellI].hitPoint()
+                  - mesh().cellCentres()[cellI]
+                );
+            }
         }
     }
 
@@ -166,6 +189,7 @@ Foam::distanceSurface::distanceSurface
         )
     ),
     distance_(readScalar(dict.lookup("distance"))),
+    signed_(readBool(dict.lookup("signed"))),
     regularise_(dict.lookupOrDefault("regularise", true)),
     zoneName_(word::null),
     facesPtr_(NULL),
diff --git a/src/sampling/sampledSurface/distanceSurface/distanceSurface.H b/src/sampling/sampledSurface/distanceSurface/distanceSurface.H
index bb7290c5d8..82fba8a83f 100644
--- a/src/sampling/sampledSurface/distanceSurface/distanceSurface.H
+++ b/src/sampling/sampledSurface/distanceSurface/distanceSurface.H
@@ -62,6 +62,9 @@ class distanceSurface
         //- distance value
         const scalar distance_;
 
+        //- signed distance
+        const bool signed_;
+
         //- Whether to coarsen
         const Switch regularise_;
 

From 856c44c2640cdfcc11c4c0fae1f90a6e6eeb1007 Mon Sep 17 00:00:00 2001
From: mattijs <mattijs@hunt.opencfd.co.uk>
Date: Fri, 7 Nov 2008 11:50:58 +0000
Subject: [PATCH 12/16] simplification

---
 .../sampledSurface/isoSurface/isoSurface.C    | 124 +++++++++++++++++-
 .../sampledSurface/isoSurface/isoSurface.H    |   2 +
 2 files changed, 124 insertions(+), 2 deletions(-)

diff --git a/src/sampling/sampledSurface/isoSurface/isoSurface.C b/src/sampling/sampledSurface/isoSurface/isoSurface.C
index 9a60ab84ad..4e3d08f44a 100644
--- a/src/sampling/sampledSurface/isoSurface/isoSurface.C
+++ b/src/sampling/sampledSurface/isoSurface/isoSurface.C
@@ -24,15 +24,14 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-#include "Field.H"
 #include "isoSurface.H"
 #include "dictionary.H"
 #include "polyMesh.H"
 #include "mergePoints.H"
 #include "tetMatcher.H"
 #include "syncTools.H"
-
 #include "addToRunTimeSelectionTable.H"
+#include "faceTriangulation.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
@@ -1867,7 +1866,128 @@ Foam::isoSurface::isoSurface
     }
 
     orientSurface(*this, faceEdges, edgeFace0, edgeFace1, edgeFacesRest);
+
+    //combineCellTriangles();
 }
 
 
+//XXXXXXX
+// Experimental retriangulation of triangles per cell. Problem is that
+// -it is very expensive   -only gets rid of internal points, not of boundary
+// ones so limited benefit (e.g. 60 v.s. 88 triangles)
+void Foam::isoSurface::combineCellTriangles()
+{
+    if (size() > 0)
+    {
+        DynamicList<labelledTri> newTris(size());
+        DynamicList<label> newTriToCell(size());
+
+        label startTriI = 0;
+
+        DynamicList<labelledTri> tris;
+
+        for (label triI = 1; triI <= meshCells_.size(); triI++)
+        {
+            if
+            (
+                triI == meshCells_.size()
+             || meshCells_[triI] != meshCells_[startTriI]
+            )
+            {
+                label nTris = triI-startTriI;
+
+                if (nTris == 1)
+                {
+                    newTris.append(operator[](startTriI));
+                    newTriToCell.append(meshCells_[startTriI]);
+                }
+                else
+                {
+                    // Collect from startTriI to triI in a triSurface
+                    tris.clear();
+                    for (label i = startTriI; i < triI; i++)
+                    {
+                        tris.append(operator[](i));
+                    }
+                    triSurface cellTris(tris, patches(), points());
+                    tris.clear();
+
+                    // Get outside
+                    const labelListList& loops = cellTris.edgeLoops();
+
+                    forAll(loops, i)
+                    {
+                        // Do proper triangulation of loop
+                        face loop(renumber(cellTris.meshPoints(), loops[i]));
+
+                        faceTriangulation faceTris
+                        (
+                            points(),
+                            loop,
+                            true
+                        );
+
+                        // Copy into newTris
+                        forAll(faceTris, faceTriI)
+                        {
+                            const triFace& tri = faceTris[faceTriI];
+
+                            newTris.append
+                            (
+                                labelledTri
+                                (
+                                    tri[0],
+                                    tri[1],
+                                    tri[2],
+                                    operator[](startTriI).region()
+                                )
+                            );
+                            newTriToCell.append(meshCells_[startTriI]);
+                        }
+                    }
+                }
+
+                startTriI = triI;
+            }
+        }
+        newTris.shrink();
+        newTriToCell.shrink();
+
+        // Compact
+        pointField newPoints(points().size());
+        label newPointI = 0;
+        labelList oldToNewPoint(points().size(), -1);
+
+        forAll(newTris, i)
+        {
+            labelledTri& tri = newTris[i];
+            forAll(tri, j)
+            {
+                label pointI = tri[j];
+
+                if (oldToNewPoint[pointI] == -1)
+                {
+                    oldToNewPoint[pointI] = newPointI;
+                    newPoints[newPointI++] = points()[pointI];
+                }
+                tri[j] = oldToNewPoint[pointI];
+            }
+        }
+        newPoints.setSize(newPointI);
+
+        triSurface::operator=
+        (
+            triSurface
+            (
+                newTris,
+                patches(),
+                newPoints,
+                true
+            )
+        );
+        meshCells_.transfer(newTriToCell);
+    }
+}
+//XXXXXXX
+
 // ************************************************************************* //
diff --git a/src/sampling/sampledSurface/isoSurface/isoSurface.H b/src/sampling/sampledSurface/isoSurface/isoSurface.H
index d696d40048..33ef3517ad 100644
--- a/src/sampling/sampledSurface/isoSurface/isoSurface.H
+++ b/src/sampling/sampledSurface/isoSurface/isoSurface.H
@@ -279,6 +279,8 @@ class isoSurface
             labelList& newToOldPoints
         );
 
+        //- Combine all triangles inside a cell into a minimal triangulation
+        void combineCellTriangles();
 
 public:
 

From 29d67c32406f6db8d2c449ba63259f1ad1774588 Mon Sep 17 00:00:00 2001
From: mattijs <mattijs@hunt.opencfd.co.uk>
Date: Fri, 7 Nov 2008 18:14:06 +0000
Subject: [PATCH 13/16] averaging in isoSurfaces

---
 .../postProcessing/sampling/sample/sampleDict | 20 ++--
 .../isoSurface/sampledIsoSurface.C            | 93 +++++++++++--------
 .../isoSurface/sampledIsoSurface.H            |  3 +
 3 files changed, 65 insertions(+), 51 deletions(-)

diff --git a/applications/utilities/postProcessing/sampling/sample/sampleDict b/applications/utilities/postProcessing/sampling/sample/sampleDict
index b3e489a176..57385a9555 100644
--- a/applications/utilities/postProcessing/sampling/sample/sampleDict
+++ b/applications/utilities/postProcessing/sampling/sample/sampleDict
@@ -40,7 +40,7 @@ surfaceFormat vtk;
 // 1] vertex values determined from neighbouring cell-centre values
 // 2] face values determined using the current face interpolation scheme
 //    for the field (linear, gamma, etc.)
-interpolationScheme cellPointFace;
+interpolationScheme cellPoint;
 
 // Fields to sample.
 fields
@@ -155,21 +155,21 @@ surfaces
         // Optional: whether to leave as faces (=default) or triangulate
     }
 
-/* not yet (re)implemented --
     constantIso
     {
-        name            iso;
-        field           rho;
-        value           0.5;
+        name            isoSurface;
+        isoField        rho;
+        isoValue        0.5;
+        interpolate     false
     }
-    someIso
+    interpolatedIso
     {
-        type            iso;
-        field           rho;
-        value           0.5;
+        name            isoSurface;
+        isoField        rho;
+        isoValue        0.5;
         interpolate     true;
+        //regularise      false;    //optional: do not simplify
     }
- */
 );
 
 
diff --git a/src/sampling/sampledSurface/isoSurface/sampledIsoSurface.C b/src/sampling/sampledSurface/isoSurface/sampledIsoSurface.C
index d068b51120..2780d37f25 100644
--- a/src/sampling/sampledSurface/isoSurface/sampledIsoSurface.C
+++ b/src/sampling/sampledSurface/isoSurface/sampledIsoSurface.C
@@ -105,55 +105,65 @@ void Foam::sampledIsoSurface::createGeometry() const
             volPointInterpolation::New(fvm).interpolate(cellFld)
         );
 
-        //- Direct from cell field and point field. Gives bad continuity.
-        const isoSurface iso
-        (
-            fvm,
-            cellFld.internalField(),
-            pointFld().internalField(),
-            isoVal_,
-            regularise_
-        );
+        if (average_)
+        {
+            //- From point field and interpolated cell.
+            scalarField cellAvg(fvm.nCells(), scalar(0.0));
+            labelField nPointCells(fvm.nCells(), 0);
+            {
+                for (label pointI = 0; pointI < fvm.nPoints(); pointI++)
+                {
+                    const labelList& pCells = fvm.pointCells(pointI);
 
-        ////- From point field and interpolated cell.
-        //scalarField cellAvg(fvm.nCells(), scalar(0.0));
-        //labelField nPointCells(fvm.nCells(), 0);
-        //{
-        //    for (label pointI = 0; pointI < fvm.nPoints(); pointI++)
-        //    {
-        //        const labelList& pCells = fvm.pointCells(pointI);
-        //
-        //        forAll(pCells, i)
-        //        {
-        //            label cellI = pCells[i];
-        //
-        //            cellAvg[cellI] += pointFld().internalField()[pointI];
-        //            nPointCells[cellI]++;
-        //        }
-        //    }
-        //}
-        //forAll(cellAvg, cellI)
-        //{
-        //    cellAvg[cellI] /= nPointCells[cellI];
-        //}
-        //
-        //const isoSurface iso
-        //(
-        //    fvm,
-        //    cellAvg,
-        //    pointFld().internalField(),
-        //    isoVal_,
-        //    regularise_
-        //);
+                    forAll(pCells, i)
+                    {
+                        label cellI = pCells[i];
 
+                        cellAvg[cellI] += pointFld().internalField()[pointI];
+                        nPointCells[cellI]++;
+                    }
+                }
+            }
+            forAll(cellAvg, cellI)
+            {
+                cellAvg[cellI] /= nPointCells[cellI];
+            }
+
+            const isoSurface iso
+            (
+                fvm,
+                cellAvg,
+                pointFld().internalField(),
+                isoVal_,
+                regularise_
+            );
+
+            const_cast<sampledIsoSurface&>(*this).triSurface::operator=(iso);
+            meshCells_ = iso.meshCells();
+        }
+        else
+        {
+            //- Direct from cell field and point field. Gives bad continuity.
+            const isoSurface iso
+            (
+                fvm,
+                cellFld.internalField(),
+                pointFld().internalField(),
+                isoVal_,
+                regularise_
+            );
+
+            const_cast<sampledIsoSurface&>(*this).triSurface::operator=(iso);
+            meshCells_ = iso.meshCells();
+        }
 
-        const_cast<sampledIsoSurface&>(*this).triSurface::operator=(iso);
-        meshCells_ = iso.meshCells();
 
         if (debug)
         {
             Pout<< "sampledIsoSurface::createGeometry() : constructed iso:"
                 << nl
+                << "    regularise     : " << regularise_ << nl
+                << "    average        : " << average_ << nl
                 << "    isoField       : " << isoField_ << nl
                 << "    isoValue       : " << isoVal_ << nl
                 << "    points         : " << points().size() << nl
@@ -177,6 +187,7 @@ Foam::sampledIsoSurface::sampledIsoSurface
     isoField_(dict.lookup("isoField")),
     isoVal_(readScalar(dict.lookup("isoValue"))),
     regularise_(dict.lookupOrDefault("regularise", true)),
+    average_(dict.lookupOrDefault("average", true)),
     zoneName_(word::null),
     facesPtr_(NULL),
     storedTimeIndex_(-1),
diff --git a/src/sampling/sampledSurface/isoSurface/sampledIsoSurface.H b/src/sampling/sampledSurface/isoSurface/sampledIsoSurface.H
index e4213dbbde..02b62f151f 100644
--- a/src/sampling/sampledSurface/isoSurface/sampledIsoSurface.H
+++ b/src/sampling/sampledSurface/isoSurface/sampledIsoSurface.H
@@ -66,6 +66,9 @@ class sampledIsoSurface
         //- Whether to coarse
         const Switch regularise_;
 
+        //- Whether to recalculate cell values as average of point values
+        const Switch average_;
+
         //- zone name (if restricted to zones)
         word zoneName_;
 

From 0fe10dcf33bfac316c5b8b2e388fc0c80a381ff5 Mon Sep 17 00:00:00 2001
From: mattijs <mattijs@hunt.opencfd.co.uk>
Date: Wed, 12 Nov 2008 10:48:12 +0000
Subject: [PATCH 14/16] guarantee 2:1 on non-cubic grids

---
 .../polyTopoChange/polyTopoChange/hexRef8.C   | 21 +++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef8.C b/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef8.C
index f117968fe1..4cfba30501 100644
--- a/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef8.C
+++ b/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef8.C
@@ -2875,6 +2875,8 @@ Foam::labelList Foam::hexRef8::consistentSlowRefinement2
     }
 
     // 2. Extend to 2:1. I don't understand yet why this is not done
+    // 2. Extend to 2:1. For non-cube cells the scalar distance does not work
+    // so make sure it at least provides 2:1.
     PackedList<1> refineCell(mesh_.nCells(), 0);
     forAll(allCellInfo, cellI)
     {
@@ -2887,6 +2889,25 @@ Foam::labelList Foam::hexRef8::consistentSlowRefinement2
     }
     faceConsistentRefinement(true, refineCell);
 
+    while (true)
+    {
+        label nChanged = faceConsistentRefinement(true, refineCell);
+
+        reduce(nChanged, sumOp<label>());
+
+        if (debug)
+        {
+            Pout<< "hexRef8::consistentSlowRefinement2 : Changed " << nChanged
+                << " refinement levels due to 2:1 conflicts."
+                << endl;
+        }
+
+        if (nChanged == 0)
+        {
+            break;
+        }
+    }
+
     // 3. Convert back to labelList.
     label nRefined = 0;
 

From 4d2284c99dbf197a7a892a0be17c056421261a8b Mon Sep 17 00:00:00 2001
From: mattijs <mattijs@hunt.opencfd.co.uk>
Date: Wed, 12 Nov 2008 16:05:22 +0000
Subject: [PATCH 15/16] rmt isosurface correction

---
 .../postProcessing/sampling/sample/sampleDict |   20 +-
 src/sampling/Make/files                       |    2 +
 .../distanceSurface/distanceSurface.C         |    3 +-
 .../sampledSurface/isoSurface/isoSurface.C    | 1216 ++++------
 .../sampledSurface/isoSurface/isoSurface.H    |  181 +-
 .../isoSurface/isoSurfaceCell.C               | 2000 +++++++++++++++++
 .../isoSurface/isoSurfaceCell.H               |  325 +++
 .../isoSurface/isoSurfaceTemplates.C          |  485 ++++
 .../isoSurface/sampledIsoSurface.C            |  235 +-
 .../isoSurface/sampledIsoSurface.H            |   34 +-
 .../isoSurface/sampledIsoSurfaceCell.C        |  344 +++
 .../isoSurface/sampledIsoSurfaceCell.H        |  238 ++
 .../sampledIsoSurfaceCellTemplates.C          |   89 +
 .../isoSurface/sampledIsoSurfaceTemplates.C   |   50 +-
 14 files changed, 4206 insertions(+), 1016 deletions(-)
 create mode 100644 src/sampling/sampledSurface/isoSurface/isoSurfaceCell.C
 create mode 100644 src/sampling/sampledSurface/isoSurface/isoSurfaceCell.H
 create mode 100644 src/sampling/sampledSurface/isoSurface/isoSurfaceTemplates.C
 create mode 100644 src/sampling/sampledSurface/isoSurface/sampledIsoSurfaceCell.C
 create mode 100644 src/sampling/sampledSurface/isoSurface/sampledIsoSurfaceCell.H
 create mode 100644 src/sampling/sampledSurface/isoSurface/sampledIsoSurfaceCellTemplates.C

diff --git a/applications/utilities/postProcessing/sampling/sample/sampleDict b/applications/utilities/postProcessing/sampling/sample/sampleDict
index 57385a9555..db42299d1e 100644
--- a/applications/utilities/postProcessing/sampling/sample/sampleDict
+++ b/applications/utilities/postProcessing/sampling/sample/sampleDict
@@ -155,21 +155,25 @@ surfaces
         // Optional: whether to leave as faces (=default) or triangulate
     }
 
-    constantIso
-    {
-        name            isoSurface;
-        isoField        rho;
-        isoValue        0.5;
-        interpolate     false
-    }
     interpolatedIso
     {
-        name            isoSurface;
+        // Iso surface for interpolated values only
+        type            isoSurface;
         isoField        rho;
         isoValue        0.5;
         interpolate     true;
         //regularise      false;    //optional: do not simplify
     }
+    constantIso
+    {
+        // Iso surface for constant values. Guarantees triangles to not
+        // cross cells.
+        type            isoSurfaceCell;
+        isoField        rho;
+        isoValue        0.5;
+        interpolate     false;
+        //regularise      false;    //optional: do not simplify
+    }
 );
 
 
diff --git a/src/sampling/Make/files b/src/sampling/Make/files
index bbc77a3dde..991057a157 100644
--- a/src/sampling/Make/files
+++ b/src/sampling/Make/files
@@ -24,6 +24,8 @@ sampledSurface/patch/sampledPatch.C
 sampledSurface/plane/sampledPlane.C
 sampledSurface/isoSurface/isoSurface.C
 sampledSurface/isoSurface/sampledIsoSurface.C
+sampledSurface/isoSurface/isoSurfaceCell.C
+sampledSurface/isoSurface/sampledIsoSurfaceCell.C
 sampledSurface/distanceSurface/distanceSurface.C
 sampledSurface/sampledSurface/sampledSurface.C
 sampledSurface/sampledSurfaces/sampledSurfaces.C
diff --git a/src/sampling/sampledSurface/distanceSurface/distanceSurface.C b/src/sampling/sampledSurface/distanceSurface/distanceSurface.C
index fca90949ca..8c4acea996 100644
--- a/src/sampling/sampledSurface/distanceSurface/distanceSurface.C
+++ b/src/sampling/sampledSurface/distanceSurface/distanceSurface.C
@@ -30,6 +30,7 @@ License
 #include "volPointInterpolation.H"
 #include "addToRunTimeSelectionTable.H"
 #include "fvMesh.H"
+#include "isoSurfaceCell.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
@@ -110,7 +111,7 @@ void Foam::distanceSurface::createGeometry() const
     }
 
     //- Direct from cell field and point field.
-    const isoSurface iso
+    const isoSurfaceCell iso
     (
         mesh(),
         cellDistance,
diff --git a/src/sampling/sampledSurface/isoSurface/isoSurface.C b/src/sampling/sampledSurface/isoSurface/isoSurface.C
index 4e3d08f44a..13c210d395 100644
--- a/src/sampling/sampledSurface/isoSurface/isoSurface.C
+++ b/src/sampling/sampledSurface/isoSurface/isoSurface.C
@@ -25,13 +25,10 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "isoSurface.H"
-#include "dictionary.H"
-#include "polyMesh.H"
+#include "fvMesh.H"
 #include "mergePoints.H"
-#include "tetMatcher.H"
 #include "syncTools.H"
 #include "addToRunTimeSelectionTable.H"
-#include "faceTriangulation.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
@@ -61,142 +58,128 @@ Foam::scalar Foam::isoSurface::isoFraction
 }
 
 
-//Foam::List<Foam::triFace> Foam::isoSurface::triangulate(const face& f) const
-//{
-//    faceList triFaces(f.nTriangles(mesh_.points()));
-//    label triFaceI = 0;
-//    f.triangles(mesh_.points(), triFaceI, triFaces);
-//
-//    List<triFace> tris(triFaces.size());
-//    forAll(triFaces, i)
-//    {
-//        tris[i][0] = triFaces[i][0];
-//        tris[i][1] = triFaces[i][1];
-//        tris[i][2] = triFaces[i][2];
-//    }
-//    return tris;
-//}
-
-
-Foam::isoSurface::cellCutType Foam::isoSurface::calcCutType
+// Determine for every face/cell whether it (possibly) generates triangles.
+void Foam::isoSurface::calcCutTypes
 (
-    const PackedList<1>& isTet,
-    const scalarField& cellValues,
-    const scalarField& pointValues,
-    const label cellI
-) const
+    const volScalarField& cVals,
+    const scalarField& pVals
+)
 {
-    const cell& cFaces = mesh_.cells()[cellI];
+    const polyBoundaryMesh& patches = mesh_.boundaryMesh();
+    const labelList& own = mesh_.faceOwner();
+    const labelList& nei = mesh_.faceNeighbour();
 
-    if (isTet.get(cellI) == 1)
+    faceCutType_.setSize(mesh_.nFaces());
+    faceCutType_ = NOTCUT;
+
+    for (label faceI = 0; faceI < mesh_.nInternalFaces(); faceI++)
     {
-        forAll(cFaces, cFaceI)
+        // CC edge.
+        bool ownLower = (cVals[own[faceI]] < iso_);
+        bool neiLower = (cVals[nei[faceI]] < iso_);
+
+        if (ownLower != neiLower)
         {
-            const face& f = mesh_.faces()[cFaces[cFaceI]];
-
-            for (label fp = 1; fp < f.size() - 1; fp++)
-            {
-                triFace tri(f[0], f[fp], f[f.fcIndex(fp)]);
-
-                bool aLower = (pointValues[tri[0]] < iso_);
-                bool bLower = (pointValues[tri[1]] < iso_);
-                bool cLower = (pointValues[tri[2]] < iso_);
-
-                if (aLower == bLower && aLower == cLower)
-                {}
-                else
-                {
-                    return CUT;
-                }
-            }
-        }
-        return NOTCUT;
-    }
-    else
-    {
-        bool cellLower = (cellValues[cellI] < iso_);
-
-        // First check if there is any cut in cell
-        bool edgeCut = false;
-
-        forAll(cFaces, cFaceI)
-        {
-            const face& f = mesh_.faces()[cFaces[cFaceI]];
-
-            // Check pyramids cut
-            forAll(f, fp)
-            {
-                if ((pointValues[f[fp]] < iso_) != cellLower)
-                {
-                    edgeCut = true;
-                    break;
-                }
-            }
-
-            if (edgeCut)
-            {
-                break;
-            }
-
-            for (label fp = 1; fp < f.size() - 1; fp++)
-            {
-                triFace tri(f[0], f[fp], f[f.fcIndex(fp)]);
-            //List<triFace> tris(triangulate(f));
-            //forAll(tris, i)
-            //{
-            //    const triFace& tri = tris[i];
-
-                bool aLower = (pointValues[tri[0]] < iso_);
-                bool bLower = (pointValues[tri[1]] < iso_);
-                bool cLower = (pointValues[tri[2]] < iso_);
-
-                if (aLower == bLower && aLower == cLower)
-                {}
-                else
-                {
-                    edgeCut = true;
-                    break;
-                }
-            }
-
-            if (edgeCut)
-            {
-                break;
-            }
-        }
-
-        if (edgeCut)
-        {
-            // Count actual cuts (expensive since addressing needed)
-            // Note: not needed if you don't want to preserve maxima/minima
-            // centred around cellcentre. In that case just always return CUT
-
-            const labelList& cPoints = mesh_.cellPoints(cellI);
-
-            label nPyrCuts = 0;
-
-            forAll(cPoints, i)
-            {
-                if ((pointValues[cPoints[i]] < iso_) != cellLower)
-                {
-                    nPyrCuts++;
-                }
-            }
-
-            if (nPyrCuts == cPoints.size())
-            {
-                return SPHERE;
-            }
-            else
-            {
-                return CUT;
-            }
+            faceCutType_[faceI] = CUT;
         }
         else
         {
-            return NOTCUT;
+            // Mesh edge.
+            const face f = mesh_.faces()[faceI];
+
+            forAll(f, fp)
+            {
+                bool fpLower = (pVals[f[fp]] < iso_);
+                if
+                (
+                    (fpLower != (pVals[f[f.fcIndex(fp)]] < iso_))
+                 || (fpLower != ownLower)
+                 || (fpLower != neiLower)
+                )
+                {
+                    faceCutType_[faceI] = CUT;
+                    break;
+                }
+            }
         }
     }
+    forAll(patches, patchI)
+    {
+        const polyPatch& pp = patches[patchI];
+
+        label faceI = pp.start();
+        forAll(pp, i)
+        {
+            bool ownLower = (cVals[own[faceI]] < iso_);
+            bool neiLower = (cVals.boundaryField()[patchI][i] < iso_);
+
+            if (ownLower != neiLower)
+            {
+                faceCutType_[faceI] = CUT;
+            }
+            else
+            {
+                // Mesh edge.
+                const face f = mesh_.faces()[faceI];
+
+                forAll(f, fp)
+                {
+                    bool fpLower = (pVals[f[fp]] < iso_);
+                    if
+                    (
+                        (fpLower != (pVals[f[f.fcIndex(fp)]] < iso_))
+                     || (fpLower != ownLower)
+                     || (fpLower != neiLower)
+                    )
+                    {
+                        faceCutType_[faceI] = CUT;
+                        break;
+                    }
+                }
+            }
+            faceI++;
+        }
+    }
+
+
+
+    nCutCells_ = 0;
+    cellCutType_.setSize(mesh_.nCells());
+    cellCutType_ = NOTCUT;
+
+    for (label faceI = 0; faceI < mesh_.nInternalFaces(); faceI++)
+    {
+        if (faceCutType_[faceI] != NOTCUT)
+        {
+            if (cellCutType_[own[faceI]] == NOTCUT)
+            {
+                cellCutType_[own[faceI]] = CUT;
+                nCutCells_++;
+            }
+            if (cellCutType_[nei[faceI]] == NOTCUT)
+            {
+                cellCutType_[nei[faceI]] = CUT;
+                nCutCells_++;
+            }
+        }
+    }
+    for (label faceI = mesh_.nInternalFaces(); faceI < mesh_.nFaces(); faceI++)
+    {
+        if (faceCutType_[faceI] != NOTCUT)
+        {
+            if (cellCutType_[own[faceI]] == NOTCUT)
+            {
+                cellCutType_[own[faceI]] = CUT;
+                nCutCells_++;
+            }
+        }
+    }
+
+    if (debug)
+    {
+        Pout<< "isoSurface : detected " << nCutCells_
+            << " candidate cut cells." << endl;
+    }
 }
 
 
@@ -319,151 +302,195 @@ Foam::pointIndexHit Foam::isoSurface::collapseSurface
 }
 
 
+// Get neighbour value and position.
+void Foam::isoSurface::getNeighbour
+(
+    const labelList& boundaryRegion,
+    const volScalarField& cVals,
+    const label cellI,
+    const label faceI,
+    scalar& nbrValue,
+    point& nbrPoint
+) const
+{
+    const labelList& own = mesh_.faceOwner();
+    const labelList& nei = mesh_.faceNeighbour();
+
+    if (mesh_.isInternalFace(faceI))
+    {
+        label nbr = (own[faceI] == cellI ? nei[faceI] : own[faceI]);
+        nbrValue = cVals[nbr];
+        nbrPoint = mesh_.C()[nbr];
+    }
+    else
+    {
+        label bFaceI = faceI-mesh_.nInternalFaces();
+        label patchI = boundaryRegion[bFaceI];
+        label patchFaceI = faceI-mesh_.boundaryMesh()[patchI].start();
+
+        nbrValue = cVals.boundaryField()[patchI][patchFaceI];
+        nbrPoint = mesh_.C().boundaryField()[patchI][patchFaceI];
+    }
+}
+
+
+// Determine per cell centre whether all the intersections get collapsed
+// to a single point
 void Foam::isoSurface::calcSnappedCc
 (
-    const PackedList<1>& isTet,
-    const scalarField& cVals,
+    const labelList& boundaryRegion,
+    const volScalarField& cVals,
     const scalarField& pVals,
-    const List<cellCutType>& cellCutType,
 
     DynamicList<point>& snappedPoints,
     labelList& snappedCc
 ) const
 {
-    const pointField& cc = mesh_.cellCentres();
     const pointField& pts = mesh_.points();
 
     snappedCc.setSize(mesh_.nCells());
     snappedCc = -1;
 
     // Work arrays
-    DynamicList<point, 64> localPoints(64);
-    DynamicList<labelledTri, 64> localTris(64);
-    Map<label> pointToLocal(64);
+    DynamicList<point, 64> localTriPoints(64);
 
     forAll(mesh_.cells(), cellI)
     {
-        if (cellCutType[cellI] == CUT && isTet.get(cellI) == 0)
+        if (cellCutType_[cellI] == CUT)
         {
             scalar cVal = cVals[cellI];
 
             const cell& cFaces = mesh_.cells()[cellI];
 
-            localPoints.clear();
-            localTris.clear();
-            pointToLocal.clear();
+            localTriPoints.clear();
+            label nOther = 0;
+            point otherPointSum = vector::zero;
 
             // Create points for all intersections close to cell centre
             // (i.e. from pyramid edges)
 
             forAll(cFaces, cFaceI)
             {
+                label faceI = cFaces[cFaceI];
+
+                scalar nbrValue;
+                point nbrPoint;
+                getNeighbour
+                (
+                    boundaryRegion,
+                    cVals,
+                    cellI,
+                    faceI,
+                    nbrValue,
+                    nbrPoint
+                );
+
+                // Calculate intersection points of edges to cell centre
+                FixedList<scalar, 3> s;
+                FixedList<point, 3> pt;
+
+                // From cc to neighbour cc.
+                s[2] = isoFraction(cVal, nbrValue);
+                pt[2] = (1.0-s[2])*mesh_.C()[cellI] + s[2]*nbrPoint;
+
                 const face& f = mesh_.faces()[cFaces[cFaceI]];
 
                 forAll(f, fp)
                 {
-                    label pointI = f[fp];
+                    // From cc to fp
+                    label p0 = f[fp];
+                    s[0] = isoFraction(cVal, pVals[p0]);
+                    pt[0] = (1.0-s[0])*mesh_.C()[cellI] + s[0]*pts[p0];
 
-                    scalar s = isoFraction(cVal, pVals[pointI]);
+                    // From cc to fp+1
+                    label p1 = f[f.fcIndex(fp)];
+                    s[1] = isoFraction(cVal, pVals[p1]);
+                    pt[1] = (1.0-s[1])*mesh_.C()[cellI] + s[1]*pts[p1];
 
-                    if (s >= 0.0 && s <= 0.5)
+                    if
+                    (
+                        (s[0] >= 0.0 && s[0] <= 0.5)
+                     && (s[1] >= 0.0 && s[1] <= 0.5)
+                     && (s[2] >= 0.0 && s[2] <= 0.5)
+                    )
                     {
-                        if (pointToLocal.insert(pointI, localPoints.size()))
+                        localTriPoints.append(pt[0]);
+                        localTriPoints.append(pt[1]);
+                        localTriPoints.append(pt[2]);
+                    }
+                    else
+                    {
+                        // Get average of all other points
+                        forAll(s, i)
                         {
-                            localPoints.append((1.0-s)*cc[cellI]+s*pts[pointI]);
+                            if (s[i] >= 0.0 && s[i] <= 0.5)
+                            {
+                                otherPointSum += pt[i];
+                                nOther++;
+                            }
                         }
                     }
                 }
             }
 
-            if (localPoints.size() == 0)
+            if (localTriPoints.size() == 0)
             {
-                // No near intersections
-            }
-            else if (localPoints.size() == 1)
-            {
-                // No need for any analysis.
-                snappedCc[cellI] = snappedPoints.size();
-                snappedPoints.append(localPoints[0]);
+                // No complete triangles. Get average of all intersection
+                // points.
+                if (nOther > 0)
+                {
+                    snappedCc[cellI] = snappedPoints.size();
+                    snappedPoints.append(otherPointSum/nOther);
 
-                //Pout<< "cell:" << cellI
-                //    << " at " << mesh_.cellCentres()[cellI]
-                //    << " collapsing " << localPoints
-                //    << " intersections down to "
-                //    << snappedPoints[snappedCc[cellI]] << endl;
+                    //Pout<< "    point:" << pointI
+                    //    << " replacing coord:" << mesh_.points()[pointI]
+                    //    << " by average:" << collapsedPoint[pointI] << endl;
+                }
             }
-            else if (localPoints.size() == 2)
+            else if (localTriPoints.size() == 3)
             {
-                //? No need for any analysis.???
+                // Single triangle. No need for any analysis. Average points.
+                pointField points;
+                points.transfer(localTriPoints);
                 snappedCc[cellI] = snappedPoints.size();
-                snappedPoints.append(0.5*(localPoints[0]+localPoints[1]));
+                snappedPoints.append(sum(points)/points.size());
 
-                //Pout<< "cell:" << cellI
-                //    << " at " << mesh_.cellCentres()[cellI]
-                //    << " collapsing " << localPoints
-                //    << " intersections down to "
-                //    << snappedPoints[snappedCc[cellI]] << endl;
+                //Pout<< "    point:" << pointI
+                //    << " replacing coord:" << mesh_.points()[pointI]
+                //    << " by average:" << collapsedPoint[pointI] << endl;
             }
             else
             {
-                // Need to analyse 
-                forAll(cFaces, cFaceI)
-                {
-                    const face& f = mesh_.faces()[cFaces[cFaceI]];
+                // Convert points into triSurface.
 
-                    // Do a tetrahedrisation. Each face to cc becomes pyr.
-                    // Each pyr gets split into tets by diagonalisation
-                    // of face.
+                // Merge points and compact out non-valid triangles
+                labelList triMap;               // merged to unmerged triangle
+                labelList triPointReverseMap;   // unmerged to merged point
+                triSurface surf
+                (
+                    stitchTriPoints
+                    (
+                        false,              // do not check for duplicate tris
+                        localTriPoints,
+                        triPointReverseMap,  
+                        triMap
+                    )
+                );
 
-                    for (label fp = 1; fp < f.size() - 1; fp++)
-                    {
-                        triFace tri(f[0], f[fp], f[f.fcIndex(fp)]);
-                    //List<triFace> tris(triangulate(f));
-                    //forAll(tris, i)
-                    //{
-                    //    const triFace& tri = tris[i];
+                labelList faceZone;
+                label nZones = surf.markZones
+                (
+                    boolList(surf.nEdges(), false),
+                    faceZone
+                );
 
-                        // Get fractions for the three edges to cell centre
-                        FixedList<scalar, 3> s(3);
-                        s[0] = isoFraction(cVal, pVals[tri[0]]);
-                        s[1] = isoFraction(cVal, pVals[tri[1]]);
-                        s[2] = isoFraction(cVal, pVals[tri[2]]);
-
-                        if
-                        (
-                            (s[0] >= 0.0 && s[0] <= 0.5)
-                         && (s[1] >= 0.0 && s[1] <= 0.5)
-                         && (s[2] >= 0.0 && s[2] <= 0.5)
-                        )
-                        {
-                            localTris.append
-                            (
-                                labelledTri
-                                (
-                                    pointToLocal[tri[0]],
-                                    pointToLocal[tri[1]],
-                                    pointToLocal[tri[2]],
-                                    0
-                                )
-                            );
-                        }
-                    }
-                }
-
-                pointField surfPoints;
-                surfPoints.transfer(localPoints);
-                pointIndexHit info = collapseSurface(surfPoints, localTris);
-
-                if (info.hit())
+                if (nZones == 1)
                 {
                     snappedCc[cellI] = snappedPoints.size();
-                    snappedPoints.append(info.hitPoint());
-
-                    //Pout<< "cell:" << cellI
-                    //    << " at " << mesh_.cellCentres()[cellI]
-                    //    << " collapsing " << surfPoints
-                    //    << " intersections down to "
-                    //    << snappedPoints[snappedCc[cellI]] << endl;
+                    snappedPoints.append(calcCentre(surf));
+                    //Pout<< "    point:" << pointI << " nZones:" << nZones
+                    //    << " replacing coord:" << mesh_.points()[pointI]
+                    //    << " by average:" << collapsedPoint[pointI] << endl;
                 }
             }
         }
@@ -471,151 +498,28 @@ void Foam::isoSurface::calcSnappedCc
 }
 
 
-// Generate triangles for face connected to pointI
-void Foam::isoSurface::genPointTris
-(
-    const scalarField& cellValues,
-    const scalarField& pointValues,
-    const label pointI,
-    const face& f,
-    const label cellI,
-    DynamicList<point, 64>& localTriPoints
-) const
-{
-    const pointField& cc = mesh_.cellCentres();
-    const pointField& pts = mesh_.points();
-
-    for (label fp = 1; fp < f.size() - 1; fp++)
-    {
-        triFace tri(f[0], f[fp], f[f.fcIndex(fp)]);
-    //List<triFace> tris(triangulate(f));
-    //forAll(tris, i)
-    //{
-    //    const triFace& tri = tris[i];
-
-        label index = findIndex(tri, pointI);
-
-        if (index == -1)
-        {
-            continue;
-        }
-
-        // Tet between index..index-1, index..index+1, index..cc
-        label b = tri[tri.fcIndex(index)];
-        label c = tri[tri.rcIndex(index)];
-
-        // Get fractions for the three edges emanating from point
-        FixedList<scalar, 3> s(3);
-        s[0] = isoFraction(pointValues[pointI], pointValues[b]);
-        s[1] = isoFraction(pointValues[pointI], pointValues[c]);
-        s[2] = isoFraction(pointValues[pointI], cellValues[cellI]);
-
-        if
-        (
-            (s[0] >= 0.0 && s[0] <= 0.5)
-         && (s[1] >= 0.0 && s[1] <= 0.5)
-         && (s[2] >= 0.0 && s[2] <= 0.5)
-        )
-        {
-            localTriPoints.append((1.0-s[0])*pts[pointI] + s[0]*pts[b]);
-            localTriPoints.append((1.0-s[1])*pts[pointI] + s[1]*pts[c]);
-            localTriPoints.append((1.0-s[2])*pts[pointI] + s[2]*cc[cellI]);
-        }
-    }
-}
-
-
-// Generate triangle for tet connected to pointI
-void Foam::isoSurface::genPointTris
-(
-    const scalarField& pointValues,
-    const label pointI,
-    const label cellI,
-    DynamicList<point, 64>& localTriPoints
-) const
-{
-    const pointField& pts = mesh_.points();
-    const cell& cFaces = mesh_.cells()[cellI];
-
-    FixedList<label, 4> tet;
-
-    label face0 = cFaces[0];
-    const face& f0 = mesh_.faces()[face0];
-
-    if (mesh_.faceOwner()[face0] != cellI)
-    {
-        tet[0] = f0[0];
-        tet[1] = f0[1];
-        tet[2] = f0[2];
-    }
-    else
-    {
-        tet[0] = f0[0];
-        tet[1] = f0[2];
-        tet[2] = f0[1];
-    }
-
-    // Find the point on the next face that is not on f0
-    const face& f1 = mesh_.faces()[cFaces[1]];
-
-    forAll(f1, fp)
-    {
-        label p1 = f1[fp];
-
-        if (p1 != tet[0] && p1 != tet[1] && p1 != tet[2])
-        {
-            tet[3] = p1;
-            break;
-        }
-    }
-
-
-    // Get the index of pointI
-
-    label i0 = findIndex(tet, pointI);
-    label i1 = tet.fcIndex(i0);
-    label i2 = tet.fcIndex(i1);
-    label i3 = tet.fcIndex(i2);
-
-    // Get fractions for the three edges emanating from point
-    FixedList<scalar, 3> s(3);
-    s[0] = isoFraction(pointValues[pointI], pointValues[tet[i1]]);
-    s[1] = isoFraction(pointValues[pointI], pointValues[tet[i2]]);
-    s[2] = isoFraction(pointValues[pointI], pointValues[tet[i3]]);
-
-    if
-    (
-        (s[0] >= 0.0 && s[0] <= 0.5)
-     && (s[1] >= 0.0 && s[1] <= 0.5)
-     && (s[2] >= 0.0 && s[2] <= 0.5)
-    )
-    {
-        localTriPoints.append((1.0-s[0])*pts[pointI] + s[0]*pts[tet[i1]]);
-        localTriPoints.append((1.0-s[1])*pts[pointI] + s[1]*pts[tet[i2]]);
-        localTriPoints.append((1.0-s[2])*pts[pointI] + s[2]*pts[tet[i3]]);
-    }
-}
-
-
+// Determine per meshpoint whether all the intersections get collapsed
+// to a single point
 void Foam::isoSurface::calcSnappedPoint
 (
     const PackedList<1>& isBoundaryPoint,
-    const PackedList<1>& isTet,
-    const scalarField& cVals,
+    const labelList& boundaryRegion,
+    const volScalarField& cVals,
     const scalarField& pVals,
-    const List<cellCutType>& cellCutType,
 
     DynamicList<point>& snappedPoints,
     labelList& snappedPoint
 ) const
 {
+    const pointField& pts = mesh_.points();
+
+
     const point greatPoint(VGREAT, VGREAT, VGREAT);
     pointField collapsedPoint(mesh_.nPoints(), greatPoint);
 
 
     // Work arrays
     DynamicList<point, 64> localTriPoints(100);
-    labelHashSet localPointCells(100);
 
     forAll(mesh_.pointFaces(), pointI)
     {
@@ -632,14 +536,7 @@ void Foam::isoSurface::calcSnappedPoint
         {
             label faceI = pFaces[i];
 
-            if
-            (
-                cellCutType[mesh_.faceOwner()[faceI]] == CUT
-             || (
-                    mesh_.isInternalFace(faceI)
-                 && cellCutType[mesh_.faceNeighbour()[faceI]] == CUT
-                )
-            )
+            if (faceCutType_[faceI] == CUT)
             {
                 anyCut = true;
                 break;
@@ -652,8 +549,9 @@ void Foam::isoSurface::calcSnappedPoint
         }
 
 
-        localPointCells.clear();
         localTriPoints.clear();
+        label nOther = 0;
+        point otherPointSum = vector::zero;
 
         forAll(pFaces, pFaceI)
         {
@@ -661,40 +559,82 @@ void Foam::isoSurface::calcSnappedPoint
             const face& f = mesh_.faces()[faceI];
             label own = mesh_.faceOwner()[faceI];
 
-            // Triangulate around f[0] on owner side
-            if (isTet.get(own) == 1)
+            // Create points for all intersections close to point
+            // (i.e. from pyramid edges)
+
+            scalar nbrValue;
+            point nbrPoint;
+            getNeighbour
+            (
+                boundaryRegion,
+                cVals,
+                own,
+                faceI,
+                nbrValue,
+                nbrPoint
+            );
+
+            // Calculate intersection points of edges emanating from point
+            FixedList<scalar, 4> s;
+            FixedList<point, 4> pt;
+
+            label fp = findIndex(f, pointI);
+            s[0] = isoFraction(pVals[pointI], cVals[own]);
+            pt[0] = (1.0-s[0])*pts[pointI] + s[0]*mesh_.C()[own];
+
+            s[1] = isoFraction(pVals[pointI], nbrValue);
+            pt[1] = (1.0-s[1])*pts[pointI] + s[1]*nbrPoint;
+
+            label nextPointI = f[f.fcIndex(fp)];
+            s[2] = isoFraction(pVals[pointI], pVals[nextPointI]);
+            pt[2] = (1.0-s[2])*pts[pointI] + s[2]*pts[nextPointI];
+
+            label prevPointI = f[f.rcIndex(fp)];
+            s[3] = isoFraction(pVals[pointI], pVals[prevPointI]);
+            pt[3] = (1.0-s[3])*pts[pointI] + s[3]*pts[prevPointI];
+
+            if
+            (
+                (s[0] >= 0.0 && s[0] <= 0.5)
+             && (s[1] >= 0.0 && s[1] <= 0.5)
+             && (s[2] >= 0.0 && s[2] <= 0.5)
+            )
             {
-                if (localPointCells.insert(own))
-                {
-                    genPointTris(pVals, pointI, own, localTriPoints);
-                }
+                localTriPoints.append(pt[0]);
+                localTriPoints.append(pt[1]);
+                localTriPoints.append(pt[2]);
             }
-            else
+            if
+            (
+                (s[0] >= 0.0 && s[0] <= 0.5)
+             && (s[1] >= 0.0 && s[1] <= 0.5)
+             && (s[3] >= 0.0 && s[3] <= 0.5)
+            )
             {
-                genPointTris(cVals, pVals, pointI, f, own, localTriPoints);
+                localTriPoints.append(pt[3]);
+                localTriPoints.append(pt[0]);
+                localTriPoints.append(pt[1]);
             }
 
-            if (mesh_.isInternalFace(faceI))
+            // Get average of points as fallback
+            forAll(s, i)
             {
-                label nei = mesh_.faceNeighbour()[faceI];
-
-                if (isTet.get(nei) == 1)
+                if (s[i] >= 0.0 && s[i] <= 0.5)
                 {
-                    if (localPointCells.insert(nei))
-                    {
-                        genPointTris(pVals, pointI, nei, localTriPoints);
-                    }
-                }
-                else
-                {
-                    genPointTris(cVals, pVals, pointI, f, nei, localTriPoints);
+                    otherPointSum += pt[i];
+                    nOther++;
                 }
             }
         }
 
         if (localTriPoints.size() == 0)
         {
-            // No near intersections
+            // No complete triangles. Get average of all intersection
+            // points.
+            if (nOther > 0)
+            {
+                collapsedPoint[pointI] = otherPointSum/nOther;
+            }
         }
         else if (localTriPoints.size() == 3)
         {
@@ -702,10 +642,6 @@ void Foam::isoSurface::calcSnappedPoint
             pointField points;
             points.transfer(localTriPoints);
             collapsedPoint[pointI] = sum(points)/points.size();
-
-            //Pout<< "    point:" << pointI
-            //    << " replacing coord:" << mesh_.points()[pointI]
-            //    << " by average:" << collapsedPoint[pointI] << endl;
         }
         else
         {
@@ -735,9 +671,6 @@ void Foam::isoSurface::calcSnappedPoint
             if (nZones == 1)
             {
                 collapsedPoint[pointI] = calcCentre(surf);
-                //Pout<< "    point:" << pointI << " nZones:" << nZones
-                //    << " replacing coord:" << mesh_.points()[pointI]
-                //    << " by average:" << collapsedPoint[pointI] << endl;
             }
         }
     }
@@ -765,173 +698,6 @@ void Foam::isoSurface::calcSnappedPoint
 }
 
 
-Foam::point Foam::isoSurface::generatePoint
-(
-    const DynamicList<point>& snappedPoints,
-
-    const scalar s0,
-    const point& p0,
-    const label p0Index,
-
-    const scalar s1,
-    const point& p1,
-    const label p1Index
-) const
-{
-    scalar d = s1-s0;
-
-    if (mag(d) > VSMALL)
-    {
-        scalar s = (iso_-s0)/d;
-
-        if (s >= 0.5 && s <= 1 && p1Index != -1)
-        {
-            return snappedPoints[p1Index];
-        }
-        else if (s >= 0.0 && s <= 0.5 && p0Index != -1)
-        {
-            return snappedPoints[p0Index];
-        }
-        else
-        {
-            return s*p1 + (1.0-s)*p0;
-        }
-    }
-    else
-    {
-        scalar s = 0.4999;
-
-        return s*p1 + (1.0-s)*p0;
-    }
-}
-
-
-void Foam::isoSurface::generateTriPoints
-(
-    const DynamicList<point>& snapped,
-
-    const scalar s0,
-    const point& p0,
-    const label p0Index,
-
-    const scalar s1,
-    const point& p1,
-    const label p1Index,
-
-    const scalar s2,
-    const point& p2,
-    const label p2Index,
-
-    const scalar s3,
-    const point& p3,
-    const label p3Index,
-
-    DynamicList<point>& points
-) const
-{
-    int triIndex = 0;
-    if (s0 < iso_)
-    {
-        triIndex |= 1;
-    }
-    if (s1 < iso_)
-    {
-        triIndex |= 2;
-    }
-    if (s2 < iso_)
-    {
-        triIndex |= 4;
-    }
-    if (s3 < iso_)
-    {
-        triIndex |= 8;
-    }
-
-    /* Form the vertices of the triangles for each case */
-    switch (triIndex)
-    {
-        case 0x00:
-        case 0x0F:
-        break;
-
-        case 0x0E:
-        case 0x01:
-            points.append(generatePoint(snapped,s0,p0,p0Index,s1,p1,p1Index));
-            points.append(generatePoint(snapped,s0,p0,p0Index,s2,p2,p2Index));
-            points.append(generatePoint(snapped,s0,p0,p0Index,s3,p3,p3Index));
-        break;
-
-        case 0x0D:
-        case 0x02:
-            points.append(generatePoint(snapped,s1,p1,p1Index,s0,p0,p0Index));
-            points.append(generatePoint(snapped,s1,p1,p1Index,s3,p3,p3Index));
-            points.append(generatePoint(snapped,s1,p1,p1Index,s2,p2,p2Index));
-        break;
-
-        case 0x0C:
-        case 0x03:
-        {
-            point tp1 = generatePoint(snapped,s0,p0,p0Index,s2,p2,p2Index);
-            point tp2 = generatePoint(snapped,s1,p1,p1Index,s3,p3,p3Index);
-
-            points.append(generatePoint(snapped,s0,p0,p0Index,s3,p3,p3Index));
-            points.append(tp1);
-            points.append(tp2);
-            points.append(tp2);
-            points.append(generatePoint(snapped,s1,p1,p1Index,s2,p2,p2Index));
-            points.append(tp1);
-        }
-        break;
-
-        case 0x0B:
-        case 0x04:
-        {
-            points.append(generatePoint(snapped,s2,p2,p2Index,s0,p0,p0Index));
-            points.append(generatePoint(snapped,s2,p2,p2Index,s1,p1,p1Index));
-            points.append(generatePoint(snapped,s2,p2,p2Index,s3,p3,p3Index));
-        }
-        break;
-
-        case 0x0A:
-        case 0x05:
-        {
-            point tp0 = generatePoint(snapped,s0,p0,p0Index,s1,p1,p1Index);
-            point tp1 = generatePoint(snapped,s2,p2,p2Index,s3,p3,p3Index);
-
-            points.append(tp0);
-            points.append(tp1);
-            points.append(generatePoint(snapped,s0,p0,p0Index,s3,p3,p3Index));
-            points.append(tp0);
-            points.append(generatePoint(snapped,s1,p1,p1Index,s2,p2,p2Index));
-            points.append(tp1);
-        }
-        break;
-
-        case 0x09:
-        case 0x06:
-        {
-            point tp0 = generatePoint(snapped,s0,p0,p0Index,s1,p1,p1Index);
-            point tp1 = generatePoint(snapped,s2,p2,p2Index,s3,p3,p3Index);
-
-            points.append(tp0);
-            points.append(generatePoint(snapped,s1,p1,p1Index,s3,p3,p3Index));
-            points.append(tp1);
-            points.append(tp0);
-            points.append(generatePoint(snapped,s0,p0,p0Index,s2,p2,p2Index));
-            points.append(tp1);
-        }
-        break;
-
-        case 0x07:
-        case 0x08:
-            points.append(generatePoint(snapped,s3,p3,p3Index,s0,p0,p0Index));
-            points.append(generatePoint(snapped,s3,p3,p3Index,s2,p2,p2Index));
-            points.append(generatePoint(snapped,s3,p3,p3Index,s1,p1,p1Index));
-        break;
-    }
-}
-
-
 Foam::triSurface Foam::isoSurface::stitchTriPoints
 (
     const bool checkDuplicates,
@@ -1014,6 +780,7 @@ Foam::triSurface Foam::isoSurface::stitchTriPoints
     }
 
 
+
     // Use face centres to determine 'flat hole' situation (see RMT paper).
     // Two unconnected triangles get connected because (some of) the edges
     // separating them get collapsed. Below only checks for duplicate triangles,
@@ -1135,8 +902,10 @@ bool Foam::isoSurface::validTri(const triSurface& surf, const label faceI)
         {
             WarningIn("validTri(const triSurface&, const label)")
                 << "triangle " << faceI << " vertices " << f
+                << " fc:" << f.centre(surf.points())
                 << " has the same vertices as triangle " << nbrFaceI
                 << " vertices " << nbrF
+                << " fc:" << nbrF.centre(surf.points())
                 << endl;
 
             return false;
@@ -1200,7 +969,7 @@ void Foam::isoSurface::calcAddressing
         faceEdges[triI][1] = oldToMerged[edgeI++];
         faceEdges[triI][2] = oldToMerged[edgeI++];
     }
-    
+
 
     // Determine edgeFaces
     edgeFace0.setSize(mergedCentres.size());
@@ -1376,8 +1145,10 @@ void Foam::isoSurface::orientSurface
         }
         else if (flipState[triI] == -1)
         {
-            FatalErrorIn("isoSurface::orientSurface(triSurface&, const label)")
-                << "problem" << abort(FatalError);
+            FatalErrorIn
+            (
+                "isoSurface::orientSurface(triSurface&, const label)"
+            )   << "problem" << abort(FatalError);
         }
     }
 }
@@ -1463,6 +1234,7 @@ Foam::triSurface Foam::isoSurface::subsetMesh
 (
     const triSurface& s,
     const labelList& newToOldFaces,
+    labelList& oldToNewPoints,
     labelList& newToOldPoints
 )
 {
@@ -1478,7 +1250,8 @@ Foam::triSurface Foam::isoSurface::subsetMesh
     );
 
     newToOldPoints.setSize(s.points().size());
-    labelList oldToNewPoints(s.points().size(), -1);
+    oldToNewPoints.setSize(s.points().size());
+    oldToNewPoints = -1;
     {
         label pointI = 0;
 
@@ -1533,36 +1306,29 @@ Foam::triSurface Foam::isoSurface::subsetMesh
 
 Foam::isoSurface::isoSurface
 (
-    const polyMesh& mesh,
-    const scalarField& cVals,
+    const volScalarField& cVals,
     const scalarField& pVals,
     const scalar iso,
     const bool regularise,
     const scalar mergeTol
 )
 :
-    mesh_(mesh),
+    mesh_(cVals.mesh()),
     iso_(iso),
-    mergeDistance_(mergeTol*mag(mesh.bounds().max()-mesh.bounds().min()))
+    mergeDistance_(mergeTol*mag(mesh_.bounds().max()-mesh_.bounds().min()))
 {
-    // Determine if cell is tet
-    PackedList<1> isTet(mesh_.nCells());
-    {
-        tetMatcher tet;
+    // Determine if any cut through face/cell
+    calcCutTypes(cVals, pVals);
 
-        forAll(isTet, cellI)
-        {
-            if (tet.isA(mesh_, cellI))
-            {
-                isTet.set(cellI, 1);
-            }
-        }
-    }
 
     // Determine if point is on boundary. Points on boundaries are never
     // snapped. Coupled boundaries are handled explicitly so not marked here.
     PackedList<1> isBoundaryPoint(mesh_.nPoints());
+
+    labelList boundaryRegion(mesh_.nFaces()-mesh_.nInternalFaces());
     const polyBoundaryMesh& patches = mesh_.boundaryMesh();
+    const labelList& own = mesh_.faceOwner();
+
     forAll(patches, patchI)
     {
         const polyPatch& pp = patches[patchI];
@@ -1570,8 +1336,11 @@ Foam::isoSurface::isoSurface
         if (!pp.coupled())
         {
             label faceI = pp.start();
+
             forAll(pp, i)
             {
+                boundaryRegion[faceI-mesh_.nInternalFaces()] = patchI;
+
                 const face& f = mesh_.faces()[faceI++];
 
                 forAll(f, fp)
@@ -1583,27 +1352,7 @@ Foam::isoSurface::isoSurface
     }
 
 
-    // Determine if any cut through cell
-
-    List<cellCutType> cellCutType(mesh_.nCells());
-    label nCutCells = 0;
-    forAll(mesh_.cells(), cellI)
-    {
-        cellCutType[cellI] = calcCutType(isTet, cVals, pVals, cellI);
-
-        if (cellCutType[cellI] == CUT)
-        {
-            nCutCells++;
-        }
-    }
-
-    if (debug)
-    {
-        Pout<< "isoSurface : detected " << nCutCells
-            << " candidate cut cells." << endl;
-    }
-
-    DynamicList<point> snappedPoints(nCutCells);
+    DynamicList<point> snappedPoints(nCutCells_);
 
     // Per cc -1 or a point inside snappedPoints.
     labelList snappedCc;
@@ -1611,10 +1360,10 @@ Foam::isoSurface::isoSurface
     {
         calcSnappedCc
         (
-            isTet,
+            boundaryRegion,
             cVals,
             pVals,
-            cellCutType,
+
             snappedPoints,
             snappedCc
         );
@@ -1625,6 +1374,26 @@ Foam::isoSurface::isoSurface
         snappedCc = -1;
     }
 
+    // Determine neighbouring snap status
+    labelList neiSnappedCc(mesh_.nFaces()-mesh_.nInternalFaces(), -1);
+    forAll(patches, patchI)
+    {
+        const polyPatch& pp = patches[patchI];
+
+        if (pp.coupled())
+        {
+            label faceI = pp.start();
+            forAll(pp, i)
+            {
+                neiSnappedCc[faceI-mesh_.nInternalFaces()] =
+                    snappedCc[own[faceI]];
+                faceI++;
+            }
+        }
+    }
+    syncTools::swapBoundaryFaceList(mesh_, neiSnappedCc, false);
+
+
     if (debug)
     {
         Pout<< "isoSurface : shifted " << snappedPoints.size()
@@ -1640,10 +1409,10 @@ Foam::isoSurface::isoSurface
         calcSnappedPoint
         (
             isBoundaryPoint,
-            isTet,
+            boundaryRegion,
             cVals,
             pVals,
-            cellCutType,
+
             snappedPoints,
             snappedPoint
         );
@@ -1661,116 +1430,24 @@ Foam::isoSurface::isoSurface
     }
 
 
+    DynamicList<point> triPoints(nCutCells_);
+    DynamicList<label> triMeshCells(nCutCells_);
 
-    DynamicList<point> triPoints(nCutCells);
-    DynamicList<label> triMeshCells(nCutCells);
+    generateTriPoints
+    (
+        cVals,
+        pVals,
 
-    forAll(mesh_.cells(), cellI)
-    {
-        if (cellCutType[cellI] != NOTCUT)
-        {
-            label oldNPoints = triPoints.size();
+        mesh_.C(),
+        mesh_.points(),
 
-            const cell& cFaces = mesh_.cells()[cellI];
+        snappedPoints,
+        snappedCc,
+        snappedPoint,
 
-            if (isTet.get(cellI) == 1)
-            {
-                // For tets don't do cell-centre decomposition, just use the
-                // tet points and values
-
-                const face& f0 = mesh_.faces()[cFaces[0]];
-
-                // Get the other point
-                const face& f1 = mesh_.faces()[cFaces[1]];
-                label oppositeI = -1;
-                forAll(f1, fp)
-                {
-                    oppositeI = f1[fp];
-
-                    if (findIndex(f0, oppositeI) == -1)
-                    {
-                        break;
-                    }
-                }
-
-                generateTriPoints
-                (
-                    snappedPoints,
-                    pVals[f0[0]],
-                    mesh_.points()[f0[0]],
-                    snappedPoint[f0[0]],
-
-                    pVals[f0[1]],
-                    mesh_.points()[f0[1]],
-                    snappedPoint[f0[1]],
-
-                    pVals[f0[2]],
-                    mesh_.points()[f0[2]],
-                    snappedPoint[f0[2]],
-
-                    pVals[oppositeI],
-                    mesh_.points()[oppositeI],
-                    snappedPoint[oppositeI],
-
-                    triPoints
-                );
-            }
-            else
-            {
-                const cell& cFaces = mesh_.cells()[cellI];
-
-                forAll(cFaces, cFaceI)
-                {
-                    label faceI = cFaces[cFaceI];
-                    const face& f = mesh_.faces()[faceI];
-
-                    for (label fp = 1; fp < f.size() - 1; fp++)
-                    {
-                        triFace tri(f[0], f[fp], f[f.fcIndex(fp)]);
-                    //List<triFace> tris(triangulate(f));
-                    //forAll(tris, i)
-                    //{
-                    //    const triFace& tri = tris[i];
-
-
-                        generateTriPoints
-                        (
-                            snappedPoints,
-
-                            pVals[tri[0]],
-                            mesh_.points()[tri[0]],
-                            snappedPoint[tri[0]],
-
-                            pVals[tri[1]],
-                            mesh_.points()[tri[1]],
-                            snappedPoint[tri[1]],
-
-                            pVals[tri[2]],
-                            mesh_.points()[tri[2]],
-                            snappedPoint[tri[2]],
-
-                            cVals[cellI],
-                            mesh_.cellCentres()[cellI],
-                            snappedCc[cellI],
-
-                            triPoints
-                        );
-                    }
-                }
-            }
-
-
-            // Every three triPoints is a cell
-            label nCells = (triPoints.size()-oldNPoints)/3;
-            for (label i = 0; i < nCells; i++)
-            {
-                triMeshCells.append(cellI);
-            }
-        }
-    }
-
-    triPoints.shrink();
-    triMeshCells.shrink();
+        triPoints,
+        triMeshCells
+    );
 
     if (debug)
     {
@@ -1778,6 +1455,7 @@ Foam::isoSurface::isoSurface
             << " unmerged triangles." << endl;
     }
 
+
     // Merge points and compact out non-valid triangles
     labelList triMap;           // merged to unmerged triangle
     triSurface::operator=
@@ -1816,6 +1494,8 @@ Foam::isoSurface::isoSurface
     }
 
 
+    //if (false)
+    //{
     List<FixedList<label, 3> > faceEdges;
     labelList edgeFace0, edgeFace1;
     Map<labelList> edgeFacesRest;
@@ -1852,142 +1532,24 @@ Foam::isoSurface::isoSurface
         labelList subsetTriMap(findIndices(keepTriangles, true));
 
         labelList subsetPointMap;
+        labelList reversePointMap;
         triSurface::operator=
         (
             subsetMesh
             (
                 *this,
                 subsetTriMap,
+                reversePointMap,
                 subsetPointMap
             )
         );
         meshCells_ = labelField(meshCells_, subsetTriMap);
-        triPointMergeMap_ = labelField(triPointMergeMap_, subsetPointMap);
+        inplaceRenumber(reversePointMap, triPointMergeMap_);
     }
 
     orientSurface(*this, faceEdges, edgeFace0, edgeFace1, edgeFacesRest);
-
-    //combineCellTriangles();
+    //}
 }
 
 
-//XXXXXXX
-// Experimental retriangulation of triangles per cell. Problem is that
-// -it is very expensive   -only gets rid of internal points, not of boundary
-// ones so limited benefit (e.g. 60 v.s. 88 triangles)
-void Foam::isoSurface::combineCellTriangles()
-{
-    if (size() > 0)
-    {
-        DynamicList<labelledTri> newTris(size());
-        DynamicList<label> newTriToCell(size());
-
-        label startTriI = 0;
-
-        DynamicList<labelledTri> tris;
-
-        for (label triI = 1; triI <= meshCells_.size(); triI++)
-        {
-            if
-            (
-                triI == meshCells_.size()
-             || meshCells_[triI] != meshCells_[startTriI]
-            )
-            {
-                label nTris = triI-startTriI;
-
-                if (nTris == 1)
-                {
-                    newTris.append(operator[](startTriI));
-                    newTriToCell.append(meshCells_[startTriI]);
-                }
-                else
-                {
-                    // Collect from startTriI to triI in a triSurface
-                    tris.clear();
-                    for (label i = startTriI; i < triI; i++)
-                    {
-                        tris.append(operator[](i));
-                    }
-                    triSurface cellTris(tris, patches(), points());
-                    tris.clear();
-
-                    // Get outside
-                    const labelListList& loops = cellTris.edgeLoops();
-
-                    forAll(loops, i)
-                    {
-                        // Do proper triangulation of loop
-                        face loop(renumber(cellTris.meshPoints(), loops[i]));
-
-                        faceTriangulation faceTris
-                        (
-                            points(),
-                            loop,
-                            true
-                        );
-
-                        // Copy into newTris
-                        forAll(faceTris, faceTriI)
-                        {
-                            const triFace& tri = faceTris[faceTriI];
-
-                            newTris.append
-                            (
-                                labelledTri
-                                (
-                                    tri[0],
-                                    tri[1],
-                                    tri[2],
-                                    operator[](startTriI).region()
-                                )
-                            );
-                            newTriToCell.append(meshCells_[startTriI]);
-                        }
-                    }
-                }
-
-                startTriI = triI;
-            }
-        }
-        newTris.shrink();
-        newTriToCell.shrink();
-
-        // Compact
-        pointField newPoints(points().size());
-        label newPointI = 0;
-        labelList oldToNewPoint(points().size(), -1);
-
-        forAll(newTris, i)
-        {
-            labelledTri& tri = newTris[i];
-            forAll(tri, j)
-            {
-                label pointI = tri[j];
-
-                if (oldToNewPoint[pointI] == -1)
-                {
-                    oldToNewPoint[pointI] = newPointI;
-                    newPoints[newPointI++] = points()[pointI];
-                }
-                tri[j] = oldToNewPoint[pointI];
-            }
-        }
-        newPoints.setSize(newPointI);
-
-        triSurface::operator=
-        (
-            triSurface
-            (
-                newTris,
-                patches(),
-                newPoints,
-                true
-            )
-        );
-        meshCells_.transfer(newTriToCell);
-    }
-}
-//XXXXXXX
-
 // ************************************************************************* //
diff --git a/src/sampling/sampledSurface/isoSurface/isoSurface.H b/src/sampling/sampledSurface/isoSurface/isoSurface.H
index 33ef3517ad..28fc8b7c4a 100644
--- a/src/sampling/sampledSurface/isoSurface/isoSurface.H
+++ b/src/sampling/sampledSurface/isoSurface/isoSurface.H
@@ -27,9 +27,7 @@ Class
 
 Description
     A surface formed by the iso value.
-    After "Polygonising A Scalar Field Using Tetrahedrons", Paul Bourke
-    and
-    "Regularised Marching Tetrahedra: improved iso-surface extraction",
+    After "Regularised Marching Tetrahedra: improved iso-surface extraction",
     G.M. Treece, R.W. Prager and A.H. Gee.
 
     Note:
@@ -39,7 +37,9 @@ Description
     - does tets without using cell centres/cell values. Not tested.
     - regularisation can create duplicate triangles/non-manifold surfaces.
     Current handling of those is bit ad-hoc for now and not perfect.
-    Uses geometric merge.
+    - uses geometric merge with fraction of bounding box as distance.
+    - triangles can be between two cell centres so constant sampling
+      does not make sense.
     - does not do 2D correctly, creates non-flat iso surface.
 
 SourceFiles
@@ -54,13 +54,14 @@ SourceFiles
 #include "labelPair.H"
 #include "pointIndexHit.H"
 #include "PackedList.H"
+#include "volFields.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 namespace Foam
 {
 
-class polyMesh;
+class fvMesh;
 
 /*---------------------------------------------------------------------------*\
                        Class isoSurface Declaration
@@ -88,7 +89,7 @@ class isoSurface
 
 
         //- Reference to mesh
-        const polyMesh& mesh_;
+        const fvMesh& mesh_;
 
         //- Isosurface value
         const scalar iso_;
@@ -97,6 +98,15 @@ class isoSurface
         const scalar mergeDistance_;
 
 
+        //- Whether face might be cut
+        List<cellCutType> faceCutType_;
+
+        //- Whether cell might be cut
+        List<cellCutType> cellCutType_;
+
+        //- Estimated number of cut cells
+        label nCutCells_;
+
         //- For every triangle the original cell in mesh
         labelList meshCells_;
 
@@ -113,16 +123,12 @@ class isoSurface
             const scalar s1
         ) const;
 
-        //List<triFace> triangulate(const face& f) const;
-
-        //- Determine whether cell is cut
-        cellCutType calcCutType
+        //- Set faceCutType,cellCutType.
+        void calcCutTypes
         (
-            const PackedList<1>&,
-            const scalarField& cellValues,
-            const scalarField& pointValues,
-            const label
-        ) const;
+            const volScalarField& cVals,
+            const scalarField& pVals
+        );
 
         static labelPair findCommonPoints
         (
@@ -138,79 +144,115 @@ class isoSurface
             DynamicList<labelledTri, 64>& localTris
         );
 
+        void getNeighbour
+        (
+            const labelList& boundaryRegion,
+            const volScalarField& cVals,
+            const label cellI,
+            const label faceI,
+            scalar& nbrValue,
+            point& nbrPoint
+        ) const;
+
         //- Determine per cc whether all near cuts can be snapped to single
         //  point.
         void calcSnappedCc
         (
-            const PackedList<1>& isTet,
-            const scalarField& cVals,
+            const labelList& boundaryRegion,
+            const volScalarField& cVals,
             const scalarField& pVals,
-            const List<cellCutType>& cellCutType,
-            DynamicList<point>& triPoints,
+            DynamicList<point>& snappedPoints,
             labelList& snappedCc
         ) const;
 
-        //- Generate triangles for face connected to pointI
-        void genPointTris
-        (
-            const scalarField& cellValues,
-            const scalarField& pointValues,
-            const label pointI,
-            const face& f,
-            const label cellI,
-            DynamicList<point, 64>& localTriPoints
-        ) const;
-
-        //- Generate triangles for tet connected to pointI
-        void genPointTris
-        (
-            const scalarField& pointValues,
-            const label pointI,
-            const label cellI,
-            DynamicList<point, 64>& localTriPoints
-        ) const;
-
         //- Determine per point whether all near cuts can be snapped to single
         //  point.
         void calcSnappedPoint
         (
             const PackedList<1>& isBoundaryPoint,
-            const PackedList<1>& isTet,
-            const scalarField& cVals,
+            const labelList& boundaryRegion,
+            const volScalarField& cVals,
             const scalarField& pVals,
-            const List<cellCutType>& cellCutType,
-            DynamicList<point>& triPoints,
+            DynamicList<point>& snappedPoints,
             labelList& snappedPoint
         ) const;
 
         //- Generate single point by interpolation or snapping
-        point generatePoint
+        template<class Type>
+        Type generatePoint
         (
-            const DynamicList<point>& snappedPoints,
+            const DynamicList<Type>& snappedPoints,
+
             const scalar s0,
-            const point& p0,
+            const Type& p0,
             const label p0Index,
+
             const scalar s1,
-            const point& p1,
+            const Type& p1,
             const label p1Index
         ) const;
 
+        template<class Type>
         void generateTriPoints
         (
-            const DynamicList<point>& snapped,
+            const DynamicList<Type>& snapped,
+
             const scalar s0,
-            const point& p0,
+            const Type& p0,
             const label p0Index,
+
             const scalar s1,
-            const point& p1,
+            const Type& p1,
             const label p1Index,
+
             const scalar s2,
-            const point& p2,
+            const Type& p2,
             const label p2Index,
+
             const scalar s3,
-            const point& p3,
+            const Type& p3,
             const label p3Index,
-            DynamicList<point>& points
+
+            DynamicList<Type>& points
+        ) const;
+
+        template<class Type>
+        label generateTriPoints
+        (
+            const volScalarField& cVals,
+            const scalarField& pVals,
+
+            const GeometricField<Type, fvPatchField, volMesh>& cCoords,
+            const Field<Type>& pCoords,
+
+            const DynamicList<Type>& snappedPoints,
+            const labelList& snappedCc,
+            const labelList& snappedPoint,
+            const label faceI,
+
+            const scalar neiVal,
+            const Type& neiPt,
+            const label neiSnap,
+
+            DynamicList<Type>& triPoints,
+            DynamicList<label>& triMeshCells
+        ) const;
+
+        template<class Type>
+        void generateTriPoints
+        (
+            const volScalarField& cVals,
+            const scalarField& pVals,
+
+            const GeometricField<Type, fvPatchField, volMesh>& cCoords,
+            const Field<Type>& pCoords,
+
+            const DynamicList<Type>& snappedPoints,
+            const labelList& snappedCc,
+            const labelList& snappedPoint,
+
+            DynamicList<Type>& triPoints,
+            DynamicList<label>& triMeshCells
         ) const;
 
         triSurface stitchTriPoints
@@ -276,12 +318,10 @@ class isoSurface
         (
             const triSurface& s,
             const labelList& newToOldFaces,
+            labelList& oldToNewPoints,
             labelList& newToOldPoints
         );
 
-        //- Combine all triangles inside a cell into a minimal triangulation
-        void combineCellTriangles();
-
 public:
 
     //- Runtime type information
@@ -290,12 +330,13 @@ public:
 
     // Constructors
 
-        //- Construct from dictionary
+        //- Construct from cell values and point values. Uses boundaryField
+        //  for boundary values. Requires on coupled patchfields to be set
+        //  to the opposite cell value.
         isoSurface
         (
-            const polyMesh& mesh,
-            const scalarField& cellValues,
-            const scalarField& pointValues,
+            const volScalarField& cellIsoVals,
+            const scalarField& pointIsoVals,
             const scalar iso,
             const bool regularise,
             const scalar mergeTol = 1E-6    // fraction of bounding box
@@ -311,10 +352,22 @@ public:
         }
 
         //- For every unmerged triangle point the point in the triSurface
-        const labelList triPointMergeMap() const
+        const labelList& triPointMergeMap() const
         {
             return triPointMergeMap_;
         }
+
+        //- Interpolates cCoords,pCoords. Takes the original fields
+        //  used to create the iso surface.
+        template <class Type>
+        tmp<Field<Type> > interpolate
+        (
+            const volScalarField& cellIsoVals,
+            const scalarField& pointIsoVals,
+            const GeometricField<Type, fvPatchField, volMesh>& cCoords,
+            const Field<Type>& pCoords
+        ) const;
+
 };
 
 
@@ -324,6 +377,12 @@ public:
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
+#ifdef NoRepository
+#   include "isoSurfaceTemplates.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
 #endif
 
 // ************************************************************************* //
diff --git a/src/sampling/sampledSurface/isoSurface/isoSurfaceCell.C b/src/sampling/sampledSurface/isoSurface/isoSurfaceCell.C
new file mode 100644
index 0000000000..2812645aa3
--- /dev/null
+++ b/src/sampling/sampledSurface/isoSurface/isoSurfaceCell.C
@@ -0,0 +1,2000 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+\*---------------------------------------------------------------------------*/
+
+#include "isoSurfaceCell.H"
+#include "dictionary.H"
+#include "polyMesh.H"
+#include "mergePoints.H"
+#include "tetMatcher.H"
+#include "syncTools.H"
+#include "addToRunTimeSelectionTable.H"
+#include "faceTriangulation.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(isoSurfaceCell, 0);
+}
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+Foam::scalar Foam::isoSurfaceCell::isoFraction
+(
+    const scalar s0,
+    const scalar s1
+) const
+{
+    scalar d = s1-s0;
+
+    if (mag(d) > VSMALL)
+    {
+        return (iso_-s0)/d;
+    }
+    else
+    {
+        return -1.0;
+    }
+}
+
+
+//Foam::List<Foam::triFace> Foam::isoSurfaceCell::triangulate(const face& f)
+// const
+//{
+//    faceList triFaces(f.nTriangles(mesh_.points()));
+//    label triFaceI = 0;
+//    f.triangles(mesh_.points(), triFaceI, triFaces);
+//
+//    List<triFace> tris(triFaces.size());
+//    forAll(triFaces, i)
+//    {
+//        tris[i][0] = triFaces[i][0];
+//        tris[i][1] = triFaces[i][1];
+//        tris[i][2] = triFaces[i][2];
+//    }
+//    return tris;
+//}
+
+
+Foam::isoSurfaceCell::cellCutType Foam::isoSurfaceCell::calcCutType
+(
+    const PackedList<1>& isTet,
+    const scalarField& cellValues,
+    const scalarField& pointValues,
+    const label cellI
+) const
+{
+    const cell& cFaces = mesh_.cells()[cellI];
+
+    if (isTet.get(cellI) == 1)
+    {
+        forAll(cFaces, cFaceI)
+        {
+            const face& f = mesh_.faces()[cFaces[cFaceI]];
+
+            for (label fp = 1; fp < f.size() - 1; fp++)
+            {
+                triFace tri(f[0], f[fp], f[f.fcIndex(fp)]);
+
+                bool aLower = (pointValues[tri[0]] < iso_);
+                bool bLower = (pointValues[tri[1]] < iso_);
+                bool cLower = (pointValues[tri[2]] < iso_);
+
+                if (aLower == bLower && aLower == cLower)
+                {}
+                else
+                {
+                    return CUT;
+                }
+            }
+        }
+        return NOTCUT;
+    }
+    else
+    {
+        bool cellLower = (cellValues[cellI] < iso_);
+
+        // First check if there is any cut in cell
+        bool edgeCut = false;
+
+        forAll(cFaces, cFaceI)
+        {
+            const face& f = mesh_.faces()[cFaces[cFaceI]];
+
+            // Check pyramids cut
+            forAll(f, fp)
+            {
+                if ((pointValues[f[fp]] < iso_) != cellLower)
+                {
+                    edgeCut = true;
+                    break;
+                }
+            }
+
+            if (edgeCut)
+            {
+                break;
+            }
+
+            for (label fp = 1; fp < f.size() - 1; fp++)
+            {
+                triFace tri(f[0], f[fp], f[f.fcIndex(fp)]);
+            //List<triFace> tris(triangulate(f));
+            //forAll(tris, i)
+            //{
+            //    const triFace& tri = tris[i];
+
+                bool aLower = (pointValues[tri[0]] < iso_);
+                bool bLower = (pointValues[tri[1]] < iso_);
+                bool cLower = (pointValues[tri[2]] < iso_);
+
+                if (aLower == bLower && aLower == cLower)
+                {}
+                else
+                {
+                    edgeCut = true;
+                    break;
+                }
+            }
+
+            if (edgeCut)
+            {
+                break;
+            }
+        }
+
+        if (edgeCut)
+        {
+            // Count actual cuts (expensive since addressing needed)
+            // Note: not needed if you don't want to preserve maxima/minima
+            // centred around cellcentre. In that case just always return CUT
+
+            const labelList& cPoints = mesh_.cellPoints(cellI);
+
+            label nPyrCuts = 0;
+
+            forAll(cPoints, i)
+            {
+                if ((pointValues[cPoints[i]] < iso_) != cellLower)
+                {
+                    nPyrCuts++;
+                }
+            }
+
+            if (nPyrCuts == cPoints.size())
+            {
+                return SPHERE;
+            }
+            else
+            {
+                return CUT;
+            }
+        }
+        else
+        {
+            return NOTCUT;
+        }
+    }
+}
+
+
+// Return the two common points between two triangles
+Foam::labelPair Foam::isoSurfaceCell::findCommonPoints
+(
+    const labelledTri& tri0,
+    const labelledTri& tri1
+)
+{
+    labelPair common(-1, -1);
+
+    label fp0 = 0;
+    label fp1 = findIndex(tri1, tri0[fp0]);
+
+    if (fp1 == -1)
+    {
+        fp0 = 1;
+        fp1 = findIndex(tri1, tri0[fp0]);
+    }
+
+    if (fp1 != -1)
+    {
+        // So tri0[fp0] is tri1[fp1]
+
+        // Find next common point
+        label fp0p1 = tri0.fcIndex(fp0);
+        label fp1p1 = tri1.fcIndex(fp1);
+        label fp1m1 = tri1.rcIndex(fp1);
+
+        if (tri0[fp0p1] == tri1[fp1p1] || tri0[fp0p1] == tri1[fp1m1])
+        {
+            common[0] = tri0[fp0];
+            common[1] = tri0[fp0p1];
+        }
+    }
+    return common;
+}
+
+
+// Caculate centre of surface.
+Foam::point Foam::isoSurfaceCell::calcCentre(const triSurface& s)
+{
+    vector sum = vector::zero;
+
+    forAll(s, i)
+    {
+        sum += s[i].centre(s.points());
+    }
+    return sum/s.size();
+}
+
+
+// Replace surface (localPoints, localTris) with single point. Returns
+// point. Destructs arguments.
+Foam::pointIndexHit Foam::isoSurfaceCell::collapseSurface
+(
+    pointField& localPoints,
+    DynamicList<labelledTri, 64>& localTris
+)
+{
+    pointIndexHit info(false, vector::zero, localTris.size());
+
+    if (localTris.size() == 0)
+    {}
+    else if (localTris.size() == 1)
+    {
+        const labelledTri& tri = localTris[0];
+        info.setPoint(tri.centre(localPoints));
+        info.setHit();
+    }
+    else if (localTris.size() == 2)
+    {
+        // Check if the two triangles share an edge.
+        const labelledTri& tri0 = localTris[0];
+        const labelledTri& tri1 = localTris[0];
+
+        labelPair shared = findCommonPoints(tri0, tri1);
+
+        if (shared[0] != -1)
+        {
+            info.setPoint
+            (
+                0.5
+              * (
+                    tri0.centre(localPoints)
+                  + tri1.centre(localPoints)
+                )
+            );
+            info.setHit();
+        }
+    }
+    else
+    {
+        // Check if single region. Rare situation.
+        triSurface surf
+        (
+            localTris,
+            geometricSurfacePatchList(0),
+            localPoints,
+            true
+        );
+        localTris.clearStorage();
+
+        labelList faceZone;
+        label nZones = surf.markZones
+        (
+            boolList(surf.nEdges(), false),
+            faceZone
+        );
+
+        if (nZones == 1)
+        {
+            info.setPoint(calcCentre(surf));
+            info.setHit();
+        }
+    }
+
+    return info;
+}
+
+
+void Foam::isoSurfaceCell::calcSnappedCc
+(
+    const PackedList<1>& isTet,
+    const scalarField& cVals,
+    const scalarField& pVals,
+    const List<cellCutType>& cellCutType,
+
+    DynamicList<point>& snappedPoints,
+    labelList& snappedCc
+) const
+{
+    const pointField& cc = mesh_.cellCentres();
+    const pointField& pts = mesh_.points();
+
+    snappedCc.setSize(mesh_.nCells());
+    snappedCc = -1;
+
+    // Work arrays
+    DynamicList<point, 64> localPoints(64);
+    DynamicList<labelledTri, 64> localTris(64);
+    Map<label> pointToLocal(64);
+
+    forAll(mesh_.cells(), cellI)
+    {
+        if (cellCutType[cellI] == CUT && isTet.get(cellI) == 0)
+        {
+            scalar cVal = cVals[cellI];
+
+            const cell& cFaces = mesh_.cells()[cellI];
+
+            localPoints.clear();
+            localTris.clear();
+            pointToLocal.clear();
+
+            // Create points for all intersections close to cell centre
+            // (i.e. from pyramid edges)
+
+            forAll(cFaces, cFaceI)
+            {
+                const face& f = mesh_.faces()[cFaces[cFaceI]];
+
+                forAll(f, fp)
+                {
+                    label pointI = f[fp];
+
+                    scalar s = isoFraction(cVal, pVals[pointI]);
+
+                    if (s >= 0.0 && s <= 0.5)
+                    {
+                        if (pointToLocal.insert(pointI, localPoints.size()))
+                        {
+                            localPoints.append((1.0-s)*cc[cellI]+s*pts[pointI]);
+                        }
+                    }
+                }
+            }
+
+            if (localPoints.size() == 0)
+            {
+                // No near intersections
+            }
+            else if (localPoints.size() == 1)
+            {
+                // No need for any analysis.
+                snappedCc[cellI] = snappedPoints.size();
+                snappedPoints.append(localPoints[0]);
+
+                //Pout<< "cell:" << cellI
+                //    << " at " << mesh_.cellCentres()[cellI]
+                //    << " collapsing " << localPoints
+                //    << " intersections down to "
+                //    << snappedPoints[snappedCc[cellI]] << endl;
+            }
+            else if (localPoints.size() == 2)
+            {
+                //? No need for any analysis.???
+                snappedCc[cellI] = snappedPoints.size();
+                snappedPoints.append(0.5*(localPoints[0]+localPoints[1]));
+
+                //Pout<< "cell:" << cellI
+                //    << " at " << mesh_.cellCentres()[cellI]
+                //    << " collapsing " << localPoints
+                //    << " intersections down to "
+                //    << snappedPoints[snappedCc[cellI]] << endl;
+            }
+            else
+            {
+                // Need to analyse 
+                forAll(cFaces, cFaceI)
+                {
+                    const face& f = mesh_.faces()[cFaces[cFaceI]];
+
+                    // Do a tetrahedrisation. Each face to cc becomes pyr.
+                    // Each pyr gets split into tets by diagonalisation
+                    // of face.
+
+                    for (label fp = 1; fp < f.size() - 1; fp++)
+                    {
+                        triFace tri(f[0], f[fp], f[f.fcIndex(fp)]);
+                    //List<triFace> tris(triangulate(f));
+                    //forAll(tris, i)
+                    //{
+                    //    const triFace& tri = tris[i];
+
+                        // Get fractions for the three edges to cell centre
+                        FixedList<scalar, 3> s(3);
+                        s[0] = isoFraction(cVal, pVals[tri[0]]);
+                        s[1] = isoFraction(cVal, pVals[tri[1]]);
+                        s[2] = isoFraction(cVal, pVals[tri[2]]);
+
+                        if
+                        (
+                            (s[0] >= 0.0 && s[0] <= 0.5)
+                         && (s[1] >= 0.0 && s[1] <= 0.5)
+                         && (s[2] >= 0.0 && s[2] <= 0.5)
+                        )
+                        {
+                            localTris.append
+                            (
+                                labelledTri
+                                (
+                                    pointToLocal[tri[0]],
+                                    pointToLocal[tri[1]],
+                                    pointToLocal[tri[2]],
+                                    0
+                                )
+                            );
+                        }
+                    }
+                }
+
+                pointField surfPoints;
+                surfPoints.transfer(localPoints);
+                pointIndexHit info = collapseSurface(surfPoints, localTris);
+
+                if (info.hit())
+                {
+                    snappedCc[cellI] = snappedPoints.size();
+                    snappedPoints.append(info.hitPoint());
+
+                    //Pout<< "cell:" << cellI
+                    //    << " at " << mesh_.cellCentres()[cellI]
+                    //    << " collapsing " << surfPoints
+                    //    << " intersections down to "
+                    //    << snappedPoints[snappedCc[cellI]] << endl;
+                }
+            }
+        }
+    }
+}
+
+
+// Generate triangles for face connected to pointI
+void Foam::isoSurfaceCell::genPointTris
+(
+    const scalarField& cellValues,
+    const scalarField& pointValues,
+    const label pointI,
+    const face& f,
+    const label cellI,
+    DynamicList<point, 64>& localTriPoints
+) const
+{
+    const pointField& cc = mesh_.cellCentres();
+    const pointField& pts = mesh_.points();
+
+    for (label fp = 1; fp < f.size() - 1; fp++)
+    {
+        triFace tri(f[0], f[fp], f[f.fcIndex(fp)]);
+    //List<triFace> tris(triangulate(f));
+    //forAll(tris, i)
+    //{
+    //    const triFace& tri = tris[i];
+
+        label index = findIndex(tri, pointI);
+
+        if (index == -1)
+        {
+            continue;
+        }
+
+        // Tet between index..index-1, index..index+1, index..cc
+        label b = tri[tri.fcIndex(index)];
+        label c = tri[tri.rcIndex(index)];
+
+        // Get fractions for the three edges emanating from point
+        FixedList<scalar, 3> s(3);
+        s[0] = isoFraction(pointValues[pointI], pointValues[b]);
+        s[1] = isoFraction(pointValues[pointI], pointValues[c]);
+        s[2] = isoFraction(pointValues[pointI], cellValues[cellI]);
+
+        if
+        (
+            (s[0] >= 0.0 && s[0] <= 0.5)
+         && (s[1] >= 0.0 && s[1] <= 0.5)
+         && (s[2] >= 0.0 && s[2] <= 0.5)
+        )
+        {
+            localTriPoints.append((1.0-s[0])*pts[pointI] + s[0]*pts[b]);
+            localTriPoints.append((1.0-s[1])*pts[pointI] + s[1]*pts[c]);
+            localTriPoints.append((1.0-s[2])*pts[pointI] + s[2]*cc[cellI]);
+        }
+    }
+}
+
+
+// Generate triangle for tet connected to pointI
+void Foam::isoSurfaceCell::genPointTris
+(
+    const scalarField& pointValues,
+    const label pointI,
+    const label cellI,
+    DynamicList<point, 64>& localTriPoints
+) const
+{
+    const pointField& pts = mesh_.points();
+    const cell& cFaces = mesh_.cells()[cellI];
+
+    FixedList<label, 4> tet;
+
+    label face0 = cFaces[0];
+    const face& f0 = mesh_.faces()[face0];
+
+    if (mesh_.faceOwner()[face0] != cellI)
+    {
+        tet[0] = f0[0];
+        tet[1] = f0[1];
+        tet[2] = f0[2];
+    }
+    else
+    {
+        tet[0] = f0[0];
+        tet[1] = f0[2];
+        tet[2] = f0[1];
+    }
+
+    // Find the point on the next face that is not on f0
+    const face& f1 = mesh_.faces()[cFaces[1]];
+
+    forAll(f1, fp)
+    {
+        label p1 = f1[fp];
+
+        if (p1 != tet[0] && p1 != tet[1] && p1 != tet[2])
+        {
+            tet[3] = p1;
+            break;
+        }
+    }
+
+
+    // Get the index of pointI
+
+    label i0 = findIndex(tet, pointI);
+    label i1 = tet.fcIndex(i0);
+    label i2 = tet.fcIndex(i1);
+    label i3 = tet.fcIndex(i2);
+
+    // Get fractions for the three edges emanating from point
+    FixedList<scalar, 3> s(3);
+    s[0] = isoFraction(pointValues[pointI], pointValues[tet[i1]]);
+    s[1] = isoFraction(pointValues[pointI], pointValues[tet[i2]]);
+    s[2] = isoFraction(pointValues[pointI], pointValues[tet[i3]]);
+
+    if
+    (
+        (s[0] >= 0.0 && s[0] <= 0.5)
+     && (s[1] >= 0.0 && s[1] <= 0.5)
+     && (s[2] >= 0.0 && s[2] <= 0.5)
+    )
+    {
+        localTriPoints.append((1.0-s[0])*pts[pointI] + s[0]*pts[tet[i1]]);
+        localTriPoints.append((1.0-s[1])*pts[pointI] + s[1]*pts[tet[i2]]);
+        localTriPoints.append((1.0-s[2])*pts[pointI] + s[2]*pts[tet[i3]]);
+    }
+}
+
+
+void Foam::isoSurfaceCell::calcSnappedPoint
+(
+    const PackedList<1>& isBoundaryPoint,
+    const PackedList<1>& isTet,
+    const scalarField& cVals,
+    const scalarField& pVals,
+    const List<cellCutType>& cellCutType,
+
+    DynamicList<point>& snappedPoints,
+    labelList& snappedPoint
+) const
+{
+    const point greatPoint(VGREAT, VGREAT, VGREAT);
+    pointField collapsedPoint(mesh_.nPoints(), greatPoint);
+
+
+    // Work arrays
+    DynamicList<point, 64> localTriPoints(100);
+    labelHashSet localPointCells(100);
+
+    forAll(mesh_.pointFaces(), pointI)
+    {
+        if (isBoundaryPoint.get(pointI) == 1)
+        {
+            continue;
+        }
+
+        const labelList& pFaces = mesh_.pointFaces()[pointI];
+
+        bool anyCut = false;
+
+        forAll(pFaces, i)
+        {
+            label faceI = pFaces[i];
+
+            if
+            (
+                cellCutType[mesh_.faceOwner()[faceI]] == CUT
+             || (
+                    mesh_.isInternalFace(faceI)
+                 && cellCutType[mesh_.faceNeighbour()[faceI]] == CUT
+                )
+            )
+            {
+                anyCut = true;
+                break;
+            }
+        }
+
+        if (!anyCut)
+        {
+            continue;
+        }
+
+
+        localPointCells.clear();
+        localTriPoints.clear();
+
+        forAll(pFaces, pFaceI)
+        {
+            label faceI = pFaces[pFaceI];
+            const face& f = mesh_.faces()[faceI];
+            label own = mesh_.faceOwner()[faceI];
+
+            // Triangulate around f[0] on owner side
+            if (isTet.get(own) == 1)
+            {
+                if (localPointCells.insert(own))
+                {
+                    genPointTris(pVals, pointI, own, localTriPoints);
+                }
+            }
+            else
+            {
+                genPointTris(cVals, pVals, pointI, f, own, localTriPoints);
+            }
+
+            if (mesh_.isInternalFace(faceI))
+            {
+                label nei = mesh_.faceNeighbour()[faceI];
+
+                if (isTet.get(nei) == 1)
+                {
+                    if (localPointCells.insert(nei))
+                    {
+                        genPointTris(pVals, pointI, nei, localTriPoints);
+                    }
+                }
+                else
+                {
+                    genPointTris(cVals, pVals, pointI, f, nei, localTriPoints);
+                }
+            }
+        }
+
+        if (localTriPoints.size() == 0)
+        {
+            // No near intersections
+        }
+        else if (localTriPoints.size() == 3)
+        {
+            // Single triangle. No need for any analysis. Average points.
+            pointField points;
+            points.transfer(localTriPoints);
+            collapsedPoint[pointI] = sum(points)/points.size();
+
+            //Pout<< "    point:" << pointI
+            //    << " replacing coord:" << mesh_.points()[pointI]
+            //    << " by average:" << collapsedPoint[pointI] << endl;
+        }
+        else
+        {
+            // Convert points into triSurface.
+
+            // Merge points and compact out non-valid triangles
+            labelList triMap;               // merged to unmerged triangle
+            labelList triPointReverseMap;   // unmerged to merged point
+            triSurface surf
+            (
+                stitchTriPoints
+                (
+                    false,                  // do not check for duplicate tris
+                    localTriPoints,
+                    triPointReverseMap,  
+                    triMap
+                )
+            );
+
+            labelList faceZone;
+            label nZones = surf.markZones
+            (
+                boolList(surf.nEdges(), false),
+                faceZone
+            );
+
+            if (nZones == 1)
+            {
+                collapsedPoint[pointI] = calcCentre(surf);
+                //Pout<< "    point:" << pointI << " nZones:" << nZones
+                //    << " replacing coord:" << mesh_.points()[pointI]
+                //    << " by average:" << collapsedPoint[pointI] << endl;
+            }
+        }
+    }
+
+    syncTools::syncPointList
+    (
+        mesh_,
+        collapsedPoint,
+        minEqOp<point>(),
+        greatPoint,
+        true                // are coordinates so separate
+    );
+
+    snappedPoint.setSize(mesh_.nPoints());
+    snappedPoint = -1;
+
+    forAll(collapsedPoint, pointI)
+    {
+        if (collapsedPoint[pointI] != greatPoint)
+        {
+            snappedPoint[pointI] = snappedPoints.size();
+            snappedPoints.append(collapsedPoint[pointI]);
+        }
+    }
+}
+
+
+Foam::point Foam::isoSurfaceCell::generatePoint
+(
+    const DynamicList<point>& snappedPoints,
+
+    const scalar s0,
+    const point& p0,
+    const label p0Index,
+
+    const scalar s1,
+    const point& p1,
+    const label p1Index
+) const
+{
+    scalar d = s1-s0;
+
+    if (mag(d) > VSMALL)
+    {
+        scalar s = (iso_-s0)/d;
+
+        if (s >= 0.5 && s <= 1 && p1Index != -1)
+        {
+            return snappedPoints[p1Index];
+        }
+        else if (s >= 0.0 && s <= 0.5 && p0Index != -1)
+        {
+            return snappedPoints[p0Index];
+        }
+        else
+        {
+            return s*p1 + (1.0-s)*p0;
+        }
+    }
+    else
+    {
+        scalar s = 0.4999;
+
+        return s*p1 + (1.0-s)*p0;
+    }
+}
+
+
+void Foam::isoSurfaceCell::generateTriPoints
+(
+    const DynamicList<point>& snapped,
+
+    const scalar s0,
+    const point& p0,
+    const label p0Index,
+
+    const scalar s1,
+    const point& p1,
+    const label p1Index,
+
+    const scalar s2,
+    const point& p2,
+    const label p2Index,
+
+    const scalar s3,
+    const point& p3,
+    const label p3Index,
+
+    DynamicList<point>& points
+) const
+{
+    int triIndex = 0;
+    if (s0 < iso_)
+    {
+        triIndex |= 1;
+    }
+    if (s1 < iso_)
+    {
+        triIndex |= 2;
+    }
+    if (s2 < iso_)
+    {
+        triIndex |= 4;
+    }
+    if (s3 < iso_)
+    {
+        triIndex |= 8;
+    }
+
+    /* Form the vertices of the triangles for each case */
+    switch (triIndex)
+    {
+        case 0x00:
+        case 0x0F:
+        break;
+
+        case 0x0E:
+        case 0x01:
+            points.append(generatePoint(snapped,s0,p0,p0Index,s1,p1,p1Index));
+            points.append(generatePoint(snapped,s0,p0,p0Index,s2,p2,p2Index));
+            points.append(generatePoint(snapped,s0,p0,p0Index,s3,p3,p3Index));
+        break;
+
+        case 0x0D:
+        case 0x02:
+            points.append(generatePoint(snapped,s1,p1,p1Index,s0,p0,p0Index));
+            points.append(generatePoint(snapped,s1,p1,p1Index,s3,p3,p3Index));
+            points.append(generatePoint(snapped,s1,p1,p1Index,s2,p2,p2Index));
+        break;
+
+        case 0x0C:
+        case 0x03:
+        {
+            point tp1 = generatePoint(snapped,s0,p0,p0Index,s2,p2,p2Index);
+            point tp2 = generatePoint(snapped,s1,p1,p1Index,s3,p3,p3Index);
+
+            points.append(generatePoint(snapped,s0,p0,p0Index,s3,p3,p3Index));
+            points.append(tp1);
+            points.append(tp2);
+            points.append(tp2);
+            points.append(generatePoint(snapped,s1,p1,p1Index,s2,p2,p2Index));
+            points.append(tp1);
+        }
+        break;
+
+        case 0x0B:
+        case 0x04:
+        {
+            points.append(generatePoint(snapped,s2,p2,p2Index,s0,p0,p0Index));
+            points.append(generatePoint(snapped,s2,p2,p2Index,s1,p1,p1Index));
+            points.append(generatePoint(snapped,s2,p2,p2Index,s3,p3,p3Index));
+        }
+        break;
+
+        case 0x0A:
+        case 0x05:
+        {
+            point tp0 = generatePoint(snapped,s0,p0,p0Index,s1,p1,p1Index);
+            point tp1 = generatePoint(snapped,s2,p2,p2Index,s3,p3,p3Index);
+
+            points.append(tp0);
+            points.append(tp1);
+            points.append(generatePoint(snapped,s0,p0,p0Index,s3,p3,p3Index));
+            points.append(tp0);
+            points.append(generatePoint(snapped,s1,p1,p1Index,s2,p2,p2Index));
+            points.append(tp1);
+        }
+        break;
+
+        case 0x09:
+        case 0x06:
+        {
+            point tp0 = generatePoint(snapped,s0,p0,p0Index,s1,p1,p1Index);
+            point tp1 = generatePoint(snapped,s2,p2,p2Index,s3,p3,p3Index);
+
+            points.append(tp0);
+            points.append(generatePoint(snapped,s1,p1,p1Index,s3,p3,p3Index));
+            points.append(tp1);
+            points.append(tp0);
+            points.append(generatePoint(snapped,s0,p0,p0Index,s2,p2,p2Index));
+            points.append(tp1);
+        }
+        break;
+
+        case 0x07:
+        case 0x08:
+            points.append(generatePoint(snapped,s3,p3,p3Index,s0,p0,p0Index));
+            points.append(generatePoint(snapped,s3,p3,p3Index,s2,p2,p2Index));
+            points.append(generatePoint(snapped,s3,p3,p3Index,s1,p1,p1Index));
+        break;
+    }
+}
+
+
+Foam::triSurface Foam::isoSurfaceCell::stitchTriPoints
+(
+    const bool checkDuplicates,
+    const List<point>& triPoints,
+    labelList& triPointReverseMap,  // unmerged to merged point
+    labelList& triMap               // merged to unmerged triangle
+) const
+{
+    label nTris = triPoints.size()/3;
+
+    if ((triPoints.size() % 3) != 0)
+    {
+        FatalErrorIn("isoSurfaceCell::stitchTriPoints(..)")
+            << "Problem: number of points " << triPoints.size()
+            << " not a multiple of 3." << abort(FatalError);
+    }
+
+    pointField newPoints;
+    mergePoints
+    (
+        triPoints,
+        mergeDistance_,
+        false,
+        triPointReverseMap,
+        newPoints
+    );
+
+    // Check that enough merged.
+    if (debug)
+    {
+        pointField newNewPoints;
+        labelList oldToNew;
+        bool hasMerged = mergePoints
+        (
+            newPoints,
+            mergeDistance_,
+            true,
+            oldToNew,
+            newNewPoints
+        );
+
+        if (hasMerged)
+        {
+            FatalErrorIn("isoSurfaceCell::stitchTriPoints(..)")
+                << "Merged points contain duplicates"
+                << " when merging with distance " << mergeDistance_ << endl
+                << "merged:" << newPoints.size() << " re-merged:"
+                << newNewPoints.size()
+                << abort(FatalError);
+        }
+    }
+
+
+    List<labelledTri> tris;
+    {
+        DynamicList<labelledTri> dynTris(nTris);
+        label rawPointI = 0;
+        DynamicList<label> newToOldTri(nTris);
+
+        for (label oldTriI = 0; oldTriI < nTris; oldTriI++)
+        {
+            labelledTri tri
+            (
+                triPointReverseMap[rawPointI],
+                triPointReverseMap[rawPointI+1],
+                triPointReverseMap[rawPointI+2],
+                0
+            );
+            rawPointI += 3;
+
+            if ((tri[0] != tri[1]) && (tri[0] != tri[2]) && (tri[1] != tri[2]))
+            {
+                newToOldTri.append(oldTriI);
+                dynTris.append(tri);
+            }
+        }
+
+        triMap.transfer(newToOldTri.shrink());
+        tris.transfer(dynTris.shrink());
+    }
+
+
+    // Use face centres to determine 'flat hole' situation (see RMT paper).
+    // Two unconnected triangles get connected because (some of) the edges
+    // separating them get collapsed. Below only checks for duplicate triangles,
+    // not non-manifold edge connectivity.
+    if (checkDuplicates)
+    {
+        if (debug)
+        {
+            Pout<< "isoSurfaceCell : merged from " << nTris
+                << " down to " << tris.size() << " triangles." << endl;
+        }
+
+        pointField centres(tris.size());
+        forAll(tris, triI)
+        {
+            centres[triI] = tris[triI].centre(newPoints);
+        }
+
+        pointField mergedCentres;
+        labelList oldToMerged;
+        bool hasMerged = mergePoints
+        (
+            centres,
+            mergeDistance_,
+            false,
+            oldToMerged,
+            mergedCentres
+        );
+
+        if (debug)
+        {
+            Pout<< "isoSurfaceCell : detected "
+                << centres.size()-mergedCentres.size()
+                << " duplicate triangles." << endl;
+        }
+
+        if (hasMerged)
+        {
+            // Filter out duplicates.
+            label newTriI = 0;
+            DynamicList<label> newToOldTri(tris.size());
+            labelList newToMaster(mergedCentres.size(), -1);
+            forAll(tris, triI)
+            {
+                label mergedI = oldToMerged[triI];
+
+                if (newToMaster[mergedI] == -1)
+                {
+                    newToMaster[mergedI] = triI;
+                    newToOldTri.append(triMap[triI]);
+                    tris[newTriI++] = tris[triI];
+                }
+            }
+
+            triMap.transfer(newToOldTri.shrink());
+            tris.setSize(newTriI);
+        }
+    }
+
+    return triSurface(tris, geometricSurfacePatchList(0), newPoints, true);
+}
+
+
+// Does face use valid vertices?
+bool Foam::isoSurfaceCell::validTri(const triSurface& surf, const label faceI)
+{
+    // Simple check on indices ok.
+
+    const labelledTri& f = surf[faceI];
+
+    if
+    (
+        (f[0] < 0) || (f[0] >= surf.points().size())
+     || (f[1] < 0) || (f[1] >= surf.points().size())
+     || (f[2] < 0) || (f[2] >= surf.points().size())
+    )
+    {
+        WarningIn("validTri(const triSurface&, const label)")
+            << "triangle " << faceI << " vertices " << f
+            << " uses point indices outside point range 0.."
+            << surf.points().size()-1 << endl;
+
+        return false;
+    }
+
+    if ((f[0] == f[1]) || (f[0] == f[2]) || (f[1] == f[2]))
+    {
+        WarningIn("validTri(const triSurface&, const label)")
+            << "triangle " << faceI
+            << " uses non-unique vertices " << f
+            << endl;
+        return false;
+    }
+
+    // duplicate triangle check
+
+    const labelList& fFaces = surf.faceFaces()[faceI];
+
+    // Check if faceNeighbours use same points as this face.
+    // Note: discards normal information - sides of baffle are merged.
+    forAll(fFaces, i)
+    {
+        label nbrFaceI = fFaces[i];
+
+        if (nbrFaceI <= faceI)
+        {
+            // lower numbered faces already checked
+            continue;
+        }
+
+        const labelledTri& nbrF = surf[nbrFaceI];
+
+        if
+        (
+            ((f[0] == nbrF[0]) || (f[0] == nbrF[1]) || (f[0] == nbrF[2]))
+         && ((f[1] == nbrF[0]) || (f[1] == nbrF[1]) || (f[1] == nbrF[2]))
+         && ((f[2] == nbrF[0]) || (f[2] == nbrF[1]) || (f[2] == nbrF[2]))
+        )
+        {
+            WarningIn("validTri(const triSurface&, const label)")
+                << "triangle " << faceI << " vertices " << f
+                << " has the same vertices as triangle " << nbrFaceI
+                << " vertices " << nbrF
+                << endl;
+
+            return false;
+        }
+    }
+    return true;
+}
+
+
+void Foam::isoSurfaceCell::calcAddressing
+(
+    const triSurface& surf,
+    List<FixedList<label, 3> >& faceEdges,
+    labelList& edgeFace0,
+    labelList& edgeFace1,
+    Map<labelList>& edgeFacesRest
+) const
+{
+    const pointField& points = surf.points();
+
+    pointField edgeCentres(3*surf.size());
+    label edgeI = 0;
+    forAll(surf, triI)
+    {
+        const labelledTri& tri = surf[triI];
+        edgeCentres[edgeI++] = 0.5*(points[tri[0]]+points[tri[1]]);
+        edgeCentres[edgeI++] = 0.5*(points[tri[1]]+points[tri[2]]);
+        edgeCentres[edgeI++] = 0.5*(points[tri[2]]+points[tri[0]]);
+    }
+
+    pointField mergedCentres;
+    labelList oldToMerged;
+    bool hasMerged = mergePoints
+    (
+        edgeCentres,
+        mergeDistance_,
+        false,
+        oldToMerged,
+        mergedCentres
+    );
+
+    if (debug)
+    {
+        Pout<< "isoSurfaceCell : detected "
+            << mergedCentres.size()
+            << " edges on " << surf.size() << " triangles." << endl;
+    }
+
+    if (!hasMerged)
+    {
+        return;
+    }
+
+
+    // Determine faceEdges
+    faceEdges.setSize(surf.size());
+    edgeI = 0;
+    forAll(surf, triI)
+    {
+        faceEdges[triI][0] = oldToMerged[edgeI++];
+        faceEdges[triI][1] = oldToMerged[edgeI++];
+        faceEdges[triI][2] = oldToMerged[edgeI++];
+    }
+    
+
+    // Determine edgeFaces
+    edgeFace0.setSize(mergedCentres.size());
+    edgeFace0 = -1;
+    edgeFace1.setSize(mergedCentres.size());
+    edgeFace1 = -1;
+    edgeFacesRest.clear();
+
+    forAll(oldToMerged, oldEdgeI)
+    {
+        label triI = oldEdgeI / 3;
+        label edgeI = oldToMerged[oldEdgeI];
+
+        if (edgeFace0[edgeI] == -1)
+        {
+            edgeFace0[edgeI] = triI;
+        }
+        else if (edgeFace1[edgeI] == -1)
+        {
+            edgeFace1[edgeI] = triI;
+        }
+        else
+        {
+            //WarningIn("orientSurface(triSurface&)")
+            //    << "Edge " << edgeI << " with centre " << mergedCentres[edgeI]
+            //    << " used by more than two triangles: " << edgeFace0[edgeI]
+            //    << ", "
+            //    << edgeFace1[edgeI] << " and " << triI << endl;
+            Map<labelList>::iterator iter = edgeFacesRest.find(edgeI);
+
+            if (iter != edgeFacesRest.end())
+            {
+                labelList& eFaces = iter();
+                label sz = eFaces.size();
+                eFaces.setSize(sz+1);
+                eFaces[sz] = triI;
+            }
+            else
+            {
+                edgeFacesRest.insert(edgeI, labelList(1, triI));
+            }
+        }
+    }
+}
+
+
+void Foam::isoSurfaceCell::walkOrientation
+(
+    const triSurface& surf,
+    const List<FixedList<label, 3> >& faceEdges,
+    const labelList& edgeFace0,
+    const labelList& edgeFace1,
+    const label seedTriI,
+    labelList& flipState
+)
+{
+    // Do walk for consistent orientation.
+    DynamicList<label> changedFaces(surf.size());
+
+    changedFaces.append(seedTriI);
+
+    while (changedFaces.size() > 0)
+    {
+        DynamicList<label> newChangedFaces(changedFaces.size());
+
+        forAll(changedFaces, i)
+        {
+            label triI = changedFaces[i];
+            const labelledTri& tri = surf[triI];
+            const FixedList<label, 3>& fEdges = faceEdges[triI];
+
+            forAll(fEdges, fp)
+            {
+                label edgeI = fEdges[fp];
+    
+                // my points:
+                label p0 = tri[fp];
+                label p1 = tri[tri.fcIndex(fp)];
+
+                label nbrI =
+                (
+                    edgeFace0[edgeI] != triI
+                  ? edgeFace0[edgeI]
+                  : edgeFace1[edgeI]
+                );
+
+                if (nbrI != -1 && flipState[nbrI] == -1)
+                {
+                    const labelledTri& nbrTri = surf[nbrI];
+
+                    // nbr points
+                    label nbrFp = findIndex(nbrTri, p0);
+                    label nbrP1 = nbrTri[nbrTri.rcIndex(nbrFp)];
+
+                    bool sameOrientation = (p1 == nbrP1);
+
+                    if (flipState[triI] == 0)
+                    {
+                        flipState[nbrI] = (sameOrientation ? 0 : 1);
+                    }
+                    else
+                    {
+                        flipState[nbrI] = (sameOrientation ? 1 : 0);
+                    }
+                    newChangedFaces.append(nbrI);
+                }
+            }
+        }
+
+        changedFaces.transfer(newChangedFaces);
+    }
+}    
+
+
+void Foam::isoSurfaceCell::orientSurface
+(
+    triSurface& surf,
+    const List<FixedList<label, 3> >& faceEdges,
+    const labelList& edgeFace0,
+    const labelList& edgeFace1,
+    const Map<labelList>& edgeFacesRest
+)
+{
+    // -1 : unvisited
+    //  0 : leave as is
+    //  1 : flip
+    labelList flipState(surf.size(), -1);
+
+    label seedTriI = 0;
+
+    while (true)
+    {
+        // Find first unvisited triangle
+        for
+        (
+            ;
+            seedTriI < surf.size() && flipState[seedTriI] != -1; 
+            seedTriI++
+        )
+        {}
+
+        if (seedTriI == surf.size())
+        {
+            break;
+        }
+
+        // Note: Determine orientation of seedTriI?
+        // for now assume it is ok
+        flipState[seedTriI] = 0;
+
+        walkOrientation
+        (
+            surf,
+            faceEdges,
+            edgeFace0,
+            edgeFace1,
+            seedTriI,
+            flipState
+        );
+    }
+
+    // Do actual flipping
+    surf.clearOut();
+    forAll(surf, triI)
+    {
+        if (flipState[triI] == 1)
+        {
+            labelledTri tri(surf[triI]);
+
+            surf[triI][0] = tri[0];
+            surf[triI][1] = tri[2];
+            surf[triI][2] = tri[1];
+        }
+        else if (flipState[triI] == -1)
+        {
+            FatalErrorIn
+            (
+                "isoSurfaceCell::orientSurface(triSurface&, const label)"
+            )   << "problem" << abort(FatalError);
+        }
+    }
+}
+
+
+// Checks if triangle is connected through edgeI only.
+bool Foam::isoSurfaceCell::danglingTriangle
+(
+    const FixedList<label, 3>& fEdges,
+    const labelList& edgeFace1
+)
+{
+    label nOpen = 0;
+    forAll(fEdges, i)
+    {
+        if (edgeFace1[fEdges[i]] == -1)
+        {
+            nOpen++;
+        }
+    }
+
+    if (nOpen == 1 || nOpen == 2 || nOpen == 3)
+    {
+        return true;
+    }
+    else
+    {
+        return false;
+    }
+}
+
+
+// Mark triangles to keep. Returns number of dangling triangles.
+Foam::label Foam::isoSurfaceCell::markDanglingTriangles
+(
+    const List<FixedList<label, 3> >& faceEdges,
+    const labelList& edgeFace0,
+    const labelList& edgeFace1,
+    const Map<labelList>& edgeFacesRest,
+    boolList& keepTriangles
+)
+{
+    keepTriangles.setSize(faceEdges.size());
+    keepTriangles = true;
+
+    label nDangling = 0;
+
+    // Remove any dangling triangles
+    forAllConstIter(Map<labelList>,  edgeFacesRest, iter)
+    {
+        // These are all the non-manifold edges. Filter out all triangles
+        // with only one connected edge (= this edge)
+
+        label edgeI = iter.key();
+        const labelList& otherEdgeFaces = iter();
+
+        // Remove all dangling triangles
+        if (danglingTriangle(faceEdges[edgeFace0[edgeI]], edgeFace1))
+        {
+            keepTriangles[edgeFace0[edgeI]] = false;
+            nDangling++;
+        }
+        if (danglingTriangle(faceEdges[edgeFace1[edgeI]], edgeFace1))
+        {
+            keepTriangles[edgeFace1[edgeI]] = false;
+            nDangling++;
+        }
+        forAll(otherEdgeFaces, i)
+        {
+            label triI = otherEdgeFaces[i];
+            if (danglingTriangle(faceEdges[triI], edgeFace1))
+            {
+                keepTriangles[triI] = false;
+                nDangling++;
+            }
+        }
+    }
+    return nDangling;
+}
+
+
+Foam::triSurface Foam::isoSurfaceCell::subsetMesh
+(
+    const triSurface& s,
+    const labelList& newToOldFaces,
+    labelList& oldToNewPoints,
+    labelList& newToOldPoints
+)
+{
+    const boolList include
+    (
+        createWithValues<boolList>
+        (
+            s.size(),
+            false,
+            newToOldFaces,
+            true
+        )
+    );
+
+    newToOldPoints.setSize(s.points().size());
+    oldToNewPoints.setSize(s.points().size());
+    oldToNewPoints = -1;
+    {
+        label pointI = 0;
+
+        forAll(include, oldFacei)
+        {
+            if (include[oldFacei])
+            {
+                // Renumber labels for triangle
+                const labelledTri& tri = s[oldFacei];
+
+                forAll(tri, fp)
+                {
+                    label oldPointI = tri[fp];
+
+                    if (oldToNewPoints[oldPointI] == -1)
+                    {
+                        oldToNewPoints[oldPointI] = pointI;
+                        newToOldPoints[pointI++] = oldPointI;
+                    }
+                }
+            }
+        }
+        newToOldPoints.setSize(pointI);
+    }
+
+    // Extract points
+    pointField newPoints(newToOldPoints.size());
+    forAll(newToOldPoints, i)
+    {
+        newPoints[i] = s.points()[newToOldPoints[i]];
+    }
+    // Extract faces
+    List<labelledTri> newTriangles(newToOldFaces.size());
+
+    forAll(newToOldFaces, i)
+    {
+        // Get old vertex labels
+        const labelledTri& tri = s[newToOldFaces[i]];
+
+        newTriangles[i][0] = oldToNewPoints[tri[0]];
+        newTriangles[i][1] = oldToNewPoints[tri[1]];
+        newTriangles[i][2] = oldToNewPoints[tri[2]];
+        newTriangles[i].region() = tri.region();
+    }
+
+    // Reuse storage.
+    return triSurface(newTriangles, s.patches(), newPoints, true);
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::isoSurfaceCell::isoSurfaceCell
+(
+    const polyMesh& mesh,
+    const scalarField& cVals,
+    const scalarField& pVals,
+    const scalar iso,
+    const bool regularise,
+    const scalar mergeTol
+)
+:
+    mesh_(mesh),
+    iso_(iso),
+    mergeDistance_(mergeTol*mag(mesh.bounds().max()-mesh.bounds().min()))
+{
+    // Determine if cell is tet
+    PackedList<1> isTet(mesh_.nCells());
+    {
+        tetMatcher tet;
+
+        forAll(isTet, cellI)
+        {
+            if (tet.isA(mesh_, cellI))
+            {
+                isTet.set(cellI, 1);
+            }
+        }
+    }
+
+    // Determine if point is on boundary. Points on boundaries are never
+    // snapped. Coupled boundaries are handled explicitly so not marked here.
+    PackedList<1> isBoundaryPoint(mesh_.nPoints());
+    const polyBoundaryMesh& patches = mesh_.boundaryMesh();
+    forAll(patches, patchI)
+    {
+        const polyPatch& pp = patches[patchI];
+
+        if (!pp.coupled())
+        {
+            label faceI = pp.start();
+            forAll(pp, i)
+            {
+                const face& f = mesh_.faces()[faceI++];
+
+                forAll(f, fp)
+                {
+                    isBoundaryPoint.set(f[fp], 1);
+                }
+            }
+        }
+    }
+
+
+    // Determine if any cut through cell
+
+    List<cellCutType> cellCutType(mesh_.nCells());
+    label nCutCells = 0;
+    forAll(mesh_.cells(), cellI)
+    {
+        cellCutType[cellI] = calcCutType(isTet, cVals, pVals, cellI);
+
+        if (cellCutType[cellI] == CUT)
+        {
+            nCutCells++;
+        }
+    }
+
+    if (debug)
+    {
+        Pout<< "isoSurfaceCell : detected " << nCutCells
+            << " candidate cut cells." << endl;
+    }
+
+    DynamicList<point> snappedPoints(nCutCells);
+
+    // Per cc -1 or a point inside snappedPoints.
+    labelList snappedCc;
+    if (regularise)
+    {
+        calcSnappedCc
+        (
+            isTet,
+            cVals,
+            pVals,
+            cellCutType,
+            snappedPoints,
+            snappedCc
+        );
+    }
+    else
+    {
+        snappedCc.setSize(mesh_.nCells());
+        snappedCc = -1;
+    }
+
+    if (debug)
+    {
+        Pout<< "isoSurfaceCell : shifted " << snappedPoints.size()
+            << " cell centres to intersection." << endl;
+    }
+
+    label nCellSnaps = snappedPoints.size();
+
+    // Per point -1 or a point inside snappedPoints.
+    labelList snappedPoint;
+    if (regularise)
+    {
+        calcSnappedPoint
+        (
+            isBoundaryPoint,
+            isTet,
+            cVals,
+            pVals,
+            cellCutType,
+            snappedPoints,
+            snappedPoint
+        );
+    }
+    else
+    {
+        snappedPoint.setSize(mesh_.nPoints());
+        snappedPoint = -1;
+    }
+
+    if (debug)
+    {
+        Pout<< "isoSurfaceCell : shifted " << snappedPoints.size()-nCellSnaps
+            << " vertices to intersection." << endl;
+    }
+
+
+
+    DynamicList<point> triPoints(nCutCells);
+    DynamicList<label> triMeshCells(nCutCells);
+
+    forAll(mesh_.cells(), cellI)
+    {
+        if (cellCutType[cellI] != NOTCUT)
+        {
+            label oldNPoints = triPoints.size();
+
+            const cell& cFaces = mesh_.cells()[cellI];
+
+            if (isTet.get(cellI) == 1)
+            {
+                // For tets don't do cell-centre decomposition, just use the
+                // tet points and values
+
+                const face& f0 = mesh_.faces()[cFaces[0]];
+
+                // Get the other point
+                const face& f1 = mesh_.faces()[cFaces[1]];
+                label oppositeI = -1;
+                forAll(f1, fp)
+                {
+                    oppositeI = f1[fp];
+
+                    if (findIndex(f0, oppositeI) == -1)
+                    {
+                        break;
+                    }
+                }
+
+                generateTriPoints
+                (
+                    snappedPoints,
+                    pVals[f0[0]],
+                    mesh_.points()[f0[0]],
+                    snappedPoint[f0[0]],
+
+                    pVals[f0[1]],
+                    mesh_.points()[f0[1]],
+                    snappedPoint[f0[1]],
+
+                    pVals[f0[2]],
+                    mesh_.points()[f0[2]],
+                    snappedPoint[f0[2]],
+
+                    pVals[oppositeI],
+                    mesh_.points()[oppositeI],
+                    snappedPoint[oppositeI],
+
+                    triPoints
+                );
+            }
+            else
+            {
+                const cell& cFaces = mesh_.cells()[cellI];
+
+                forAll(cFaces, cFaceI)
+                {
+                    label faceI = cFaces[cFaceI];
+                    const face& f = mesh_.faces()[faceI];
+
+                    for (label fp = 1; fp < f.size() - 1; fp++)
+                    {
+                        triFace tri(f[0], f[fp], f[f.fcIndex(fp)]);
+                    //List<triFace> tris(triangulate(f));
+                    //forAll(tris, i)
+                    //{
+                    //    const triFace& tri = tris[i];
+
+
+                        generateTriPoints
+                        (
+                            snappedPoints,
+
+                            pVals[tri[0]],
+                            mesh_.points()[tri[0]],
+                            snappedPoint[tri[0]],
+
+                            pVals[tri[1]],
+                            mesh_.points()[tri[1]],
+                            snappedPoint[tri[1]],
+
+                            pVals[tri[2]],
+                            mesh_.points()[tri[2]],
+                            snappedPoint[tri[2]],
+
+                            cVals[cellI],
+                            mesh_.cellCentres()[cellI],
+                            snappedCc[cellI],
+
+                            triPoints
+                        );
+                    }
+                }
+            }
+
+
+            // Every three triPoints is a cell
+            label nCells = (triPoints.size()-oldNPoints)/3;
+            for (label i = 0; i < nCells; i++)
+            {
+                triMeshCells.append(cellI);
+            }
+        }
+    }
+
+    triPoints.shrink();
+    triMeshCells.shrink();
+
+    if (debug)
+    {
+        Pout<< "isoSurfaceCell : generated " << triMeshCells.size()
+            << " unmerged triangles." << endl;
+    }
+
+    // Merge points and compact out non-valid triangles
+    labelList triMap;           // merged to unmerged triangle
+    triSurface::operator=
+    (
+        stitchTriPoints
+        (
+            true,               // check for duplicate tris
+            triPoints,
+            triPointMergeMap_,  // unmerged to merged point
+            triMap
+        )
+    );
+
+    if (debug)
+    {
+        Pout<< "isoSurfaceCell : generated " << triMap.size()
+            << " merged triangles." << endl;
+    }
+
+    meshCells_.setSize(triMap.size());
+    forAll(triMap, i)
+    {
+        meshCells_[i] = triMeshCells[triMap[i]];
+    }
+
+    if (debug)
+    {
+        Pout<< "isoSurfaceCell : checking " << size()
+            << " triangles for validity." << endl;
+
+        forAll(*this, triI)
+        {
+            // Copied from surfaceCheck
+            validTri(*this, triI);
+        }
+    }
+
+
+    List<FixedList<label, 3> > faceEdges;
+    labelList edgeFace0, edgeFace1;
+    Map<labelList> edgeFacesRest;
+
+
+    while (true)
+    {
+        // Calculate addressing
+        calcAddressing(*this, faceEdges, edgeFace0, edgeFace1, edgeFacesRest);
+
+        // See if any dangling triangles
+        boolList keepTriangles;
+        label nDangling = markDanglingTriangles
+        (
+            faceEdges,
+            edgeFace0,
+            edgeFace1,
+            edgeFacesRest,
+            keepTriangles
+        );
+
+        if (debug)
+        {
+            Pout<< "isoSurfaceCell : detected " << nDangling
+                << " dangling triangles." << endl;
+        }
+
+        if (nDangling == 0)
+        {
+            break;
+        }
+
+        // Create face map (new to old)
+        labelList subsetTriMap(findIndices(keepTriangles, true));
+
+        labelList subsetPointMap;
+        labelList reversePointMap;
+        triSurface::operator=
+        (
+            subsetMesh
+            (
+                *this,
+                subsetTriMap,
+                reversePointMap,
+                subsetPointMap
+            )
+        );
+        meshCells_ = labelField(meshCells_, subsetTriMap);
+        inplaceRenumber(reversePointMap, triPointMergeMap_);
+    }
+
+    orientSurface(*this, faceEdges, edgeFace0, edgeFace1, edgeFacesRest);
+
+    //combineCellTriangles();
+}
+
+
+//XXXXXXX
+// Experimental retriangulation of triangles per cell. Problem is that
+// -it is very expensive   -only gets rid of internal points, not of boundary
+// ones so limited benefit (e.g. 60 v.s. 88 triangles)
+void Foam::isoSurfaceCell::combineCellTriangles()
+{
+    if (size() > 0)
+    {
+        DynamicList<labelledTri> newTris(size());
+        DynamicList<label> newTriToCell(size());
+
+        label startTriI = 0;
+
+        DynamicList<labelledTri> tris;
+
+        for (label triI = 1; triI <= meshCells_.size(); triI++)
+        {
+            if
+            (
+                triI == meshCells_.size()
+             || meshCells_[triI] != meshCells_[startTriI]
+            )
+            {
+                label nTris = triI-startTriI;
+
+                if (nTris == 1)
+                {
+                    newTris.append(operator[](startTriI));
+                    newTriToCell.append(meshCells_[startTriI]);
+                }
+                else
+                {
+                    // Collect from startTriI to triI in a triSurface
+                    tris.clear();
+                    for (label i = startTriI; i < triI; i++)
+                    {
+                        tris.append(operator[](i));
+                    }
+                    triSurface cellTris(tris, patches(), points());
+                    tris.clear();
+
+                    // Get outside
+                    const labelListList& loops = cellTris.edgeLoops();
+
+                    forAll(loops, i)
+                    {
+                        // Do proper triangulation of loop
+                        face loop(renumber(cellTris.meshPoints(), loops[i]));
+
+                        faceTriangulation faceTris
+                        (
+                            points(),
+                            loop,
+                            true
+                        );
+
+                        // Copy into newTris
+                        forAll(faceTris, faceTriI)
+                        {
+                            const triFace& tri = faceTris[faceTriI];
+
+                            newTris.append
+                            (
+                                labelledTri
+                                (
+                                    tri[0],
+                                    tri[1],
+                                    tri[2],
+                                    operator[](startTriI).region()
+                                )
+                            );
+                            newTriToCell.append(meshCells_[startTriI]);
+                        }
+                    }
+                }
+
+                startTriI = triI;
+            }
+        }
+        newTris.shrink();
+        newTriToCell.shrink();
+
+        // Compact
+        pointField newPoints(points().size());
+        label newPointI = 0;
+        labelList oldToNewPoint(points().size(), -1);
+
+        forAll(newTris, i)
+        {
+            labelledTri& tri = newTris[i];
+            forAll(tri, j)
+            {
+                label pointI = tri[j];
+
+                if (oldToNewPoint[pointI] == -1)
+                {
+                    oldToNewPoint[pointI] = newPointI;
+                    newPoints[newPointI++] = points()[pointI];
+                }
+                tri[j] = oldToNewPoint[pointI];
+            }
+        }
+        newPoints.setSize(newPointI);
+
+        triSurface::operator=
+        (
+            triSurface
+            (
+                newTris,
+                patches(),
+                newPoints,
+                true
+            )
+        );
+        meshCells_.transfer(newTriToCell);
+    }
+}
+//XXXXXXX
+
+// ************************************************************************* //
diff --git a/src/sampling/sampledSurface/isoSurface/isoSurfaceCell.H b/src/sampling/sampledSurface/isoSurface/isoSurfaceCell.H
new file mode 100644
index 0000000000..86b2dbef46
--- /dev/null
+++ b/src/sampling/sampledSurface/isoSurface/isoSurfaceCell.H
@@ -0,0 +1,325 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Class
+    Foam::isoSurfaceCell
+
+Description
+    A surface formed by the iso value.
+    After "Polygonising A Scalar Field Using Tetrahedrons", Paul Bourke
+    and
+    "Regularised Marching Tetrahedra: improved iso-surface extraction",
+    G.M. Treece, R.W. Prager and A.H. Gee.
+
+    See isoSurface. This is a variant which does tetrahedrisation from
+    triangulation of face to cell centre instead of edge of face to two
+    neighbouring cell centres. This gives much lower quality triangles
+    but they are local to a cell.
+
+SourceFiles
+    isoSurfaceCell.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef isoSurfaceCell_H
+#define isoSurfaceCell_H
+
+#include "triSurface.H"
+#include "labelPair.H"
+#include "pointIndexHit.H"
+#include "PackedList.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+class polyMesh;
+
+/*---------------------------------------------------------------------------*\
+                       Class isoSurfaceCell Declaration
+\*---------------------------------------------------------------------------*/
+
+class isoSurfaceCell
+:
+    public triSurface
+{
+    // Private data
+
+        enum segmentCutType
+        {
+            NEARFIRST,      // intersection close to e.first()
+            NEARSECOND,     //  ,,                   e.second()
+            NOTNEAR         // no intersection
+        };
+
+        enum cellCutType
+        {
+            NOTCUT,     // not cut
+            SPHERE,     // all edges to cell centre cut
+            CUT         // normal cut
+        };
+
+
+        //- Reference to mesh
+        const polyMesh& mesh_;
+
+        //- isoSurfaceCell value
+        const scalar iso_;
+
+        //- When to merge points
+        const scalar mergeDistance_;
+
+
+        //- For every triangle the original cell in mesh
+        labelList meshCells_;
+
+        //- For every unmerged triangle point the point in the triSurface
+        labelList triPointMergeMap_;
+
+
+    // Private Member Functions
+
+        //- Get location of iso value as fraction inbetween s0,s1
+        scalar isoFraction
+        (
+            const scalar s0,
+            const scalar s1
+        ) const;
+
+        //List<triFace> triangulate(const face& f) const;
+
+        //- Determine whether cell is cut
+        cellCutType calcCutType
+        (
+            const PackedList<1>&,
+            const scalarField& cellValues,
+            const scalarField& pointValues,
+            const label
+        ) const;
+
+        static labelPair findCommonPoints
+        (
+            const labelledTri&,
+            const labelledTri&
+        );
+
+        static point calcCentre(const triSurface&);
+
+        static pointIndexHit collapseSurface
+        (
+            pointField& localPoints,
+            DynamicList<labelledTri, 64>& localTris
+        );
+
+        //- Determine per cc whether all near cuts can be snapped to single
+        //  point.
+        void calcSnappedCc
+        (
+            const PackedList<1>& isTet,
+            const scalarField& cVals,
+            const scalarField& pVals,
+            const List<cellCutType>& cellCutType,
+            DynamicList<point>& triPoints,
+            labelList& snappedCc
+        ) const;
+
+        //- Generate triangles for face connected to pointI
+        void genPointTris
+        (
+            const scalarField& cellValues,
+            const scalarField& pointValues,
+            const label pointI,
+            const face& f,
+            const label cellI,
+            DynamicList<point, 64>& localTriPoints
+        ) const;
+
+        //- Generate triangles for tet connected to pointI
+        void genPointTris
+        (
+            const scalarField& pointValues,
+            const label pointI,
+            const label cellI,
+            DynamicList<point, 64>& localTriPoints
+        ) const;
+
+        //- Determine per point whether all near cuts can be snapped to single
+        //  point.
+        void calcSnappedPoint
+        (
+            const PackedList<1>& isBoundaryPoint,
+            const PackedList<1>& isTet,
+            const scalarField& cVals,
+            const scalarField& pVals,
+            const List<cellCutType>& cellCutType,
+            DynamicList<point>& triPoints,
+            labelList& snappedPoint
+        ) const;
+
+        //- Generate single point by interpolation or snapping
+        point generatePoint
+        (
+            const DynamicList<point>& snappedPoints,
+            const scalar s0,
+            const point& p0,
+            const label p0Index,
+            const scalar s1,
+            const point& p1,
+            const label p1Index
+        ) const;
+
+        void generateTriPoints
+        (
+            const DynamicList<point>& snapped,
+            const scalar s0,
+            const point& p0,
+            const label p0Index,
+            const scalar s1,
+            const point& p1,
+            const label p1Index,
+            const scalar s2,
+            const point& p2,
+            const label p2Index,
+            const scalar s3,
+            const point& p3,
+            const label p3Index,
+            DynamicList<point>& points
+        ) const;
+
+        triSurface stitchTriPoints
+        (
+            const bool checkDuplicates,
+            const List<point>& triPoints,
+            labelList& triPointReverseMap,  // unmerged to merged point
+            labelList& triMap               // merged to unmerged triangle
+        ) const;
+
+        //- Check single triangle for (topological) validity
+        static bool validTri(const triSurface&, const label);
+
+        //- Determine edge-face addressing
+        void calcAddressing
+        (
+            const triSurface& surf,
+            List<FixedList<label, 3> >& faceEdges,
+            labelList& edgeFace0,
+            labelList& edgeFace1,
+            Map<labelList>& edgeFacesRest
+        ) const;
+
+        //- Determine orientation
+        static void walkOrientation
+        (
+            const triSurface& surf,
+            const List<FixedList<label, 3> >& faceEdges,
+            const labelList& edgeFace0,
+            const labelList& edgeFace1,
+            const label seedTriI,
+            labelList& flipState
+        );
+
+        //- Orient surface
+        static void orientSurface
+        (
+            triSurface&,
+            const List<FixedList<label, 3> >& faceEdges,
+            const labelList& edgeFace0,
+            const labelList& edgeFace1,
+            const Map<labelList>& edgeFacesRest
+        );
+
+        //- Is triangle (given by 3 edges) not fully connected?
+        static bool danglingTriangle
+        (
+            const FixedList<label, 3>& fEdges,
+            const labelList& edgeFace1
+        );
+
+        //- Mark all non-fully connected triangles
+        static label markDanglingTriangles
+        (
+            const List<FixedList<label, 3> >& faceEdges,
+            const labelList& edgeFace0,
+            const labelList& edgeFace1,
+            const Map<labelList>& edgeFacesRest,
+            boolList& keepTriangles
+        );
+
+        static triSurface subsetMesh
+        (
+            const triSurface& s,
+            const labelList& newToOldFaces,
+            labelList& oldToNewPoints,
+            labelList& newToOldPoints
+        );
+
+        //- Combine all triangles inside a cell into a minimal triangulation
+        void combineCellTriangles();
+
+public:
+
+    //- Runtime type information
+    TypeName("isoSurfaceCell");
+
+
+    // Constructors
+
+        //- Construct from dictionary
+        isoSurfaceCell
+        (
+            const polyMesh& mesh,
+            const scalarField& cellValues,
+            const scalarField& pointValues,
+            const scalar iso,
+            const bool regularise,
+            const scalar mergeTol = 1E-6    // fraction of bounding box
+        );
+
+
+    // Member Functions
+
+        //- For every face original cell in mesh
+        const labelList& meshCells() const
+        {
+            return meshCells_;
+        }
+
+        //- For every unmerged triangle point the point in the triSurface
+        const labelList triPointMergeMap() const
+        {
+            return triPointMergeMap_;
+        }
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/sampling/sampledSurface/isoSurface/isoSurfaceTemplates.C b/src/sampling/sampledSurface/isoSurface/isoSurfaceTemplates.C
new file mode 100644
index 0000000000..b4d440c4fd
--- /dev/null
+++ b/src/sampling/sampledSurface/isoSurface/isoSurfaceTemplates.C
@@ -0,0 +1,485 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+\*---------------------------------------------------------------------------*/
+
+#include "isoSurface.H"
+#include "polyMesh.H"
+#include "syncTools.H"
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+template<class Type>
+Type Foam::isoSurface::generatePoint
+(
+    const DynamicList<Type>& snappedPoints,
+
+    const scalar s0,
+    const Type& p0,
+    const label p0Index,
+
+    const scalar s1,
+    const Type& p1,
+    const label p1Index
+) const
+{
+    scalar d = s1-s0;
+
+    if (mag(d) > VSMALL)
+    {
+        scalar s = (iso_-s0)/d;
+
+        if (s >= 0.5 && s <= 1 && p1Index != -1)
+        {
+            return snappedPoints[p1Index];
+        }
+        else if (s >= 0.0 && s <= 0.5 && p0Index != -1)
+        {
+            return snappedPoints[p0Index];
+        }
+        else
+        {
+            return s*p1 + (1.0-s)*p0;
+        }
+    }
+    else
+    {
+        scalar s = 0.4999;
+
+        return s*p1 + (1.0-s)*p0;
+    }
+}
+
+
+template<class Type>
+void Foam::isoSurface::generateTriPoints
+(
+    const DynamicList<Type>& snapped,
+
+    const scalar s0,
+    const Type& p0,
+    const label p0Index,
+
+    const scalar s1,
+    const Type& p1,
+    const label p1Index,
+
+    const scalar s2,
+    const Type& p2,
+    const label p2Index,
+
+    const scalar s3,
+    const Type& p3,
+    const label p3Index,
+
+    DynamicList<Type>& points
+) const
+{
+    int triIndex = 0;
+    if (s0 < iso_)
+    {
+        triIndex |= 1;
+    }
+    if (s1 < iso_)
+    {
+        triIndex |= 2;
+    }
+    if (s2 < iso_)
+    {
+        triIndex |= 4;
+    }
+    if (s3 < iso_)
+    {
+        triIndex |= 8;
+    }
+
+    /* Form the vertices of the triangles for each case */
+    switch (triIndex)
+    {
+        case 0x00:
+        case 0x0F:
+        break;
+
+        case 0x0E:
+        case 0x01:
+            points.append(generatePoint(snapped,s0,p0,p0Index,s1,p1,p1Index));
+            points.append(generatePoint(snapped,s0,p0,p0Index,s2,p2,p2Index));
+            points.append(generatePoint(snapped,s0,p0,p0Index,s3,p3,p3Index));
+        break;
+
+        case 0x0D:
+        case 0x02:
+            points.append(generatePoint(snapped,s1,p1,p1Index,s0,p0,p0Index));
+            points.append(generatePoint(snapped,s1,p1,p1Index,s3,p3,p3Index));
+            points.append(generatePoint(snapped,s1,p1,p1Index,s2,p2,p2Index));
+        break;
+
+        case 0x0C:
+        case 0x03:
+        {
+            Type tp1 = generatePoint(snapped,s0,p0,p0Index,s2,p2,p2Index);
+            Type tp2 = generatePoint(snapped,s1,p1,p1Index,s3,p3,p3Index);
+
+            points.append(generatePoint(snapped,s0,p0,p0Index,s3,p3,p3Index));
+            points.append(tp1);
+            points.append(tp2);
+            points.append(tp2);
+            points.append(generatePoint(snapped,s1,p1,p1Index,s2,p2,p2Index));
+            points.append(tp1);
+        }
+        break;
+
+        case 0x0B:
+        case 0x04:
+        {
+            points.append(generatePoint(snapped,s2,p2,p2Index,s0,p0,p0Index));
+            points.append(generatePoint(snapped,s2,p2,p2Index,s1,p1,p1Index));
+            points.append(generatePoint(snapped,s2,p2,p2Index,s3,p3,p3Index));
+        }
+        break;
+
+        case 0x0A:
+        case 0x05:
+        {
+            Type tp0 = generatePoint(snapped,s0,p0,p0Index,s1,p1,p1Index);
+            Type tp1 = generatePoint(snapped,s2,p2,p2Index,s3,p3,p3Index);
+
+            points.append(tp0);
+            points.append(tp1);
+            points.append(generatePoint(snapped,s0,p0,p0Index,s3,p3,p3Index));
+            points.append(tp0);
+            points.append(generatePoint(snapped,s1,p1,p1Index,s2,p2,p2Index));
+            points.append(tp1);
+        }
+        break;
+
+        case 0x09:
+        case 0x06:
+        {
+            Type tp0 = generatePoint(snapped,s0,p0,p0Index,s1,p1,p1Index);
+            Type tp1 = generatePoint(snapped,s2,p2,p2Index,s3,p3,p3Index);
+
+            points.append(tp0);
+            points.append(generatePoint(snapped,s1,p1,p1Index,s3,p3,p3Index));
+            points.append(tp1);
+            points.append(tp0);
+            points.append(generatePoint(snapped,s0,p0,p0Index,s2,p2,p2Index));
+            points.append(tp1);
+        }
+        break;
+
+        case 0x07:
+        case 0x08:
+            points.append(generatePoint(snapped,s3,p3,p3Index,s0,p0,p0Index));
+            points.append(generatePoint(snapped,s3,p3,p3Index,s2,p2,p2Index));
+            points.append(generatePoint(snapped,s3,p3,p3Index,s1,p1,p1Index));
+        break;
+    }
+}
+
+
+template<class Type>
+Foam::label Foam::isoSurface::generateTriPoints
+(
+    const volScalarField& cVals,
+    const scalarField& pVals,
+
+    const GeometricField<Type, fvPatchField, volMesh>& cCoords,
+    const Field<Type>& pCoords,
+
+    const DynamicList<Type>& snappedPoints,
+    const labelList& snappedCc,
+    const labelList& snappedPoint,
+    const label faceI,
+
+    const scalar neiVal,
+    const Type& neiPt,
+    const label neiSnap,
+
+    DynamicList<Type>& triPoints,
+    DynamicList<label>& triMeshCells
+) const
+{
+    label own = mesh_.faceOwner()[faceI];
+
+    label oldNPoints = triPoints.size();
+
+    const face& f = mesh_.faces()[faceI];
+
+    forAll(f, fp)
+    {
+        label pointI = f[fp];
+        label nextPointI = f[f.fcIndex(fp)];
+
+        generateTriPoints
+        (
+            snappedPoints,
+
+            pVals[pointI],
+            pCoords[pointI],
+            snappedPoint[pointI],
+
+            pVals[nextPointI],
+            pCoords[nextPointI],
+            snappedPoint[nextPointI],
+
+            cVals[own],
+            cCoords[own],
+            snappedCc[own],
+
+            neiVal,
+            neiPt,
+            neiSnap,
+
+            triPoints
+        );
+    }
+
+    // Every three triPoints is a triangle
+    label nTris = (triPoints.size()-oldNPoints)/3;
+    for (label i = 0; i < nTris; i++)
+    {
+        triMeshCells.append(own);
+    }
+
+    return nTris;
+}
+
+
+template<class Type>
+void Foam::isoSurface::generateTriPoints
+(
+    const volScalarField& cVals,
+    const scalarField& pVals,
+
+    const GeometricField<Type, fvPatchField, volMesh>& cCoords,
+    const Field<Type>& pCoords,
+
+    const DynamicList<Type>& snappedPoints,
+    const labelList& snappedCc,
+    const labelList& snappedPoint,
+
+    DynamicList<Type>& triPoints,
+    DynamicList<label>& triMeshCells
+) const
+{
+    const polyBoundaryMesh& patches = mesh_.boundaryMesh();
+    const labelList& own = mesh_.faceOwner();
+    const labelList& nei = mesh_.faceNeighbour();
+
+
+    // Determine neighbouring snap status
+    labelList neiSnappedCc(mesh_.nFaces()-mesh_.nInternalFaces(), -1);
+    forAll(patches, patchI)
+    {
+        const polyPatch& pp = patches[patchI];
+
+        if (pp.coupled())
+        {
+            label faceI = pp.start();
+            forAll(pp, i)
+            {
+                neiSnappedCc[faceI-mesh_.nInternalFaces()] =
+                    snappedCc[own[faceI]];
+                faceI++;
+            }
+        }
+    }
+    syncTools::swapBoundaryFaceList(mesh_, neiSnappedCc, false);
+
+
+
+    // Generate triangle points
+
+    triPoints.clear();
+    triMeshCells.clear();
+
+    for (label faceI = 0; faceI < mesh_.nInternalFaces(); faceI++)
+    {
+        if (faceCutType_[faceI] != NOTCUT)
+        {
+            generateTriPoints
+            (
+                cVals,
+                pVals,
+
+                cCoords,
+                pCoords,
+
+                snappedPoints,
+                snappedCc,
+                snappedPoint,
+                faceI,
+
+                cVals[nei[faceI]],
+                cCoords[nei[faceI]],
+                snappedCc[nei[faceI]],
+
+                triPoints,
+                triMeshCells
+            );
+        }
+    }
+
+
+    forAll(patches, patchI)
+    {
+        const polyPatch& pp = patches[patchI];
+
+        if (pp.coupled())
+        {
+            if (refCast<const processorPolyPatch>(pp).owner())
+            {
+                label faceI = pp.start();
+
+                forAll(pp, i)
+                {
+                    if (faceCutType_[faceI] != NOTCUT)
+                    {
+                        generateTriPoints
+                        (
+                            cVals,
+                            pVals,
+
+                            cCoords,
+                            pCoords,
+
+                            snappedPoints,
+                            snappedCc,
+                            snappedPoint,
+                            faceI,
+
+                            cVals.boundaryField()[patchI][i],
+                            cCoords.boundaryField()[patchI][i],
+                            neiSnappedCc[faceI-mesh_.nInternalFaces()],
+
+                            triPoints,
+                            triMeshCells
+                        );
+                    }
+                    faceI++;
+                }
+            }
+        }
+        else
+        {
+            label faceI = pp.start();
+
+            forAll(pp, i)
+            {
+                if (faceCutType_[faceI] != NOTCUT)
+                {
+                    generateTriPoints
+                    (
+                        cVals,
+                        pVals,
+
+                        cCoords,
+                        pCoords,
+
+                        snappedPoints,
+                        snappedCc,
+                        snappedPoint,
+                        faceI,
+
+                        cVals.boundaryField()[patchI][i],
+                        cCoords.boundaryField()[patchI][i],
+                        -1, // fc not snapped
+
+                        triPoints,
+                        triMeshCells
+                    );
+                }
+                faceI++;
+            }
+        }
+    }
+
+    triPoints.shrink();
+    triMeshCells.shrink();
+}
+
+
+//template <class Type>
+//Foam::tmp<Foam::Field<Type> >
+//Foam::isoSurface::sample(const Field<Type>& vField) const
+//{
+//    return tmp<Field<Type> >(new Field<Type>(vField, meshCells()));
+//}
+//
+//
+template <class Type>
+Foam::tmp<Foam::Field<Type> >
+Foam::isoSurface::interpolate
+(
+    const volScalarField& cVals,
+    const scalarField& pVals,
+    const GeometricField<Type, fvPatchField, volMesh>& cCoords,
+    const Field<Type>& pCoords
+) const
+{
+    DynamicList<Type> triPoints(nCutCells_);
+    DynamicList<label> triMeshCells(nCutCells_);
+
+    // Dummy snap data
+    DynamicList<Type> snappedPoints;
+    labelList snappedCc(mesh_.nCells(), -1);
+    labelList snappedPoint(mesh_.nPoints(), -1);
+
+    generateTriPoints
+    (
+        cVals,
+        pVals,
+
+        cCoords,
+        pCoords,
+
+        snappedPoints,
+        snappedCc,
+        snappedPoint,
+
+        triPoints,
+        triMeshCells
+    );
+
+
+    // One value per point
+    tmp<Field<Type> > tvalues(new Field<Type>(points().size()));
+    Field<Type>& values = tvalues();
+
+    forAll(triPoints, i)
+    {
+        label mergedPointI = triPointMergeMap_[i];
+
+        if (mergedPointI >= 0)
+        {
+            values[mergedPointI] = triPoints[i];
+        }
+    }
+
+    return tvalues;
+}
+
+
+// ************************************************************************* //
diff --git a/src/sampling/sampledSurface/isoSurface/sampledIsoSurface.C b/src/sampling/sampledSurface/isoSurface/sampledIsoSurface.C
index 2780d37f25..782615107b 100644
--- a/src/sampling/sampledSurface/isoSurface/sampledIsoSurface.C
+++ b/src/sampling/sampledSurface/isoSurface/sampledIsoSurface.C
@@ -41,6 +41,100 @@ namespace Foam
 
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 
+void Foam::sampledIsoSurface::getIsoFields() const
+{
+    const fvMesh& fvm = static_cast<const fvMesh&>(mesh());
+
+    // Get volField
+    // ~~~~~~~~~~~~
+
+    if (fvm.foundObject<volScalarField>(isoField_))
+    {
+        if (debug)
+        {
+            Info<< "sampledIsoSurface::getIsoField() : lookup "
+                << isoField_ << endl;
+        }
+        storedVolFieldPtr_.clear();
+        volFieldPtr_ = &fvm.lookupObject<volScalarField>(isoField_);
+    }
+    else
+    {
+        // Bit of a hack. Read field and store.
+
+        if (debug)
+        {
+            Info<< "sampledIsoSurface::getIsoField() : reading "
+                << isoField_ << " from time " <<fvm.time().timeName()
+                << endl;
+        }
+
+        storedVolFieldPtr_.reset
+        (
+            new volScalarField
+            (
+                IOobject
+                (
+                    isoField_,
+                    fvm.time().timeName(),
+                    fvm,
+                    IOobject::MUST_READ,
+                    IOobject::NO_WRITE,
+                    false
+                ),
+                fvm
+            )
+        );
+        volFieldPtr_ = storedVolFieldPtr_.operator->();
+    }
+
+
+
+    // Get pointField
+    // ~~~~~~~~~~~~~~
+
+    word pointFldName = "volPointInterpolate(" + isoField_ + ')';
+
+    if (fvm.foundObject<pointScalarField>(pointFldName))
+    {
+        if (debug)
+        {
+            Info<< "sampledIsoSurface::getIsoField() : lookup "
+                << pointFldName << endl;
+        }
+        storedPointFieldPtr_.clear();
+        pointFieldPtr_ = &fvm.lookupObject<pointScalarField>(pointFldName);
+    }
+    else
+    {
+        // Not in registry. Interpolate.
+
+        if (debug)
+        {
+            Info<< "sampledIsoSurface::getIsoField() : interpolating "
+                << pointFldName << endl;
+        }
+
+        storedPointFieldPtr_.reset
+        (
+            volPointInterpolation::New(fvm).interpolate(*volFieldPtr_).ptr()
+        );
+        pointFieldPtr_ = storedPointFieldPtr_.operator->();
+    }
+
+    if (debug)
+    {
+        Info<< "sampledIsoSurface::getIsoField() : obtained volField "
+            << volFieldPtr_->name() << " min:" << min(*volFieldPtr_).value()
+            << " max:" << max(*volFieldPtr_).value() << endl;
+        Info<< "sampledIsoSurface::getIsoField() : obtained pointField "
+            << pointFieldPtr_->name()
+            << " min:" << gMin(pointFieldPtr_->internalField())
+            << " max:" << gMax(pointFieldPtr_->internalField()) << endl;
+    }
+}
+
+
 void Foam::sampledIsoSurface::createGeometry() const
 {
     const fvMesh& fvm = static_cast<const fvMesh&>(mesh());
@@ -49,66 +143,29 @@ void Foam::sampledIsoSurface::createGeometry() const
     {
         storedTimeIndex_ = fvm.time().timeIndex();
 
+        getIsoFields();
+
         // Clear any stored topo
+        surfPtr_.clear();
         facesPtr_.clear();
 
-        // Optionally read volScalarField
-        autoPtr<volScalarField> readFieldPtr_;
-
-        // 1. see if field in database
-        // 2. see if field can be read
-        const volScalarField* cellFldPtr = NULL;
-        if (fvm.foundObject<volScalarField>(isoField_))
-        {
-            if (debug)
-            {
-                Info<< "sampledIsoSurface::createGeometry() : lookup "
-                    << isoField_ << endl;
-            }
-
-            cellFldPtr = &fvm.lookupObject<volScalarField>(isoField_);
-        }
-        else
-        {
-            // Bit of a hack. Read field and store.
-
-            if (debug)
-            {
-                Info<< "sampledIsoSurface::createGeometry() : reading "
-                    << isoField_ << " from time " <<fvm.time().timeName()
-                    << endl;
-            }
-
-            readFieldPtr_.reset
-            (
-                new volScalarField
-                (
-                    IOobject
-                    (
-                        isoField_,
-                        fvm.time().timeName(),
-                        fvm,
-                        IOobject::MUST_READ,
-                        IOobject::NO_WRITE,
-                        false
-                    ),
-                    fvm
-                )
-            );
-
-            cellFldPtr = readFieldPtr_.operator->();
-        }
-        const volScalarField& cellFld = *cellFldPtr;
-
-        tmp<pointScalarField> pointFld
-        (
-            volPointInterpolation::New(fvm).interpolate(cellFld)
-        );
-
         if (average_)
         {
             //- From point field and interpolated cell.
-            scalarField cellAvg(fvm.nCells(), scalar(0.0));
+            volScalarField cellAvg
+            (
+                IOobject
+                (
+                    "cellAvg",
+                    fvm.time().timeName(),
+                    fvm.time(),
+                    IOobject::NO_READ,
+                    IOobject::NO_WRITE,
+                    false
+                ),
+                fvm,
+                dimensionedScalar("zero", dimless, scalar(0.0))
+            );
             labelField nPointCells(fvm.nCells(), 0);
             {
                 for (label pointI = 0; pointI < fvm.nPoints(); pointI++)
@@ -119,7 +176,7 @@ void Foam::sampledIsoSurface::createGeometry() const
                     {
                         label cellI = pCells[i];
 
-                        cellAvg[cellI] += pointFld().internalField()[pointI];
+                        cellAvg[cellI] += (*pointFieldPtr_)[pointI];
                         nPointCells[cellI]++;
                     }
                 }
@@ -128,33 +185,33 @@ void Foam::sampledIsoSurface::createGeometry() const
             {
                 cellAvg[cellI] /= nPointCells[cellI];
             }
+            // Give value to calculatedFvPatchFields
+            cellAvg.correctBoundaryConditions();
 
-            const isoSurface iso
+            surfPtr_.reset
             (
-                fvm,
-                cellAvg,
-                pointFld().internalField(),
-                isoVal_,
-                regularise_
+                new isoSurface
+                (
+                    cellAvg,
+                    *pointFieldPtr_,
+                    isoVal_,
+                    regularise_
+                )
             );
-
-            const_cast<sampledIsoSurface&>(*this).triSurface::operator=(iso);
-            meshCells_ = iso.meshCells();
         }
         else
         {
-            //- Direct from cell field and point field. Gives bad continuity.
-            const isoSurface iso
+            //- Direct from cell field and point field.
+            surfPtr_.reset
             (
-                fvm,
-                cellFld.internalField(),
-                pointFld().internalField(),
-                isoVal_,
-                regularise_
+                new isoSurface
+                (
+                    *volFieldPtr_,
+                    *pointFieldPtr_,
+                    isoVal_,
+                    regularise_
+                )
             );
-
-            const_cast<sampledIsoSurface&>(*this).triSurface::operator=(iso);
-            meshCells_ = iso.meshCells();
         }
 
 
@@ -167,8 +224,9 @@ void Foam::sampledIsoSurface::createGeometry() const
                 << "    isoField       : " << isoField_ << nl
                 << "    isoValue       : " << isoVal_ << nl
                 << "    points         : " << points().size() << nl
-                << "    tris           : " << triSurface::size() << nl
-                << "    cut cells      : " << meshCells_.size() << endl;
+                << "    tris           : " << surface().size() << nl
+                << "    cut cells      : " << surface().meshCells().size()
+                << endl;
         }
     }
 }
@@ -187,12 +245,26 @@ Foam::sampledIsoSurface::sampledIsoSurface
     isoField_(dict.lookup("isoField")),
     isoVal_(readScalar(dict.lookup("isoValue"))),
     regularise_(dict.lookupOrDefault("regularise", true)),
-    average_(dict.lookupOrDefault("average", true)),
+    average_(dict.lookupOrDefault("average", false)),
     zoneName_(word::null),
+    surfPtr_(NULL),
     facesPtr_(NULL),
     storedTimeIndex_(-1),
-    meshCells_(0)
+    storedVolFieldPtr_(NULL),
+    volFieldPtr_(NULL),
+    storedPointFieldPtr_(NULL),
+    pointFieldPtr_(NULL)
 {
+    if (!sampledSurface::interpolate())
+    {
+        FatalErrorIn
+        (
+            "sampledIsoSurface::sampledIsoSurface"
+            "(const word&, const polyMesh&, const dictionary&)"
+        )   << "Non-interpolated iso surface not supported since triangles"
+            << " span across cells." << exit(FatalError);
+    }
+
 //    label zoneId = -1;
 //    if (dict.readIfPresent("zone", zoneName_))
 //    {
@@ -220,6 +292,7 @@ void Foam::sampledIsoSurface::correct(const bool meshChanged)
     // Only change of mesh changes plane - zone restriction gets lost
     if (meshChanged)
     {
+        surfPtr_.clear();
         facesPtr_.clear();
     }
 }
@@ -328,9 +401,9 @@ void Foam::sampledIsoSurface::print(Ostream& os) const
 {
     os  << "sampledIsoSurface: " << name() << " :"
         << "  field:" << isoField_
-        << "  value:" << isoVal_
-        << "  faces:" << faces().size()
-        << "  points:" << points().size();
+        << "  value:" << isoVal_;
+        //<< "  faces:" << faces().size()       // note: possibly no geom yet
+        //<< "  points:" << points().size();
 }
 
 
diff --git a/src/sampling/sampledSurface/isoSurface/sampledIsoSurface.H b/src/sampling/sampledSurface/isoSurface/sampledIsoSurface.H
index 02b62f151f..3ccd72f629 100644
--- a/src/sampling/sampledSurface/isoSurface/sampledIsoSurface.H
+++ b/src/sampling/sampledSurface/isoSurface/sampledIsoSurface.H
@@ -39,7 +39,7 @@ SourceFiles
 #define sampledIsoSurface_H
 
 #include "sampledSurface.H"
-#include "triSurface.H"
+#include "isoSurface.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -52,8 +52,7 @@ namespace Foam
 
 class sampledIsoSurface
 :
-    public sampledSurface,
-    public triSurface
+    public sampledSurface
 {
     // Private data
 
@@ -72,6 +71,8 @@ class sampledIsoSurface
         //- zone name (if restricted to zones)
         word zoneName_;
 
+        mutable autoPtr<isoSurface> surfPtr_;
+
         //- triangles converted to faceList
         mutable autoPtr<faceList> facesPtr_;
 
@@ -81,12 +82,21 @@ class sampledIsoSurface
             //- Time at last call
             mutable label storedTimeIndex_;
 
-            //- For every triangle the original cell in mesh
-            mutable labelList meshCells_;
+            //- Cached volfield
+            mutable autoPtr<volScalarField> storedVolFieldPtr_;
+            mutable const volScalarField* volFieldPtr_;
+
+            //- Cached pointfield
+            mutable autoPtr<pointScalarField> storedPointFieldPtr_;
+            mutable const pointScalarField* pointFieldPtr_;
+
 
 
     // Private Member Functions
 
+        //- Get fields needed to recreate iso surface.
+        void getIsoFields() const;
+
         //- Create iso surface (if time has changed)
         void createGeometry() const;
 
@@ -130,7 +140,7 @@ public:
         //- Points of surface
         virtual const pointField& points() const
         {
-            return triSurface::points();
+            return surface().points();
         }
 
         //- Faces of surface
@@ -138,7 +148,7 @@ public:
         {
             if (!facesPtr_.valid())
             {
-                const triSurface& s = *this;
+                const triSurface& s = surface();
 
                 facesPtr_.reset(new faceList(s.size()));
 
@@ -150,11 +160,19 @@ public:
             return facesPtr_;
         }
 
-
         //- Correct for mesh movement and/or field changes
         virtual void correct(const bool meshChanged);
 
 
+        const isoSurface& surface() const
+        {
+            return surfPtr_();
+        }
+
+        //- Lookup or read isoField. Sets volFieldPtr_ and pointFieldPtr_.
+        void getIsoField();
+
+
         //- sample field on surface
         virtual tmp<scalarField> sample
         (
diff --git a/src/sampling/sampledSurface/isoSurface/sampledIsoSurfaceCell.C b/src/sampling/sampledSurface/isoSurface/sampledIsoSurfaceCell.C
new file mode 100644
index 0000000000..c258761ab7
--- /dev/null
+++ b/src/sampling/sampledSurface/isoSurface/sampledIsoSurfaceCell.C
@@ -0,0 +1,344 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+\*---------------------------------------------------------------------------*/
+
+#include "sampledIsoSurfaceCell.H"
+#include "dictionary.H"
+#include "volFields.H"
+#include "volPointInterpolation.H"
+#include "addToRunTimeSelectionTable.H"
+#include "fvMesh.H"
+#include "isoSurfaceCell.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(sampledIsoSurfaceCell, 0);
+    addNamedToRunTimeSelectionTable(sampledSurface, sampledIsoSurfaceCell, word, isoSurfaceCell);
+}
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+void Foam::sampledIsoSurfaceCell::createGeometry() const
+{
+    const fvMesh& fvm = static_cast<const fvMesh&>(mesh());
+
+    if (fvm.time().timeIndex() != storedTimeIndex_)
+    {
+        storedTimeIndex_ = fvm.time().timeIndex();
+
+        // Clear any stored topo
+        facesPtr_.clear();
+
+        // Optionally read volScalarField
+        autoPtr<volScalarField> readFieldPtr_;
+
+        // 1. see if field in database
+        // 2. see if field can be read
+        const volScalarField* cellFldPtr = NULL;
+        if (fvm.foundObject<volScalarField>(isoField_))
+        {
+            if (debug)
+            {
+                Info<< "sampledIsoSurfaceCell::createGeometry() : lookup "
+                    << isoField_ << endl;
+            }
+
+            cellFldPtr = &fvm.lookupObject<volScalarField>(isoField_);
+        }
+        else
+        {
+            // Bit of a hack. Read field and store.
+
+            if (debug)
+            {
+                Info<< "sampledIsoSurfaceCell::createGeometry() : reading "
+                    << isoField_ << " from time " <<fvm.time().timeName()
+                    << endl;
+            }
+
+            readFieldPtr_.reset
+            (
+                new volScalarField
+                (
+                    IOobject
+                    (
+                        isoField_,
+                        fvm.time().timeName(),
+                        fvm,
+                        IOobject::MUST_READ,
+                        IOobject::NO_WRITE,
+                        false
+                    ),
+                    fvm
+                )
+            );
+
+            cellFldPtr = readFieldPtr_.operator->();
+        }
+        const volScalarField& cellFld = *cellFldPtr;
+
+        tmp<pointScalarField> pointFld
+        (
+            volPointInterpolation::New(fvm).interpolate(cellFld)
+        );
+
+        if (average_)
+        {
+            //- From point field and interpolated cell.
+            scalarField cellAvg(fvm.nCells(), scalar(0.0));
+            labelField nPointCells(fvm.nCells(), 0);
+            {
+                for (label pointI = 0; pointI < fvm.nPoints(); pointI++)
+                {
+                    const labelList& pCells = fvm.pointCells(pointI);
+
+                    forAll(pCells, i)
+                    {
+                        label cellI = pCells[i];
+
+                        cellAvg[cellI] += pointFld().internalField()[pointI];
+                        nPointCells[cellI]++;
+                    }
+                }
+            }
+            forAll(cellAvg, cellI)
+            {
+                cellAvg[cellI] /= nPointCells[cellI];
+            }
+
+            const isoSurfaceCell iso
+            (
+                fvm,
+                cellAvg,
+                pointFld().internalField(),
+                isoVal_,
+                regularise_
+            );
+
+            const_cast<sampledIsoSurfaceCell&>
+            (
+                *this
+            ).triSurface::operator=(iso);
+            meshCells_ = iso.meshCells();
+        }
+        else
+        {
+            //- Direct from cell field and point field. Gives bad continuity.
+            const isoSurfaceCell iso
+            (
+                fvm,
+                cellFld.internalField(),
+                pointFld().internalField(),
+                isoVal_,
+                regularise_
+            );
+
+            const_cast<sampledIsoSurfaceCell&>
+            (
+                *this
+            ).triSurface::operator=(iso);
+            meshCells_ = iso.meshCells();
+        }
+
+
+        if (debug)
+        {
+            Pout<< "sampledIsoSurfaceCell::createGeometry() : constructed iso:"
+                << nl
+                << "    regularise     : " << regularise_ << nl
+                << "    average        : " << average_ << nl
+                << "    isoField       : " << isoField_ << nl
+                << "    isoValue       : " << isoVal_ << nl
+                << "    points         : " << points().size() << nl
+                << "    tris           : " << triSurface::size() << nl
+                << "    cut cells      : " << meshCells_.size() << endl;
+        }
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::sampledIsoSurfaceCell::sampledIsoSurfaceCell
+(
+    const word& name,
+    const polyMesh& mesh,
+    const dictionary& dict
+)
+:
+    sampledSurface(name, mesh, dict),
+    isoField_(dict.lookup("isoField")),
+    isoVal_(readScalar(dict.lookup("isoValue"))),
+    regularise_(dict.lookupOrDefault("regularise", true)),
+    average_(dict.lookupOrDefault("average", true)),
+    zoneName_(word::null),
+    facesPtr_(NULL),
+    storedTimeIndex_(-1),
+    meshCells_(0)
+{
+//    label zoneId = -1;
+//    if (dict.readIfPresent("zone", zoneName_))
+//    {
+//        zoneId = mesh.cellZones().findZoneID(zoneName_);
+//        if (debug && zoneId < 0)
+//        {
+//            Info<< "cellZone \"" << zoneName_
+//                << "\" not found - using entire mesh"
+//                << endl;
+//        }
+//    }
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::sampledIsoSurfaceCell::~sampledIsoSurfaceCell()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+void Foam::sampledIsoSurfaceCell::correct(const bool meshChanged)
+{
+    // Only change of mesh changes plane - zone restriction gets lost
+    if (meshChanged)
+    {
+        facesPtr_.clear();
+    }
+}
+
+
+Foam::tmp<Foam::scalarField>
+Foam::sampledIsoSurfaceCell::sample
+(
+    const volScalarField& vField
+) const
+{
+    return sampleField(vField);
+}
+
+
+Foam::tmp<Foam::vectorField>
+Foam::sampledIsoSurfaceCell::sample
+(
+    const volVectorField& vField
+) const
+{
+    return sampleField(vField);
+}
+
+
+Foam::tmp<Foam::sphericalTensorField>
+Foam::sampledIsoSurfaceCell::sample
+(
+    const volSphericalTensorField& vField
+) const
+{
+    return sampleField(vField);
+}
+
+
+Foam::tmp<Foam::symmTensorField>
+Foam::sampledIsoSurfaceCell::sample
+(
+    const volSymmTensorField& vField
+) const
+{
+    return sampleField(vField);
+}
+
+
+Foam::tmp<Foam::tensorField>
+Foam::sampledIsoSurfaceCell::sample
+(
+    const volTensorField& vField
+) const
+{
+    return sampleField(vField);
+}
+
+
+Foam::tmp<Foam::scalarField>
+Foam::sampledIsoSurfaceCell::interpolate
+(
+    const interpolation<scalar>& interpolator
+) const
+{
+    return interpolateField(interpolator);
+}
+
+
+Foam::tmp<Foam::vectorField>
+Foam::sampledIsoSurfaceCell::interpolate
+(
+    const interpolation<vector>& interpolator
+) const
+{
+    return interpolateField(interpolator);
+}
+
+Foam::tmp<Foam::sphericalTensorField>
+Foam::sampledIsoSurfaceCell::interpolate
+(
+    const interpolation<sphericalTensor>& interpolator
+) const
+{
+    return interpolateField(interpolator);
+}
+
+
+Foam::tmp<Foam::symmTensorField>
+Foam::sampledIsoSurfaceCell::interpolate
+(
+    const interpolation<symmTensor>& interpolator
+) const
+{
+    return interpolateField(interpolator);
+}
+
+
+Foam::tmp<Foam::tensorField>
+Foam::sampledIsoSurfaceCell::interpolate
+(
+    const interpolation<tensor>& interpolator
+) const
+{
+    return interpolateField(interpolator);
+}
+
+
+void Foam::sampledIsoSurfaceCell::print(Ostream& os) const
+{
+    os  << "sampledIsoSurfaceCell: " << name() << " :"
+        << "  field:" << isoField_
+        << "  value:" << isoVal_;
+        //<< "  faces:" << faces().size()   // possibly no geom yet
+        //<< "  points:" << points().size();
+}
+
+
+// ************************************************************************* //
diff --git a/src/sampling/sampledSurface/isoSurface/sampledIsoSurfaceCell.H b/src/sampling/sampledSurface/isoSurface/sampledIsoSurfaceCell.H
new file mode 100644
index 0000000000..7d6868ae98
--- /dev/null
+++ b/src/sampling/sampledSurface/isoSurface/sampledIsoSurfaceCell.H
@@ -0,0 +1,238 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Class
+    Foam::sampledIsoSurfaceCell
+
+Description
+    A sampledSurface defined by a surface of iso value. Always triangulated.
+    To be used in sampleSurfaces / functionObjects. Recalculates iso surface
+    only if time changes.
+
+SourceFiles
+    sampledIsoSurfaceCell.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef sampledIsoSurfaceCell_H
+#define sampledIsoSurfaceCell_H
+
+#include "sampledSurface.H"
+#include "triSurface.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                       Class sampledIsoSurfaceCell Declaration
+\*---------------------------------------------------------------------------*/
+
+class sampledIsoSurfaceCell
+:
+    public sampledSurface,
+    public triSurface
+{
+    // Private data
+
+        //- Field to get isoSurface of
+        const word isoField_;
+
+        //- iso value
+        const scalar isoVal_;
+
+        //- Whether to coarse
+        const Switch regularise_;
+
+        //- Whether to recalculate cell values as average of point values
+        const Switch average_;
+
+        //- zone name (if restricted to zones)
+        word zoneName_;
+
+        //- triangles converted to faceList
+        mutable autoPtr<faceList> facesPtr_;
+
+
+        // Recreated for every isoSurface
+
+            //- Time at last call
+            mutable label storedTimeIndex_;
+
+            //- For every triangle the original cell in mesh
+            mutable labelList meshCells_;
+
+
+    // Private Member Functions
+
+        //- Create iso surface (if time has changed)
+        void createGeometry() const;
+
+        //- sample field on faces
+        template <class Type>
+        tmp<Field<Type> > sampleField
+        (
+            const GeometricField<Type, fvPatchField, volMesh>& vField
+        ) const;
+
+
+        template <class Type>
+        tmp<Field<Type> >
+        interpolateField(const interpolation<Type>&) const;
+
+
+public:
+
+    //- Runtime type information
+    TypeName("sampledIsoSurfaceCell");
+
+
+    // Constructors
+
+        //- Construct from dictionary
+        sampledIsoSurfaceCell
+        (
+            const word& name,
+            const polyMesh& mesh,
+            const dictionary& dict
+        );
+
+
+    // Destructor
+
+        virtual ~sampledIsoSurfaceCell();
+
+
+    // Member Functions
+
+        //- Points of surface
+        virtual const pointField& points() const
+        {
+            return triSurface::points();
+        }
+
+        //- Faces of surface
+        virtual const faceList& faces() const
+        {
+            if (!facesPtr_.valid())
+            {
+                const triSurface& s = *this;
+
+                facesPtr_.reset(new faceList(s.size()));
+
+                forAll(s, i)
+                {
+                    facesPtr_()[i] = s[i].triFaceFace();
+                }
+            }
+            return facesPtr_;
+        }
+
+
+        //- Correct for mesh movement and/or field changes
+        virtual void correct(const bool meshChanged);
+
+
+        //- sample field on surface
+        virtual tmp<scalarField> sample
+        (
+            const volScalarField&
+        ) const;
+
+        //- sample field on surface
+        virtual tmp<vectorField> sample
+        (
+            const volVectorField&
+        ) const;
+
+        //- sample field on surface
+        virtual tmp<sphericalTensorField> sample
+        (
+            const volSphericalTensorField&
+        ) const;
+
+        //- sample field on surface
+        virtual tmp<symmTensorField> sample
+        (
+            const volSymmTensorField&
+        ) const;
+
+        //- sample field on surface
+        virtual tmp<tensorField> sample
+        (
+            const volTensorField&
+        ) const;
+
+
+        //- interpolate field on surface
+        virtual tmp<scalarField> interpolate
+        (
+            const interpolation<scalar>&
+        ) const;
+
+        //- interpolate field on surface
+        virtual tmp<vectorField> interpolate
+        (
+            const interpolation<vector>&
+        ) const;
+
+        //- interpolate field on surface
+        virtual tmp<sphericalTensorField> interpolate
+        (
+            const interpolation<sphericalTensor>&
+        ) const;
+
+        //- interpolate field on surface
+        virtual tmp<symmTensorField> interpolate
+        (
+            const interpolation<symmTensor>&
+        ) const;
+
+        //- interpolate field on surface
+        virtual tmp<tensorField> interpolate
+        (
+            const interpolation<tensor>&
+        ) const;
+
+        //- Write
+        virtual void print(Ostream&) const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+#   include "sampledIsoSurfaceCellTemplates.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/sampling/sampledSurface/isoSurface/sampledIsoSurfaceCellTemplates.C b/src/sampling/sampledSurface/isoSurface/sampledIsoSurfaceCellTemplates.C
new file mode 100644
index 0000000000..144a0ddf41
--- /dev/null
+++ b/src/sampling/sampledSurface/isoSurface/sampledIsoSurfaceCellTemplates.C
@@ -0,0 +1,89 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+\*---------------------------------------------------------------------------*/
+
+#include "sampledIsoSurfaceCell.H"
+#include "isoSurface.H"
+#include "volFieldsFwd.H"
+#include "pointFields.H"
+#include "volPointInterpolation.H"
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+template <class Type>
+Foam::tmp<Foam::Field<Type> >
+Foam::sampledIsoSurfaceCell::sampleField
+(
+    const GeometricField<Type, fvPatchField, volMesh>& vField
+) const
+{
+    // Recreate geometry if time has changed
+    createGeometry();
+
+    return tmp<Field<Type> >(new Field<Type>(vField, meshCells_));
+}
+
+
+template <class Type>
+Foam::tmp<Foam::Field<Type> >
+Foam::sampledIsoSurfaceCell::interpolateField
+(
+    const interpolation<Type>& interpolator
+) const
+{
+    // Recreate geometry if time has changed
+    createGeometry();
+
+    // One value per point
+    tmp<Field<Type> > tvalues(new Field<Type>(points().size()));
+    Field<Type>& values = tvalues();
+
+    boolList pointDone(points().size(), false);
+
+    forAll(faces(), cutFaceI)
+    {
+        const face& f = faces()[cutFaceI];
+
+        forAll(f, faceVertI)
+        {
+            label pointI = f[faceVertI];
+
+            if (!pointDone[pointI])
+            {
+                values[pointI] = interpolator.interpolate
+                (
+                    points()[pointI],
+                    meshCells_[cutFaceI]
+                );
+                pointDone[pointI] = true;
+            }
+        }
+    }
+
+    return tvalues;
+}
+
+
+// ************************************************************************* //
diff --git a/src/sampling/sampledSurface/isoSurface/sampledIsoSurfaceTemplates.C b/src/sampling/sampledSurface/isoSurface/sampledIsoSurfaceTemplates.C
index dc2abbd74b..4d4f75c739 100644
--- a/src/sampling/sampledSurface/isoSurface/sampledIsoSurfaceTemplates.C
+++ b/src/sampling/sampledSurface/isoSurface/sampledIsoSurfaceTemplates.C
@@ -25,7 +25,6 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "sampledIsoSurface.H"
-#include "isoSurface.H"
 #include "volFieldsFwd.H"
 #include "pointFields.H"
 #include "volPointInterpolation.H"
@@ -41,8 +40,7 @@ Foam::sampledIsoSurface::sampleField
 {
     // Recreate geometry if time has changed
     createGeometry();
-
-    return tmp<Field<Type> >(new Field<Type>(vField, meshCells_));
+    return tmp<Field<Type> >(new Field<Type>(vField, surface().meshCells()));
 }
 
 
@@ -53,36 +51,28 @@ Foam::sampledIsoSurface::interpolateField
     const interpolation<Type>& interpolator
 ) const
 {
+    const fvMesh& fvm = static_cast<const fvMesh&>(mesh());
+
+    // Get fields to sample. Assume volPointInterpolation!
+    const GeometricField<Type, fvPatchField, volMesh>& volFld =
+        interpolator.psi();
+
+    tmp<GeometricField<Type, pointPatchField, pointMesh> > pointFld
+    (
+        volPointInterpolation::New(fvm).interpolate(volFld)
+    );
+
     // Recreate geometry if time has changed
     createGeometry();
 
-    // One value per point
-    tmp<Field<Type> > tvalues(new Field<Type>(points().size()));
-    Field<Type>& values = tvalues();
-
-    boolList pointDone(points().size(), false);
-
-    forAll(faces(), cutFaceI)
-    {
-        const face& f = faces()[cutFaceI];
-
-        forAll(f, faceVertI)
-        {
-            label pointI = f[faceVertI];
-
-            if (!pointDone[pointI])
-            {
-                values[pointI] = interpolator.interpolate
-                (
-                    points()[pointI],
-                    meshCells_[cutFaceI]
-                );
-                pointDone[pointI] = true;
-            }
-        }
-    }
-
-    return tvalues;
+    // Sample.
+    return surface().interpolate
+    (
+        *volFieldPtr_,
+        *pointFieldPtr_,
+        volFld,
+        pointFld()
+    );
 }
 
 

From 80c19974f1e2d12221f9dd28c14b02a9c8fbf60a Mon Sep 17 00:00:00 2001
From: mattijs <mattijs@hunt.opencfd.co.uk>
Date: Fri, 14 Nov 2008 13:42:28 +0000
Subject: [PATCH 16/16] ignore status

---
 src/Pstream/mpi/IPread.C  |  8 ++------
 src/Pstream/mpi/OPwrite.C |  8 ++------
 src/Pstream/mpi/Pstream.C | 12 ++++--------
 3 files changed, 8 insertions(+), 20 deletions(-)

diff --git a/src/Pstream/mpi/IPread.C b/src/Pstream/mpi/IPread.C
index 487749b24b..ac7c2e787a 100644
--- a/src/Pstream/mpi/IPread.C
+++ b/src/Pstream/mpi/IPread.C
@@ -193,15 +193,13 @@ void Foam::IPstream::waitRequests()
 {
     if (IPstream_outstandingRequests_.size() > 0)
     {
-        List<MPI_Status> status(IPstream_outstandingRequests_.size());
-
         if
         (
             MPI_Waitall
             (
                 IPstream_outstandingRequests_.size(),
                 IPstream_outstandingRequests_.begin(),
-                status.begin()
+                MPI_STATUSES_IGNORE
             )
         )
         {
@@ -231,9 +229,7 @@ bool Foam::IPstream::finishedRequest(const label i)
     }
 
     int flag;
-    MPI_Status status;
-
-    MPI_Test(&IPstream_outstandingRequests_[i], &flag, &status);
+    MPI_Test(&IPstream_outstandingRequests_[i], &flag, MPI_STATUS_IGNORE);
 
     return flag != 0;
 }
diff --git a/src/Pstream/mpi/OPwrite.C b/src/Pstream/mpi/OPwrite.C
index 86d9c998ab..d0cdcbd0bc 100644
--- a/src/Pstream/mpi/OPwrite.C
+++ b/src/Pstream/mpi/OPwrite.C
@@ -131,15 +131,13 @@ void Foam::OPstream::waitRequests()
 {
     if (OPstream_outstandingRequests_.size() > 0)
     {
-        List<MPI_Status> status(OPstream_outstandingRequests_.size());
-
         if
         (
             MPI_Waitall
             (
                 OPstream_outstandingRequests_.size(),
                 OPstream_outstandingRequests_.begin(),
-                status.begin()
+                MPI_STATUSES_IGNORE
             )
         )
         {
@@ -169,9 +167,7 @@ bool Foam::OPstream::finishedRequest(const label i)
     }
 
     int flag;
-    MPI_Status status;
-
-    MPI_Test(&OPstream_outstandingRequests_[i], &flag, &status);
+    MPI_Test(&OPstream_outstandingRequests_[i], &flag, MPI_STATUS_IGNORE);
 
     return flag != 0;
 }
diff --git a/src/Pstream/mpi/Pstream.C b/src/Pstream/mpi/Pstream.C
index a6361ab102..caa21b6dcc 100644
--- a/src/Pstream/mpi/Pstream.C
+++ b/src/Pstream/mpi/Pstream.C
@@ -157,8 +157,6 @@ void Foam::reduce(scalar& Value, const sumOp<scalar>& bop)
 
     if (Pstream::nProcs() <= Pstream::nProcsSimpleSum)
     {
-        MPI_Status status;
-
         if (Pstream::master())
         {
             for
@@ -180,7 +178,7 @@ void Foam::reduce(scalar& Value, const sumOp<scalar>& bop)
                         Pstream::procID(slave),
                         Pstream::msgType(),
                         MPI_COMM_WORLD,
-                        &status
+                        MPI_STATUS_IGNORE
                     )
                 )
                 {
@@ -260,7 +258,7 @@ void Foam::reduce(scalar& Value, const sumOp<scalar>& bop)
                     Pstream::procID(Pstream::masterNo()),
                     Pstream::msgType(),
                     MPI_COMM_WORLD,
-                    &status
+                    MPI_STATUS_IGNORE
                 )
             )
             {
@@ -279,8 +277,6 @@ void Foam::reduce(scalar& Value, const sumOp<scalar>& bop)
         Value = sum;
 
         /*
-        MPI_Status status;
-
         int myProcNo = Pstream::myProcNo();
         int nProcs = Pstream::nProcs();
 
@@ -314,7 +310,7 @@ void Foam::reduce(scalar& Value, const sumOp<scalar>& bop)
                         Pstream::procID(childProcId),
                         Pstream::msgType(),
                         MPI_COMM_WORLD,
-                        &status
+                        MPI_STATUS_IGNORE
                     )
                 )
                 {
@@ -370,7 +366,7 @@ void Foam::reduce(scalar& Value, const sumOp<scalar>& bop)
                     Pstream::procID(parentId),
                     Pstream::msgType(),
                     MPI_COMM_WORLD,
-                    &status
+                    MPI_STATUS_IGNORE
                 )
             )
             {