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] 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
-
-// ************************************************************************* //