From b0dcf59307577ec0921d824ce50ffb37cfa8114f Mon Sep 17 00:00:00 2001
From: Mark Olesen <Mark.Olesen@Germany>
Date: Fri, 5 Aug 2016 10:00:00 +0200
Subject: [PATCH 1/6] ENH: ease access restrictions on meshReader data
 structures (issue #204)

- helps when implementing polyhedral readers.
---
 .../meshReader/createPolyBoundary.C           |  19 ++--
 src/conversion/meshReader/createPolyCells.C   |   8 +-
 src/conversion/meshReader/meshReader.C        |  22 ++--
 src/conversion/meshReader/meshReader.H        | 106 +++++++-----------
 src/conversion/meshTables/cellTable.H         |   2 +-
 src/conversion/meshWriter/meshWriter.H        |  23 ++--
 6 files changed, 73 insertions(+), 107 deletions(-)

diff --git a/src/conversion/meshReader/createPolyBoundary.C b/src/conversion/meshReader/createPolyBoundary.C
index c9a98e8c52..7279b73c41 100644
--- a/src/conversion/meshReader/createPolyBoundary.C
+++ b/src/conversion/meshReader/createPolyBoundary.C
@@ -3,7 +3,7 @@
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
     \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
-     \\/     M anipulation  |
+     \\/     M anipulation  | Copyright (C) 2016 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -90,7 +90,12 @@ void Foam::meshReader::addPolyBoundaryFace
     const label nCreatedFaces
 )
 {
-    addPolyBoundaryFace(identifier.cell, identifier.face, nCreatedFaces);
+    addPolyBoundaryFace
+    (
+        identifier.cellId(),
+        identifier.faceId(),
+        nCreatedFaces
+    );
 }
 
 
@@ -153,7 +158,7 @@ void Foam::meshReader::createPolyBoundary()
 
                 forAll(idList, bndI)
                 {
-                    label baffleI = idList[bndI].cell - baffleOffset;
+                    label baffleI = idList[bndI].cellId() - baffleOffset;
 
                     if
                     (
@@ -189,13 +194,13 @@ void Foam::meshReader::createPolyBoundary()
         else if (patchPhysicalTypes_[patchi] == "monitoring")
         {
             // translate the "monitoring" pseudo-boundaries to face sets
-            List<label> monitoring(idList.size());
+            labelList monitoring(idList.size());
 
             label monitorI = 0;
             forAll(idList, bndI)
             {
-                label cellId = idList[bndI].cell;
-                label faceId = idList[bndI].face;
+                label cellId = idList[bndI].cellId();
+                label faceId = idList[bndI].faceId();
 
                 // standard case: volume cells
                 if (cellId < baffleOffset)
@@ -215,7 +220,7 @@ void Foam::meshReader::createPolyBoundary()
             forAll(idList, bndI)
             {
                 // standard case: volume cells
-                if (idList[bndI].cell < baffleOffset)
+                if (idList[bndI].cellId() < baffleOffset)
                 {
                     addPolyBoundaryFace
                     (
diff --git a/src/conversion/meshReader/createPolyCells.C b/src/conversion/meshReader/createPolyCells.C
index d9f731ed55..9f9c407203 100644
--- a/src/conversion/meshReader/createPolyCells.C
+++ b/src/conversion/meshReader/createPolyCells.C
@@ -3,7 +3,7 @@
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
     \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
-     \\/     M anipulation  |
+     \\/     M anipulation  | Copyright (C) 2016 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -138,7 +138,7 @@ void Foam::meshReader::createPolyCells()
                         << endl;
 #endif
 
-                    if (baffleIds_[baffleI][side].unused())
+                    if (baffleIds_[baffleI][side].notUsed())
                     {
                         baffleIds_[baffleI][side] = cellFaceIdentifier
                         (
@@ -166,8 +166,8 @@ void Foam::meshReader::createPolyCells()
         {
             for (label side = 0; side < nNeighbours; ++side)
             {
-                label neiCell = baffleIds_[baffleI][side].cell;
-                label neiFace = baffleIds_[baffleI][side].face;
+                label neiCell = baffleIds_[baffleI][side].cellId();
+                label neiFace = baffleIds_[baffleI][side].faceId();
 
                 if (baffleIds_[baffleI][side].used())
                 {
diff --git a/src/conversion/meshReader/meshReader.C b/src/conversion/meshReader/meshReader.C
index 611b655d6f..c7e2d67980 100644
--- a/src/conversion/meshReader/meshReader.C
+++ b/src/conversion/meshReader/meshReader.C
@@ -84,13 +84,7 @@ void Foam::meshReader::addFaceZones(polyMesh& mesh) const
     }
 
     nZone = 0;
-    for
-    (
-        HashTable<List<label>, word, string::hash>::const_iterator
-        iter = monitoringSets_.begin();
-        iter != monitoringSets_.end();
-        ++iter
-    )
+    forAllConstIter(HashTable<labelList>, monitoringSets_, iter)
     {
         Info<< "faceZone " << nZone
             << " (size: " << iter().size() << ") name: "
@@ -103,7 +97,7 @@ void Foam::meshReader::addFaceZones(polyMesh& mesh) const
             (
                 iter.key(),
                 iter(),
-                List<bool>(iter().size(), false),
+                boolList(iter().size(), false),
                 nZone,
                 mesh.faceZones()
             )
@@ -196,15 +190,13 @@ Foam::meshReader::meshReader
     const fileName& fileOrPrefix,
     const scalar scaleFactor
 )
-    :
+:
     pointCellsPtr_(nullptr),
-    nInternalFaces_(0),
-    patchStarts_(0),
-    patchSizes_(0),
     interfaces_(0),
     baffleIds_(0),
-    meshFaces_(0),
     cellPolys_(0),
+    monitoringSets_(),
+    // protected
     geometryFile_(fileOrPrefix),
     scaleFactor_(scaleFactor),
     points_(0),
@@ -213,6 +205,10 @@ Foam::meshReader::meshReader
     patchTypes_(0),
     patchNames_(0),
     patchPhysicalTypes_(0),
+    patchStarts_(0),
+    patchSizes_(0),
+    nInternalFaces_(0),
+    meshFaces_(0),
     cellFaces_(0),
     baffleFaces_(0),
     cellTableId_(0),
diff --git a/src/conversion/meshReader/meshReader.H b/src/conversion/meshReader/meshReader.H
index c07bf3cd9c..54d5876e96 100644
--- a/src/conversion/meshReader/meshReader.H
+++ b/src/conversion/meshReader/meshReader.H
@@ -3,7 +3,7 @@
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
     \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
-     \\/     M anipulation  |
+     \\/     M anipulation  | Copyright (C) 2016 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -21,13 +21,6 @@ License
     You should have received a copy of the GNU General Public License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
-Namespace
-    Foam::meshReaders
-
-Description
-    A namespace for holding various types of mesh readers.
-
-
 Class
     Foam::meshReader
 
@@ -59,7 +52,6 @@ SourceFiles
 #include "polyMesh.H"
 #include "HashTable.H"
 #include "IOstream.H"
-
 #include "cellTable.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@@ -76,66 +68,48 @@ class meshReader
 protected:
 
     //- Identify cell faces in terms of cell Id and face Id
-    class cellFaceIdentifier
+    class cellFaceIdentifier : public labelPair
     {
     public:
-        // Public data
-
-            //- Cell Id
-            label cell;
-
-            //- Face Id
-            label face;
-
 
         // Constructors
 
-            //- Construct null
-            cellFaceIdentifier() : cell(-1), face(-1) {}
+            //- Construct null, as invalid pair
+            cellFaceIdentifier() : labelPair(-1, -1) {}
 
             //- Construct from cell/face components
-            cellFaceIdentifier(label c, label f) : cell(c), face(f) {}
+            cellFaceIdentifier(label c, label f) : labelPair(c, f) {}
+
+
+        // Access
+
+            //- The cell id (readonly)
+            const label& cellId() const
+            {
+                return first();
+            }
+
+            //- The face id (readonly)
+            const label& faceId() const
+            {
+                return second();
+            }
 
 
         // Check
 
-            //- Used if cell or face are non-negative
+            //- Used if both cell or face are non-negative
             bool used() const
             {
-                return (cell >= 0 && face >= 0);
+                return (first() >= 0 && second() >= 0);
             }
 
-            //- Unused if cell or face are negative
-            bool unused() const
+            //- Unused if either cell or face are negative
+            bool notUsed() const
             {
-                return (cell < 0 || face < 0);
+                return (first() < 0 || second() < 0);
             }
-
-
-        // Member Operators
-
-            bool operator!=(const cellFaceIdentifier& cf) const
-            {
-                return (cell != cf.cell || face != cf.face);
-            }
-
-            bool operator==(const cellFaceIdentifier& cf) const
-            {
-                return (cell == cf.cell && face == cf.face);
-            }
-
-        // IOstream Operators
-
-            friend Ostream& operator<<
-            (
-                Ostream& os,
-                const cellFaceIdentifier& cf
-            )
-            {
-                os << "(" << cf.cell << "/" << cf.face << ")";
-                return os;
-            }
-        };
+    };
 
 
 private:
@@ -147,36 +121,26 @@ private:
         // duplicate cell entries. Use additional checking
         mutable labelListList* pointCellsPtr_;
 
-        //- Number of internal faces for polyMesh
-        label nInternalFaces_;
-
-        //- Polyhedral mesh boundary patch start indices and dimensions
-        labelList patchStarts_;
-        labelList patchSizes_;
-
         //- Association between two faces
         List<labelPair> interfaces_;
 
         //- List of cells/faces id pairs for each baffle
         List<List<cellFaceIdentifier>> baffleIds_;
 
-        //- Global face list for polyMesh
-        faceList meshFaces_;
-
         //- Cells as polyhedra for polyMesh
         cellList cellPolys_;
 
         //- Face sets for monitoring
-        HashTable<List<label>, word, string::hash> monitoringSets_;
+        HashTable<labelList> monitoringSets_;
 
 
     // Private Member Functions
 
         //- Disallow default bitwise copy construct
-        meshReader(const meshReader&);
+        meshReader(const meshReader&) = delete;
 
         //- Disallow default bitwise assignment
-        void operator=(const meshReader&);
+        void operator=(const meshReader&) = delete;
 
         //- Calculate pointCells
         void calcPointCells() const;
@@ -220,7 +184,7 @@ private:
 
         void writeInterfaces(const objectRegistry&) const;
 
-        //- Write List<label> in constant/polyMesh
+        //- Write labelList in constant/polyMesh
         void writeMeshLabelList
         (
             const objectRegistry& registry,
@@ -272,6 +236,16 @@ protected:
         //- Boundary patch physical types
         wordList patchPhysicalTypes_;
 
+        //- Polyhedral mesh boundary patch start indices and dimensions
+        labelList patchStarts_;
+        labelList patchSizes_;
+
+        //- Number of internal faces for polyMesh
+        label nInternalFaces_;
+
+        //- Global face list for polyMesh
+        faceList meshFaces_;
+
         //- List of faces for every cell
         faceListList cellFaces_;
 
diff --git a/src/conversion/meshTables/cellTable.H b/src/conversion/meshTables/cellTable.H
index 951575610d..0ee17a7c2b 100644
--- a/src/conversion/meshTables/cellTable.H
+++ b/src/conversion/meshTables/cellTable.H
@@ -49,7 +49,7 @@ Description
     \endverbatim
 
     If the \a Label is missing, a value <tt>cellTable_{ID}</tt> will be
-    inferred. If the \a MaterialType is missing, the value @a fluid will
+    inferred. If the \a MaterialType is missing, the value \a fluid will
     be inferred.
 
 SourceFiles
diff --git a/src/conversion/meshWriter/meshWriter.H b/src/conversion/meshWriter/meshWriter.H
index d7b6ca004a..51f4c4014a 100644
--- a/src/conversion/meshWriter/meshWriter.H
+++ b/src/conversion/meshWriter/meshWriter.H
@@ -3,7 +3,7 @@
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
     \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
-     \\/     M anipulation  |
+     \\/     M anipulation  | Copyright (C) 2016 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -21,19 +21,11 @@ License
     You should have received a copy of the GNU General Public License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
-Namespace
-    Foam::meshWriters
-
-Description
-    A namespace for holding various types of mesh writers.
-
-
 Class
     Foam::meshWriter
 
 Description
-    write OpenFOAM meshes and/or results to another CFD format
-    - currently just STAR-CD
+    Write OpenFOAM meshes and/or results to another CFD format.
 
 \par Files
 
@@ -65,9 +57,7 @@ Description
 
 
 SourceFiles
-    meshWriterI.H
     meshWriter.C
-    meshWriterIO.C
 
 \*---------------------------------------------------------------------------*/
 
@@ -92,10 +82,10 @@ class meshWriter
     // Private Member Functions
 
         //- Disallow default bitwise copy construct
-        meshWriter(const meshWriter&);
+        meshWriter(const meshWriter&) = delete;
 
         //- Disallow default bitwise assignment
-        void operator=(const meshWriter&);
+        void operator=(const meshWriter&) = delete;
 
 
 protected:
@@ -137,7 +127,7 @@ public:
 
     // Constructors
 
-        //- Create a writer obejct
+        //- Create a writer object
         meshWriter
         (
             const polyMesh&,
@@ -159,12 +149,13 @@ public:
                 scaleFactor_ = scaling;
             }
 
-            //- Suppress writing bnd file
+            //- Suppress writing boundary (bnd) file
             void noBoundary()
             {
                 writeBoundary_ = false;
             }
 
+
         // Write
 
             //- Write volume mesh. Subclass must supply this method

From c5e364dd38af5993f99c3055cfa2bbc9ae800719 Mon Sep 17 00:00:00 2001
From: Mark Olesen <Mark.Olesen@Germany>
Date: Fri, 5 Aug 2016 12:00:00 +0200
Subject: [PATCH 2/6] STYLE: Remove meshReaders/meshWriters namespace (issue
 #204)

- Relocate classes (STARCDMeshReader, STARCDMeshWriter)
  into fileFormats namespace instead.
---
 .../foamToStarMesh/foamToStarMesh.C           |  6 ++--
 .../mesh/conversion/star4ToFoam/star4ToFoam.C |  9 +++--
 .../meshReader/starcd/STARCDMeshReader.C      | 35 +++++++++++--------
 .../meshReader/starcd/STARCDMeshReader.H      | 18 +++++-----
 .../meshWriter/starcd/STARCDMeshWriter.C      | 30 +++++++++-------
 .../meshWriter/starcd/STARCDMeshWriter.H      | 24 ++++++-------
 6 files changed, 66 insertions(+), 56 deletions(-)

diff --git a/applications/utilities/mesh/conversion/foamToStarMesh/foamToStarMesh.C b/applications/utilities/mesh/conversion/foamToStarMesh/foamToStarMesh.C
index 37e9c24992..b4692d201a 100644
--- a/applications/utilities/mesh/conversion/foamToStarMesh/foamToStarMesh.C
+++ b/applications/utilities/mesh/conversion/foamToStarMesh/foamToStarMesh.C
@@ -3,7 +3,7 @@
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
     \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
-     \\/     M anipulation  |
+     \\/     M anipulation  | Copyright (C) 2016 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -48,7 +48,7 @@ Note
     creating the cellTable information.
 
 See also
-    Foam::cellTable, Foam::meshWriter and Foam::meshWriters::STARCD
+    Foam::cellTable, Foam::meshWriter and Foam::fileFormats::STARCDMeshWriter
 
 \*---------------------------------------------------------------------------*/
 
@@ -116,7 +116,7 @@ int main(int argc, char *argv[])
 
         if (!timeI || state != polyMesh::UNCHANGED)
         {
-            meshWriters::STARCD writer(mesh, scaleFactor);
+            fileFormats::STARCDMeshWriter writer(mesh, scaleFactor);
 
             if (args.optionFound("noBnd"))
             {
diff --git a/applications/utilities/mesh/conversion/star4ToFoam/star4ToFoam.C b/applications/utilities/mesh/conversion/star4ToFoam/star4ToFoam.C
index 65cb4d01b7..af57977d78 100644
--- a/applications/utilities/mesh/conversion/star4ToFoam/star4ToFoam.C
+++ b/applications/utilities/mesh/conversion/star4ToFoam/star4ToFoam.C
@@ -3,7 +3,7 @@
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
     \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
-     \\/     M anipulation  |
+     \\/     M anipulation  | Copyright (C) 2016 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -48,6 +48,9 @@ Usage
 Note
     Baffles are written as interfaces for later use
 
+See Also
+    Foam::cellTable, Foam::meshReader and Foam::fileFormats::STARCDMeshReader
+
 \*---------------------------------------------------------------------------*/
 
 #include "argList.H"
@@ -95,7 +98,7 @@ int main(int argc, char *argv[])
         scaleFactor = 1;
     }
 
-    meshReaders::STARCD::keepSolids = args.optionFound("solids");
+    fileFormats::STARCDMeshReader::keepSolids = args.optionFound("solids");
 
     // default to binary output, unless otherwise specified
     IOstream::streamFormat format = IOstream::BINARY;
@@ -110,7 +113,7 @@ int main(int argc, char *argv[])
     // remove extensions and/or trailing '.'
     const fileName prefix = fileName(args[1]).lessExt();
 
-    meshReaders::STARCD reader(prefix, runTime, scaleFactor);
+    fileFormats::STARCDMeshReader reader(prefix, runTime, scaleFactor);
 
     autoPtr<polyMesh> mesh = reader.mesh(runTime);
     reader.writeMesh(mesh, format);
diff --git a/src/conversion/meshReader/starcd/STARCDMeshReader.C b/src/conversion/meshReader/starcd/STARCDMeshReader.C
index 3ddd01c37b..e5ddc1bcb5 100644
--- a/src/conversion/meshReader/starcd/STARCDMeshReader.C
+++ b/src/conversion/meshReader/starcd/STARCDMeshReader.C
@@ -35,15 +35,15 @@ License
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-const char* const Foam::meshReaders::STARCD::defaultBoundaryName =
+const char* const Foam::fileFormats::STARCDMeshReader::defaultBoundaryName =
     "Default_Boundary_Region";
 
-const char* const Foam::meshReaders::STARCD::defaultSolidBoundaryName =
+const char* const Foam::fileFormats::STARCDMeshReader::defaultSolidBoundaryName =
     "Default_Boundary_Solid";
 
-bool Foam::meshReaders::STARCD::keepSolids = false;
+bool Foam::fileFormats::STARCDMeshReader::keepSolids = false;
 
-const int Foam::meshReaders::STARCD::starToFoamFaceAddr[4][6] =
+const int Foam::fileFormats::STARCDMeshReader::starToFoamFaceAddr[4][6] =
 {
     { 4, 5, 2, 3, 0, 1 },     // 11 = pro-STAR hex
     { 0, 1, 4, -1, 2, 3 },    // 12 = pro-STAR prism
@@ -54,7 +54,7 @@ const int Foam::meshReaders::STARCD::starToFoamFaceAddr[4][6] =
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-void Foam::meshReaders::STARCD::readToNewline(IFstream& is)
+void Foam::fileFormats::STARCDMeshReader::readToNewline(IFstream& is)
 {
     char ch = '\n';
     do
@@ -65,7 +65,7 @@ void Foam::meshReaders::STARCD::readToNewline(IFstream& is)
 }
 
 
-bool Foam::meshReaders::STARCD::readHeader(IFstream& is, word fileSignature)
+bool Foam::fileFormats::STARCDMeshReader::readHeader(IFstream& is, word fileSignature)
 {
     if (!is.good())
     {
@@ -95,7 +95,10 @@ bool Foam::meshReaders::STARCD::readHeader(IFstream& is, word fileSignature)
 
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 
-void Foam::meshReaders::STARCD::readAux(const objectRegistry& registry)
+void Foam::fileFormats::STARCDMeshReader::readAux
+(
+    const objectRegistry& registry
+)
 {
     boundaryRegion_.readDict(registry);
     cellTable_.readDict(registry);
@@ -115,7 +118,7 @@ Body:
   <vertexId>  <x>  <y>  <z> [newline]
 
 \*---------------------------------------------------------------------------*/
-void Foam::meshReaders::STARCD::readPoints
+void Foam::fileFormats::STARCDMeshReader::readPoints
 (
     const fileName& inputName,
     const scalar scaleFactor
@@ -197,7 +200,6 @@ void Foam::meshReaders::STARCD::readPoints
             << "no points in file " << inputName
             << abort(FatalError);
     }
-
 }
 
 
@@ -241,7 +243,7 @@ for each cell face.
 Strictly speaking, we only need the cellModeller for adding boundaries.
 \*---------------------------------------------------------------------------*/
 
-void Foam::meshReaders::STARCD::readCells(const fileName& inputName)
+void Foam::fileFormats::STARCDMeshReader::readCells(const fileName& inputName)
 {
     const word fileSignature = "PROSTAR_CELL";
     label nFluids = 0, nSolids = 0, nBaffles = 0, nShells = 0;
@@ -632,7 +634,10 @@ BAFFLE
 etc,
 \*---------------------------------------------------------------------------*/
 
-void Foam::meshReaders::STARCD::readBoundary(const fileName& inputName)
+void Foam::fileFormats::STARCDMeshReader::readBoundary
+(
+    const fileName& inputName
+)
 {
     const word fileSignature = "PROSTAR_BOUNDARY";
     label nPatches = 0, nFaces = 0, nBafflePatches = 0, maxId = 0;
@@ -979,7 +984,7 @@ void Foam::meshReaders::STARCD::readBoundary(const fileName& inputName)
 //
 // remove unused points
 //
-void Foam::meshReaders::STARCD::cullPoints()
+void Foam::fileFormats::STARCDMeshReader::cullPoints()
 {
     label nPoints = points_.size();
     labelList oldToNew(nPoints, -1);
@@ -1039,7 +1044,7 @@ void Foam::meshReaders::STARCD::cullPoints()
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-bool Foam::meshReaders::STARCD::readGeometry(const scalar scaleFactor)
+bool Foam::fileFormats::STARCDMeshReader::readGeometry(const scalar scaleFactor)
 {
     readPoints(geometryFile_ + ".vrt", scaleFactor);
     readCells(geometryFile_ + ".cel");
@@ -1052,7 +1057,7 @@ bool Foam::meshReaders::STARCD::readGeometry(const scalar scaleFactor)
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
-Foam::meshReaders::STARCD::STARCD
+Foam::fileFormats::STARCDMeshReader::STARCDMeshReader
 (
     const fileName& prefix,
     const objectRegistry& registry,
@@ -1070,7 +1075,7 @@ Foam::meshReaders::STARCD::STARCD
 
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
-Foam::meshReaders::STARCD::~STARCD()
+Foam::fileFormats::STARCDMeshReader::~STARCDMeshReader()
 {}
 
 
diff --git a/src/conversion/meshReader/starcd/STARCDMeshReader.H b/src/conversion/meshReader/starcd/STARCDMeshReader.H
index bde13a9cd2..5025a5c11a 100644
--- a/src/conversion/meshReader/starcd/STARCDMeshReader.H
+++ b/src/conversion/meshReader/starcd/STARCDMeshReader.H
@@ -22,7 +22,7 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Class
-    Foam::meshReaders::STARCD
+    Foam::fileFormats::STARCDMeshReader
 
 Description
     Read pro-STAR vrt/cel/bnd files.
@@ -52,14 +52,14 @@ SourceFiles
 namespace Foam
 {
 
-namespace meshReaders
+namespace fileFormats
 {
 
 /*---------------------------------------------------------------------------*\
-                    Class meshReaders::STARCD Declaration
+                Class fileFormats::STARCDMeshReader Declaration
 \*---------------------------------------------------------------------------*/
 
-class STARCD
+class STARCDMeshReader
 :
     public meshReader
 {
@@ -119,10 +119,10 @@ private:
     // Private member functions
 
         //- Disallow default bitwise copy construct
-        STARCD(const STARCD&);
+        STARCDMeshReader(const STARCDMeshReader&) = delete;
 
         //- Disallow default bitwise assignment
-        void operator=(const STARCD&);
+        void operator=(const STARCDMeshReader&) = delete;
 
 
 protected:
@@ -161,7 +161,7 @@ public:
     // Constructors
 
         //- Construct from case name
-        STARCD
+        STARCDMeshReader
         (
             const fileName& prefix,
             const objectRegistry&,
@@ -170,13 +170,13 @@ public:
 
 
     //- Destructor
-    virtual ~STARCD();
+    virtual ~STARCDMeshReader();
 };
 
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-} // End namespace meshReaders
+} // End namespace fileFormats
 } // End namespace Foam
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
diff --git a/src/conversion/meshWriter/starcd/STARCDMeshWriter.C b/src/conversion/meshWriter/starcd/STARCDMeshWriter.C
index 3c90126416..3436fc5a76 100644
--- a/src/conversion/meshWriter/starcd/STARCDMeshWriter.C
+++ b/src/conversion/meshWriter/starcd/STARCDMeshWriter.C
@@ -31,10 +31,10 @@ License
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-const char* Foam::meshWriters::STARCD::defaultBoundaryName =
+const char* Foam::fileFormats::STARCDMeshWriter::defaultBoundaryName =
     "Default_Boundary_Region";
 
-const Foam::label Foam::meshWriters::STARCD::foamToStarFaceAddr[4][6] =
+const Foam::label Foam::fileFormats::STARCDMeshWriter::foamToStarFaceAddr[4][6] =
 {
     { 4, 5, 2, 3, 0, 1 },     // 11 = pro-STAR hex
     { 0, 1, 4, 5, 2, -1 },    // 12 = pro-STAR prism
@@ -45,7 +45,7 @@ const Foam::label Foam::meshWriters::STARCD::foamToStarFaceAddr[4][6] =
 
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 
-Foam::label Foam::meshWriters::STARCD::findDefaultBoundary() const
+Foam::label Foam::fileFormats::STARCDMeshWriter::findDefaultBoundary() const
 {
     const polyBoundaryMesh& patches = mesh_.boundaryMesh();
 
@@ -64,7 +64,7 @@ Foam::label Foam::meshWriters::STARCD::findDefaultBoundary() const
 }
 
 
-void Foam::meshWriters::STARCD::getCellTable()
+void Foam::fileFormats::STARCDMeshWriter::getCellTable()
 {
     // read constant/polyMesh/propertyName
     IOList<label> ioList
@@ -171,7 +171,7 @@ void Foam::meshWriters::STARCD::getCellTable()
 }
 
 
-void Foam::meshWriters::STARCD::writeHeader(Ostream& os, const char* filetype)
+void Foam::fileFormats::STARCDMeshWriter::writeHeader(Ostream& os, const char* filetype)
 {
     os  << "PROSTAR_" << filetype << nl
         << 4000
@@ -186,7 +186,7 @@ void Foam::meshWriters::STARCD::writeHeader(Ostream& os, const char* filetype)
 }
 
 
-void Foam::meshWriters::STARCD::writePoints(const fileName& prefix) const
+void Foam::fileFormats::STARCDMeshWriter::writePoints(const fileName& prefix) const
 {
     OFstream os(prefix + ".vrt");
     writeHeader(os, "VERTEX");
@@ -216,7 +216,10 @@ void Foam::meshWriters::STARCD::writePoints(const fileName& prefix) const
 }
 
 
-void Foam::meshWriters::STARCD::writeCells(const fileName& prefix) const
+void Foam::fileFormats::STARCDMeshWriter::writeCells
+(
+    const fileName& prefix
+) const
 {
     OFstream os(prefix + ".cel");
     writeHeader(os, "CELL");
@@ -358,7 +361,10 @@ void Foam::meshWriters::STARCD::writeCells(const fileName& prefix) const
 }
 
 
-void Foam::meshWriters::STARCD::writeBoundary(const fileName& prefix) const
+void Foam::fileFormats::STARCDMeshWriter::writeBoundary
+(
+    const fileName& prefix
+) const
 {
     OFstream os(prefix + ".bnd");
     writeHeader(os, "BOUNDARY");
@@ -464,7 +470,7 @@ void Foam::meshWriters::STARCD::writeBoundary(const fileName& prefix) const
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
-Foam::meshWriters::STARCD::STARCD
+Foam::fileFormats::STARCDMeshWriter::STARCDMeshWriter
 (
     const polyMesh& mesh,
     const scalar scaleFactor
@@ -480,13 +486,13 @@ Foam::meshWriters::STARCD::STARCD
 
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
-Foam::meshWriters::STARCD::~STARCD()
+Foam::fileFormats::STARCDMeshWriter::~STARCDMeshWriter()
 {}
 
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
-void Foam::meshWriters::STARCD::rmFiles(const fileName& baseName) const
+void Foam::fileFormats::STARCDMeshWriter::rmFiles(const fileName& baseName) const
 {
     rm(baseName + ".vrt");
     rm(baseName + ".cel");
@@ -495,7 +501,7 @@ void Foam::meshWriters::STARCD::rmFiles(const fileName& baseName) const
 }
 
 
-bool Foam::meshWriters::STARCD::write(const fileName& meshName) const
+bool Foam::fileFormats::STARCDMeshWriter::write(const fileName& meshName) const
 {
     fileName baseName(meshName);
 
diff --git a/src/conversion/meshWriter/starcd/STARCDMeshWriter.H b/src/conversion/meshWriter/starcd/STARCDMeshWriter.H
index 42df2d9f22..9de8c60490 100644
--- a/src/conversion/meshWriter/starcd/STARCDMeshWriter.H
+++ b/src/conversion/meshWriter/starcd/STARCDMeshWriter.H
@@ -22,7 +22,7 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Class
-    Foam::meshWriters::STARCD
+    Foam::fileFormats::STARCDMeshWriter
 
 Description
     Writes polyMesh in pro-STAR (v4) bnd/cel/vrt format
@@ -46,14 +46,14 @@ SourceFiles
 namespace Foam
 {
 
-namespace meshWriters
+namespace fileFormats
 {
 
 /*---------------------------------------------------------------------------*\
-                    Class meshWriters::STARCD Declaration
+                Class fileFormats::STARCDMeshWriter Declaration
 \*---------------------------------------------------------------------------*/
 
-class STARCD
+class STARCDMeshWriter
 :
     public meshWriter
 {
@@ -65,10 +65,10 @@ class STARCD
     // Private Member Functions
 
         //- Disallow default bitwise copy construct
-        STARCD(const STARCD&);
+        STARCDMeshWriter(const STARCDMeshWriter&) = delete;
 
         //- Disallow default bitwise assignment
-        void operator=(const STARCD&);
+        void operator=(const STARCDMeshWriter&) = delete;
 
         //- Pro-STAR 4+ header format
         static void writeHeader(Ostream&, const char* filetype);
@@ -97,16 +97,12 @@ public:
 
     // Constructors
 
-        //- Open a file for writing
-        STARCD
-        (
-            const polyMesh&,
-            const scalar scaleFactor = 1.0
-        );
+        //- Write mesh files in PROSTAR format
+        STARCDMeshWriter(const polyMesh&, const scalar scaleFactor = 1.0);
 
 
     //- Destructor
-    virtual ~STARCD();
+    virtual ~STARCDMeshWriter();
 
 
     // Member Functions
@@ -130,7 +126,7 @@ public:
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-} // End namespace meshWriters
+} // End namespace fileFormats
 } // End namespace Foam
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

From b475ae851eed6a732e12acf5f21428588d401f06 Mon Sep 17 00:00:00 2001
From: Mark Olesen <Mark.Olesen@Germany>
Date: Fri, 5 Aug 2016 11:05:30 +0200
Subject: [PATCH 3/6] DEFEATURE: remove samm, pro-am, prostar3 convertors
 (issue #204)

- these frontends are defunct and their formats were quite a mess.
  Prostar 4 versions (star4ToFoam, foamToStarMesh) should be used
  instead.
---
 .../mesh/conversion/sammToFoam/Make/files     |   17 -
 .../mesh/conversion/sammToFoam/Make/options   |    0
 .../conversion/sammToFoam/calcPointCells.C    |  139 --
 .../sammToFoam/createBoundaryFaces.C          |  126 --
 .../sammToFoam/createPolyBoundary.C           |  144 --
 .../conversion/sammToFoam/createPolyCells.C   |  188 --
 .../sammToFoam/fillSammAddressingTable.C      |  216 ---
 .../sammToFoam/fillSammCellShapeTable.C       |  131 --
 .../conversion/sammToFoam/fixCollapsedEdges.C |  149 --
 .../conversion/sammToFoam/purgeCellShapes.C   |   66 -
 .../mesh/conversion/sammToFoam/readBoundary.C |  258 ---
 .../mesh/conversion/sammToFoam/readCells.C    |  319 ----
 .../mesh/conversion/sammToFoam/readCouples.C  |  177 --
 .../mesh/conversion/sammToFoam/readPoints.C   |   34 -
 .../mesh/conversion/sammToFoam/sammMesh.C     |  220 ---
 .../mesh/conversion/sammToFoam/sammMesh.H     |  253 ---
 .../mesh/conversion/sammToFoam/sammToFoam.C   |   79 -
 .../mesh/conversion/sammToFoam/starMesh.H     |    1 -
 .../mesh/conversion/sammToFoam/writeMesh.C    |   91 -
 .../mesh/conversion/star3ToFoam/Make/files    |   19 -
 .../mesh/conversion/star3ToFoam/Make/options  |    7 -
 .../conversion/star3ToFoam/calcPointCells.C   |  139 --
 .../conversion/star3ToFoam/coupledFacePair.C  |   66 -
 .../conversion/star3ToFoam/coupledFacePair.H  |  146 --
 .../star3ToFoam/createBoundaryFaces.C         |  201 ---
 .../star3ToFoam/createCoupleMatches.C         | 1508 -----------------
 .../star3ToFoam/createPolyBoundary.C          |  315 ----
 .../conversion/star3ToFoam/createPolyCells.C  |  188 --
 .../star3ToFoam/fixCollapsedEdges.C           |  148 --
 .../star3ToFoam/mergeCoupleFacePoints.C       |  423 -----
 .../conversion/star3ToFoam/purgeCellShapes.C  |   66 -
 .../conversion/star3ToFoam/readBoundary.C     |  256 ---
 .../mesh/conversion/star3ToFoam/readCells.C   |  388 -----
 .../mesh/conversion/star3ToFoam/readCouples.C |  185 --
 .../mesh/conversion/star3ToFoam/readPoints.C  |  175 --
 .../star3ToFoam/readSeparatedPoints.C         |  116 --
 .../mesh/conversion/star3ToFoam/star3ToFoam.C |   84 -
 .../mesh/conversion/star3ToFoam/starMesh.C    |  295 ----
 .../mesh/conversion/star3ToFoam/starMesh.H    |  318 ----
 .../mesh/conversion/star3ToFoam/writeMesh.C   |   98 --
 etc/cellModels                                |  194 +--
 41 files changed, 2 insertions(+), 7941 deletions(-)
 delete mode 100644 applications/utilities/mesh/conversion/sammToFoam/Make/files
 delete mode 100644 applications/utilities/mesh/conversion/sammToFoam/Make/options
 delete mode 100644 applications/utilities/mesh/conversion/sammToFoam/calcPointCells.C
 delete mode 100644 applications/utilities/mesh/conversion/sammToFoam/createBoundaryFaces.C
 delete mode 100644 applications/utilities/mesh/conversion/sammToFoam/createPolyBoundary.C
 delete mode 100644 applications/utilities/mesh/conversion/sammToFoam/createPolyCells.C
 delete mode 100644 applications/utilities/mesh/conversion/sammToFoam/fillSammAddressingTable.C
 delete mode 100644 applications/utilities/mesh/conversion/sammToFoam/fillSammCellShapeTable.C
 delete mode 100644 applications/utilities/mesh/conversion/sammToFoam/fixCollapsedEdges.C
 delete mode 100644 applications/utilities/mesh/conversion/sammToFoam/purgeCellShapes.C
 delete mode 100644 applications/utilities/mesh/conversion/sammToFoam/readBoundary.C
 delete mode 100644 applications/utilities/mesh/conversion/sammToFoam/readCells.C
 delete mode 100644 applications/utilities/mesh/conversion/sammToFoam/readCouples.C
 delete mode 100644 applications/utilities/mesh/conversion/sammToFoam/readPoints.C
 delete mode 100644 applications/utilities/mesh/conversion/sammToFoam/sammMesh.C
 delete mode 100644 applications/utilities/mesh/conversion/sammToFoam/sammMesh.H
 delete mode 100644 applications/utilities/mesh/conversion/sammToFoam/sammToFoam.C
 delete mode 100644 applications/utilities/mesh/conversion/sammToFoam/starMesh.H
 delete mode 100644 applications/utilities/mesh/conversion/sammToFoam/writeMesh.C
 delete mode 100644 applications/utilities/mesh/conversion/star3ToFoam/Make/files
 delete mode 100644 applications/utilities/mesh/conversion/star3ToFoam/Make/options
 delete mode 100644 applications/utilities/mesh/conversion/star3ToFoam/calcPointCells.C
 delete mode 100644 applications/utilities/mesh/conversion/star3ToFoam/coupledFacePair.C
 delete mode 100644 applications/utilities/mesh/conversion/star3ToFoam/coupledFacePair.H
 delete mode 100644 applications/utilities/mesh/conversion/star3ToFoam/createBoundaryFaces.C
 delete mode 100644 applications/utilities/mesh/conversion/star3ToFoam/createCoupleMatches.C
 delete mode 100644 applications/utilities/mesh/conversion/star3ToFoam/createPolyBoundary.C
 delete mode 100644 applications/utilities/mesh/conversion/star3ToFoam/createPolyCells.C
 delete mode 100644 applications/utilities/mesh/conversion/star3ToFoam/fixCollapsedEdges.C
 delete mode 100644 applications/utilities/mesh/conversion/star3ToFoam/mergeCoupleFacePoints.C
 delete mode 100644 applications/utilities/mesh/conversion/star3ToFoam/purgeCellShapes.C
 delete mode 100644 applications/utilities/mesh/conversion/star3ToFoam/readBoundary.C
 delete mode 100644 applications/utilities/mesh/conversion/star3ToFoam/readCells.C
 delete mode 100644 applications/utilities/mesh/conversion/star3ToFoam/readCouples.C
 delete mode 100644 applications/utilities/mesh/conversion/star3ToFoam/readPoints.C
 delete mode 100644 applications/utilities/mesh/conversion/star3ToFoam/readSeparatedPoints.C
 delete mode 100644 applications/utilities/mesh/conversion/star3ToFoam/star3ToFoam.C
 delete mode 100644 applications/utilities/mesh/conversion/star3ToFoam/starMesh.C
 delete mode 100644 applications/utilities/mesh/conversion/star3ToFoam/starMesh.H
 delete mode 100644 applications/utilities/mesh/conversion/star3ToFoam/writeMesh.C

diff --git a/applications/utilities/mesh/conversion/sammToFoam/Make/files b/applications/utilities/mesh/conversion/sammToFoam/Make/files
deleted file mode 100644
index b0b81c5ea5..0000000000
--- a/applications/utilities/mesh/conversion/sammToFoam/Make/files
+++ /dev/null
@@ -1,17 +0,0 @@
-sammMesh.C
-fillSammCellShapeTable.C
-fillSammAddressingTable.C
-readPoints.C
-readCells.C
-readBoundary.C
-fixCollapsedEdges.C
-readCouples.C
-calcPointCells.C
-createPolyCells.C
-createBoundaryFaces.C
-createPolyBoundary.C
-purgeCellShapes.C
-writeMesh.C
-sammToFoam.C
-
-EXE = $(FOAM_APPBIN)/sammToFoam
diff --git a/applications/utilities/mesh/conversion/sammToFoam/Make/options b/applications/utilities/mesh/conversion/sammToFoam/Make/options
deleted file mode 100644
index e69de29bb2..0000000000
diff --git a/applications/utilities/mesh/conversion/sammToFoam/calcPointCells.C b/applications/utilities/mesh/conversion/sammToFoam/calcPointCells.C
deleted file mode 100644
index 1204fb810f..0000000000
--- a/applications/utilities/mesh/conversion/sammToFoam/calcPointCells.C
+++ /dev/null
@@ -1,139 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-Description
-    Create intermediate mesh files from SAMM files
-
-\*---------------------------------------------------------------------------*/
-
-#include "sammMesh.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-void Foam::sammMesh::calcPointCells() const
-{
-    static const label UNIT_POINT_CELLS = 12;
-
-    if (pointCellsPtr_)
-    {
-        FatalErrorInFunction
-            << "PointCells already calculated"
-            << abort(FatalError);
-    }
-
-
-    pointCellsPtr_ = new labelListList(points_.size());
-
-    labelListList& pc = *pointCellsPtr_;
-
-    forAll(pc, i)
-    {
-        pc[i].setSize(UNIT_POINT_CELLS);
-    }
-
-    // Initialise the list of labels which will hold the count the
-    // actual number of cells per point during the analysis
-    labelList cellCount(points_.size());
-
-    forAll(cellCount, i)
-    {
-        cellCount[i] = 0;
-    }
-
-    // Note. Unlike the standard point-cell algorithm, which asks the cell for
-    // the supporting point labels, we need to work based on the cell faces.
-    // This is because some of the faces for meshes with arbitrary interfaces
-    // do not come from the cell shape, but from the slaves of the coupled
-    // match. It is also adventageous to remove the duplicates from the
-    // point-cell addressing, because this removes a lot of waste later.
-    //
-
-    // For each cell
-    forAll(cellShapes_, celli)
-    {
-        const faceList& faces = cellFaces_[celli];
-
-        forAll(faces, i)
-        {
-            // For each vertex
-            const labelList& labels = faces[i];
-
-            forAll(labels, j)
-            {
-                // Set working point label
-                label curPoint = labels[j];
-                labelList& curPointCells = pc[curPoint];
-                label curCount = cellCount[curPoint];
-
-                // check if the cell has been added before
-                bool found = false;
-
-                for (label f = 0; f < curCount; f++)
-                {
-                    if (curPointCells[f] == celli)
-                    {
-                        found = true;
-
-                        break;
-                    }
-                }
-
-                if (!found)
-                {
-
-                    // If the list of pointCells is not big enough, double it
-                    if (curPointCells.size() <= curCount)
-                    {
-                        curPointCells.setSize(curPointCells.size()*2);
-                    }
-
-                    // Enter the cell label in the point's cell list
-                    curPointCells[curCount] = celli;
-
-                    // Increment the cell count for the point addressed
-                    cellCount[curPoint]++;
-                }
-            }
-        }
-    }
-
-    // Finally, truncate the lists made to their active size
-    forAll(pc, i)
-    {
-        pc[i].setSize(cellCount[i]);
-    }
-}
-
-
-const Foam::labelListList& Foam::sammMesh::pointCells() const
-{
-    if (!pointCellsPtr_)
-    {
-        calcPointCells();
-    }
-
-    return *pointCellsPtr_;
-}
-
-
-// ************************************************************************* //
diff --git a/applications/utilities/mesh/conversion/sammToFoam/createBoundaryFaces.C b/applications/utilities/mesh/conversion/sammToFoam/createBoundaryFaces.C
deleted file mode 100644
index e3d3ed1f44..0000000000
--- a/applications/utilities/mesh/conversion/sammToFoam/createBoundaryFaces.C
+++ /dev/null
@@ -1,126 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-Description
-    Create intermediate mesh files from SAMM files
-
-\*---------------------------------------------------------------------------*/
-
-#include "sammMesh.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-bool Foam::sammMesh::sammEqualFace
-(
-    const face& boundaryFace,
-    const face& cellFace
-) const
-{
-    // A PROSTAR boundary face is defined by 4 vertices irrespective
-    // of its topology.
-    // In order to deal with all possibilities, two faces will be
-    // considered equal if three of the vertices are the same.
-    label nEqual = 0;
-
-    forAll(cellFace, cellFaceLabelI)
-    {
-        const label curCellFaceLabel = cellFace[cellFaceLabelI];
-
-        forAll(boundaryFace, bouFaceLabelI)
-        {
-            if (boundaryFace[bouFaceLabelI] == curCellFaceLabel)
-            {
-                nEqual++;
-
-                break;
-            }
-        }
-    }
-
-    if (nEqual >= 3)
-    {
-        return true;
-    }
-    else
-    {
-        return false;
-    }
-}
-
-
-void Foam::sammMesh::createBoundaryFaces()
-{
-    forAll(boundary_, patchi)
-    {
-        faceList& patchFaces = boundary_[patchi];
-
-        const labelListList& PointCells = pointCells();
-
-        forAll(patchFaces, facei)
-        {
-            bool found = false;
-
-            face& curFace = patchFaces[facei];
-            const labelList& facePoints = curFace;
-
-            forAll(facePoints, pointi)
-            {
-                const labelList& facePointCells =
-                    PointCells[facePoints[pointi]];
-
-                forAll(facePointCells, celli)
-                {
-                    const faceList& curCellFaces =
-                        cellFaces_[facePointCells[celli]];
-
-                    forAll(curCellFaces, cellFacei)
-                    {
-                        if (sammEqualFace(curCellFaces[cellFacei], curFace))
-                        {
-                            // Found the cell face corresponding to this face
-                            found = true;
-
-                            // Set boundary face to the corresponding cell face
-                            // which guarantees it is outward-pointing
-                            curFace = curCellFaces[cellFacei];
-                        }
-                        if (found) break;
-                    }
-                    if (found) break;
-                }
-                if (found) break;
-            }
-            if (!found)
-            {
-                FatalErrorInFunction
-                    << "Face " << facei
-                    << " does not have neighbour cell." << endl
-                    << "    face : " << endl << curFace
-                    << abort(FatalError);
-            }
-        }
-    }
-}
-
-
-// ************************************************************************* //
diff --git a/applications/utilities/mesh/conversion/sammToFoam/createPolyBoundary.C b/applications/utilities/mesh/conversion/sammToFoam/createPolyBoundary.C
deleted file mode 100644
index 3bdafa60d8..0000000000
--- a/applications/utilities/mesh/conversion/sammToFoam/createPolyBoundary.C
+++ /dev/null
@@ -1,144 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-Description
-    Create intermediate mesh files from SAMM files
-
-\*---------------------------------------------------------------------------*/
-
-#include "sammMesh.H"
-#include "polyPatch.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-void Foam::sammMesh::createPolyBoundary()
-{
-    label nBoundaryFacesFound = 0;
-
-    polyBoundaryPatchStartIndices_.setSize(boundary_.size());
-
-    label nCreatedFaces = nInternalFaces_;
-
-    const labelListList& PointCells = pointCells();
-
-    forAll(boundary_, patchi)
-    {
-        const faceList& curShapePatch = boundary_[patchi];
-
-        polyBoundaryPatchStartIndices_[patchi] = nCreatedFaces;
-
-        forAll(curShapePatch, facei)
-        {
-            bool found = false;
-
-            const face& curFace = curShapePatch[facei];
-
-            meshFaces_[nCreatedFaces] = curFace;
-
-            // Must find which cell this face belongs to in order to
-            // mark it in the cellPolys_
-            const labelList& facePoints = curFace;
-
-            forAll(facePoints, pointi)
-            {
-                const labelList& facePointCells =
-                    PointCells[facePoints[pointi]];
-
-                forAll(facePointCells, celli)
-                {
-                    const faceList& curCellFaces =
-                        cellFaces_[facePointCells[celli]];
-
-                    forAll(curCellFaces, cellFacei)
-                    {
-                        if (curCellFaces[cellFacei] == curFace)
-                        {
-                            // Found the cell face corresponding to this face
-                            found = true;
-
-                            // Debugging
-                            if
-                            (
-                                cellPolys_[facePointCells[celli]][cellFacei]
-                             != -1
-                            )
-                            {
-                                FatalErrorInFunction
-                                    << "This looks like an already detected "
-                                    << "internal face"
-                                    << abort(FatalError);
-                            }
-
-                            cellPolys_[facePointCells[celli]][cellFacei] =
-                                nCreatedFaces;
-
-                            nBoundaryFacesFound++;
-                        }
-                        if (found) break;
-                    }
-                    if (found) break;
-                }
-                if (found) break;
-            }
-
-            nCreatedFaces++;
-        }
-    }
-
-    // reset the size of the face list
-    meshFaces_.setSize(nCreatedFaces);
-
-    Info<< "Number of boundary faces: " << nBoundaryFacesFound << endl;
-    Info<< "Total number of faces: " << nCreatedFaces << endl;
-}
-
-
-Foam::List<Foam::polyPatch* > Foam::sammMesh::polyBoundaryPatches
-(
-    const polyMesh& pMesh
-)
-{
-    List<polyPatch* > p(boundary_.size());
-
-    forAll(boundary_, patchi)
-    {
-        const faceList& curShapePatch = boundary_[patchi];
-
-        p[patchi] = polyPatch::New
-        (
-            patchTypes_[patchi],
-            patchNames_[patchi],
-            curShapePatch.size(),
-            polyBoundaryPatchStartIndices_[patchi],
-            patchi,
-            pMesh.boundaryMesh()
-        ).ptr();
-
-        p[patchi]->physicalType() = patchPhysicalTypes_[patchi];
-    }
-
-    return p;
-}
-
-
-// ************************************************************************* //
diff --git a/applications/utilities/mesh/conversion/sammToFoam/createPolyCells.C b/applications/utilities/mesh/conversion/sammToFoam/createPolyCells.C
deleted file mode 100644
index 8ae1dafe01..0000000000
--- a/applications/utilities/mesh/conversion/sammToFoam/createPolyCells.C
+++ /dev/null
@@ -1,188 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-Description
-    Create intermediate mesh files from SAMM files
-
-\*---------------------------------------------------------------------------*/
-
-#include "sammMesh.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-void Foam::sammMesh::createPolyCells()
-{
-    // loop through all cell faces and create connectivity. This will produce
-    // a global face list and will describe all cells as lists of face labels
-
-    // count the maximum number of faces and set the size of the cellPolys_
-    cellPolys_.setSize(cellShapes_.size());
-
-    label maxFaces = 0;
-
-    forAll(cellPolys_, celli)
-    {
-        cell& curCell = cellPolys_[celli];
-
-        curCell.setSize(cellFaces_[celli].size());
-
-        forAll(curCell, fI)
-        {
-            curCell[fI] = -1;
-        }
-
-        maxFaces += cellFaces_[celli].size();
-    }
-
-    Info<< "Maximum possible number of faces in mesh: " << maxFaces << endl;
-
-    meshFaces_.setSize(maxFaces);
-
-    // set reference to point-cell addressing
-    const labelListList& PointCells = pointCells();
-
-    bool found = false;
-
-    nInternalFaces_ = 0;
-
-    forAll(cellFaces_, celli)
-    {
-        // Note:
-        // Insertion cannot be done in one go as the faces need to be
-        // added into the list in the increasing order of neighbour
-        // cells.  Therefore, all neighbours will be detected first
-        // and then added in the correct order.
-
-        const faceList& curFaces = cellFaces_[celli];
-
-        // Record the neighbour cell
-        labelList neiCells(curFaces.size(), -1);
-
-        // Record the face of neighbour cell
-        labelList faceOfNeiCell(curFaces.size(), -1);
-
-        label nNeighbours = 0;
-
-        // For all faces ...
-        forAll(curFaces, facei)
-        {
-            // Skip faces that have already been matched
-            if (cellPolys_[celli][facei] >= 0) continue;
-
-            found = false;
-
-            const face& curFace = curFaces[facei];
-
-            // get the list of labels
-            const labelList& curPoints = curFace;
-
-            // For all points
-            forAll(curPoints, pointi)
-            {
-                // get the list of cells sharing this point
-                const labelList& curNeighbours = PointCells[curPoints[pointi]];
-
-                // For all neighbours
-                forAll(curNeighbours, neiI)
-                {
-                    label curNei = curNeighbours[neiI];
-
-                    // reject neighbours with the lower label. This should
-                    // also reject current cell.
-                    if (curNei > celli)
-                    {
-                        // get the list of search faces
-                        const faceList& searchFaces = cellFaces_[curNei];
-
-                        forAll(searchFaces, neiFacei)
-                        {
-                            if (searchFaces[neiFacei] == curFace)
-                            {
-                                // match!!
-                                found = true;
-
-                                // Record the neighbour cell and face
-                                neiCells[facei] = curNei;
-                                faceOfNeiCell[facei] = neiFacei;
-                                nNeighbours++;
-
-                                break;
-                            }
-                        }
-                        if (found) break;
-                    }
-                    if (found) break;
-                }
-                if (found) break;
-            } // End of current points
-        } // End of current faces
-
-        // Add the faces in the increasing order of neighbours
-        for (label neiSearch = 0; neiSearch < nNeighbours; neiSearch++)
-        {
-            // Find the lowest neighbour which is still valid
-            label nextNei = -1;
-            label minNei = cellPolys_.size();
-
-            forAll(neiCells, ncI)
-            {
-                if (neiCells[ncI] > -1 && neiCells[ncI] < minNei)
-                {
-                    nextNei = ncI;
-                    minNei = neiCells[ncI];
-                }
-            }
-
-            if (nextNei > -1)
-            {
-                // Add the face to the list of faces
-                meshFaces_[nInternalFaces_] = curFaces[nextNei];
-
-                // Mark for owner
-                cellPolys_[celli][nextNei] = nInternalFaces_;
-
-                // Mark for neighbour
-                cellPolys_[neiCells[nextNei]][faceOfNeiCell[nextNei]] =
-                    nInternalFaces_;
-
-                // Stop the neighbour from being used again
-                neiCells[nextNei] = -1;
-
-                // Increment number of faces counter
-                nInternalFaces_++;
-            }
-            else
-            {
-              FatalErrorInFunction
-                  << "Error in internal face insertion"
-                  << abort(FatalError);
-            }
-        }
-    }
-
-    // I won't reset the size of internal faces, because more faces will be
-    // added in createPolyBoundary()
-}
-
-
-// ************************************************************************* //
diff --git a/applications/utilities/mesh/conversion/sammToFoam/fillSammAddressingTable.C b/applications/utilities/mesh/conversion/sammToFoam/fillSammAddressingTable.C
deleted file mode 100644
index 529d996d69..0000000000
--- a/applications/utilities/mesh/conversion/sammToFoam/fillSammAddressingTable.C
+++ /dev/null
@@ -1,216 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2015 OpenFOAM Foundation
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-\*---------------------------------------------------------------------------*/
-
-#include "sammMesh.H"
-
-// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
-
-void Foam::sammMesh::fillSammAddressingTable()
-{
-    // SAMM trim type 1: 8 models
-    static label SammTrim1Rot0[10] = {1, 5, 6, 2, 8, 10, 4, 7, 3, 9};
-    static label SammTrim1Rot1[10] = {2, 6, 7, 3, 8, 10, 5, 4, 0, 9};
-    static label SammTrim1Rot2[10] = {3, 7, 4, 0, 8, 10, 6, 5, 1, 9};
-    static label SammTrim1Rot3[10] = {0, 4, 5, 1, 8, 10, 7, 6, 2, 9};
-    static label SammTrim1Rot4[10] = {7, 3, 2, 6, 8, 10, 0, 1, 5, 9};
-    static label SammTrim1Rot5[10] = {4, 0, 3, 7, 8, 10, 1, 2, 6, 9};
-    static label SammTrim1Rot6[10] = {5, 1, 0, 4, 8, 10, 2, 3, 7, 9};
-    static label SammTrim1Rot7[10] = {6, 2, 1, 5, 8, 10, 3, 0, 4, 9};
-
-    sammAddressingTable[1]   = SammTrim1Rot0;
-    sammAddressingTable[2]   = SammTrim1Rot1;
-    sammAddressingTable[4]   = SammTrim1Rot2;
-    sammAddressingTable[8]   = SammTrim1Rot3;
-    sammAddressingTable[16]  = SammTrim1Rot4;
-    sammAddressingTable[32]  = SammTrim1Rot5;
-    sammAddressingTable[64]  = SammTrim1Rot6;
-    sammAddressingTable[128] = SammTrim1Rot7;
-
-
-    // SAMM trim type 2: 12 models
-    static label SammTrim2Rot0[10]  = {9, 3, 7, 4, 10, 8, 2, 6, 5, 11};
-    static label SammTrim2Rot1[10]  = {9, 1, 5, 6, 10, 8, 0, 4, 7, 11};
-    static label SammTrim2Rot2[10]  = {9, 2, 1, 5, 10, 8, 3, 0, 4, 11};
-    static label SammTrim2Rot3[10]  = {9, 0, 3, 7, 10, 8, 1, 2, 6, 11};
-
-    static label SammTrim2Rot4[10]  = {9, 4, 5, 1, 10, 8, 7, 6, 2, 11};
-    static label SammTrim2Rot5[10]  = {9, 5, 1, 0, 10, 8, 6, 2, 3, 11};
-    static label SammTrim2Rot6[10]  = {9, 1, 0, 4, 10, 8, 2, 3, 7, 11};
-    static label SammTrim2Rot7[10]  = {9, 0, 4, 5, 10, 8, 3, 7, 6, 11};
-
-    static label SammTrim2Rot8[10]  = {9, 1, 2, 3, 10, 8, 5, 6, 7, 11};
-    static label SammTrim2Rot9[10]  = {9, 2, 3, 0, 10, 8, 6, 7, 4, 11};
-    static label SammTrim2Rot10[10] = {9, 3, 0, 1, 10, 8, 7, 4, 5, 11};
-    static label SammTrim2Rot11[10] = {9, 0, 1, 2, 10, 8, 4, 5, 6, 11};
-
-    sammAddressingTable[3]   = SammTrim2Rot0;
-    sammAddressingTable[12]  = SammTrim2Rot1;
-    sammAddressingTable[192] = SammTrim2Rot2;
-    sammAddressingTable[48]  = SammTrim2Rot3;
-    sammAddressingTable[9]   = SammTrim2Rot4;
-    sammAddressingTable[144] = SammTrim2Rot5;
-    sammAddressingTable[96]  = SammTrim2Rot6;
-    sammAddressingTable[6]   = SammTrim2Rot7;
-    sammAddressingTable[17]  = SammTrim2Rot8;
-    sammAddressingTable[34]  = SammTrim2Rot9;
-    sammAddressingTable[68]  = SammTrim2Rot10;
-    sammAddressingTable[136] = SammTrim2Rot11;
-
-
-    // SAMM trim type 3: 24 models
-    static label SammTrim3Rot0[10]  = {5, 4, 7, 6, 11, 10, 9, 3, 8, 12};
-    static label SammTrim3Rot1[10]  = {6, 5, 4, 7, 11, 10, 9, 0, 8, 12};
-    static label SammTrim3Rot2[10]  = {7, 6, 5, 4, 11, 10, 9, 1, 8, 12};
-    static label SammTrim3Rot3[10]  = {4, 7, 6, 5, 11, 10, 9, 2, 8, 12};
-    static label SammTrim3Rot4[10]  = {1, 2, 3, 0, 11, 10, 9, 7, 8, 12};
-    static label SammTrim3Rot5[10]  = {2, 3, 0, 1, 11, 10, 9, 4, 8, 12};
-    static label SammTrim3Rot6[10]  = {3, 0, 1, 2, 11, 10, 9, 5, 8, 12};
-    static label SammTrim3Rot7[10]  = {0, 1, 2, 3, 11, 10, 9, 6, 8, 12};
-    static label SammTrim3Rot8[10]  = {0, 3, 7, 4, 11, 10, 9, 6, 8, 12};
-    static label SammTrim3Rot9[10]  = {3, 7, 4, 0, 11, 10, 9, 5, 8, 12};
-    static label SammTrim3Rot10[10] = {7, 4, 0, 3, 11, 10, 9, 1, 8, 12};
-    static label SammTrim3Rot11[10] = {4, 0, 3, 7, 11, 10, 9, 2, 8, 12};
-    static label SammTrim3Rot12[10] = {1, 5, 6, 2, 11, 10, 9, 7, 8, 12};
-    static label SammTrim3Rot13[10] = {2, 1, 5, 6, 11, 10, 9, 4, 8, 12};
-    static label SammTrim3Rot14[10] = {6, 2, 1, 5, 11, 10, 9, 0, 8, 12};
-    static label SammTrim3Rot15[10] = {5, 6, 1, 2, 11, 10, 9, 3, 8, 12};
-    static label SammTrim3Rot16[10] = {7, 3, 2, 6, 11, 10, 9, 1, 8, 12};
-    static label SammTrim3Rot17[10] = {6, 7, 3, 2, 11, 10, 9, 0, 8, 12};
-    static label SammTrim3Rot18[10] = {2, 6, 7, 3, 11, 10, 9, 4, 8, 12};
-    static label SammTrim3Rot19[10] = {3, 2, 6, 7, 11, 10, 9, 5, 8, 12};
-    static label SammTrim3Rot20[10] = {4, 5, 1, 0, 11, 10, 9, 2, 8, 12};
-    static label SammTrim3Rot21[10] = {5, 1, 0, 4, 11, 10, 9, 3, 8, 12};
-    static label SammTrim3Rot22[10] = {1, 0, 4, 5, 11, 10, 9, 7, 8, 12};
-    static label SammTrim3Rot23[10] = {0, 4, 5, 1, 11, 10, 9, 6, 8, 12};
-
-    sammAddressingTable[7]   = SammTrim3Rot0;
-    sammAddressingTable[14]  = SammTrim3Rot1;
-    sammAddressingTable[13]  = SammTrim3Rot2;
-    sammAddressingTable[11]  = SammTrim3Rot3;
-    sammAddressingTable[112] = SammTrim3Rot4;
-    sammAddressingTable[224] = SammTrim3Rot5;
-    sammAddressingTable[208] = SammTrim3Rot6;
-    sammAddressingTable[176] = SammTrim3Rot7;
-    sammAddressingTable[38]  = SammTrim3Rot8;
-    sammAddressingTable[70]  = SammTrim3Rot9;
-    sammAddressingTable[100] = SammTrim3Rot10;
-    sammAddressingTable[98]  = SammTrim3Rot11;
-    sammAddressingTable[25]  = SammTrim3Rot12;
-    sammAddressingTable[137] = SammTrim3Rot13;
-    sammAddressingTable[152] = SammTrim3Rot14;
-    sammAddressingTable[145] = SammTrim3Rot15;
-    sammAddressingTable[49]  = SammTrim3Rot16;
-    sammAddressingTable[50]  = SammTrim3Rot17;
-    sammAddressingTable[35]  = SammTrim3Rot18;
-    sammAddressingTable[19]  = SammTrim3Rot19;
-    sammAddressingTable[200] = SammTrim3Rot20;
-    sammAddressingTable[196] = SammTrim3Rot21;
-    sammAddressingTable[76]  = SammTrim3Rot22;
-    sammAddressingTable[140] = SammTrim3Rot23;
-
-
-    // SAMM trim type 4: 8 models
-    static label SammTrim4Rot0[10] = {6, 7, 2, 5, 13, 12 ,11, 10, 9, 8};
-    static label SammTrim4Rot1[10] = {7, 4, 3, 6, 13, 12 ,11, 10, 9, 8};
-    static label SammTrim4Rot2[10] = {4, 5, 6, 7, 13, 12 ,11, 10, 9, 8};
-    static label SammTrim4Rot3[10] = {5, 6, 1, 4, 13, 12 ,11, 10, 9, 8};
-    static label SammTrim4Rot4[10] = {2, 1, 6, 3, 13, 12 ,11, 10, 9, 8};
-    static label SammTrim4Rot5[10] = {3, 2, 7, 0, 13, 12 ,11, 10, 9, 8};
-    static label SammTrim4Rot6[10] = {0, 3, 4, 1, 13, 12 ,11, 10, 9, 8};
-    static label SammTrim4Rot7[10] = {1, 0, 5, 2, 13, 12 ,11, 10, 9, 8};
-
-    sammAddressingTable[27]  = SammTrim4Rot0;
-    sammAddressingTable[39]  = SammTrim4Rot1;
-    sammAddressingTable[78]  = SammTrim4Rot2;
-    sammAddressingTable[141] = SammTrim4Rot3;
-    sammAddressingTable[177] = SammTrim4Rot4;
-    sammAddressingTable[114] = SammTrim4Rot5;
-    sammAddressingTable[228] = SammTrim4Rot6;
-    sammAddressingTable[216] = SammTrim4Rot7;
-
-
-    // SAMM trim type 5: 24 models
-    static label SammTrim5Rot0[8]  = {12, 0, 1, 2, 8, 11, 10, 9};
-    static label SammTrim5Rot1[8]  = {12, 1, 2, 3, 8, 11, 10, 9};
-    static label SammTrim5Rot2[8]  = {12, 2, 3, 0, 8, 11, 10, 9};
-    static label SammTrim5Rot3[8]  = {12, 3, 0, 1, 8, 11, 10, 9};
-    static label SammTrim5Rot4[8]  = {12, 6, 5, 4, 8, 11, 10, 9};
-    static label SammTrim5Rot5[8]  = {12, 7, 6, 5, 8, 11, 10, 9};
-    static label SammTrim5Rot6[8]  = {12, 4, 7, 6, 8, 11, 10, 9};
-    static label SammTrim5Rot7[8]  = {12, 5, 4, 7, 8, 11, 10, 9};
-    static label SammTrim5Rot8[8]  = {12, 2, 1, 5, 8, 11, 10, 9};
-    static label SammTrim5Rot9[8]  = {12, 6, 2, 1, 8, 11, 10, 9};
-    static label SammTrim5Rot10[8] = {12, 5, 6, 2, 8, 11, 10, 9};
-    static label SammTrim5Rot11[8] = {12, 1, 5, 6, 8, 11, 10, 9};
-    static label SammTrim5Rot12[8] = {12, 4, 0, 3, 8, 11, 10, 9};
-    static label SammTrim5Rot13[8] = {12, 0, 3, 7, 8, 11, 10, 9};
-    static label SammTrim5Rot14[8] = {12, 3, 7, 4, 8, 11, 10, 9};
-    static label SammTrim5Rot15[8] = {12, 7, 4, 0, 8, 11, 10, 9};
-    static label SammTrim5Rot16[8] = {12, 0, 4, 5, 8, 11, 10, 9};
-    static label SammTrim5Rot17[8] = {12, 4, 5, 1, 8, 11, 10, 9};
-    static label SammTrim5Rot18[8] = {12, 5, 1, 0, 8, 11, 10, 9};
-    static label SammTrim5Rot19[8] = {12, 1, 0, 4, 8, 11, 10, 9};
-    static label SammTrim5Rot20[8] = {12, 6, 7, 3, 8, 11, 10, 9};
-    static label SammTrim5Rot21[8] = {12, 2, 6, 7, 8, 11, 10, 9};
-    static label SammTrim5Rot22[8] = {12, 3, 2, 6, 8, 11, 10, 9};
-    static label SammTrim5Rot23[8] = {12, 7, 3, 2, 8, 11, 10, 9};
-
-    sammAddressingTable[248] = SammTrim5Rot0;
-    sammAddressingTable[241] = SammTrim5Rot1;
-    sammAddressingTable[242] = SammTrim5Rot2;
-    sammAddressingTable[244] = SammTrim5Rot3;
-    sammAddressingTable[143] = SammTrim5Rot4;
-    sammAddressingTable[31]  = SammTrim5Rot5;
-    sammAddressingTable[47]  = SammTrim5Rot6;
-    sammAddressingTable[79]  = SammTrim5Rot7;
-    sammAddressingTable[217] = SammTrim5Rot8;
-    sammAddressingTable[185] = SammTrim5Rot9;
-    sammAddressingTable[155] = SammTrim5Rot10;
-    sammAddressingTable[157] = SammTrim5Rot11;
-    sammAddressingTable[230] = SammTrim5Rot12;
-    sammAddressingTable[118] = SammTrim5Rot13;
-    sammAddressingTable[103] = SammTrim5Rot14;
-    sammAddressingTable[110] = SammTrim5Rot15;
-    sammAddressingTable[206] = SammTrim5Rot16;
-    sammAddressingTable[205] = SammTrim5Rot17;
-    sammAddressingTable[220] = SammTrim5Rot18;
-    sammAddressingTable[236] = SammTrim5Rot19;
-    sammAddressingTable[55]  = SammTrim5Rot20;
-    sammAddressingTable[59]  = SammTrim5Rot21;
-    sammAddressingTable[179] = SammTrim5Rot22;
-    sammAddressingTable[115] = SammTrim5Rot23;
-
-
-    // SAMM trim type 8: 1 model
-    static label SammTrim8[12] = {8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19};
-
-    sammAddressingTable[255]  = SammTrim8;
-}
-
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-
-// ************************************************************************* //
diff --git a/applications/utilities/mesh/conversion/sammToFoam/fillSammCellShapeTable.C b/applications/utilities/mesh/conversion/sammToFoam/fillSammCellShapeTable.C
deleted file mode 100644
index 551d9aa745..0000000000
--- a/applications/utilities/mesh/conversion/sammToFoam/fillSammCellShapeTable.C
+++ /dev/null
@@ -1,131 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2015 OpenFOAM Foundation
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-Description
-    SAMM cell shape lookup table
-
-\*---------------------------------------------------------------------------*/
-
-#include "sammMesh.H"
-
-// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
-
-void Foam::sammMesh::fillSammCellShapeTable()
-{
-    // Fill the list by hand
-
-    // SAMM trim type 1: 8 models
-    sammShapeLookup[1]   = sammTrim1Ptr_;
-    sammShapeLookup[2]   = sammTrim1Ptr_;
-    sammShapeLookup[4]   = sammTrim1Ptr_;
-    sammShapeLookup[8]   = sammTrim1Ptr_;
-    sammShapeLookup[16]  = sammTrim1Ptr_;
-    sammShapeLookup[32]  = sammTrim1Ptr_;
-    sammShapeLookup[64]  = sammTrim1Ptr_;
-    sammShapeLookup[128] = sammTrim1Ptr_;
-
-    //SAMM trim type 2: 12 models
-    sammShapeLookup[3]   = sammTrim2Ptr_;
-    sammShapeLookup[12]  = sammTrim2Ptr_;
-    sammShapeLookup[192] = sammTrim2Ptr_;
-    sammShapeLookup[48]  = sammTrim2Ptr_;
-    sammShapeLookup[9]   = sammTrim2Ptr_;
-    sammShapeLookup[144] = sammTrim2Ptr_;
-    sammShapeLookup[96]  = sammTrim2Ptr_;
-    sammShapeLookup[6]   = sammTrim2Ptr_;
-    sammShapeLookup[17]  = sammTrim2Ptr_;
-    sammShapeLookup[34]  = sammTrim2Ptr_;
-    sammShapeLookup[68]  = sammTrim2Ptr_;
-    sammShapeLookup[136] = sammTrim2Ptr_;
-
-    // SAMM trim type 3: 24 models
-    sammShapeLookup[7]   = sammTrim3Ptr_;
-    sammShapeLookup[14]  = sammTrim3Ptr_;
-    sammShapeLookup[13]  = sammTrim3Ptr_;
-    sammShapeLookup[11]  = sammTrim3Ptr_;
-    sammShapeLookup[112] = sammTrim3Ptr_;
-    sammShapeLookup[224] = sammTrim3Ptr_;
-    sammShapeLookup[208] = sammTrim3Ptr_;
-    sammShapeLookup[176] = sammTrim3Ptr_;
-    sammShapeLookup[38]  = sammTrim3Ptr_;
-    sammShapeLookup[70]  = sammTrim3Ptr_;
-    sammShapeLookup[100] = sammTrim3Ptr_;
-    sammShapeLookup[98]  = sammTrim3Ptr_;
-    sammShapeLookup[25]  = sammTrim3Ptr_;
-    sammShapeLookup[137] = sammTrim3Ptr_;
-    sammShapeLookup[152] = sammTrim3Ptr_;
-    sammShapeLookup[145] = sammTrim3Ptr_;
-    sammShapeLookup[49]  = sammTrim3Ptr_;
-    sammShapeLookup[50]  = sammTrim3Ptr_;
-    sammShapeLookup[35]  = sammTrim3Ptr_;
-    sammShapeLookup[19]  = sammTrim3Ptr_;
-    sammShapeLookup[200] = sammTrim3Ptr_;
-    sammShapeLookup[196] = sammTrim3Ptr_;
-    sammShapeLookup[76]  = sammTrim3Ptr_;
-    sammShapeLookup[140] = sammTrim3Ptr_;
-
-    // SAMM trim type 4: 8 models
-    sammShapeLookup[27]  = sammTrim4Ptr_;
-    sammShapeLookup[39]  = sammTrim4Ptr_;
-    sammShapeLookup[78]  = sammTrim4Ptr_;
-    sammShapeLookup[141] = sammTrim4Ptr_;
-    sammShapeLookup[177] = sammTrim4Ptr_;
-    sammShapeLookup[114] = sammTrim4Ptr_;
-    sammShapeLookup[228] = sammTrim4Ptr_;
-    sammShapeLookup[216] = sammTrim4Ptr_;
-
-    // SAMM trim type 5: 24 models
-    sammShapeLookup[248] = sammTrim5Ptr_;
-    sammShapeLookup[241] = sammTrim5Ptr_;
-    sammShapeLookup[242] = sammTrim5Ptr_;
-    sammShapeLookup[244] = sammTrim5Ptr_;
-    sammShapeLookup[143] = sammTrim5Ptr_;
-    sammShapeLookup[31]  = sammTrim5Ptr_;
-    sammShapeLookup[47]  = sammTrim5Ptr_;
-    sammShapeLookup[79]  = sammTrim5Ptr_;
-    sammShapeLookup[217] = sammTrim5Ptr_;
-    sammShapeLookup[185] = sammTrim5Ptr_;
-    sammShapeLookup[155] = sammTrim5Ptr_;
-    sammShapeLookup[157] = sammTrim5Ptr_;
-    sammShapeLookup[230] = sammTrim5Ptr_;
-    sammShapeLookup[118] = sammTrim5Ptr_;
-    sammShapeLookup[103] = sammTrim5Ptr_;
-    sammShapeLookup[110] = sammTrim5Ptr_;
-    sammShapeLookup[206] = sammTrim5Ptr_;
-    sammShapeLookup[205] = sammTrim5Ptr_;
-    sammShapeLookup[220] = sammTrim5Ptr_;
-    sammShapeLookup[236] = sammTrim5Ptr_;
-    sammShapeLookup[55]  = sammTrim5Ptr_;
-    sammShapeLookup[59]  = sammTrim5Ptr_;
-    sammShapeLookup[179] = sammTrim5Ptr_;
-    sammShapeLookup[115] = sammTrim5Ptr_;
-
-    // SAMM hexagonal prism (trim type 8): 1 model
-    sammShapeLookup[255] = sammTrim8Ptr_;
-}
-
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-
-// ************************************************************************* //
diff --git a/applications/utilities/mesh/conversion/sammToFoam/fixCollapsedEdges.C b/applications/utilities/mesh/conversion/sammToFoam/fixCollapsedEdges.C
deleted file mode 100644
index 8cebcb2728..0000000000
--- a/applications/utilities/mesh/conversion/sammToFoam/fixCollapsedEdges.C
+++ /dev/null
@@ -1,149 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-Description
-    Create intermediate mesh files from SAMM files
-
-\*---------------------------------------------------------------------------*/
-
-#include "sammMesh.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-void Foam::sammMesh::fixCollapsedEdges()
-{
-    cellFaces_.setSize(cellShapes_.size());
-
-    forAll(cellShapes_, celli)
-    {
-        cellFaces_[celli] = cellShapes_[celli].faces();
-    }
-
-    // go through the faces and find if there exist faces with duplicate
-    // vertices. If so, purge the duplicates and mark the mesh as a polyMesh
-
-    forAll(cellFaces_, celli)
-    {
-        faceList& curFaces = cellFaces_[celli];
-
-        forAll(curFaces, facei)
-        {
-            face& vertexLabels = curFaces[facei];
-
-            bool duplicatesFound = false;
-
-            forAll(vertexLabels, vI)
-            {
-                label curLabel = vertexLabels[vI];
-
-                label nFound = 0;
-
-                forAll(vertexLabels, searchI)
-                {
-                    if (vertexLabels[searchI] == curLabel)
-                    {
-                        nFound++;
-                    }
-                }
-
-                if (nFound > 1)
-                {
-                    duplicatesFound = true;
-
-                    break;
-                }
-            }
-
-            if (duplicatesFound)
-            {
-                // this mesh cannot be described as a shapeMesh
-                isShapeMesh_ = false;
-
-                // I am not allowed to reset the shape pointer to unknown
-                // here as the shape is still needed to determine which face
-                // of the shape is used in potential couple matches.  This
-                // will be done in the end using the purgeShapes()
-                //
-
-                // create a new face without duplicates and replace original
-                face newFace(vertexLabels.size());
-
-                label nNewVertices = 0;
-
-                forAll(vertexLabels, vI)
-                {
-                    // In order for a face to be a valid entity, duplicate
-                    // vertices can only be consecutive (othervise, the
-                    // collapse creates an invalid face). We shall use this
-                    // property in the creation of the collapsed face
-
-                    label curLabel = vertexLabels[vI];
-
-                    bool found = false;
-
-                    // search through all vertices from the new face. If the
-                    // current label has not been added, add it to the end.
-                    for (label searchI = 0; searchI < nNewVertices; searchI++)
-                    {
-                        if (newFace[searchI] == curLabel)
-                        {
-                            found = true;
-
-                            break;
-                        }
-                    }
-
-                    if (!found)
-                    {
-                        newFace[nNewVertices] = curLabel;
-                        nNewVertices++;
-                    }
-                }
-
-                newFace.setSize(nNewVertices);
-
-                // If the number of non-duplicate labels in the face is less
-                // than three, the face has been collapsed in an invalid
-                // manner. Error.
-
-                if (nNewVertices < 3)
-                {
-                    FatalErrorInFunction
-                        << "face " << facei << " of cell " << celli
-                        << " is colapsed down to a point or edge, which is "
-                        << "not permitted" << endl
-                        << "original face: " << vertexLabels << endl
-                        << "purged face: " << newFace << endl
-                        << abort(FatalError);
-                }
-                else
-                {
-                    vertexLabels = newFace;
-                }
-            }
-        }
-    }
-}
-
-
-// ************************************************************************* //
diff --git a/applications/utilities/mesh/conversion/sammToFoam/purgeCellShapes.C b/applications/utilities/mesh/conversion/sammToFoam/purgeCellShapes.C
deleted file mode 100644
index 83b01bf72d..0000000000
--- a/applications/utilities/mesh/conversion/sammToFoam/purgeCellShapes.C
+++ /dev/null
@@ -1,66 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-Description
-    Purge cell shapes which have been rendered invalid by cell face collapse
-
-\*---------------------------------------------------------------------------*/
-
-#include "sammMesh.H"
-
-// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
-
-void Foam::sammMesh::purgeCellShapes()
-{
-    forAll(cellFaces_, celli)
-    {
-        const faceList& curFaces = cellFaces_[celli];
-
-        // Get model faces
-        faceList shapeFaces = cellShapes_[celli].faces();
-
-        forAll(shapeFaces, facei)
-        {
-            bool found = false;
-
-            forAll(curFaces, i)
-            {
-                if (shapeFaces[facei] == curFaces[i])
-                {
-                    found = true;
-                    break;
-                }
-            }
-
-            if (!found)
-            {
-                Info<< "Purging cell shape " << celli << endl;
-                cellShapes_[celli] = cellShape(*unknownPtr_, labelList(0));
-                break;
-            }
-        }
-    }
-}
-
-
-// ************************************************************************* //
diff --git a/applications/utilities/mesh/conversion/sammToFoam/readBoundary.C b/applications/utilities/mesh/conversion/sammToFoam/readBoundary.C
deleted file mode 100644
index 8502c312ae..0000000000
--- a/applications/utilities/mesh/conversion/sammToFoam/readBoundary.C
+++ /dev/null
@@ -1,258 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-Description
-    Create intermediate mesh files from SAMM files
-
-\*---------------------------------------------------------------------------*/
-
-#include "sammMesh.H"
-#include "Time.H"
-#include "wallPolyPatch.H"
-#include "oldCyclicPolyPatch.H"
-#include "symmetryPolyPatch.H"
-#include "preservePatchTypes.H"
-#include "IFstream.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-void Foam::sammMesh::readBoundary()
-{
-    label nPatches=0, nFaces=0;
-    labelList nPatchFaces(1000);
-
-    label lineIndex, sammLabel;
-    label sammRegion, configNumber;
-
-    labelList pointLabels(4);
-    labelList pointLabelsTri(3);
-
-    labelList patchLabels(1000, label(-1));
-
-    word patchType;
-    patchTypes_.setSize(1000);
-    patchNames_.setSize(1000);
-
-    fileName boundaryFileName(casePrefix_ + ".bnd");
-
-    {
-        IFstream boundaryFile(boundaryFileName);
-
-        // Collect no. of faces (nFaces),
-        // no. of patches (nPatches)
-        // and for each of these patches the number of faces
-        // (nPatchFaces[patchLabel])
-        // and a conversion table from Samm regions to (Foam) patchLabels
-
-        if (boundaryFile.good())
-        {
-            forAll(nPatchFaces, faceLabel)
-            {
-                nPatchFaces[faceLabel] = 0;
-            }
-
-            while ((boundaryFile >> lineIndex).good())
-            {
-                nFaces++;
-
-                // Skip point numbers
-                for (int i=0; i<4; i++)
-                {
-                    boundaryFile >> sammLabel;
-                }
-
-                boundaryFile >> sammRegion;
-                boundaryFile >> configNumber;
-                boundaryFile >> patchType;
-
-                // Build translation table to convert samm patch to foam patch
-                label patchLabel = patchLabels[sammRegion];
-                if (patchLabel == -1)
-                {
-                    patchLabel = nPatches;
-                    patchLabels[sammRegion] = patchLabel;
-                    patchTypes_[patchLabel] = patchType;
-                    patchNames_[patchLabel] = patchType + name(sammRegion);
-
-                    nPatches++;
-
-                    Info<< "Samm region " << sammRegion
-                        << " with type " << patchType
-                        << " is now Foam patch " << patchLabel << endl;
-
-                }
-
-                nPatchFaces[patchLabel]++;
-            }
-
-
-            Info<< nl
-                << "Setting size of shapePatchList to " << nPatches
-                << nl << endl;
-
-            nPatchFaces.setSize(nPatches);
-            patchTypes_.setSize(nPatches);
-            patchNames_.setSize(nPatches);
-        }
-        else
-        {
-            FatalErrorInFunction
-                << "Cannot read file "
-                << boundaryFileName
-                << abort(FatalError);
-        }
-    }
-
-    if (nPatches > 0)
-    {
-        boundary_.setSize(nPatchFaces.size());
-        patchTypes_.setSize(nPatchFaces.size());
-        patchNames_.setSize(nPatchFaces.size());
-
-        // size the lists and reset the counters to be used again
-        forAll(boundary_, patchLabel)
-        {
-            boundary_[patchLabel].setSize(nPatchFaces[patchLabel]);
-
-            nPatchFaces[patchLabel] = 0;
-        }
-
-        IFstream boundaryFile(boundaryFileName);
-
-        for (label facei=0; facei<nFaces; facei++)
-        {
-            boundaryFile >> lineIndex;
-
-            for (int i = 0; i < 4; i++)
-            {
-                boundaryFile >> sammLabel;
-
-                // convert Samm label to Foam point label
-                // through lookup-list starPointLabelLookup_
-                pointLabels[i] = starPointLabelLookup_[sammLabel];
-
-                if (pointLabels[i] < 0)
-                {
-                    Info<< "Boundary file not consistent with vertex file\n"
-                        << "Samm vertex number " << sammLabel
-                        << " does not exist\n";
-                }
-
-            }
-
-            boundaryFile >> sammRegion;
-            label patchLabel = patchLabels[sammRegion];
-
-            boundaryFile >> configNumber;
-            boundaryFile >> patchType;
-
-            if   // Triangle
-            (
-                pointLabels[2] == pointLabels[3]
-            )
-            {
-                //Info<< "Converting collapsed quad into triangle"
-                //    << " for face " << facei
-                //    << " in Samm boundary " << lineIndex << endl;
-
-                pointLabelsTri[0] = pointLabels[0];
-                pointLabelsTri[1] = pointLabels[1];
-                pointLabelsTri[2] = pointLabels[2];
-
-                boundary_[patchLabel][nPatchFaces[patchLabel]]
-                    = face(pointLabelsTri);
-            }
-            else
-            {
-                boundary_[patchLabel][nPatchFaces[patchLabel]]
-                    = face(pointLabels);
-            }
-
-            // increment counter of faces in current patch
-            nPatchFaces[patchLabel]++;
-        }
-
-        forAll(boundary_, patchLabel)
-        {
-            word patchType = patchTypes_[patchLabel];
-
-            if (patchType == "SYMP")
-            {
-                patchTypes_[patchLabel] = symmetryPolyPatch::typeName;
-            }
-            else if (patchType == "WALL")
-            {
-                patchTypes_[patchLabel] = wallPolyPatch::typeName;
-            }
-            else if (patchType == "CYCL")
-            {
-                // incorrect. should be cyclicPatch but this
-                // requires info on connected faces.
-                patchTypes_[patchLabel] = oldCyclicPolyPatch::typeName;
-            }
-            else
-            {
-                patchTypes_[patchLabel] = polyPatch::typeName;
-            }
-
-            Info<< "Foam patch " << patchLabel
-                << " is of type " << patchTypes_[patchLabel]
-                << " with name " << patchNames_[patchLabel] << endl;
-        }
-    }
-    else
-    {
-        FatalErrorInFunction
-            << "No boundary faces in file "
-            << boundaryFileName
-            << endl;
-    }
-
-    patchPhysicalTypes_.setSize(patchTypes_.size());
-
-    PtrList<dictionary> patchDicts;
-
-    preservePatchTypes
-    (
-        runTime_,
-        runTime_.constant(),
-        polyMesh::meshSubDir,
-        patchNames_,
-        patchDicts,
-        defaultFacesName_,
-        defaultFacesType_
-    );
-
-    forAll(patchDicts, patchi)
-    {
-        if (patchDicts.set(patchi))
-        {
-            const dictionary& dict = patchDicts[patchi];
-            dict.readIfPresent("type", patchTypes_[patchi]);
-            dict.readIfPresent("physicalType", patchPhysicalTypes_[patchi]);
-        }
-    }
-}
-
-
-// ************************************************************************* //
diff --git a/applications/utilities/mesh/conversion/sammToFoam/readCells.C b/applications/utilities/mesh/conversion/sammToFoam/readCells.C
deleted file mode 100644
index 355596b711..0000000000
--- a/applications/utilities/mesh/conversion/sammToFoam/readCells.C
+++ /dev/null
@@ -1,319 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-Description
-    Create intermediate mesh from SAMM files
-
-\*---------------------------------------------------------------------------*/
-
-#include "sammMesh.H"
-#include "IFstream.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-void Foam::sammMesh::addRegularCell
-(
-    const labelList& labels,
-    const label nCreatedCells
-)
-{
-    // Momory management
-    static labelList labelsHex(8);
-    static labelList labelsWedge(7);
-    static labelList labelsPrism(6);
-    static labelList labelsPyramid(5);
-    static labelList labelsTet(4);
-    static labelList labelsTetWedge(5);
-
-    if      // Tetrahedron
-    (
-        labels[2] == labels[3]
-     && labels[4] == labels[5]
-     && labels[5] == labels[6]
-     && labels[6] == labels[7]
-    )
-    {
-        labelsTet[0] = labels[0];
-        labelsTet[1] = labels[1];
-        labelsTet[2] = labels[2];
-        labelsTet[3] = labels[4];
-        cellShapes_[nCreatedCells] = cellShape(*tetPtr_, labelsTet);
-    }
-
-    else if // Square-based pyramid
-    (
-        labels[4] == labels[5]
-     && labels[5] == labels[6]
-     && labels[6] == labels[7]
-    )
-    {
-        labelsPyramid[0] = labels[0];
-        labelsPyramid[1] = labels[1];
-        labelsPyramid[2] = labels[2];
-        labelsPyramid[3] = labels[3];
-        labelsPyramid[4] = labels[4];
-        cellShapes_[nCreatedCells] = cellShape(*pyrPtr_, labelsPyramid);
-    }
-
-    else if // Tet Wedge
-    (
-        labels[2] == labels[3]
-     && labels[4] == labels[5]
-     && labels[6] == labels[7]
-    )
-    {
-        labelsTetWedge[0] = labels[0];
-        labelsTetWedge[1] = labels[1];
-        labelsTetWedge[2] = labels[2];
-        labelsTetWedge[3] = labels[4];
-        labelsTetWedge[4] = labels[6];
-        cellShapes_[nCreatedCells] = cellShape(*tetWedgePtr_, labelsTetWedge);
-    }
-
-    else if // Triangular prism
-    (
-        labels[2] == labels[3]
-     && labels[6] == labels[7]
-    )
-    {
-        labelsPrism[0] = labels[0];
-        labelsPrism[1] = labels[1];
-        labelsPrism[2] = labels[2];
-        labelsPrism[3] = labels[4];
-        labelsPrism[4] = labels[5];
-        labelsPrism[5] = labels[6];
-        cellShapes_[nCreatedCells] = cellShape(*prismPtr_, labelsPrism);
-    }
-
-    else if // Wedge
-    (
-        labels[4] == labels[7]
-    )
-    {
-        labelsWedge[0] = labels[7];
-        labelsWedge[1] = labels[6];
-        labelsWedge[2] = labels[5];
-        labelsWedge[3] = labels[3];
-        labelsWedge[4] = labels[2];
-        labelsWedge[5] = labels[1];
-        labelsWedge[6] = labels[0];
-        cellShapes_[nCreatedCells] = cellShape(*wedgePtr_, labelsWedge);
-    }
-
-    else    // Hex
-    {
-        labelsHex[0] = labels[0];
-        labelsHex[1] = labels[1];
-        labelsHex[2] = labels[2];
-        labelsHex[3] = labels[3];
-        labelsHex[4] = labels[4];
-        labelsHex[5] = labels[5];
-        labelsHex[6] = labels[6];
-        labelsHex[7] = labels[7];
-        cellShapes_[nCreatedCells] = cellShape(*hexPtr_, labelsHex);
-    }
-}
-
-
-void Foam::sammMesh::addSAMMcell
-(
-    const label typeFlag,
-    const labelList& globalLabels,
-    const label nCreatedCells
-)
-{
-
-    // grab the shape from the table
-    if (!sammShapeLookup[typeFlag] || !sammAddressingTable[typeFlag])
-    {
-        FatalErrorInFunction
-            << "SAMM type " << typeFlag << " has no registered label. BUG!"
-            << abort(FatalError);
-    }
-
-     const cellModel& curModel = *(sammShapeLookup[typeFlag]);
-
-    // get reference to the addressing list
-    const label* addressing = sammAddressingTable[typeFlag];
-
-    // make a list of labels
-    labelList sammCellLabels(curModel.nPoints(), -1);
-
-    forAll(sammCellLabels, labelI)
-    {
-        sammCellLabels[labelI] = globalLabels[addressing[labelI]];
-    }
-
-    cellShapes_[nCreatedCells] = cellShape(curModel, sammCellLabels);
-}
-
-
-void Foam::sammMesh::readCells()
-{
-    label nCells = 0;
-    label maxLabel = -1;
-
-    fileName cellsFileName(casePrefix_ + ".cel");
-
-    {
-        IFstream cellsFile(cellsFileName);
-
-        if (cellsFile.good())
-        {
-            label lineLabel, cellLabel = -1, pointLabel, regionLabel, typeFlag;
-
-            maxLabel = -1;
-            while (!(cellsFile >> lineLabel).eof())
-            {
-                maxLabel = max(maxLabel, lineLabel);
-                for (int i=0; i<8; i++)
-                {
-                    cellsFile >> pointLabel;
-                }
-
-                cellsFile >> regionLabel;
-                cellsFile >> typeFlag;
-
-                if (lineLabel != cellLabel)
-                {
-                    cellLabel = lineLabel;
-                    nCells++;
-                }
-            }
-        }
-        else
-        {
-            FatalErrorInFunction
-                << "Cannot read file "
-                << cellsFileName
-                << abort(FatalError);
-        }
-    }
-
-    Info<< "Number of cells = " << nCells << endl << endl;
-
-    cellShapes_.setSize(nCells);
-
-    starCellLabelLookup_.setSize(maxLabel+1);
-
-    // reset point labels to invalid value
-    forAll(starCellLabelLookup_, i)
-    {
-        starCellLabelLookup_[i] = -1;
-    }
-
-
-    if (nCells > 0)
-    {
-        IFstream cellsFile(cellsFileName);
-
-        labelList labels(24, label(-1));
-        label lineLabel, sammLabel, regionLabel, typeFlag;
-
-        for (label celli = 0; celli < nCells; celli++)
-        {
-            label nLabels = 0;
-
-            bool addOnToCell = false;
-
-            do
-            {
-                if (nLabels > 24)
-                {
-                    FatalErrorInFunction
-                        << "Unknown SAMM cell. "
-                        << "More than 24 vertices"
-                        << abort(FatalError);
-                }
-
-                if ((cellsFile >> lineLabel).eof())
-                {
-                    FatalErrorInFunction
-                        << "Reached end of cells file before "
-                        << "all cells are read in."
-                        << abort(FatalError);
-                }
-
-                // prepare for possible continuation
-                nLabels += 8;
-
-                for (int i=nLabels-8; i<nLabels; i++)
-                {
-                    cellsFile >> sammLabel;
-
-                    if (sammLabel != 0)
-                    {
-                        // Convert Samm vertex number to point label
-                        labels[i] = starPointLabelLookup_[sammLabel];
-
-                        if (labels[i] < 0)
-                        {
-                            Info<< "Cell file not consistent with vertex file. "
-                                << "Samm vertex number " << sammLabel
-                                << " does not exist\n";
-                        }
-                    }
-                    else
-                    {
-                        labels[i] = -1;
-                    }
-                }
-
-                cellsFile >> regionLabel;
-                cellsFile >> typeFlag;
-
-                // check for continuation line
-                if (!addOnToCell && typeFlag == 255)
-                {
-                    addOnToCell = true;
-                }
-                else
-                {
-                    addOnToCell = false;
-                }
-
-            } while (typeFlag == -1 || addOnToCell);
-
-            starCellLabelLookup_[lineLabel] = celli;
-
-            if (nLabels == 8)
-            {
-                addRegularCell(labels, celli);
-            }
-            else
-            {
-                addSAMMcell(typeFlag, labels, celli);
-            }
-        }
-    }
-    else
-    {
-        FatalErrorInFunction
-            << "No cells in file "
-            << cellsFileName
-            << abort(FatalError);
-    }
-}
-
-
-// ************************************************************************* //
diff --git a/applications/utilities/mesh/conversion/sammToFoam/readCouples.C b/applications/utilities/mesh/conversion/sammToFoam/readCouples.C
deleted file mode 100644
index 542aa7be31..0000000000
--- a/applications/utilities/mesh/conversion/sammToFoam/readCouples.C
+++ /dev/null
@@ -1,177 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-Description
-    Create intermediate mesh from SAMM files
-
-\*---------------------------------------------------------------------------*/
-
-#include "sammMesh.H"
-#include "IFstream.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-void Foam::sammMesh::readCouples()
-{
-    fileName couplesFileName(casePrefix_ + ".cpl");
-
-    IFstream couplesFile(couplesFileName);
-
-    if (couplesFile.good())
-    {
-        Info<< "\nReading couples" << endl;
-
-        // A mesh with couples cannot be a shape mesh
-        isShapeMesh_ = false;
-
-        label matchLabel, nEntries, typeFlag;
-        label masterCell, masterFace;
-        label slaveCell, slaveFace;
-
-        while (!(couplesFile >> matchLabel).eof())
-        {
-            // read number of entries and match type.
-            // Note. At the moment, only integral matches are supported
-            couplesFile >> nEntries;
-
-            couplesFile >> typeFlag;
-
-            if (typeFlag > 1)
-            {
-                Info
-                    << "void sammMesh::readCouples() : "
-                    << "couple " << matchLabel << " is not an integral match. "
-                    << "Currently not supported" << endl;
-            }
-
-            // read master cell and face
-            couplesFile >> masterCell >> masterFace;
-
-            // get reference to master cell faces
-            faceList& masterFaces = cellFaces_[masterCell - 1];
-
-//             Info<< "Master cell: " << masterCell - 1 << " index: "
-//                 << cellShapes_[masterCell - 1].model().index()
-//                 << " face: " <<
-//                 masterFaces
-//                 [
-//                     shapeFaceLookup
-//                        [cellShapes_[masterCell - 1].model().index()]
-//                        [masterFace]
-//                 ]
-//                 << endl;
-
-            // reset master face to zero size. It cannot be removed at this
-            // stage because thisw would mess up the numbering in case of
-            // more than one couple an a single master cell
-            masterFaces
-                [
-                    shapeFaceLookup
-                       [cellShapes_[masterCell - 1].model().index()]
-                       [masterFace]
-                ].setSize(0);
-
-            // number of slave faces
-            label nSlavesToRead = nEntries - 1;
-
-            // get index for slave face add
-            label slaveToAdd = masterFaces.size();
-
-            // reset size of master faces to accept new (couple) faces
-            masterFaces.setSize(masterFaces.size() + nSlavesToRead);
-
-            for (int i = 0; i < nSlavesToRead; i++)
-            {
-                couplesFile >> slaveCell >> slaveFace;
-
-                masterFaces[slaveToAdd] =
-                    cellFaces_
-                        [
-                            slaveCell - 1
-                        ]
-                        [
-                            shapeFaceLookup
-                                [cellShapes_[slaveCell - 1].model().index()]
-                                [slaveFace]
-                        ].reverseFace();
-
-//                 Info<< " slave cell: " << slaveCell - 1 << " index: "
-//                     << cellShapes_[slaveCell - 1].model().index()
-//                     << " face: " << masterFaces[slaveToAdd] << endl;
-
-                slaveToAdd++;
-
-            }
-//             Info<< endl;
-
-        }
-
-        // Once all couples are read, remove zero size faces from all cells
-        forAll(cellFaces_, celli)
-        {
-            faceList& curFaces = cellFaces_[celli];
-
-            label zeroSizeFound = 0;
-
-            forAll(curFaces, facei)
-            {
-                if (curFaces[facei].empty())
-                {
-                    zeroSizeFound++;
-                }
-            }
-
-            if (zeroSizeFound > 0)
-            {
-                // compress the list. A copy needs to made first
-                faceList oldFaces = curFaces;
-
-                curFaces.setSize(curFaces.size() - zeroSizeFound);
-
-                label nFaces = 0;
-
-                forAll(oldFaces, facei)
-                {
-                    if (oldFaces[facei].size())
-                    {
-                        curFaces[nFaces] = oldFaces[facei];
-
-                        nFaces++;
-                    }
-                }
-            }
-        }
-    }
-    else
-    {
-        Info
-            << "void sammMesh::readCouples() : "
-            << "Cannot read file "
-            << couplesFileName
-            << ". No matches defined."
-            << endl;
-        }
-}
-
-
-// ************************************************************************* //
diff --git a/applications/utilities/mesh/conversion/sammToFoam/readPoints.C b/applications/utilities/mesh/conversion/sammToFoam/readPoints.C
deleted file mode 100644
index 94bec96ce1..0000000000
--- a/applications/utilities/mesh/conversion/sammToFoam/readPoints.C
+++ /dev/null
@@ -1,34 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-Description
-    Create intermediate mesh from SAMM files
-
-\*---------------------------------------------------------------------------*/
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#define starMesh sammMesh
-#include "../star3ToFoam/readPoints.C"
-
-// ************************************************************************* //
diff --git a/applications/utilities/mesh/conversion/sammToFoam/sammMesh.C b/applications/utilities/mesh/conversion/sammToFoam/sammMesh.C
deleted file mode 100644
index 5b62de154a..0000000000
--- a/applications/utilities/mesh/conversion/sammToFoam/sammMesh.C
+++ /dev/null
@@ -1,220 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-\*---------------------------------------------------------------------------*/
-
-#include "sammMesh.H"
-#include "emptyPolyPatch.H"
-#include "demandDrivenData.H"
-#include "cellModeller.H"
-
-// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
-
-// Cell shape models
-const Foam::cellModel* Foam::sammMesh::unknownPtr_ =
-    Foam::cellModeller::lookup("unknown");
-const Foam::cellModel* Foam::sammMesh::hexPtr_ =
-    Foam::cellModeller::lookup("hex");
-const Foam::cellModel* Foam::sammMesh::wedgePtr_ =
-    Foam::cellModeller::lookup("wedge");
-const Foam::cellModel* Foam::sammMesh::prismPtr_ =
-    Foam::cellModeller::lookup("prism");
-const Foam::cellModel* Foam::sammMesh::pyrPtr_ =
-    Foam::cellModeller::lookup("pyr");
-const Foam::cellModel* Foam::sammMesh::tetPtr_ =
-    Foam::cellModeller::lookup("tet");
-const Foam::cellModel* Foam::sammMesh::tetWedgePtr_ =
-    Foam::cellModeller::lookup("tetWedge");
-
-const Foam::cellModel* Foam::sammMesh::sammTrim1Ptr_ =
-    Foam::cellModeller::lookup("sammTrim1");
-const Foam::cellModel* Foam::sammMesh::sammTrim2Ptr_ =
-    Foam::cellModeller::lookup("sammTrim2");
-const Foam::cellModel* Foam::sammMesh::sammTrim3Ptr_ =
-    Foam::cellModeller::lookup("sammTrim3");
-const Foam::cellModel* Foam::sammMesh::sammTrim4Ptr_ =
-    Foam::cellModeller::lookup("sammTrim4");
-const Foam::cellModel* Foam::sammMesh::sammTrim5Ptr_ =
-    Foam::cellModeller::lookup("sammTrim5");
-const Foam::cellModel* Foam::sammMesh::sammTrim8Ptr_ =
-    Foam::cellModeller::lookup("hexagonalPrism");
-
-// lookup table giving OpenFOAM face number when looked up with shape index
-// (first index) and STAR face number
-// - first column is always -1
-// - last column is -1 for all but hexagonal prism
-// WARNING: Possible bug for sammTrim2
-// There is a possibility that the lookup table for SAMM shapes is based on
-// the rotation of the shape. This would imply that the table below would need
-// to be split between the regular shapes (3-9), which are OK, and the SAMM
-// shapes, for which the face lookup needs to be done based on the rotation.
-// However, at the moment I haven't got enough info to complete the toble and
-// there are no cases that break it. Please reconsider in the light of mode
-// information.
-const Foam::label Foam::sammMesh::shapeFaceLookup[19][9] =
-{
-    {-1, -1, -1, -1, -1, -1, -1, -1, -1},    // shape  0 - empty+
-    {-1, -1, -1, -1, -1, -1, -1, -1, -1},    // shape  1 - empty+
-    {-1, -1, -1, -1, -1, -1, -1, -1, -1},    // shape  2 - empty+
-    {-1,  4,  5,  2,  3,  0,  1, -1, -1},    // shape  3 - hex+
-    {-1,  4,  5,  2,  3,  0,  1, -1, -1},    // shape  4 - wedge+
-    {-1,  0,  1,  4, -1,  2,  3, -1, -1},    // shape  5 - prism+
-    {-1,  0, -1,  4,  2,  1,  3, -1, -1},    // shape  6 - pyr+
-    {-1,  3, -1,  2, -1,  1,  0, -1, -1},    // shape  7 - tet+
-    {-1, -1, -1, -1, -1, -1, -1, -1, -1},    // shape  8 - splitHex (empty)
-    {-1,  0, -1,  1, -1,  2,  3, -1, -1},    // shape  9 - tetWedge+
-    {-1, -1, -1, -1, -1, -1, -1, -1, -1},    // shape 10 - empty+
-    {-1,  5,  4,  0,  1,  2,  3,  6, -1},    // shape 11 - sammTrim1+
-//    {-1,  1,  0,  2,  3,  4,  5,  6, -1},    // shape 12 - sammTrim2 ?
-    {-1, 1,  0,  2,  4,  3,  5,  6, -1},    // shape 12 - sammTrim2  f(4)=4
-    {-1,  5,  4,  0,  1,  2,  3,  6, -1},    // shape 13 - sammTrim3+
-    {-1,  5,  4,  1,  0,  3,  2,  6, -1},    // shape 14 - sammTrim4
-    {-1,  4,  3,  2,  5,  1,  0, -1, -1},    // shape 15 - sammTrim5
-    {-1, -1, -1, -1, -1, -1, -1, -1, -1},    // shape 16 - empty
-    {-1, -1, -1, -1, -1, -1, -1, -1, -1},    // shape 17 - empty
-    {-1,  0,  1,  2,  5,  3,  6,  4,  7}     // shape 18 - sammTrim8
-};
-
-// SAMM cell lookup data
-
-// List of pointers used instead of pointer list o avoid
-// de-allocation problems
-Foam::List<const Foam::cellModel*> Foam::sammMesh::sammShapeLookup
-(
-    256,
-    reinterpret_cast<cellModel*>(0)
-);
-
-Foam::List<const Foam::label*> Foam::sammMesh::sammAddressingTable
-(
-    256,
-    reinterpret_cast<label*>(0)
-);
-
-
-// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
-
-void Foam::sammMesh::createPolyMeshData()
-{
-    Info<< "Creating a polyMesh" << endl;
-
-    createPolyCells();
-
-    Info<< "\nNumber of internal faces: "
-        << nInternalFaces_ << endl;
-
-    createPolyBoundary();
-
-    label nProblemCells = 0;
-
-    // check that there is no zeros in the cellPolys_
-    forAll(cellPolys_, celli)
-    {
-        const labelList& curFaceLabels = cellPolys_[celli];
-
-        forAll(curFaceLabels, facei)
-        {
-            if (curFaceLabels[facei] == -1)
-            {
-                Info<< "cell " << celli
-                    << " has got an unmatched face. "
-                    << "Index: " << cellShapes_[celli].model().index() << endl
-//                     << "cell shape: " << cellShapes_[celli] << endl
-//                     << "shape faces: " << cellShapes_[celli].faces() << endl
-                    << "cellPolys: " << cellPolys_[celli] << endl
-//                     << "cell faces: " << cellFaces_[celli]
-                    << endl;
-
-                nProblemCells++;
-
-                break;
-            }
-        }
-    }
-
-    if (nProblemCells > 0)
-    {
-        Info<< "Number of problem cells: " << nProblemCells << endl;
-    }
-}
-
-
-// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
-
-Foam::sammMesh::sammMesh
-(
-    const fileName& prefix,
-    const Time& rt,
-    const scalar scaleFactor
-)
-:
-    casePrefix_(prefix),
-    runTime_(rt),
-    points_(0),
-    cellShapes_(0),
-    boundary_(0),
-    patchTypes_(0),
-    defaultFacesName_("defaultFaces"),
-    defaultFacesType_(emptyPolyPatch::typeName),
-    patchNames_(0),
-    patchPhysicalTypes_(0),
-    starPointLabelLookup_(0),
-    starCellLabelLookup_(0),
-    cellFaces_(0),
-    meshFaces_(0),
-    cellPolys_(0),
-    nInternalFaces_(0),
-    polyBoundaryPatchStartIndices_(0),
-    pointCellsPtr_(nullptr),
-    isShapeMesh_(true)
-{
-    // Fill in the lookup tables
-    fillSammCellShapeTable();
-    fillSammAddressingTable();
-
-    readPoints(scaleFactor);
-
-    readCells();
-
-    readBoundary();
-
-    fixCollapsedEdges();
-
-    readCouples();
-
-    // create boundary faces
-    createBoundaryFaces();
-
-    // after all this is done do couples
-}
-
-
-// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
-
-Foam::sammMesh::~sammMesh()
-{
-    deleteDemandDrivenData(pointCellsPtr_);
-}
-
-
-// ************************************************************************* //
diff --git a/applications/utilities/mesh/conversion/sammToFoam/sammMesh.H b/applications/utilities/mesh/conversion/sammToFoam/sammMesh.H
deleted file mode 100644
index a00ff8d7e9..0000000000
--- a/applications/utilities/mesh/conversion/sammToFoam/sammMesh.H
+++ /dev/null
@@ -1,253 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2015 OpenFOAM Foundation
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-Class
-    Foam::sammMesh
-
-Description
-    A messy mesh class which supports the possibility of creating a shapeMesh
-    for regular Samm meshes (no arbitrary interfaces or collapsed SAMM cells).
-    If any of these special feateres exist, the mesh is created as polyMesh
-
-SourceFiles
-    sammMesh.C
-
-\*---------------------------------------------------------------------------*/
-
-#ifndef sammMesh_H
-#define sammMesh_H
-
-#include "polyMesh.H"
-#include "cellShape.H"
-#include "cellList.H"
-#include "polyPatchList.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-namespace Foam
-{
-
-/*---------------------------------------------------------------------------*\
-                           Class sammMesh Declaration
-\*---------------------------------------------------------------------------*/
-
-class sammMesh
-{
-    // Private data
-
-        //- Name of the case
-        fileName casePrefix_;
-
-        //- Database
-        const Time& runTime_;
-
-        //- Points supporting the mesh
-        pointField points_;
-
-        //- Cell shapes
-        cellShapeList cellShapes_;
-
-        //- Boundary faces
-        faceListList boundary_;
-
-        //- Boundary patch types
-        wordList patchTypes_;
-
-        //- Default boundary patch name
-        word defaultFacesName_;
-
-        //- Default boundary patch types
-        word defaultFacesType_;
-
-        //- Boundary patch names
-        wordList patchNames_;
-
-        //- Boundary patch physical types
-        wordList patchPhysicalTypes_;
-
-        //- Point labels (SAMM point numbering is not necessarily contiguous)
-        labelList starPointLabelLookup_;
-
-        //- Point labels (SAMM point numbering is not necessarily contiguous)
-        labelList starCellLabelLookup_;
-
-        //- List of faces for every cell
-        faceListList cellFaces_;
-
-        //- Global face list for polyMesh
-        faceList meshFaces_;
-
-        //- Cells as polyhedra for polyMesh
-        cellList cellPolys_;
-
-        //- Number of internal faces for polyMesh
-        label nInternalFaces_;
-
-        //- Polyhedral mesh boundary patch start indices
-        labelList polyBoundaryPatchStartIndices_;
-
-        //- Point-cell addressing. Used for topological analysis
-        // Warning. This point cell addressing list potentially contains
-        // duplicate cell entries. Use additional checking
-        mutable labelListList* pointCellsPtr_;
-
-        //- Can the mesh be treated as a shapeMesh?
-        bool isShapeMesh_;
-
-    // Private static data members
-
-        //- Pointers to cell models
-        static const cellModel* unknownPtr_;
-        static const cellModel* hexPtr_;
-        static const cellModel* wedgePtr_;
-        static const cellModel* prismPtr_;
-        static const cellModel* pyrPtr_;
-        static const cellModel* tetPtr_;
-        static const cellModel* tetWedgePtr_;
-
-        static const cellModel* sammTrim1Ptr_;
-        static const cellModel* sammTrim2Ptr_;
-        static const cellModel* sammTrim3Ptr_;
-        static const cellModel* sammTrim4Ptr_;
-        static const cellModel* sammTrim5Ptr_;
-        static const cellModel* sammTrim8Ptr_;
-
-        static const label shapeFaceLookup[19][9];
-
-
-        //- SAMM addressing data
-        static List<const cellModel*> sammShapeLookup;
-        static List<const label*> sammAddressingTable;
-
-    // Private Member Functions
-
-        //- Disallow default bitwise copy construct
-        sammMesh(const sammMesh&);
-
-        //- Disallow default bitwise assignment
-        void operator=(const sammMesh&);
-
-
-        //- Fill SAMM lookup tables
-        void fillSammCellShapeTable();
-        void fillSammAddressingTable();
-
-
-        //- Read the points file
-        void readPoints(const scalar scaleFactor);
-
-
-        //- Read the cells file
-        void readCells();
-
-        void addRegularCell
-        (
-            const labelList& labels,
-            const label nCreatedCells
-        );
-
-        void addSAMMcell
-        (
-            const label typeFlag,
-            const labelList& globalLabels,
-            const label nCreatedCells
-        );
-
-
-        //- Read the boundary file
-        void readBoundary();
-
-
-        //- Check and correct collapsed edges on faces
-        // Note. If a collapsed edge is found, the mesh is no longer shapeMesh
-        void fixCollapsedEdges();
-
-        //- Read couples
-        void readCouples();
-
-        //- Calculate pointCells
-        void calcPointCells() const;
-
-        const labelListList& pointCells() const;
-
-        //- Create boundary faces from the quads
-        void createBoundaryFaces();
-
-        //- Specialist version of face comparison to deal with
-        // PROSTAR boundary format idiosyncracies
-        bool sammEqualFace
-        (
-            const face& boundaryFace,
-            const face& cellFace
-        ) const;
-
-        //- Purge cell shapes
-        void purgeCellShapes();
-
-        //- Make polyhedral cells and global faces if the mesh is polyhedral
-        void createPolyCells();
-
-        //- Make polyhedral boundary from shape boundary
-        // (adds more faces to the face list)
-        void createPolyBoundary();
-
-        //- Make polyhedral mesh data (packing)
-        void createPolyMeshData();
-
-        //- Add polyhedral boundary
-        List<polyPatch* > polyBoundaryPatches(const polyMesh&);
-
-
-public:
-
-    // Constructors
-
-        //- Construct from case name
-        sammMesh
-        (
-            const fileName& prefix,
-            const Time& rt,
-            const scalar scaleFactor
-        );
-
-
-    //- Destructor
-    ~sammMesh();
-
-
-    // Member Functions
-
-        //- Write mesh
-        void writeMesh();
-};
-
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#endif
-
-// ************************************************************************* //
diff --git a/applications/utilities/mesh/conversion/sammToFoam/sammToFoam.C b/applications/utilities/mesh/conversion/sammToFoam/sammToFoam.C
deleted file mode 100644
index 543b71cba3..0000000000
--- a/applications/utilities/mesh/conversion/sammToFoam/sammToFoam.C
+++ /dev/null
@@ -1,79 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2015 OpenFOAM Foundation
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-Application
-    sammToFoam
-
-Group
-    grpMeshConversionUtilities
-
-Description
-    Converts a Star-CD (v3) SAMM mesh to OpenFOAM format.
-
-\*---------------------------------------------------------------------------*/
-
-#include "argList.H"
-#include "Time.H"
-#include "sammMesh.H"
-
-using namespace Foam;
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-int main(int argc, char *argv[])
-{
-    argList::noParallel();
-    argList::validArgs.append("SAMM mesh file prefix");
-    argList::addOption
-    (
-        "scale",
-        "factor",
-        "geometry scaling factor - default is 1"
-    );
-
-    argList args(argc, argv);
-
-    if (!args.check())
-    {
-        FatalError.exit();
-    }
-
-    const scalar scaleFactor = args.optionLookupOrDefault("scale", 1.0);
-
-    #include "createTime.H"
-
-    sammMesh makeMesh(args[1], runTime, scaleFactor);
-
-    // Set the precision of the points data to 10
-    IOstream::defaultPrecision(max(10u, IOstream::defaultPrecision()));
-
-    Info<< "Writing mesh" << endl;
-    makeMesh.writeMesh();
-
-    Info<< "\nEnd\n" << endl;
-
-    return 0;
-}
-
-
-// ************************************************************************* //
diff --git a/applications/utilities/mesh/conversion/sammToFoam/starMesh.H b/applications/utilities/mesh/conversion/sammToFoam/starMesh.H
deleted file mode 100644
index 75e1c61b51..0000000000
--- a/applications/utilities/mesh/conversion/sammToFoam/starMesh.H
+++ /dev/null
@@ -1 +0,0 @@
-#include "sammMesh.H"
diff --git a/applications/utilities/mesh/conversion/sammToFoam/writeMesh.C b/applications/utilities/mesh/conversion/sammToFoam/writeMesh.C
deleted file mode 100644
index 0afee5e84a..0000000000
--- a/applications/utilities/mesh/conversion/sammToFoam/writeMesh.C
+++ /dev/null
@@ -1,91 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2015 OpenFOAM Foundation
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-Description
-    Create intermediate mesh files from SAMM files
-
-\*---------------------------------------------------------------------------*/
-
-#include "sammMesh.H"
-#include "Time.H"
-#include "polyMesh.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-void Foam::sammMesh::writeMesh()
-{
-    if (isShapeMesh_)
-    {
-        Info<< "This is a shapeMesh." << endl;
-
-        polyMesh pShapeMesh
-        (
-            IOobject
-            (
-                polyMesh::defaultRegion,
-                runTime_.constant(),
-                runTime_
-            ),
-            xferCopy(points_),           // we could probably re-use the data
-            cellShapes_,
-            boundary_,
-            patchNames_,
-            patchTypes_,
-            defaultFacesName_,
-            defaultFacesType_,
-            patchPhysicalTypes_
-        );
-
-        Info<< "Writing polyMesh" << endl;
-        pShapeMesh.write();
-    }
-    else
-    {
-        // This is a polyMesh.
-
-        createPolyMeshData();
-
-        Info<< "This is a polyMesh" << endl;
-
-        polyMesh pMesh
-        (
-            IOobject
-            (
-                polyMesh::defaultRegion,
-                runTime_.constant(),
-                runTime_
-            ),
-            xferCopy(points_),           // we could probably re-use the data
-            xferCopy(meshFaces_),
-            xferCopy(cellPolys_)
-        );
-
-        pMesh.addPatches(polyBoundaryPatches(pMesh));
-
-        Info<< "Writing polyMesh" << endl;
-        pMesh.write();
-    }
-}
-
-
-// ************************************************************************* //
diff --git a/applications/utilities/mesh/conversion/star3ToFoam/Make/files b/applications/utilities/mesh/conversion/star3ToFoam/Make/files
deleted file mode 100644
index c50cf188d6..0000000000
--- a/applications/utilities/mesh/conversion/star3ToFoam/Make/files
+++ /dev/null
@@ -1,19 +0,0 @@
-coupledFacePair.C
-starMesh.C
-readPoints.C
-/*readSeparatedPoints.C*/
-readCells.C
-readBoundary.C
-fixCollapsedEdges.C
-readCouples.C
-createCoupleMatches.C
-mergeCoupleFacePoints.C
-calcPointCells.C
-createPolyCells.C
-createBoundaryFaces.C
-createPolyBoundary.C
-purgeCellShapes.C
-writeMesh.C
-star3ToFoam.C
-
-EXE = $(FOAM_APPBIN)/star3ToFoam
diff --git a/applications/utilities/mesh/conversion/star3ToFoam/Make/options b/applications/utilities/mesh/conversion/star3ToFoam/Make/options
deleted file mode 100644
index 3dbc679a10..0000000000
--- a/applications/utilities/mesh/conversion/star3ToFoam/Make/options
+++ /dev/null
@@ -1,7 +0,0 @@
-EXE_INC = \
-    /* -DDEBUG_MERGE */ \
-    /* -DDEBUG_COUPLE */ \
-    /* -DDEBUG_COUPLE_INTERSECTION */ \
-    /* -DDEBUG_RIGHT_HAND_WALK */ \
-    /* -DDEBUG_FACE_ORDERING */ \
-    /* -DDEBUG_COUPLE_PROJECTION */
diff --git a/applications/utilities/mesh/conversion/star3ToFoam/calcPointCells.C b/applications/utilities/mesh/conversion/star3ToFoam/calcPointCells.C
deleted file mode 100644
index af9c763916..0000000000
--- a/applications/utilities/mesh/conversion/star3ToFoam/calcPointCells.C
+++ /dev/null
@@ -1,139 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-Description
-    Create intermediate mesh files from PROSTAR files
-
-\*---------------------------------------------------------------------------*/
-
-#include "starMesh.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-void Foam::starMesh::calcPointCells() const
-{
-    static const label UNIT_POINT_CELLS = 12;
-
-    if (pointCellsPtr_)
-    {
-        FatalErrorInFunction
-            << "pointCells already calculated"
-            << abort(FatalError);
-    }
-
-
-    pointCellsPtr_ = new labelListList(points_.size());
-
-    labelListList& pc = *pointCellsPtr_;
-
-    forAll(pc, i)
-    {
-        pc[i].setSize(UNIT_POINT_CELLS);
-    }
-
-    // Initialise the list of labels which will hold the count the
-    // actual number of cells per point during the analysis
-    labelList cellCount(points_.size());
-
-    forAll(cellCount, i)
-    {
-        cellCount[i] = 0;
-    }
-
-    // Note. Unlike the standard point-cell algorithm, which asks the cell for
-    // the supporting point labels, we need to work based on the cell faces.
-    // This is because some of the faces for meshes with arbitrary interfaces
-    // do not come from the cell shape, but from the slaves of the coupled
-    // match. It is also adventageous to remove the duplicates from the
-    // point-cell addressing, because this removes a lot of waste later.
-    //
-
-    // For each cell
-    forAll(cellShapes_, celli)
-    {
-        const faceList& faces = cellFaces_[celli];
-
-        forAll(faces, i)
-        {
-            // For each vertex
-            const labelList& labels = faces[i];
-
-            forAll(labels, j)
-            {
-                // Set working point label
-                label curPoint = labels[j];
-                labelList& curPointCells = pc[curPoint];
-                label curCount = cellCount[curPoint];
-
-                // check if the cell has been added before
-                bool found = false;
-
-                for (label f = 0; f < curCount; f++)
-                {
-                    if (curPointCells[f] == celli)
-                    {
-                        found = true;
-
-                        break;
-                    }
-                }
-
-                if (!found)
-                {
-
-                    // If the list of pointCells is not big enough, double it
-                    if (curPointCells.size() <= curCount)
-                    {
-                        curPointCells.setSize(curPointCells.size()*2);
-                    }
-
-                    // Enter the cell label in the point's cell list
-                    curPointCells[curCount] = celli;
-
-                    // Increment the cell count for the point addressed
-                    cellCount[curPoint]++;
-                }
-            }
-        }
-    }
-
-    // Finally, truncate the lists made to their active size
-    forAll(pc, i)
-    {
-        pc[i].setSize(cellCount[i]);
-    }
-}
-
-
-const Foam::labelListList& Foam::starMesh::pointCells() const
-{
-    if (!pointCellsPtr_)
-    {
-        calcPointCells();
-    }
-
-    return *pointCellsPtr_;
-}
-
-
-// ************************************************************************* //
diff --git a/applications/utilities/mesh/conversion/star3ToFoam/coupledFacePair.C b/applications/utilities/mesh/conversion/star3ToFoam/coupledFacePair.C
deleted file mode 100644
index 73490bd38d..0000000000
--- a/applications/utilities/mesh/conversion/star3ToFoam/coupledFacePair.C
+++ /dev/null
@@ -1,66 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2015 OpenFOAM Foundation
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-Description
-    Data associated with a pair of coupled faces.
-    1 represents integral match; all other number are arbitrary matches
-
-\*---------------------------------------------------------------------------*/
-
-#include "coupledFacePair.H"
-#include "IOstreams.H"
-
-// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
-
-Foam::coupledFacePair::coupledFacePair
-(
-    const label coupleNo,
-    const label mC, const label mF,
-    const label sC, const label sF,
-    const label integral
-)
-:
-    coupleID_(coupleNo),
-    masterCellID_(mC),
-    masterFaceID_(mF),
-    slaveCellID_(sC),
-    slaveFaceID_(sF),
-    integralMatch_(integral == 1)
-{}
-
-
-// * * * * * * * * * * * * * * * Friend Operators  * * * * * * * * * * * * * //
-
-Foam::Ostream& Foam::operator<<(Ostream& os, const coupledFacePair& c)
-{
-    os  << "Master cell: " << c.masterCellID_
-        << " face: " << c.masterFaceID_ << endl
-        << "Slave cell: " << c.slaveCellID_
-        << " face: " << c.slaveFaceID_ << endl
-        << "Integral: " << c.integralMatch_ << endl;
-
-    return os;
-}
-
-
-// ************************************************************************* //
diff --git a/applications/utilities/mesh/conversion/star3ToFoam/coupledFacePair.H b/applications/utilities/mesh/conversion/star3ToFoam/coupledFacePair.H
deleted file mode 100644
index 52597ff7db..0000000000
--- a/applications/utilities/mesh/conversion/star3ToFoam/coupledFacePair.H
+++ /dev/null
@@ -1,146 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-Class
-    Foam::coupledFacePair
-
-Description
-    Data associated with a pair of coupled faces
-
-SourceFiles
-    coupledFacePair.C
-
-\*---------------------------------------------------------------------------*/
-
-#ifndef coupledFacePair_H
-#define coupledFacePair_H
-
-#include "label.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-namespace Foam
-{
-
-// Forward declaration of friend functions and operators
-
-class coupledFacePair;
-
-Ostream& operator<<(Ostream&, const coupledFacePair&);
-
-
-/*---------------------------------------------------------------------------*\
-                           Class coupledFacePair Declaration
-\*---------------------------------------------------------------------------*/
-
-class coupledFacePair
-{
-    // Private data
-
-        //- STAR couple ID
-        label coupleID_;
-
-        //- Master cell (lower cell label)
-        label masterCellID_;
-
-        //- Master face (lower cell label)
-        label masterFaceID_;
-
-        //- Slave cell (higher cell label)
-        label slaveCellID_;
-
-        //- Slave face (higher cell label)
-        label slaveFaceID_;
-
-        //- Integral or arbitrary flag
-        bool integralMatch_;
-
-
-public:
-
-
-    // Constructors
-
-        //- Construct from components
-        coupledFacePair
-        (
-            const label coupleNo,              // STAR couple ID
-            const label mC, const label mF,    // master cell and face
-            const label sC, const label sF,    // slave cell and face
-            const label integral
-        );
-
-
-    // Member Functions
-
-        //- Return STAR couple ID
-        label coupleID() const
-        {
-            return coupleID_;
-        }
-
-        //- Return master cell
-        label masterCell() const
-        {
-            return masterCellID_;
-        }
-
-        //- Return master face
-        label masterFace() const
-        {
-            return masterFaceID_;
-        }
-
-        //- Return slave cell
-        label slaveCell() const
-        {
-            return slaveCellID_;
-        }
-
-        //- Return slave face
-        label slaveFace() const
-        {
-            return slaveFaceID_;
-        }
-
-        //- Is this an integral match?
-        bool integralMatch() const
-        {
-            return integralMatch_;
-        }
-
-    // IOstream Operators
-
-        friend Ostream& operator<<(Ostream&, const coupledFacePair&);
-};
-
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#endif
-
-// ************************************************************************* //
diff --git a/applications/utilities/mesh/conversion/star3ToFoam/createBoundaryFaces.C b/applications/utilities/mesh/conversion/star3ToFoam/createBoundaryFaces.C
deleted file mode 100644
index 0bff685546..0000000000
--- a/applications/utilities/mesh/conversion/star3ToFoam/createBoundaryFaces.C
+++ /dev/null
@@ -1,201 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-Description
-    Create intermediate mesh files from PROSTAR files
-
-\*---------------------------------------------------------------------------*/
-
-#include "starMesh.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-// Specialist version of face comparison to deal with
-// PROSTAR boundary format idiosyncracies
-bool Foam::starMesh::starEqualFace
-(
-    const face& boundaryFace,
-    const face& cellFace
-) const
-{
-    // A PROSTAR boundary face is defined by 4 vertices irrespective
-    // of its topology.
-    // In order to deal with all possibilities, cell face is
-    // considered equal if three of the vertices are the same.
-    bool cellFaceHappy = false;
-
-    label nEqual = 0;
-
-    forAll(cellFace, cellFaceLabelI)
-    {
-        const label curCellFaceLabel = cellFace[cellFaceLabelI];
-
-        forAll(boundaryFace, bouFaceLabelI)
-        {
-            if (boundaryFace[bouFaceLabelI] == curCellFaceLabel)
-            {
-                nEqual++;
-
-                break;
-            }
-        }
-    }
-
-    if (nEqual >= 3)
-    {
-        cellFaceHappy = true;
-    }
-
-    // Boundary face is happy if all of its vertices are recognised
-    bool boundaryFaceHappy = true;
-
-    forAll(boundaryFace, bouFaceLabelI)
-    {
-        const label curBouFaceLabel = boundaryFace[bouFaceLabelI];
-
-        bool found = false;
-
-        forAll(cellFace, cellFaceLabelI)
-        {
-            if (curBouFaceLabel == cellFace[cellFaceLabelI])
-            {
-                found = true;
-                break;
-            }
-        }
-
-        boundaryFaceHappy = boundaryFaceHappy && found;
-    }
-
-    return (cellFaceHappy && boundaryFaceHappy);
-}
-
-
-void Foam::starMesh::markBoundaryFaces()
-{
-    // set size of mark lists for the boundary
-    boundaryCellIDs_.setSize(boundary_.size());
-    boundaryCellFaceIDs_.setSize(boundary_.size());
-
-    forAll(boundary_, patchi)
-    {
-        const faceList& patchFaces = boundary_[patchi];
-
-        // set size of patch lists
-        labelList& curBoundaryCellIDs = boundaryCellIDs_[patchi];
-        labelList& curBoundaryCellFaceIDs = boundaryCellFaceIDs_[patchi];
-
-        curBoundaryCellIDs.setSize(patchFaces.size());
-        curBoundaryCellFaceIDs.setSize(patchFaces.size());
-
-        const labelListList& PointCells = pointCells();
-
-        forAll(patchFaces, facei)
-        {
-            bool found = false;
-
-            const face& curFace = patchFaces[facei];
-            const labelList& facePoints = curFace;
-
-            forAll(facePoints, pointi)
-            {
-                const labelList& facePointCells =
-                    PointCells[facePoints[pointi]];
-
-                forAll(facePointCells, celli)
-                {
-                    const label curCellIndex = facePointCells[celli];
-
-                    const faceList& curCellFaces =
-                        cellFaces_[curCellIndex];
-
-                    forAll(curCellFaces, cellFacei)
-                    {
-                        if (starEqualFace(curFace, curCellFaces[cellFacei]))
-                        {
-                            // Found the cell face corresponding to this face
-                            found = true;
-
-                            // Set boundary face to the corresponding cell face
-                            curBoundaryCellIDs[facei] = curCellIndex;
-                            curBoundaryCellFaceIDs[facei] = cellFacei;
-                        }
-                        if (found) break;
-                    }
-                    if (found) break;
-                }
-                if (found) break;
-            }
-            if (!found)
-            {
-                FatalErrorInFunction
-                    << "Face " << facei
-                    << " does not have neighbour cell."
-                    << " Face : " << endl << curFace << endl
-                    << "PROSTAR Command: vset,news,vlis";
-
-                forAll(curFace, spI)
-                {
-                    if (curFace[spI] > -1 && curFace[spI] < starPointID_.size())
-                    {
-                        Info<< "," << starPointID_[curFace[spI]];
-                    }
-                    else
-                    {
-                        Info<< ",???";
-                    }
-                }
-
-                FatalError
-                    << " $ bset,add,vset,all"
-                    << abort(FatalError);
-            }
-        }
-    }
-}
-
-
-void Foam::starMesh::collectBoundaryFaces()
-{
-    Info<< "Collecting boundary faces" << endl;
-    forAll(boundary_, patchi)
-    {
-        faceList& patchFaces = boundary_[patchi];
-
-        // set size of patch lists
-        const labelList& curBoundaryCellIDs = boundaryCellIDs_[patchi];
-        const labelList& curBoundaryCellFaceIDs = boundaryCellFaceIDs_[patchi];
-
-        forAll(curBoundaryCellIDs, facei)
-        {
-            patchFaces[facei] =
-                cellFaces_[curBoundaryCellIDs[facei]]
-                    [curBoundaryCellFaceIDs[facei]];
-        }
-    }
-
-    Info<< "Finished collecting boundary faces" << endl;
-}
-
-
-// ************************************************************************* //
diff --git a/applications/utilities/mesh/conversion/star3ToFoam/createCoupleMatches.C b/applications/utilities/mesh/conversion/star3ToFoam/createCoupleMatches.C
deleted file mode 100644
index cfb77ef050..0000000000
--- a/applications/utilities/mesh/conversion/star3ToFoam/createCoupleMatches.C
+++ /dev/null
@@ -1,1508 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-Description
-    Create coupled match faces and add them to the cells
-
-\*---------------------------------------------------------------------------*/
-
-#include "starMesh.H"
-#include "boolList.H"
-#include "pointHit.H"
-#include "IOmanip.H"
-#include "boundBox.H"
-#include "Map.H"
-#include "unitConversion.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-void Foam::starMesh::createCoupleMatches()
-{
-    // Loop through all couples and create intersection faces. Add all points
-    // of intersection faces to the couple points lists. The numbering of
-    // the list is set such that the list can be appended to the
-    // existing points list
-
-    // Estimate the number of cells affected by couple matches
-    const label cellMapSize = min
-    (
-        cellShapes_.size()/10,
-        couples_.size()*2
-    );
-
-    // Store newly created faces for each cell
-    Map<SLList<face>> cellAddedFaces(cellMapSize);
-
-    Map<SLList<label>> cellRemovedFaces(cellMapSize);
-
-    // In order to remove often allocation, remember the number of live points.
-    // If you run out of space in point creation, increase it by the number of
-    // couples (good scale) and resize at the end;
-    label nLivePoints = points_.size();
-
-    const label infoJump = max(1000, couples_.size()/20);
-
-    forAll(couples_, coupleI)
-    {
-        if (coupleI % infoJump == 0)
-        {
-            Info<< "Doing couple " << coupleI << ". STAR couple ID: "
-                << couples_[coupleI].coupleID() << endl;
-        }
-
-        // Initialise cell edges for master and slave cells
-        const coupledFacePair& fp = couples_[coupleI];
-        const face& masterFace = cellFaces_[fp.masterCell()][fp.masterFace()];
-        const face& slaveFace = cellFaces_[fp.slaveCell()][fp.slaveFace()];
-
-        #ifdef DEBUG_COUPLE
-        Info<< "coupleI: " << coupleI << endl
-            << "masterFace: " << masterFace << endl
-            << "master points: " << masterFace.points(points_) << endl
-            << "slaveFace: " << slaveFace << endl
-            << "slave points: " << slaveFace.points(points_)
-            << endl << endl;
-        #endif
-
-        // check the angle of face area vectors
-         scalar faceAreaAngle =
-             mag
-             (
-                 -(masterFace.normal(points_) & slaveFace.normal(points_))/
-                 (masterFace.mag(points_)*slaveFace.mag(points_) + VSMALL)
-             );
-
-         if (faceAreaAngle < 0.94)
-         {
-             Info<< "Couple direction mismatch in the couple match "
-                 << coupleI << ". STAR couple ID: "
-                 << couples_[coupleI].coupleID() << endl
-                 << "The angle between face normals is "
-                 << radToDeg(Foam::acos(faceAreaAngle))
-                 << " deg." << endl
-                 << "master cell: " << fp.masterCell()
-                 << " STAR number: " << starCellID_[fp.masterCell()]
-                 << " type: " << cellShapes_[fp.masterCell()].model().name()
-                 << " face: " << fp.masterFace() << endl
-                 << "slave cell : " << fp.slaveCell()
-                 << " STAR number: " << starCellID_[fp.slaveCell()]
-                 << " type: " << cellShapes_[fp.slaveCell()].model().name()
-                 << " face: " << fp.slaveFace() << endl;
-         }
-
-        // Deal with integral patches
-        if (fp.integralMatch())
-        {
-            // Master face is replaced by a set of slave faces
-
-            Map<SLList<label>>::iterator crfIter =
-                cellRemovedFaces.find(fp.masterCell());
-
-            if (crfIter == cellRemovedFaces.end())
-            {
-                cellRemovedFaces.insert
-                (
-                    fp.masterCell(),
-                    SLList<label>(fp.masterFace())
-                );
-            }
-            else
-            {
-                crfIter().append(fp.masterFace());
-            }
-
-            Map<SLList<face>>::iterator cafIter =
-                cellAddedFaces.find(fp.masterCell());
-            if (cafIter == cellAddedFaces.end())
-            {
-                cellAddedFaces.insert
-                (
-                    fp.masterCell(),
-                    SLList<face>(slaveFace.reverseFace())
-                );
-            }
-            else
-            {
-                cafIter().append(slaveFace.reverseFace());
-            }
-        }
-        else
-        {
-            // Create cut faces, which replace both master and slave faces
-
-            // Store newly created points
-            SLList<point> coupleFacePoints;
-
-            // Master data
-            edgeList masterEdges = masterFace.edges();
-            List<SLList<label>> masterEdgePoints(masterEdges.size());
-
-            // Slave data
-            edgeList slaveEdges = slaveFace.edges();
-            List<SLList<label>> slaveEdgePoints(slaveEdges.size());
-
-            // Find common plane
-            vector n = masterFace.normal(points_);
-            n /= mag(n) + VSMALL;
-
-            // Loop through all edges of the master face. For every edge,
-            // intersect it with all edges of the cutting face.
-            forAll(masterEdges, masterEdgeI)
-            {
-                const edge& curMasterEdge = masterEdges[masterEdgeI];
-
-                point P = points_[curMasterEdge.start()];
-
-                // get d and return it into plane
-                vector d = curMasterEdge.vec(points_);
-                d -= n*(n & d);
-
-                #ifdef DEBUG_COUPLE_INTERSECTION
-                Info<< "curMasterEdge: " << curMasterEdge << endl
-                    << "P: " << P << endl << "d: " << d << endl;
-                #endif
-
-                // go through all slave edges and try to get an intersection.
-                // The point is created along the original master edge rather
-                // than its corrected direction.
-                forAll(slaveEdges, slaveEdgeI)
-                {
-                    const edge& curSlaveEdge = slaveEdges[slaveEdgeI];
-
-                    point S = points_[curSlaveEdge.start()];
-
-                    // get e and return it into plane
-                    vector e = curSlaveEdge.vec(points_);
-                    e -= n*(n & e);
-                    scalar det = -(e & (n ^ d));
-
-                    #ifdef DEBUG_COUPLE_INTERSECTION
-                    Info<< "curSlaveEdge: " << curSlaveEdge << endl
-                        << "S: " << S << endl
-                        << "e: " << e << endl;
-                    #endif
-
-                    if (mag(det) > SMALL)
-                    {
-                        // non-singular matrix. Look for intersection
-                        scalar beta = ((S - P) & (n ^ d))/det;
-
-                        #ifdef DEBUG_COUPLE_INTERSECTION
-                        Info<< " beta: " << beta << endl;
-                        #endif
-
-                        if (beta > -smallMergeTol_ && beta < 1 + smallMergeTol_)
-                        {
-                            // slave intersection OK. Try master intersection
-                            scalar alpha =
-                                (((S - P) & d) + beta*(d & e))/magSqr(d);
-
-                            #ifdef DEBUG_COUPLE_INTERSECTION
-                            Info<< " alpha: " << alpha << endl;
-                            #endif
-
-                            if
-                            (
-                                alpha > -smallMergeTol_
-                             && alpha < 1 + smallMergeTol_
-                            )
-                            {
-                                // intersection of non-parallel edges
-                                #ifdef DEBUG_COUPLE_INTERSECTION
-                                Info<< "intersection of non-parallel edges"
-                                    << endl;
-                                #endif
-
-
-                                // check for insertion of start-end
-                                // points in the middle of the other
-                                // edge
-                                if (alpha < smallMergeTol_)
-                                {
-                                    // inserting the start of master edge
-                                    if
-                                    (
-                                        beta > smallMergeTol_
-                                     && beta < 1 - smallMergeTol_
-                                    )
-                                    {
-                                        slaveEdgePoints[slaveEdgeI].append
-                                        (
-                                            curMasterEdge.start()
-                                        );
-                                    }
-                                }
-                                else if (alpha > 1 - smallMergeTol_)
-                                {
-                                    // inserting the end of master edge
-                                    if
-                                    (
-                                        beta > smallMergeTol_
-                                     && beta < 1 - smallMergeTol_
-                                    )
-                                    {
-                                        slaveEdgePoints[slaveEdgeI].append
-                                        (
-                                            curMasterEdge.end()
-                                        );
-                                    }
-                                }
-                                else if (beta < smallMergeTol_)
-                                {
-                                    // inserting the start of the slave edge
-                                    if
-                                    (
-                                        alpha > smallMergeTol_
-                                     && alpha < 1 - smallMergeTol_
-                                    )
-                                    {
-                                        masterEdgePoints[masterEdgeI].append
-                                        (
-                                            curSlaveEdge.start()
-                                        );
-                                    }
-                                }
-                                else if (beta > 1 - smallMergeTol_)
-                                {
-                                    // inserting the start of the slave edge
-                                    if
-                                    (
-                                        alpha > smallMergeTol_
-                                     && alpha < 1 - smallMergeTol_
-                                    )
-                                    {
-                                        masterEdgePoints[masterEdgeI].append
-                                        (
-                                            curSlaveEdge.end()
-                                        );
-                                    }
-                                }
-                                else
-                                {
-                                    masterEdgePoints[masterEdgeI].append
-                                    (
-                                        nLivePoints + coupleFacePoints.size()
-                                    );
-
-                                    slaveEdgePoints[slaveEdgeI].append
-                                    (
-                                        nLivePoints + coupleFacePoints.size()
-                                    );
-
-                                    #ifdef DEBUG_COUPLE_INTERSECTION
-                                    Info<< "regular intersection. "
-                                        << "Adding point: "
-                                        << coupleFacePoints.size()
-                                        << " which is "
-                                        << P + alpha*curMasterEdge.vec(points_)
-                                        << endl;
-                                    #endif
-
-                                    // A new point is created. Warning:
-                                    // using original edge for accuracy.
-                                    //
-                                    coupleFacePoints.append
-                                        (P + alpha*curMasterEdge.vec(points_));
-                                }
-                            }
-                        }
-                    }
-                    else
-                    {
-                        // Add special cases, for intersection of two
-                        // parallel line Warning. Here, typically, no new
-                        // points will be created. Either one or two of
-                        // the slave edge points need to be added to the
-                        // master edge and vice versa. The problem is that
-                        // no symmetry exists, i.e. both operations needs
-                        // to be done separately for both master and slave
-                        // side.
-
-                        // Master side
-                        // check if the first or second point of slave edge is
-                        // on the master edge
-                        vector ps = S - P;
-
-                        bool colinear = false;
-
-                        if (mag(ps) < SMALL)
-                        {
-                            // colinear because P and S are the same point
-                            colinear = true;
-                        }
-                        else if
-                        (
-                            (ps & d)/(mag(ps)*mag(d)) > 1.0 - smallMergeTol_
-                        )
-                        {
-                            // colinear because ps and d are parallel
-                            colinear = true;
-                        }
-
-                        if (colinear)
-                        {
-                            scalar alpha1 = (ps & d)/magSqr(d);
-
-                            if
-                            (
-                                alpha1 > -smallMergeTol_
-                             && alpha1 < 1 + smallMergeTol_
-                            )
-                            {
-                                #ifdef DEBUG_COUPLE_INTERSECTION
-                                Info<< "adding irregular master "
-                                    << "intersection1: "
-                                    << points_[slaveEdges[slaveEdgeI].start()]
-                                    << endl;
-                                #endif
-
-                                masterEdgePoints[masterEdgeI].append
-                                (
-                                    slaveEdges[slaveEdgeI].start()
-                                );
-                            }
-
-                             scalar alpha2 = ((ps + e) & d)/magSqr(d);
-
-                            if
-                            (
-                                alpha2 > -smallMergeTol_
-                             && alpha2 < 1 + smallMergeTol_
-                            )
-                            {
-                                #ifdef DEBUG_COUPLE_INTERSECTION
-                                Info<< "adding irregular master "
-                                    << "intersection2: "
-                                    << points_[slaveEdges[slaveEdgeI].end()]
-                                    << endl;
-                                #endif
-
-                                masterEdgePoints[masterEdgeI].append
-                                (
-                                    slaveEdges[slaveEdgeI].end()
-                                );
-                            }
-
-                            // Slave side
-                            // check if the first or second point of
-                            // master edge is on the slave edge
-
-                            vector sp = P - S;
-
-                            scalar beta1 = (sp & e)/magSqr(e);
-
-                            #ifdef DEBUG_COUPLE_INTERSECTION
-                            Info<< "P: " << P << " S: " << S << " d: " << d
-                                << " e: " << e << " sp: " << sp
-                                << " beta1: " << beta1 << endl;
-                            #endif
-
-                            if
-                            (
-                                beta1 > -smallMergeTol_
-                             && beta1 < 1 + smallMergeTol_
-                            )
-                            {
-                                #ifdef DEBUG_COUPLE_INTERSECTION
-                                Info<< "adding irregular slave "
-                                    << "intersection1: "
-                                    << points_[masterEdges[masterEdgeI].start()]
-                                    << endl;
-                                #endif
-
-                                slaveEdgePoints[slaveEdgeI].append
-                                (
-                                    masterEdges[masterEdgeI].start()
-                                );
-                            }
-
-                            scalar beta2 = ((sp + d) & e)/magSqr(e);
-
-                            if
-                            (
-                                beta2 > -smallMergeTol_
-                             && beta2 < 1 + smallMergeTol_
-                            )
-                            {
-                                #ifdef DEBUG_COUPLE_INTERSECTION
-                                Info<< "adding irregular slave "
-                                    << "intersection2: "
-                                    << points_[masterEdges[masterEdgeI].end()]
-                                    << endl;
-                                #endif
-
-                                slaveEdgePoints[slaveEdgeI].append
-                                (
-                                    masterEdges[masterEdgeI].end()
-                                );
-                            }
-                        } // end of colinear
-                    } // end of singular intersection
-                } // end of slave edges
-            } // end of master edges
-
-            #ifdef DEBUG_COUPLE_INTERSECTION
-            Info<< "additional slave edge points: " << endl;
-            forAll(slaveEdgePoints, edgeI)
-            {
-                Info<< "edge: " << edgeI << ": " << slaveEdgePoints[edgeI]
-                    << endl;
-            }
-            #endif
-
-            // Add new points
-            if (nLivePoints + coupleFacePoints.size() >= points_.size())
-            {
-                // increase the size of the points list
-                Info<< "Resizing points list" << endl;
-                points_.setSize(points_.size() + couples_.size());
-            }
-
-            for
-            (
-                SLList<point>::iterator coupleFacePointsIter =
-                    coupleFacePoints.begin();
-                coupleFacePointsIter != coupleFacePoints.end();
-                ++coupleFacePointsIter
-            )
-            {
-                points_[nLivePoints] = coupleFacePointsIter();
-                nLivePoints++;
-            }
-
-            // edge intersection finished
-
-            // Creating new master side
-
-            // count the number of additional points for face
-            label nAdditionalMasterPoints = 0;
-
-            forAll(masterEdgePoints, edgeI)
-            {
-                nAdditionalMasterPoints += masterEdgePoints[edgeI].size();
-            }
-
-            face tmpMasterFace
-            (
-                masterFace.size()
-              + nAdditionalMasterPoints
-            );
-            label nTmpMasterLabels = 0;
-
-            #ifdef DEBUG_COUPLE_INTERSECTION
-            Info<< "masterFace: " << masterFace << endl
-                << "nAdditionalMasterPoints: " << nAdditionalMasterPoints
-                << endl;
-            #endif
-
-            forAll(masterEdges, masterEdgeI)
-            {
-                // Insert the starting point of the edge
-                tmpMasterFace[nTmpMasterLabels] =
-                    masterEdges[masterEdgeI].start();
-                nTmpMasterLabels++;
-
-                // get reference to added points of current edge
-                const SLList<label>& curMEdgePoints =
-                    masterEdgePoints[masterEdgeI];
-
-                // create a markup list of points that have been used
-                boolList usedMasterPoint(curMEdgePoints.size(), false);
-
-                vector edgeVector = masterEdges[masterEdgeI].vec(points_);
-
-                #ifdef DEBUG_FACE_ORDERING
-                Info<< "edgeVector: " << edgeVector << endl
-                    << "curMEdgePoints.size(): " << curMEdgePoints.size()
-                    << endl;
-                #endif
-
-                // renormalise
-                edgeVector /= magSqr(edgeVector);
-
-                point edgeStartPoint =
-                    points_[masterEdges[masterEdgeI].start()];
-
-                // loop until the next label to add is -1
-                for (;;)
-                {
-                    label nextPointLabel = -1;
-                    label usedI = -1;
-                    scalar minAlpha = GREAT;
-
-                    label i = 0;
-
-                    for
-                    (
-                        SLList<label>::const_iterator curMEdgePointsIter =
-                            curMEdgePoints.begin();
-                        curMEdgePointsIter != curMEdgePoints.end();
-                        ++curMEdgePointsIter
-                    )
-                    {
-                        if (!usedMasterPoint[i])
-                        {
-                            scalar alpha =
-                                edgeVector
-                              & (
-                                    points_[curMEdgePointsIter()]
-                                  - edgeStartPoint
-                                );
-
-                            #ifdef DEBUG_FACE_ORDERING
-                            Info<< " edgeStartPoint: " << edgeStartPoint
-                                << " edgeEndPoint: "
-                                << points_[masterEdges[masterEdgeI].end()]
-                                << " other point: "
-                                << points_[curMEdgePointsIter()]
-                                << " alpha: " << alpha << endl;
-                            #endif
-
-                            if (alpha < minAlpha)
-                            {
-                                minAlpha = alpha;
-                                usedI = i;
-                                nextPointLabel = curMEdgePointsIter();
-                            }
-                        }
-
-                        #ifdef DEBUG_FACE_ORDERING
-                        Info<< "nextPointLabel: " << nextPointLabel << endl;
-                        #endif
-
-                        i++;
-                    }
-
-                    if (nextPointLabel > -1)
-                    {
-                        #ifdef DEBUG_FACE_ORDERING
-                        Info<< "added nextPointLabel: " << nextPointLabel
-                            << " nTmpMasterLabels: " << nTmpMasterLabels
-                            << " to place " << nTmpMasterLabels << endl;
-                        #endif
-
-                        usedMasterPoint[usedI] = true;
-                        // add the next point
-                        tmpMasterFace[nTmpMasterLabels] =
-                            nextPointLabel;
-                        nTmpMasterLabels++;
-                    }
-                    else
-                    {
-                        break;
-                    }
-                }
-            }
-
-            // reset the size of master
-            tmpMasterFace.setSize(nTmpMasterLabels);
-
-            #ifdef DEBUG_FACE_ORDERING
-            Info<< "tmpMasterFace: " << tmpMasterFace << endl;
-            #endif
-
-            // Eliminate all zero-length edges
-            face newMasterFace(labelList(tmpMasterFace.size(), labelMax));
-
-            // insert first point by hand. Careful: the first one is
-            // used for comparison to allow the edge collapse across
-            // point zero.
-            //
-            newMasterFace[0] = tmpMasterFace[0];
-            label nMaster = 0;
-
-            edgeList mstEdgesToCollapse = tmpMasterFace.edges();
-
-            scalar masterTol =
-                cpMergePointTol_*boundBox(tmpMasterFace.points(points_)).mag();
-
-            forAll(mstEdgesToCollapse, edgeI)
-            {
-                #ifdef DEBUG_FACE_ORDERING
-                Info<< "edgeI: " << edgeI << " curEdge: "
-                    << mstEdgesToCollapse[edgeI] << endl
-                    << "master edge " << edgeI << ", "
-                    << mstEdgesToCollapse[edgeI].mag(points_) << endl;
-                #endif
-
-                // Edge merge tolerance = masterTol
-                if (mstEdgesToCollapse[edgeI].mag(points_) < masterTol)
-                {
-                    newMasterFace[nMaster] =
-                        min
-                        (
-                            newMasterFace[nMaster],
-                            mstEdgesToCollapse[edgeI].end()
-                        );
-
-                    #ifdef DEBUG_FACE_ORDERING
-                    Info<< "Collapsed: nMaster: " << nMaster
-                        << " label: " << newMasterFace[nMaster] << endl;
-                    #endif
-
-                }
-                else
-                {
-                    nMaster++;
-
-                    if (edgeI < mstEdgesToCollapse.size() - 1)
-                    {
-                        // last edge does not add the point
-                    #ifdef DEBUG_FACE_ORDERING
-                        Info<< "Added: nMaster: " << nMaster
-                            << " label: " << mstEdgesToCollapse[edgeI].end()
-                            << endl;
-                    #endif
-
-                        newMasterFace[nMaster] =
-                            mstEdgesToCollapse[edgeI].end();
-                    }
-                }
-            }
-
-            newMasterFace.setSize(nMaster);
-
-            #ifdef DEBUG_COUPLE
-            Info<< "newMasterFace: " << newMasterFace << endl
-                << "points: " << newMasterFace.points(points_) << endl;
-            #endif
-
-            // Creating new slave side
-
-            // count the number of additional points for face
-            label nAdditionalSlavePoints = 0;
-
-            forAll(slaveEdgePoints, edgeI)
-            {
-                nAdditionalSlavePoints += slaveEdgePoints[edgeI].size();
-            }
-
-            face tmpSlaveFace
-            (
-                slaveFace.size()
-              + nAdditionalSlavePoints
-            );
-            label nTmpSlaveLabels = 0;
-
-            #ifdef DEBUG_COUPLE_INTERSECTION
-            Info<< "slaveFace: " << slaveFace << endl
-                << "nAdditionalSlavePoints: " << nAdditionalSlavePoints << endl;
-            #endif
-
-            forAll(slaveEdges, slaveEdgeI)
-            {
-                // Insert the starting point of the edge
-                tmpSlaveFace[nTmpSlaveLabels] =
-                    slaveEdges[slaveEdgeI].start();
-                nTmpSlaveLabels++;
-
-                // get reference to added points of current edge
-                const SLList<label>& curSEdgePoints =
-                    slaveEdgePoints[slaveEdgeI];
-
-                // create a markup list of points that have been used
-                boolList usedSlavePoint(curSEdgePoints.size(), false);
-
-                vector edgeVector = slaveEdges[slaveEdgeI].vec(points_);
-
-                #ifdef DEBUG_FACE_ORDERING
-                Info<< "curSEdgePoints.size(): "
-                    << curSEdgePoints.size() << endl
-                    << "edgeVector: " << edgeVector << endl;
-                #endif
-
-                // renormalise
-                edgeVector /= magSqr(edgeVector);
-
-                point edgeStartPoint =
-                    points_[slaveEdges[slaveEdgeI].start()];
-
-                // loop until the next label to add is -1
-                for (;;)
-                {
-                    label nextPointLabel = -1;
-                    label usedI = -1;
-                    scalar minAlpha = GREAT;
-
-                    label i = 0;
-
-                    for
-                    (
-                        SLList<label>::const_iterator curSEdgePointsIter =
-                            curSEdgePoints.begin();
-                        curSEdgePointsIter != curSEdgePoints.end();
-                        ++curSEdgePointsIter
-                    )
-                    {
-                        if (!usedSlavePoint[i])
-                        {
-                            scalar alpha =
-                                edgeVector
-                              & (
-                                    points_[curSEdgePointsIter()]
-                                  - edgeStartPoint
-                                );
-
-                            #ifdef DEBUG_FACE_ORDERING
-                            Info<< " edgeStartPoint: " << edgeStartPoint
-                                << " edgeEndPoint: "
-                                << points_[slaveEdges[slaveEdgeI].end()]
-                                << " other point: "
-                                << points_[curSEdgePointsIter()]
-                                << " alpha: " << alpha << endl;
-                            #endif
-
-                            if (alpha < minAlpha)
-                            {
-                                minAlpha = alpha;
-                                usedI = i;
-                                nextPointLabel = curSEdgePointsIter();
-                            }
-                        }
-
-                        #ifdef DEBUG_FACE_ORDERING
-                        Info<< "nextPointLabel: " << nextPointLabel << endl;
-                        #endif
-
-                        i++;
-                    }
-
-                    if (nextPointLabel > -1)
-                    {
-                        #ifdef DEBUG_FACE_ORDERING
-                        Info<< "added nextPointLabel: " << nextPointLabel
-                            << " nTmpSlaveLabels: " << nTmpSlaveLabels
-                            << " to place " << nTmpSlaveLabels << endl;
-                        #endif
-
-                        usedSlavePoint[usedI] = true;
-                        // add the next point
-                        tmpSlaveFace[nTmpSlaveLabels] =
-                            nextPointLabel;
-                        nTmpSlaveLabels++;
-                    }
-                    else
-                    {
-                        break;
-                    }
-                }
-            }
-
-            // reset the size of slave
-            tmpSlaveFace.setSize(nTmpSlaveLabels);
-
-            #ifdef DEBUG_FACE_ORDERING
-            Info<< "tmpSlaveFace: " << tmpSlaveFace << endl;
-            #endif
-
-            // Eliminate all zero-length edges
-            face newSlaveFace(labelList(tmpSlaveFace.size(), labelMax));
-
-            // insert first point by hand. Careful: the first one is
-            // used for comparison to allow the edge collapse across
-            // point zero.
-            //
-            newSlaveFace[0] = tmpSlaveFace[0];
-            label nSlave = 0;
-
-            edgeList slvEdgesToCollapse = tmpSlaveFace.edges();
-
-            scalar slaveTol =
-                cpMergePointTol_*boundBox(tmpSlaveFace.points(points_)).mag();
-
-            forAll(slvEdgesToCollapse, edgeI)
-            {
-                #ifdef DEBUG_FACE_ORDERING
-                Info<< "slave edge length: " << edgeI << ", "
-                    << slvEdgesToCollapse[edgeI].mag(points_)<< endl;
-                #endif
-
-                 // edge merge tolerance = slaveTol
-                if (slvEdgesToCollapse[edgeI].mag(points_) < slaveTol)
-                {
-                    newSlaveFace[nSlave] =
-                        min
-                        (
-                            newSlaveFace[nSlave],
-                            slvEdgesToCollapse[edgeI].end()
-                        );
-                }
-                else
-                {
-                    nSlave++;
-                    if (edgeI < slvEdgesToCollapse.size() - 1)
-                    {
-                        // last edge does not add the point
-                        newSlaveFace[nSlave] = slvEdgesToCollapse[edgeI].end();
-                    }
-                }
-            }
-
-            newSlaveFace.setSize(nSlave);
-
-            #ifdef DEBUG_COUPLE
-            Info<< "newSlaveFace: " << newSlaveFace << endl
-                << "points: " << newSlaveFace.points(points_) << endl << endl;
-            #endif
-
-            // Create the intersection face
-
-            // Algorithm:
-            // Loop through
-            // points of the master and try to find one which falls
-            // within the slave.  If not found, look through all
-            // edges of the slave and find one which falls within the
-            // master.  This point will be the starting location for
-            // the cut face.
-
-            edgeList newMasterEdges = newMasterFace.edges();
-            edgeList newSlaveEdges = newSlaveFace.edges();
-
-            #ifdef DEBUG_RIGHT_HAND_WALK
-            Info<< "newMasterEdges: " << newMasterEdges << endl
-                << "newSlaveEdges: " << newSlaveEdges << endl;
-            #endif
-
-            edge startEdge(-1, -1);
-
-            // Remember where the start edge was found:
-            // 0 for not found
-            // 1 for master
-            // 2 for slave
-            label startEdgeFound = 0;
-
-            vector masterProjDir = -newMasterFace.normal(points_);
-
-            forAll(newSlaveEdges, edgeI)
-            {
-                // Take the slave edge points and project into the master.
-                // In order to create a good intersection, move the
-                // point away from the master in the direction of its
-                // normal.
-                point pointStart = points_[newSlaveEdges[edgeI].start()];
-
-                point pointEnd = points_[newSlaveEdges[edgeI].end()];
-
-                if
-                (
-                    newMasterFace.ray
-                    (
-                        pointStart,
-                        masterProjDir,
-                        points_,
-                        intersection::FULL_RAY
-                    ).hit()
-                 && newMasterFace.ray
-                    (
-                        pointEnd,
-                        masterProjDir,
-                        points_,
-                        intersection::FULL_RAY
-                    ).hit()
-                )
-                {
-                    startEdge = newSlaveEdges[edgeI];
-                    startEdgeFound = 2;
-
-                    #ifdef DEBUG_RIGHT_HAND_WALK
-                    Info<< "slave edge found" << endl;
-                    #endif
-
-                    break;
-                }
-            }
-
-            if (startEdgeFound == 0)
-            {
-                vector slaveProjDir = -newSlaveFace.normal(points_);
-
-                forAll(newMasterEdges, edgeI)
-                {
-                    // Take the edge master points and project into the slave.
-                    // In order to create a good intersection, move the
-                    // point away from the slave in the direction of its
-                    // normal.
-                    point pointStart = points_[newMasterEdges[edgeI].start()];
-
-                    point pointEnd = points_[newMasterEdges[edgeI].end()];
-
-                    if
-                    (
-                        newSlaveFace.ray
-                        (
-                            pointStart,
-                            slaveProjDir,
-                            points_,
-                        intersection::FULL_RAY
-                        ).hit()
-                     && newSlaveFace.ray
-                        (
-                            pointEnd,
-                            slaveProjDir,
-                            points_,
-                            intersection::FULL_RAY
-                        ).hit()
-                    )
-                    {
-                        startEdge = newMasterEdges[edgeI];
-                        startEdgeFound = 1;
-
-                        #ifdef DEBUG_RIGHT_HAND_WALK
-                        Info<< "master edge found" << endl;
-                        #endif
-
-                        break;
-                    }
-                }
-            }
-
-            // create the intersected face using right-hand walk rule
-            face intersectedFace
-            (
-                labelList(newMasterFace.size() + newSlaveFace.size(), -1)
-            );
-
-            if (startEdgeFound > 0)
-            {
-                #ifdef DEBUG_RIGHT_HAND_WALK
-                Info<< "start edge: " << startEdge << endl;
-                #endif
-
-                // Loop through both faces and add all edges
-                // containing the current point and add them to the
-                // list of edges to consider.  Make sure all edges are
-                // added such that the current point is their start.
-                // Loop through all edges to consider and find the one
-                // which produces the buggest right-hand-turn.  This
-                // is the next edge to be added to the face.  If its
-                // end is the same as the starting point, the face is
-                // complete; resize it to the number of active points
-                // and exit.
-
-                vector planeNormal = newMasterFace.normal(points_);
-                planeNormal /= mag(planeNormal) + VSMALL;
-
-                #ifdef DEBUG_RIGHT_HAND_WALK
-                Info<< "planeNormal: " << planeNormal << endl;
-                #endif
-
-                // Do a check to control the right-hand turn.  This is
-                // based on the triple product of the edge start
-                // vector to face centre, the edge vector and the
-                // plane normal.  If the triple product is negative,
-                // the edge needs to be reversed to allow the
-                // right-hand-turn rule to work.
-
-                vector faceCentre;
-
-                if (startEdgeFound == 1)
-                {
-                    faceCentre = newMasterFace.centre(points_);
-                }
-                else
-                {
-                    faceCentre = newSlaveFace.centre(points_);
-                }
-
-                scalar tripleProduct =
-                    (
-                        (faceCentre - points_[startEdge.start()])
-                      ^ startEdge.vec(points_)
-                    ) & planeNormal;
-
-                if (tripleProduct < 0)
-                {
-                    #ifdef DEBUG_RIGHT_HAND_WALK
-                    Info<< "Turning edge for right-hand turn rule" << endl;
-                    #endif
-                    startEdge.flip();
-                }
-
-                // prepare the loop for the right-hand walk
-                intersectedFace[0] = startEdge.start();
-                intersectedFace[1] = startEdge.end();
-                label nIntFacePoints = 2;
-
-                edge curEdge = startEdge;
-
-                bool completedFace = false;
-
-                do
-                {
-                    SLList<edge> edgesToConsider;
-
-                    // collect master edges
-                    forAll(newMasterEdges, edgeI)
-                    {
-                        const edge& cme = newMasterEdges[edgeI];
-
-                        if (cme != curEdge)
-                        {
-                            if (cme.start() == curEdge.end())
-                            {
-                                edgesToConsider.append(cme);
-                            }
-                            else if (cme.end() == curEdge.end())
-                            {
-                                edgesToConsider.append(cme.reverseEdge());
-                            }
-                            // otherwise, it does not have the current point
-                        }
-                    }
-
-                    // collect slave edges
-                    forAll(newSlaveEdges, edgeI)
-                    {
-                        const edge& cse = newSlaveEdges[edgeI];
-
-                        if (cse != curEdge)
-                        {
-                            if (cse.start() == curEdge.end())
-                            {
-                                edgesToConsider.append(cse);
-                            }
-                            else if (cse.end() == curEdge.end())
-                            {
-                                edgesToConsider.append(cse.reverseEdge());
-                            }
-                            // otherwise, it does not have the current point
-                        }
-                    }
-
-                    #ifdef DEBUG_RIGHT_HAND_WALK
-                    Info<< "number of edges to consider: "
-                        << edgesToConsider.size() << endl
-                        << "edges to consider: " << edgesToConsider << endl;
-                    #endif
-
-                    if (edgesToConsider.empty())
-                    {
-                        FatalErrorInFunction
-                            << setprecision(12)
-                            << "void starMesh::createCoupleMatches() : "
-                            << endl << "error in face intersection: "
-                            << "no edges to consider for closing the loop"
-                            << coupleI << ". STAR couple ID: "
-                            << couples_[coupleI].coupleID() << endl
-                            << "Cut Master Face: " << newMasterFace << endl
-                            << "points: " << newMasterFace.points(points_)
-                            << endl
-                            << "Cut Slave Face: " << newSlaveFace << endl
-                            << "points: " << newSlaveFace.points(points_)
-                            << endl << "intersected face: "
-                            << intersectedFace
-                            << abort(FatalError);
-                    }
-
-                    // vector along the edge
-                    vector ahead = curEdge.vec(points_);
-                    ahead -= planeNormal*(planeNormal & ahead);
-                    ahead /= mag(ahead) + VSMALL;
-
-                    // vector pointing right
-                    vector right = ahead ^ planeNormal;
-                    right /= mag(right) + VSMALL;
-
-                    // first edge taken for reference
-                    edge nextEdge = edgesToConsider.first();
-                    vector nextEdgeVec = nextEdge.vec(points_);
-                    nextEdgeVec -= planeNormal*(planeNormal & nextEdgeVec);
-                    nextEdgeVec /= mag(nextEdgeVec) + VSMALL;
-
-                    scalar rightTurn = nextEdgeVec & right;
-                    scalar goStraight = nextEdgeVec & ahead;
-
-                    #ifdef DEBUG_RIGHT_HAND_WALK
-                    Info<< "rightTurn: " << rightTurn
-                        << " goStraight: " << goStraight << endl;
-                    #endif
-
-                    for
-                    (
-                        SLList<edge>::iterator etcIter =
-                            edgesToConsider.begin();
-                        etcIter != edgesToConsider.end();
-                        ++etcIter
-                    )
-                    {
-                        // right-hand walk rule
-                        vector newDir = etcIter().vec(points_);
-                        newDir -= planeNormal*(planeNormal & newDir);
-                        newDir /= mag(newDir) + VSMALL;
-
-                        scalar curRightTurn = newDir & right;
-                        scalar curGoStraight = newDir & ahead;
-
-                        #ifdef DEBUG_RIGHT_HAND_WALK
-                        Info<< "curRightTurn: " << curRightTurn
-                            << " curGoStraight: " << curGoStraight << endl;
-                        #endif
-
-                        if (rightTurn < 0) // old edge turning left
-                        {
-                            if (curRightTurn < 0) // new edge turning left
-                            {
-                                // both go left. Grab one with greater ahead
-                                if (curGoStraight > goStraight)
-                                {
-                                    #ifdef DEBUG_RIGHT_HAND_WALK
-                                    Info<< "a" << endl;
-                                    #endif
-
-                                    // Good edge, turning left less than before
-                                    nextEdge = etcIter();
-                                    rightTurn = curRightTurn;
-                                    goStraight = curGoStraight;
-                                }
-                            }
-                            else // new edge turning right
-                            {
-                                #ifdef DEBUG_RIGHT_HAND_WALK
-                                Info<< "b" << endl;
-                                #endif
-
-                                // good edge, turning right
-                                nextEdge = etcIter();
-                                rightTurn = curRightTurn;
-                                goStraight = curGoStraight;
-                            }
-                        }
-                        else // old edge turning right
-                        {
-                            // new edge turning left rejected
-                            if (curRightTurn >= 0) // new edge turning right
-                            {
-                                // grab one with smaller ahead
-                                if (curGoStraight < goStraight)
-                                {
-                                    #ifdef DEBUG_RIGHT_HAND_WALK
-                                    Info<< "c" << endl;
-                                    #endif
-
-                                    // good edge, turning right more than before
-                                    nextEdge = etcIter();
-                                    rightTurn = curRightTurn;
-                                    goStraight = curGoStraight;
-                                }
-                            }
-                        }
-                    }
-
-                    // check if the loop is completed
-                    if (nextEdge.end() == intersectedFace[0])
-                    {
-                        // loop is completed. No point to add
-                        completedFace = true;
-                    }
-                    else
-                    {
-                        // Check if there is room for more points
-                        if (nIntFacePoints >= intersectedFace.size())
-                        {
-                            FatalErrorInFunction
-                                << setprecision(12)
-                                << "void starMesh::createCoupleMatches() : "
-                                << endl << "error in intersected face: "
-                                << "lost thread for intersection of couple "
-                                << coupleI << ". STAR couple ID: "
-                                << couples_[coupleI].coupleID() << endl
-                                << "Cut Master Face: " << newMasterFace << endl
-                                << "points: " << newMasterFace.points(points_)
-                                << endl
-                                << "Cut Slave Face: " << newSlaveFace << endl
-                                << "points: " << newSlaveFace.points(points_)
-                                << endl << "intersected face: "
-                                << intersectedFace
-                                << abort(FatalError);
-                        }
-
-                        // insert the point
-                        intersectedFace[nIntFacePoints] = nextEdge.end();
-                        nIntFacePoints++;
-
-                        // grab the current point and the current edge
-                        curEdge = nextEdge;
-
-                        #ifdef DEBUG_RIGHT_HAND_WALK
-                        Info<< "inserted point " << nextEdge.end() << endl
-                            << "curEdge: " << curEdge << endl;
-                        #endif
-                    }
-                }
-                while (!completedFace);
-
-                // resize the face
-                intersectedFace.setSize(nIntFacePoints);
-
-                #ifdef DEBUG_COUPLE
-                Info<< "intersectedFace: " << intersectedFace << endl;
-                #endif
-
-                // check the intersection face for duplicate points
-                forAll(intersectedFace, checkI)
-                {
-                    for
-                    (
-                        label checkJ = checkI + 1;
-                        checkJ < intersectedFace.size();
-                        checkJ++
-                    )
-                    {
-                        if (intersectedFace[checkI] == intersectedFace[checkJ])
-                        {
-                            FatalErrorInFunction
-                                << setprecision(12)
-                                << "void starMesh::createCoupleMatches() : "
-                                << endl << "error in intersected face: "
-                                << "duplicate point in intersected face "
-                                << "for couple no " << coupleI
-                                << ". STAR couple ID: "
-                                << couples_[coupleI].coupleID() << endl
-                                << "Duplicate point label: "
-                                << intersectedFace[checkI] << endl
-                                << "Cut Master Face: " << newMasterFace << endl
-                                << "points: " << newMasterFace.points(points_)
-                                << endl
-                                << "Cut Slave Face: " << newSlaveFace << endl
-                                << "points: " << newSlaveFace.points(points_)
-                                << endl << "intersected face: "
-                                << intersectedFace
-                                << abort(FatalError);
-                        }
-                    }
-                }
-            }
-            else
-            {
-                FatalErrorInFunction
-                    << setprecision(12)
-                    << "void starMesh::createCoupleMatches() : " << endl
-                    << "could not find start edge for intersection of couple "
-                    << coupleI << ". STAR couple ID: "
-                    << couples_[coupleI].coupleID() << endl
-                    << "Cut Master Face: " << newMasterFace << endl
-                    << "points: " << newMasterFace.points(points_) << endl
-                    << "Cut Slave Face: " << newSlaveFace << endl
-                    << "points: " << newSlaveFace.points(points_)
-                    << abort(FatalError);
-            }
-
-            // Project all points of the intersected face
-            // onto the master face to ensure closedness
-            vector pointProjectionNormal = -masterFace.normal(points_);
-
-            forAll(intersectedFace, intPointi)
-            {
-                #ifdef DEBUG_COUPLE_PROJECTION
-                Info<< "Proj: old point: "
-                    << points_[intersectedFace[intPointi]] << endl;
-                #endif
-
-                pointHit projHit =
-                    masterFace.ray
-                    (
-                        points_[intersectedFace[intPointi]],
-                        pointProjectionNormal,
-                        points_,
-                        intersection::FULL_RAY
-                    );
-
-                if (projHit.hit())
-                {
-                    points_[intersectedFace[intPointi]] =
-                        projHit.hitPoint();
-
-                    #ifdef DEBUG_COUPLE_PROJECTION
-                    Info<< "      new point: "
-                        << points_[intersectedFace[intPointi]] << endl;
-                    #endif
-                }
-            }
-
-            // Check the direction of the intersection face
-            if
-            (
-                (
-                    masterFace.normal(points_)
-                  & intersectedFace.normal(points_)
-                ) < VSMALL
-            )
-            {
-                intersectedFace.flip();
-            }
-
-            // Add the new face to both master and slave
-
-            // Master face is replaced by a set of slave faces
-            Map<SLList<label>>::iterator crfMasterIter =
-                cellRemovedFaces.find(fp.masterCell());
-
-            if (crfMasterIter == cellRemovedFaces.end())
-            {
-                cellRemovedFaces.insert
-                (
-                    fp.masterCell(),
-                    SLList<label>(fp.masterFace())
-                );
-            }
-            else
-            {
-                crfMasterIter().append(fp.masterFace());
-            }
-
-            Map<SLList<label>>::iterator crfSlaveIter =
-                cellRemovedFaces.find(fp.slaveCell());
-
-            if (crfSlaveIter == cellRemovedFaces.end())
-            {
-                cellRemovedFaces.insert
-                (
-                    fp.slaveCell(),
-                    SLList<label>(fp.slaveFace())
-                );
-            }
-            else
-            {
-                crfSlaveIter().append(fp.slaveFace());
-            }
-
-            Map<SLList<face>>::iterator cafMasterIter =
-                cellAddedFaces.find(fp.masterCell());
-            if (cafMasterIter == cellAddedFaces.end())
-            {
-                cellAddedFaces.insert
-                (
-                    fp.masterCell(),
-                    SLList<face>(intersectedFace)
-                );
-            }
-            else
-            {
-                cafMasterIter().append(intersectedFace);
-            }
-
-            Map<SLList<face>>::iterator cafSlaveIter =
-                cellAddedFaces.find(fp.slaveCell());
-            if (cafSlaveIter == cellAddedFaces.end())
-            {
-                cellAddedFaces.insert
-                (
-                    fp.slaveCell(),
-                    SLList<face>(intersectedFace.reverseFace())
-                );
-            }
-            else
-            {
-                cafSlaveIter().append(intersectedFace.reverseFace());
-            }
-        } // end of arbitrary match
-    }
-
-    if (couples_.size())
-    {
-        // Loop through all cells and reset faces for removal to zero size
-        const labelList crfToc = cellRemovedFaces.toc();
-
-        forAll(crfToc, celli)
-        {
-            const label curCell = crfToc[celli];
-
-            const SLList<label>& curRemovedFaces = cellRemovedFaces[curCell];
-
-            for
-            (
-                SLList<label>::const_iterator curRemovedFacesIter =
-                    curRemovedFaces.begin();
-                curRemovedFacesIter != curRemovedFaces.end();
-                ++curRemovedFacesIter
-            )
-            {
-                cellFaces_[curCell][curRemovedFacesIter()].setSize(0);
-            }
-
-            if (curRemovedFaces.size())
-            {
-                // reset the shape pointer to unknown
-                cellShapes_[curCell] = cellShape(*unknownPtr_, labelList(0));
-            }
-        }
-
-        const labelList cafToc = cellAddedFaces.toc();
-
-        // Insert the new faces into the list
-        forAll(cafToc, celli)
-        {
-            const label curCell = cafToc[celli];
-
-            const SLList<face>& curAddedFaces = cellAddedFaces[curCell];
-
-            faceList oldFaces = cellFaces_[curCell];
-
-            faceList& newFaces = cellFaces_[curCell];
-
-            newFaces.setSize(oldFaces.size() + curAddedFaces.size());
-            label nNewFaces = 0;
-
-            // copy original faces that have not been removed
-            forAll(oldFaces, facei)
-            {
-                if (oldFaces[facei].size())
-                {
-                    newFaces[nNewFaces] = oldFaces[facei];
-                    nNewFaces++;
-                }
-            }
-
-            // add new faces
-            for
-            (
-                SLList<face>::const_iterator curAddedFacesIter =
-                    curAddedFaces.begin();
-                curAddedFacesIter != curAddedFaces.end();
-                ++curAddedFacesIter
-            )
-            {
-                newFaces[nNewFaces] = curAddedFacesIter();
-                nNewFaces++;
-            }
-
-            // reset the size of the face list
-            newFaces.setSize(nNewFaces);
-
-            if (curAddedFaces.size())
-            {
-                // reset the shape pointer to unknown
-                cellShapes_[curCell] = cellShape(*unknownPtr_, labelList(0));
-            }
-        }
-
-        // Resize the point list to the number of created points
-        points_.setSize(nLivePoints);
-
-        // Finished
-        Info<< "Finished doing couples" << endl;
-    }
-}
-
-
-// ************************************************************************* //
diff --git a/applications/utilities/mesh/conversion/star3ToFoam/createPolyBoundary.C b/applications/utilities/mesh/conversion/star3ToFoam/createPolyBoundary.C
deleted file mode 100644
index 198fbe5236..0000000000
--- a/applications/utilities/mesh/conversion/star3ToFoam/createPolyBoundary.C
+++ /dev/null
@@ -1,315 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-Description
-    Create intermediate mesh files from PROSTAR files
-
-\*---------------------------------------------------------------------------*/
-
-#include "starMesh.H"
-#include "polyPatch.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-void Foam::starMesh::createPolyBoundary()
-{
-    label nBoundaryFacesFound = 0;
-
-    polyBoundaryPatchStartIndices_.setSize(boundary_.size());
-
-    label nCreatedFaces = nInternalFaces_;
-
-    const labelListList& PointCells = pointCells();
-
-    forAll(boundary_, patchi)
-    {
-        const faceList& curShapePatch = boundary_[patchi];
-
-        polyBoundaryPatchStartIndices_[patchi] = nCreatedFaces;
-
-        forAll(curShapePatch, facei)
-        {
-            bool found = false;
-
-            const face& curFace = curShapePatch[facei];
-
-            meshFaces_[nCreatedFaces] = curFace;
-
-            // Must find which cell this face belongs to in order to
-            // mark it in the cellPolys_
-            const labelList& facePoints = curFace;
-
-            forAll(facePoints, pointi)
-            {
-                const labelList& facePointCells =
-                    PointCells[facePoints[pointi]];
-
-                forAll(facePointCells, celli)
-                {
-                    const faceList& curCellFaces =
-                        cellFaces_[facePointCells[celli]];
-
-                    forAll(curCellFaces, cellFacei)
-                    {
-                        if (curCellFaces[cellFacei] == curFace)
-                        {
-                            // Found the cell face corresponding to this face
-                            found = true;
-
-                            // Debugging
-                            if
-                            (
-                                cellPolys_[facePointCells[celli]][cellFacei]
-                             != -1
-                            )
-                            {
-                                if
-                                (
-                                    cellPolys_[facePointCells[celli]][cellFacei]
-                                  > nInternalFaces_
-                                )
-                                {
-                                    InfoInFunction
-                                        << "Problem with face: " << curFace
-                                        << "\nProbably multiple definitions "
-                                        << "of a single boundary face. " << endl
-                                        << "Other boundary face: "
-                                        << curCellFaces[cellFacei]
-                                        << endl;
-
-                                    Info<< "PROSTAR Command: vset,news,vlis";
-                                    forAll(curCellFaces[cellFacei], spI)
-                                    {
-                                        // check if the point is given by STAR
-                                        // or created locally
-                                        if
-                                        (
-                                            curCellFaces[cellFacei][spI] > -1
-                                         && curCellFaces[cellFacei][spI]
-                                                < starPointID_.size()
-                                        )
-                                        {
-                                            Info<< ","
-                                                << starPointID_
-                                                 [curCellFaces[cellFacei][spI]];
-                                        }
-                                        else
-                                        {
-                                            Info<< ",???";
-                                        }
-                                    }
-                                    Info<< " $ bset,add,vset,all" << endl;
-                                }
-                                else
-                                {
-                                    InfoInFunction
-                                        << "Problem with face: " << curFace
-                                        << "\nProbably trying to define a "
-                                        << "boundary face on a previously "
-                                        << "matched internal face. " << endl
-                                        << "Internal face: "
-                                        << curCellFaces[cellFacei]
-                                        << endl;
-
-                                    Info<< "PROSTAR Command: vset,news,vlis";
-                                    forAll(curCellFaces[cellFacei], spI)
-                                    {
-                                        // check if the point is given by STAR
-                                        // or created locally
-                                        if
-                                        (
-                                            curCellFaces[cellFacei][spI] > -1
-                                         && curCellFaces[cellFacei][spI]
-                                                < starPointID_.size()
-                                        )
-                                        {
-                                            Info<< ","
-                                                << starPointID_
-                                                 [curCellFaces[cellFacei][spI]];
-                                        }
-                                        else
-                                        {
-                                            Info<< ",???";
-                                        }
-                                    }
-                                    Info<< " $ bset,add,vset,all" << endl;
-
-                                }
-                            }
-
-                            cellPolys_[facePointCells[celli]][cellFacei] =
-                                nCreatedFaces;
-
-                            nBoundaryFacesFound++;
-                        }
-                        if (found) break;
-                    }
-                    if (found) break;
-                }
-                if (found) break;
-            }
-
-            nCreatedFaces++;
-        }
-    }
-
-    // check all cellPolys_ to see if there are any missing faces
-    label nMissingFaceFound = 0;
-
-    forAll(cellPolys_, celli)
-    {
-        const labelList& curFaces = cellPolys_[celli];
-
-        forAll(curFaces, facei)
-        {
-            if (curFaces[facei] < 0)
-            {
-                const face& missingFace = cellFaces_[celli][facei];
-
-                InfoInFunction
-                    << "Missing face found in cell " << celli
-                    << ".\nType: " << cellShapes_[celli].model().name()
-                    << ". STAR cell number: " << starCellID_[celli]
-                    << ". Face: " << missingFace << endl;
-
-                nMissingFaceFound++;
-
-                Info<< "PROSTAR Command: vset,news,vlis";
-                forAll(missingFace, spI)
-                {
-                    // check if the point is given by STAR or created locally
-                    if
-                    (
-                        missingFace[spI] > -1
-                     && missingFace[spI] < starPointID_.size()
-                    )
-                    {
-                        Info<< "," << starPointID_[missingFace[spI]];
-                    }
-                    else
-                    {
-                        Info<< ",???";
-                    }
-                }
-                Info<< " $ bset,add,vset,all" << endl;
-            }
-        }
-    }
-
-    if (nMissingFaceFound > 0)
-    {
-        Info<< "Number of unmatched faces: " << nMissingFaceFound << endl;
-    }
-
-    // reset the size of the face list
-    meshFaces_.setSize(nCreatedFaces);
-
-    // check the mesh for face mismatch
-    // (faces addressed once or more than twice)
-    labelList markupFaces(meshFaces_.size(), 0);
-
-    forAll(cellPolys_, celli)
-    {
-        const labelList& curFaces = cellPolys_[celli];
-
-        forAll(curFaces, facei)
-        {
-            markupFaces[curFaces[facei]]++;
-        }
-    }
-
-    for (label i = nInternalFaces_; i < markupFaces.size(); i++)
-    {
-        markupFaces[i]++;
-    }
-
-    label nProblemFacesFound = 0;
-
-    forAll(markupFaces, facei)
-    {
-        if (markupFaces[facei] != 2)
-        {
-            const face& problemFace = meshFaces_[facei];
-
-            InfoInFunction
-                << "Problem with face " << facei << ": addressed "
-                << markupFaces[facei] << " times (should be 2!). Face: "
-                << problemFace << endl;
-
-            nProblemFacesFound++;
-
-            Info<< "PROSTAR Command: vset,news,vlis";
-            forAll(problemFace, spI)
-            {
-                // check if the point is given by STAR or created locally
-                if
-                (
-                    problemFace[spI] > -1
-                 && problemFace[spI] < starPointID_.size()
-                )
-                {
-                    Info<< "," << starPointID_[problemFace[spI]];
-                }
-                else
-                {
-                    Info<< ",???";
-                }
-            }
-            Info<< " $ bset,add,vset,all" << endl;
-        }
-    }
-
-    if (nProblemFacesFound > 0)
-    {
-        Info<< "Number of incorrectly matched faces: "
-            << nProblemFacesFound << endl;
-    }
-
-    Info<< "Number of boundary faces: " << nBoundaryFacesFound << endl;
-    Info<< "Total number of faces: " << nCreatedFaces << endl;
-}
-
-
-Foam::List<Foam::polyPatch*>
-Foam::starMesh::polyBoundaryPatches(const polyMesh& pMesh)
-{
-    List<polyPatch*> p(boundary_.size());
-
-    forAll(boundary_, patchi)
-    {
-        p[patchi] = polyPatch::New
-        (
-            patchTypes_[patchi],
-            patchNames_[patchi],
-            boundary_[patchi].size(),
-            polyBoundaryPatchStartIndices_[patchi],
-            patchi,
-            pMesh.boundaryMesh()
-        ).ptr();
-    }
-
-    return p;
-}
-
-
-// ************************************************************************* //
diff --git a/applications/utilities/mesh/conversion/star3ToFoam/createPolyCells.C b/applications/utilities/mesh/conversion/star3ToFoam/createPolyCells.C
deleted file mode 100644
index 0c7ba86a8e..0000000000
--- a/applications/utilities/mesh/conversion/star3ToFoam/createPolyCells.C
+++ /dev/null
@@ -1,188 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-Description
-    Create intermediate mesh files from PROSTAR files
-
-\*---------------------------------------------------------------------------*/
-
-#include "starMesh.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-void Foam::starMesh::createPolyCells()
-{
-    // loop through all cell faces and create connectivity. This will produce
-    // a global face list and will describe all cells as lists of face labels
-
-    // count the maximum number of faces and set the size of the cellPolys_
-    cellPolys_.setSize(cellShapes_.size());
-
-    label maxFaces = 0;
-
-    forAll(cellPolys_, celli)
-    {
-        cell& curCell = cellPolys_[celli];
-
-        curCell.setSize(cellFaces_[celli].size());
-
-        forAll(curCell, fI)
-        {
-            curCell[fI] = -1;
-        }
-
-        maxFaces += cellFaces_[celli].size();
-    }
-
-    Info<< "Maximum possible number of faces in mesh: " << maxFaces << endl;
-
-    meshFaces_.setSize(maxFaces);
-
-    // set reference to point-cell addressing
-    const labelListList& PointCells = pointCells();
-
-    bool found = false;
-
-    nInternalFaces_ = 0;
-
-    forAll(cellFaces_, celli)
-    {
-        // Note:
-        // Insertion cannot be done in one go as the faces need to be
-        // added into the list in the increasing order of neighbour
-        // cells.  Therefore, all neighbours will be detected first
-        // and then added in the correct order.
-
-        const faceList& curFaces = cellFaces_[celli];
-
-        // Record the neighbour cell
-        labelList neiCells(curFaces.size(), -1);
-
-        // Record the face of neighbour cell
-        labelList faceOfNeiCell(curFaces.size(), -1);
-
-        label nNeighbours = 0;
-
-        // For all faces ...
-        forAll(curFaces, facei)
-        {
-            // Skip faces that have already been matched
-            if (cellPolys_[celli][facei] >= 0) continue;
-
-            found = false;
-
-            const face& curFace = curFaces[facei];
-
-            // get the list of labels
-            const labelList& curPoints = curFace;
-
-            // For all points
-            forAll(curPoints, pointi)
-            {
-                // get the list of cells sharing this point
-                const labelList& curNeighbours = PointCells[curPoints[pointi]];
-
-                // For all neighbours
-                forAll(curNeighbours, neiI)
-                {
-                    label curNei = curNeighbours[neiI];
-
-                    // reject neighbours with the lower label. This should
-                    // also reject current cell.
-                    if (curNei > celli)
-                    {
-                        // get the list of search faces
-                        const faceList& searchFaces = cellFaces_[curNei];
-
-                        forAll(searchFaces, neiFacei)
-                        {
-                            if (searchFaces[neiFacei] == curFace)
-                            {
-                                // match!!
-                                found = true;
-
-                                // Record the neighbour cell and face
-                                neiCells[facei] = curNei;
-                                faceOfNeiCell[facei] = neiFacei;
-                                nNeighbours++;
-
-                                break;
-                            }
-                        }
-                        if (found) break;
-                    }
-                    if (found) break;
-                }
-                if (found) break;
-            } // End of current points
-        } // End of current faces
-
-        // Add the faces in the increasing order of neighbours
-        for (label neiSearch = 0; neiSearch < nNeighbours; neiSearch++)
-        {
-            // Find the lowest neighbour which is still valid
-            label nextNei = -1;
-            label minNei = cellPolys_.size();
-
-            forAll(neiCells, ncI)
-            {
-                if (neiCells[ncI] > -1 && neiCells[ncI] < minNei)
-                {
-                    nextNei = ncI;
-                    minNei = neiCells[ncI];
-                }
-            }
-
-            if (nextNei > -1)
-            {
-                // Add the face to the list of faces
-                meshFaces_[nInternalFaces_] = curFaces[nextNei];
-
-                // Mark for owner
-                cellPolys_[celli][nextNei] = nInternalFaces_;
-
-                // Mark for neighbour
-                cellPolys_[neiCells[nextNei]][faceOfNeiCell[nextNei]] =
-                    nInternalFaces_;
-
-                // Stop the neighbour from being used again
-                neiCells[nextNei] = -1;
-
-                // Increment number of faces counter
-                nInternalFaces_++;
-            }
-            else
-            {
-              FatalErrorInFunction
-                  << "Error in internal face insertion"
-                  << abort(FatalError);
-            }
-        }
-    }
-
-    // I won't reset the size of internal faces, because more faces will be
-    // added in createPolyBoundary()
-}
-
-
-// ************************************************************************* //
diff --git a/applications/utilities/mesh/conversion/star3ToFoam/fixCollapsedEdges.C b/applications/utilities/mesh/conversion/star3ToFoam/fixCollapsedEdges.C
deleted file mode 100644
index 1598ab80da..0000000000
--- a/applications/utilities/mesh/conversion/star3ToFoam/fixCollapsedEdges.C
+++ /dev/null
@@ -1,148 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-Description
-    Create intermediate mesh files from PROSTAR files
-
-\*---------------------------------------------------------------------------*/
-
-#include "starMesh.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-void Foam::starMesh::fixCollapsedEdges()
-{
-    cellFaces_.setSize(cellShapes_.size());
-
-    forAll(cellShapes_, celli)
-    {
-        cellFaces_[celli] = cellShapes_[celli].faces();
-    }
-
-    // go through the faces and find if there exist faces with duplicate
-    // vertices. If so, purge the duplicates and mark the mesh as a polyMesh
-
-    forAll(cellFaces_, celli)
-    {
-        faceList& curFaces = cellFaces_[celli];
-
-        forAll(curFaces, facei)
-        {
-            face& vertexLabels = curFaces[facei];
-
-            bool duplicatesFound = false;
-
-            forAll(vertexLabels, vI)
-            {
-                label curLabel = vertexLabels[vI];
-
-                label nFound = 0;
-
-                forAll(vertexLabels, searchI)
-                {
-                    if (vertexLabels[searchI] == curLabel)
-                    {
-                        nFound++;
-                    }
-                }
-
-                if (nFound > 1)
-                {
-                    duplicatesFound = true;
-
-                    break;
-                }
-            }
-
-            if (duplicatesFound)
-            {
-                // this mesh cannot be described as a shapeMesh
-                isShapeMesh_ = false;
-
-                // I am not allowed to reset the shape pointer to unknown
-                // here as the shape is still needed to determine which face
-                // of the shape is used in potential couple matches.  This
-                // will be done in the end using the purgeShapes()
-                //
-
-                // create a new face without duplicates and replace original
-                face newFace(vertexLabels.size());
-                label nNewVertices = 0;
-
-                forAll(vertexLabels, vI)
-                {
-                    // In order for a face to be a valid entity, duplicate
-                    // vertices can only be consecutive (othervise, the
-                    // collapse creates an invalid face). We shall use this
-                    // property in the creation of the collapsed face
-
-                    label curLabel = vertexLabels[vI];
-
-                    bool found = false;
-
-                    // search through all vertices from the new face. If the
-                    // current label has not been added, add it to the end.
-                    for (label searchI = 0; searchI < nNewVertices; searchI++)
-                    {
-                        if (newFace[searchI] == curLabel)
-                        {
-                            found = true;
-
-                            break;
-                        }
-                    }
-
-                    if (!found)
-                    {
-                        newFace[nNewVertices] = curLabel;
-                        nNewVertices++;
-                    }
-                }
-
-                newFace.setSize(nNewVertices);
-
-                // If the number of non-duplicate labels in the face is less
-                // than three, the face has been collapsed in an invalid
-                // manner. Error.
-
-                if (nNewVertices < 3)
-                {
-                    FatalErrorInFunction
-                        << "Face " << facei << " of cell " << celli
-                        << " is colapsed down to a point or edge, which is "
-                        << "not permitted" << endl
-                        << "original face: " << vertexLabels << endl
-                        << "purged face: " << newFace << endl
-                        << abort(FatalError);
-                }
-                else
-                {
-                    vertexLabels = newFace;
-                }
-            }
-        }
-    }
-}
-
-
-// ************************************************************************* //
diff --git a/applications/utilities/mesh/conversion/star3ToFoam/mergeCoupleFacePoints.C b/applications/utilities/mesh/conversion/star3ToFoam/mergeCoupleFacePoints.C
deleted file mode 100644
index 7addc9c688..0000000000
--- a/applications/utilities/mesh/conversion/star3ToFoam/mergeCoupleFacePoints.C
+++ /dev/null
@@ -1,423 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-Description
-    Merge duplicate points created by arbitrary face coupling and remove unused
-    points.
-
-\*---------------------------------------------------------------------------*/
-
-#include "starMesh.H"
-#include "demandDrivenData.H"
-
-// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
-
-void Foam::starMesh::mergeCoupleFacePoints()
-{
-    // mark all used points by looping through all faces in two goes.
-    // First, go into every cell and find min edge length.  Use a
-    // fraction of that as a merge tolerance.  Loop through all the
-    // points of the cell and query a merge against every other point
-    // of the same cell based on the current tolerance.  If two points
-    // merge, find out if any of them already belongs to a "merge set"
-    // (group of points that merge together.  If so, add the current
-    // points into the merge set and make sure that the merge label
-    // for the whole set is the lowest of all encountered vertices.
-    // This is stored in a mergeSetID list, under the index of the
-    // merge set.  Once all cells (and thus points) are visited, go
-    // through the renumbering list and for each merging point use the
-    // label of the merge set as the new point label.
-    // This is VERY fancy. Use care if/when changing.
-
-    Info<< endl << "Creating merge sets" << endl;
-
-    // Create a renumbering list for points
-    // In the first instance the renumbering list is used as a
-    // mergeSetID storage
-    labelList renumberPoints(points_.size(), -1);
-
-    // create storage of mergeSetIDs
-    label mergeIncrement = points_.size()/10;
-    labelList mergeSetID(mergeIncrement, -1);
-
-    label nMergeSets = 0;
-
-    forAll(cellFaces_, celli)
-    {
-        const faceList& curFaces = cellFaces_[celli];
-
-        // create a list of all points for the cell with duplicates
-        // and find the shortest edge length
-
-        label nPointsInCell = 0;
-
-        scalar pointMergeTol = GREAT;
-
-        forAll(curFaces, facei)
-        {
-            nPointsInCell += curFaces[facei].size();
-
-            edgeList curEdges = curFaces[facei].edges();
-
-            forAll(curEdges, edgeI)
-            {
-                scalar length = curEdges[edgeI].mag(points_);
-
-                if (length < pointMergeTol)
-                {
-                    pointMergeTol = length;
-                }
-            }
-        }
-
-        // set merge tolerance as a fraction of the shortest edge
-        pointMergeTol /= 100.0;
-
-        // create a list of points
-        labelList cellPoints(nPointsInCell);
-        label nAddedPoints = 0;
-
-        forAll(curFaces, facei)
-        {
-            const face& f = curFaces[facei];
-
-            forAll(f, fI)
-            {
-                cellPoints[nAddedPoints] = f[fI];
-                nAddedPoints++;
-            }
-        }
-
-        // loop n-squared through the local points and merge them up
-        for (label firstPI = 0; firstPI < cellPoints.size() - 1; firstPI++)
-        {
-            for
-            (
-                label otherPI = firstPI;
-                otherPI < cellPoints.size();
-                otherPI++
-            )
-            {
-                if (cellPoints[firstPI] != cellPoints[otherPI])
-                {
-                    label a = cellPoints[firstPI];
-                    label b = cellPoints[otherPI];
-
-                    if (edge (a, b).mag(points_) < pointMergeTol)
-                    {
-                        // found a pair of points to merge
-                        #ifdef DEBUG_MERGE
-                        Info<< "Merging points " << a << " and " << b << endl;
-                        #endif
-
-                        // are the two points in a merge group?
-                        label mergeSetA = -1;
-                        label mergeSetB = -1;
-
-                        if (renumberPoints[a] > -1)
-                        {
-                            mergeSetA = renumberPoints[a];
-                        }
-
-                        if (renumberPoints[b] > -1)
-                        {
-                            mergeSetB = renumberPoints[b];
-                        }
-
-                        if (mergeSetA == -1 && mergeSetB == -1)
-                        {
-                            // add new merge group
-                            #ifdef DEBUG_MERGE
-                            Info<< "adding new merge group " << nMergeSets
-                                << endl;
-                            #endif
-
-                            // mark points as belonging to a new merge set
-                            renumberPoints[a] = nMergeSets;
-                            renumberPoints[b] = nMergeSets;
-
-                            mergeSetID[nMergeSets] = min(a, b);
-                            nMergeSets++;
-
-                            if (nMergeSets >= mergeSetID.size())
-                            {
-                                Info<< "Resizing mergeSetID" << endl;
-
-                                mergeSetID.setSize
-                                    (mergeSetID.size() + mergeIncrement);
-                            }
-                        }
-                        else if (mergeSetA == -1 && mergeSetB != -1)
-                        {
-                            #ifdef DEBUG_MERGE
-                            Info<< "adding point a into the merge set of b. "
-                                << "a: " << a << endl;
-                            #endif
-
-                            // add point a into the merge set of b
-                            renumberPoints[a] = mergeSetB;
-
-                            // reset the min label of the mergeSet
-                            mergeSetID[mergeSetB] =
-                                min(a, mergeSetID[mergeSetB]);
-                        }
-                        else if  (mergeSetA != -1 && mergeSetB == -1)
-                        {
-                            #ifdef DEBUG_MERGE
-                            Info<< "adding point b into the merge set of a. "
-                                << "b: " << b << endl;
-                            #endif
-
-                            // add point b into the merge set of a
-                            renumberPoints[b] = mergeSetA;
-
-                            // reset the min label of the mergeSet
-                            mergeSetID[mergeSetA] =
-                                min(b, mergeSetID[mergeSetA]);
-                        }
-                        else if (mergeSetA != mergeSetB)
-                        {
-                            // Points already belong to two different merge
-                            // sets. Eliminate the higher merge set
-                            label minMerge = min(mergeSetA, mergeSetB);
-                            label maxMerge = max(mergeSetA, mergeSetB);
-
-                            #ifdef DEBUG_MERGE
-                            Info<< "Points already belong to two "
-                                << "different merge sets. "
-                                << "Eliminate the higher merge set. Sets: "
-                                << minMerge << " and " << maxMerge << endl;
-                            #endif
-
-                            forAll(renumberPoints, elimI)
-                            {
-                                if (renumberPoints[elimI] == maxMerge)
-                                {
-                                    renumberPoints[elimI] = minMerge;
-                                }
-                            }
-
-                            // set the lower label
-                            mergeSetID[minMerge] =
-                                min(mergeSetID[minMerge], mergeSetID[maxMerge]);
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    mergeSetID.setSize(nMergeSets);
-
-    Info<< "Finished creating merge sets.  Number of merge sets: "
-        << nMergeSets << "." << endl;
-
-    // Insert the primary point renumbering into the list
-    // Take care of possibly unused points in the list
-    forAll(renumberPoints, pointi)
-    {
-        if (renumberPoints[pointi] < 0)
-        {
-            // point not merged
-            renumberPoints[pointi] = pointi;
-        }
-        else
-        {
-            renumberPoints[pointi] = mergeSetID[renumberPoints[pointi]];
-        }
-    }
-
-    // Now every point carries either its own label or the lowest of
-    // the labels of the points it is merged with. Now do PRELIMINARY
-    // renumbering of all faces.  This will only be used to see which
-    // points are still used!
-
-    forAll(cellFaces_, celli)
-    {
-        faceList& prelimFaces = cellFaces_[celli];
-
-        forAll(prelimFaces, facei)
-        {
-            face oldFacePoints = prelimFaces[facei];
-
-            face& prelimFacePoints = prelimFaces[facei];
-
-            forAll(prelimFacePoints, pointi)
-            {
-                if (renumberPoints[oldFacePoints[pointi]] < 0)
-                {
-                    FatalErrorInFunction
-                        << "Error in point renumbering. Old face: "
-                        << oldFacePoints << endl
-                        << "prelim face: " << prelimFacePoints
-                        << abort(FatalError);
-                }
-
-                prelimFacePoints[pointi] =
-                    renumberPoints[oldFacePoints[pointi]];
-            }
-        }
-    }
-
-    // First step complete. Reset the renumbering list, mark all used points,
-    // re-create the point list and renumber the whole lot
-    renumberPoints = 0;
-
-    forAll(cellFaces_, celli)
-    {
-        const faceList& curFaces = cellFaces_[celli];
-
-        forAll(curFaces, facei)
-        {
-            const face& curFacePoints = curFaces[facei];
-
-            forAll(curFacePoints, pointi)
-            {
-                renumberPoints[curFacePoints[pointi]]++;
-            }
-        }
-    }
-
-    forAll(cellShapes_, celli)
-    {
-        const labelList& curLabels = cellShapes_[celli];
-
-        forAll(curLabels, pointi)
-        {
-            if (renumberPoints[curLabels[pointi]] == 0)
-            {
-                FatalErrorInFunction
-                    << "Error in point merging for cell "
-                    << celli << ". STAR index: " << starCellID_[celli]
-                    << ". " << endl
-                    << "Point index: " << curLabels[pointi] << " STAR index "
-                    << starPointID_[curLabels[pointi]] << endl
-                    << "Please check the geometry for the cell." << endl;
-            }
-        }
-    }
-
-    label nUsedPoints = 0;
-
-    forAll(renumberPoints, pointi)
-    {
-        if (renumberPoints[pointi] > 0)
-        {
-            // This should be OK as the compressed points list will always
-            // have less points that the original lists.  Even if there is
-            // no points removed, this will copy the list back onto itself
-            //
-            renumberPoints[pointi] = nUsedPoints;
-            points_[nUsedPoints] = points_[pointi];
-
-            nUsedPoints++;
-        }
-        else
-        {
-            renumberPoints[pointi] = -1;
-        }
-    }
-
-    Info<< "Total number of points: " << points_.size() << endl
-        << "Number of used points: " << nUsedPoints << endl;
-
-    // reset number of points which need to be sorted
-    points_.setSize(nUsedPoints);
-
-    Info<< "Renumbering all faces" << endl;
-
-    forAll(cellFaces_, celli)
-    {
-        faceList& newFaces = cellFaces_[celli];
-
-        forAll(newFaces, facei)
-        {
-            face oldFacePoints = newFaces[facei];
-
-            face& newFacePoints = newFaces[facei];
-
-            forAll(newFacePoints, pointi)
-            {
-                if (renumberPoints[oldFacePoints[pointi]] < 0)
-                {
-                    FatalErrorInFunction
-                        << "Error in point renumbering for point "
-                        << oldFacePoints[pointi]
-                        << ". Renumbering index is -1." << endl
-                        << "Old face: " << oldFacePoints << endl
-                        << "New face: " << newFacePoints << abort(FatalError);
-                }
-
-                newFacePoints[pointi] = renumberPoints[oldFacePoints[pointi]];
-            }
-        }
-    }
-
-    Info<< "Renumbering all cell shapes" << endl;
-
-    forAll(cellShapes_, celli)
-    {
-        labelList oldLabels = cellShapes_[celli];
-
-        labelList& curLabels = cellShapes_[celli];
-
-        forAll(curLabels, pointi)
-        {
-            if (renumberPoints[curLabels[pointi]] < 0)
-            {
-                FatalErrorInFunction
-                    << "Error in point renumbering for cell "
-                    << celli << ". STAR index: " << starCellID_[celli]
-                    << ". " << endl
-                    << "Point index: " << curLabels[pointi] << " STAR index "
-                    << starPointID_[curLabels[pointi]] << " returns invalid "
-                    << "renumbering index: "
-                    << renumberPoints[curLabels[pointi]] << "." << endl
-                    << "Old cellShape:  " << oldLabels << endl
-                    << "New cell shape: " << curLabels << abort(FatalError);
-                }
-
-            curLabels[pointi] = renumberPoints[oldLabels[pointi]];
-        }
-    }
-
-    Info<< "Renumbering STAR point lookup" << endl;
-
-    labelList oldStarPointID = starPointID_;
-
-    starPointID_ = -1;
-
-    forAll(starPointID_, pointi)
-    {
-        if (renumberPoints[pointi] > -1)
-        {
-            starPointID_[renumberPoints[pointi]] = oldStarPointID[pointi];
-        }
-    }
-
-    // point-cell addressing has changed. Force it to be re-created
-    deleteDemandDrivenData(pointCellsPtr_);
-}
-
-
-// ************************************************************************* //
diff --git a/applications/utilities/mesh/conversion/star3ToFoam/purgeCellShapes.C b/applications/utilities/mesh/conversion/star3ToFoam/purgeCellShapes.C
deleted file mode 100644
index 8981016043..0000000000
--- a/applications/utilities/mesh/conversion/star3ToFoam/purgeCellShapes.C
+++ /dev/null
@@ -1,66 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-Description
-    Purge cell shapes which have been rendered invalid by cell face collapse
-
-\*---------------------------------------------------------------------------*/
-
-#include "starMesh.H"
-
-// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
-
-void Foam::starMesh::purgeCellShapes()
-{
-    forAll(cellFaces_, celli)
-    {
-        const faceList& curFaces = cellFaces_[celli];
-
-        // Get model faces
-        faceList shapeFaces = cellShapes_[celli].faces();
-
-        forAll(shapeFaces, facei)
-        {
-            bool found = false;
-
-            forAll(curFaces, i)
-            {
-                if (shapeFaces[facei] == curFaces[i])
-                {
-                    found = true;
-                    break;
-                }
-            }
-
-            if (!found)
-            {
-                Info<< "Purging cell shape " << celli << endl;
-                cellShapes_[celli] = cellShape(*unknownPtr_, labelList(0));
-                break;
-            }
-        }
-    }
-}
-
-
-// ************************************************************************* //
diff --git a/applications/utilities/mesh/conversion/star3ToFoam/readBoundary.C b/applications/utilities/mesh/conversion/star3ToFoam/readBoundary.C
deleted file mode 100644
index 4f1831bb2a..0000000000
--- a/applications/utilities/mesh/conversion/star3ToFoam/readBoundary.C
+++ /dev/null
@@ -1,256 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-Description
-    Create intermediate mesh files from PROSTAR files
-
-\*---------------------------------------------------------------------------*/
-
-#include "starMesh.H"
-#include "Time.H"
-#include "wallPolyPatch.H"
-#include "oldCyclicPolyPatch.H"
-#include "symmetryPolyPatch.H"
-#include "preservePatchTypes.H"
-#include "IFstream.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-void Foam::starMesh::readBoundary()
-{
-    label nPatches=0, nFaces=0;
-    labelList nPatchFaces(1000);
-
-    label lineIndex, starLabel;
-    label starRegion, configNumber;
-
-    labelList pointLabels(4);
-    labelList pointLabelsTri(3);
-
-    labelList patchLabels(1000, label(-1));
-
-    word patchType;
-    patchTypes_.setSize(1000);
-    patchNames_.setSize(1000);
-
-    fileName boundaryFileName(casePrefix_ + ".bnd");
-
-    {
-        IFstream boundaryFile(boundaryFileName);
-
-        // Collect no. of faces (nFaces),
-        // no. of patches (nPatches)
-        // and for each of these patches the number of faces
-        // (nPatchFaces[patchLabel])
-        // and a conversion table from Star regions to (Foam) patchLabels
-
-        if (boundaryFile.good())
-        {
-            forAll(nPatchFaces, faceLabel)
-            {
-                nPatchFaces[faceLabel] = 0;
-            }
-
-            while ((boundaryFile >> lineIndex).good())
-            {
-                nFaces++;
-
-                // Skip point numbers
-                for (int i=0; i<4; i++)
-                {
-                    boundaryFile >> starLabel;
-                }
-
-                boundaryFile >> starRegion;
-                boundaryFile >> configNumber;
-                boundaryFile >> patchType;
-
-                // Build translation table to convert star patch to foam patch
-                label patchLabel = patchLabels[starRegion];
-                if (patchLabel == -1)
-                {
-                    patchLabel = nPatches;
-                    patchLabels[starRegion] = patchLabel;
-                    patchTypes_[patchLabel] = patchType;
-                    patchNames_[patchLabel] = patchType + name(starRegion);
-
-                    nPatches++;
-
-                    Info<< "Star region " << starRegion
-                        << " with type " << patchType
-                        << " is now Foam patch " << patchLabel << endl;
-
-                }
-
-                nPatchFaces[patchLabel]++;
-            }
-
-
-            Info<< nl
-                << "Setting size of boundary to " << nPatches
-                << nl << endl;
-
-            nPatchFaces.setSize(nPatches);
-        }
-        else
-        {
-            FatalErrorInFunction
-                << "Cannot read file "
-                << boundaryFileName
-                << abort(FatalError);
-        }
-    }
-
-    if (nPatches > 0)
-    {
-        boundary_.setSize(nPatchFaces.size());
-        patchTypes_.setSize(nPatchFaces.size());
-        patchNames_.setSize(nPatchFaces.size());
-
-        // size the lists and reset the counters to be used again
-        forAll(boundary_, patchLabel)
-        {
-            boundary_[patchLabel].setSize(nPatchFaces[patchLabel]);
-
-            nPatchFaces[patchLabel] = 0;
-        }
-
-        IFstream boundaryFile(boundaryFileName);
-
-        for (label facei=0; facei<nFaces; facei++)
-        {
-            boundaryFile >> lineIndex;
-
-            for (int i = 0; i < 4; i++)
-            {
-                boundaryFile >> starLabel;
-
-                // convert Star label to Foam point label
-                // through lookup-list starPointLabelLookup_
-                pointLabels[i] = starPointLabelLookup_[starLabel];
-
-                if (pointLabels[i] < 0)
-                {
-                    Info<< "Boundary file not consistent with vertex file\n"
-                        << "Star vertex number " << starLabel
-                        << " does not exist\n";
-                }
-
-            }
-
-            boundaryFile >> starRegion;
-            label patchLabel = patchLabels[starRegion];
-
-            boundaryFile >> configNumber;
-            boundaryFile >> patchType;
-
-            if   // Triangle
-            (
-                pointLabels[2] == pointLabels[3]
-            )
-            {
-                //Info<< "Converting collapsed quad into triangle"
-                //    << " for face " << facei
-                //    << " in Star boundary " << lineIndex << endl;
-
-                pointLabelsTri[0] = pointLabels[0];
-                pointLabelsTri[1] = pointLabels[1];
-                pointLabelsTri[2] = pointLabels[2];
-
-                boundary_[patchLabel][nPatchFaces[patchLabel]]
-                    = face(pointLabelsTri);
-            }
-            else
-            {
-                boundary_[patchLabel][nPatchFaces[patchLabel]]
-                    = face(pointLabels);
-            }
-
-            // increment counter of faces in current patch
-            nPatchFaces[patchLabel]++;
-        }
-
-        forAll(boundary_, patchLabel)
-        {
-            word patchType = patchTypes_[patchLabel];
-
-            if (patchType == "SYMP")
-            {
-                patchTypes_[patchLabel] = symmetryPolyPatch::typeName;
-            }
-            else if (patchType == "WALL")
-            {
-                patchTypes_[patchLabel] = wallPolyPatch::typeName;
-            }
-            else if (patchType == "CYCL")
-            {
-                // incorrect. should be cyclicPatch but this
-                // requires info on connected faces.
-                patchTypes_[patchLabel] = oldCyclicPolyPatch::typeName;
-            }
-            else
-            {
-                patchTypes_[patchLabel] = polyPatch::typeName;
-            }
-
-            Info<< "Foam patch " << patchLabel
-                << " is of type " << patchTypes_[patchLabel]
-                << " with name " << patchNames_[patchLabel] << endl;
-        }
-    }
-    else
-    {
-        WarningInFunction
-            << "no boundary faces in file "
-            << boundaryFileName
-            << endl;
-    }
-
-    patchPhysicalTypes_.setSize(patchTypes_.size());
-
-    PtrList<dictionary> patchDicts;
-
-    preservePatchTypes
-    (
-        runTime_,
-        runTime_.constant(),
-        polyMesh::meshSubDir,
-        patchNames_,
-        patchDicts,
-        defaultFacesName_,
-        defaultFacesType_
-    );
-
-    forAll(patchDicts, patchi)
-    {
-        if (patchDicts.set(patchi))
-        {
-            const dictionary& dict = patchDicts[patchi];
-            dict.readIfPresent("type", patchTypes_[patchi]);
-            dict.readIfPresent("physicalType", patchPhysicalTypes_[patchi]);
-        }
-    }
-}
-
-
-// ************************************************************************* //
diff --git a/applications/utilities/mesh/conversion/star3ToFoam/readCells.C b/applications/utilities/mesh/conversion/star3ToFoam/readCells.C
deleted file mode 100644
index 92d75fa122..0000000000
--- a/applications/utilities/mesh/conversion/star3ToFoam/readCells.C
+++ /dev/null
@@ -1,388 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-Description
-    Create intermediate mesh from Prostar files
-
-\*---------------------------------------------------------------------------*/
-
-#include "starMesh.H"
-#include "IFstream.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-void Foam::starMesh::addRegularCell
-(
-    const labelList& labels,
-    const label nCreatedCells
-)
-{
-    // Momory management
-    static labelList labelsHex(8);
-    static labelList labelsPrism(6);
-    static labelList labelsPyramid(5);
-    static labelList labelsTet(4);
-    static labelList labelsTetWedge(5);
-
-    label regularTypeFlag = -1;
-
-    // grab the shape from the table
-    const cellModel* curModelPtr = reinterpret_cast<cellModel*>(0);
-
-    if      // Tetrahedron
-    (
-        labels[2] == labels[3]
-     && labels[4] == labels[5]
-     && labels[5] == labels[6]
-     && labels[6] == labels[7]
-    )
-    {
-        regularTypeFlag = 0;
-        curModelPtr = tetPtr_;
-    }
-    else if // Square-based pyramid
-    (
-        labels[4] == labels[5]
-     && labels[5] == labels[6]
-     && labels[6] == labels[7]
-    )
-    {
-        regularTypeFlag = 1;
-        curModelPtr = pyrPtr_;
-    }
-    else if // Tet Wedge
-    (
-        labels[2] == labels[3]
-     && labels[4] == labels[5]
-     && labels[6] == labels[7]
-    )
-    {
-        regularTypeFlag = 2;
-        curModelPtr = tetWedgePtr_;
-    }
-    else if // Triangular prism
-    (
-        labels[2] == labels[3]
-     && labels[6] == labels[7]
-    )
-    {
-        regularTypeFlag = 3;
-        curModelPtr = prismPtr_;
-    }
-    else if // Wedge
-    (
-        labels[4] == labels[7]
-    )
-    {
-        regularTypeFlag = 4;
-        curModelPtr = wedgePtr_;
-    }
-    else    // Hex
-    {
-        regularTypeFlag = 5;
-        curModelPtr = hexPtr_;
-    }
-
-    labelList regularCellLabels(curModelPtr->nPoints(), -1);
-    // get reference to the addressing list
-    const label* addressing = regularAddressingTable[regularTypeFlag];
-
-    forAll(regularCellLabels, labelI)
-    {
-        regularCellLabels[labelI] = labels[addressing[labelI]];
-    }
-
-    cellShapes_[nCreatedCells] = cellShape(*curModelPtr, regularCellLabels);
-}
-
-
-void Foam::starMesh::addSAMMcell
-(
-    const labelList& labels,
-    const label nCreatedCells
-)
-{
-    // get type, reg and permutation flag
-    label typeFlag = labels[21];
-//     label regularityFlag = labels[22];  // Not used.
-    label permutationFlag = labels[23];
-
-    // grab the shape from the table
-    label sammTypeFlag = -1;
-    const cellModel* curModelPtr = reinterpret_cast<cellModel*>(0);
-
-    switch (typeFlag)
-    {
-        case 1:
-        {
-            sammTypeFlag = 1;
-            curModelPtr = sammTrim1Ptr_;
-            break;
-        }
-
-        case 2:
-        {
-            sammTypeFlag = 2;
-            curModelPtr = sammTrim2Ptr_;
-            break;
-        }
-
-        case 7:
-        {
-            if (labels[0] != -1)
-            {
-                sammTypeFlag = 3;
-                curModelPtr = sammTrim3Ptr_;
-            }
-            else
-            {
-                sammTypeFlag = 5;
-                curModelPtr = sammTrim5Ptr_;
-            }
-
-            break;
-        }
-
-        case 8:
-        {
-            sammTypeFlag = 4;
-            curModelPtr = sammTrim4Ptr_;
-            break;
-        }
-
-        case 85:
-        {
-            sammTypeFlag = 8;
-            curModelPtr = sammTrim8Ptr_;
-            break;
-        }
-
-        default:
-        {
-            FatalErrorInFunction
-                << "SAMM type " << sammTypeFlag << " is invalid"
-                << abort(FatalError);
-        }
-    }
-
-    // make a list of labels
-    labelList sammCellLabels(curModelPtr->nPoints(), -1);
-    // get reference to the addressing list
-    const label* addressing = sammAddressingTable[sammTypeFlag];
-
-    forAll(sammCellLabels, labelI)
-    {
-        sammCellLabels[labelI] = labels[addressing[labelI]];
-    }
-
-    cellShapes_[nCreatedCells] = cellShape(*curModelPtr, sammCellLabels);
-
-    // set permutation flag for cell
-    starCellPermutation_[nCreatedCells] = permutationFlag;
-}
-
-
-void Foam::starMesh::readCells()
-{
-    label nCells = 0;
-    label maxLabel = -1;
-
-    fileName cellsFileName(casePrefix_ + ".cel");
-
-    {
-        IFstream cellsFile(cellsFileName);
-
-        if (cellsFile.good())
-        {
-            label lineLabel, pointLabel, regionLabel, typeFlag;
-
-            maxLabel = -1;
-            while (!(cellsFile >> lineLabel).eof())
-            {
-                maxLabel = max(maxLabel, lineLabel);
-                for (int i=0; i<8; i++)
-                {
-                    cellsFile >> pointLabel;
-                }
-
-                cellsFile >> regionLabel;
-                cellsFile >> typeFlag;
-
-                // lines with typeFlag of zero are continuation lines.
-                if (typeFlag != 0)
-                {
-                    nCells++;
-                }
-
-                // backward compatibility: number of trailing rubbish in
-                // STAR is unknown.
-                // Fixed to cope with missing \n on last line.
-                readToNl(cellsFile);
-            }
-        }
-        else
-        {
-            FatalErrorInFunction
-                << "Cannot read file " << cellsFileName
-                << abort(FatalError);
-        }
-    }
-
-    Info<< "Number of cells = " << nCells << endl << endl;
-
-    cellShapes_.setSize(nCells);
-    starCellID_.setSize(nCells);
-    starCellPermutation_.setSize(nCells);
-
-    // reset permutation to invalid value
-    forAll(starCellPermutation_, i)
-    {
-        starCellPermutation_[i] = -1;
-    }
-
-    starCellLabelLookup_.setSize(maxLabel+1);
-
-    // reset point labels to invalid value
-    forAll(starCellLabelLookup_, i)
-    {
-        starCellLabelLookup_[i] = -1;
-    }
-
-    if (nCells > 0)
-    {
-        IFstream cellsFile(cellsFileName);
-
-        labelList labels(24, label(-1));
-        label lineLabel, starLabel, regionLabel, typeFlag;
-
-        for (label celli = 0; celli < nCells; celli++)
-        {
-            label nLabels = 0;
-
-            label addOnToCell = 0;
-
-            // reset the labels to -1. Debugging.
-            forAll(labels, i)
-            {
-                labels[i] = -1;
-            }
-
-            do
-            {
-                if ((cellsFile >> lineLabel).eof())
-                {
-                    FatalErrorInFunction
-                        << "Reached end of cells file before "
-                        << "all cells are read in."
-                        << abort(FatalError);
-                }
-
-                nLabels += 8;
-
-                for (int i=nLabels-8; i<nLabels; i++)
-                {
-                    cellsFile >> starLabel;
-
-                    if (i < 21)
-                    {
-                        if (starLabel != 0)
-                        {
-                            // Convert Star vertex number to point label
-                            labels[i] = starPointLabelLookup_[starLabel];
-
-                            if (labels[i] < 0)
-                            {
-                                Info<< "Cells not consistent with vertex file. "
-                                    << "Star vertex number " << starLabel
-                                    << " does not exist\n";
-                            }
-                        }
-                        else
-                        {
-                            labels[i] = -1;
-                        }
-                    }
-                    else
-                    {
-                        labels[i] = starLabel;
-                    }
-                }
-
-                cellsFile >> regionLabel;
-                cellsFile >> typeFlag;
-
-                // check for continuation line
-                if (typeFlag == -1)
-                {
-                    addOnToCell = 2;
-                }
-
-                // backward compatibility: number of trailing rubbish in
-                // STAR is unknown.
-                readToNl(cellsFile);
-
-                addOnToCell--;
-
-            } while (addOnToCell >= 0);
-
-            // Record STAR cell number (used for debugging)
-            starCellID_[celli] = lineLabel;
-
-            // insert STAR lookup addressing
-            starCellLabelLookup_[lineLabel] = celli;
-
-            if (nLabels == 8)
-            {
-                addRegularCell(labels, celli);
-            }
-            else
-            {
-                addSAMMcell(labels, celli);
-            }
-
-            // check cell labels
-            const labelList& curShapeLabels = cellShapes_[celli];
-
-            forAll(curShapeLabels, i)
-            {
-                if (curShapeLabels[i] < 0)
-                {
-                    FatalErrorInFunction
-                        << "Invalid vertex found in cell " << celli
-                        << ". STAR cell no: " << lineLabel
-                        << " labels: " << curShapeLabels
-                        << abort(FatalError);
-                }
-            }
-        }
-    }
-    else
-    {
-        FatalErrorInFunction
-            << "No cells in file " << cellsFileName
-            << abort(FatalError);
-    }
-}
-
-
-// ************************************************************************* //
diff --git a/applications/utilities/mesh/conversion/star3ToFoam/readCouples.C b/applications/utilities/mesh/conversion/star3ToFoam/readCouples.C
deleted file mode 100644
index cca228ae16..0000000000
--- a/applications/utilities/mesh/conversion/star3ToFoam/readCouples.C
+++ /dev/null
@@ -1,185 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2015 OpenFOAM Foundation
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-Description
-    Create intermediate mesh from PROSTAR files
-
-\*---------------------------------------------------------------------------*/
-
-#include "starMesh.H"
-#include "IFstream.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-void Foam::starMesh::readCouples()
-{
-    fileName couplesFileName(casePrefix_ + ".cpl");
-
-    label nCouples = 0;
-
-    // Count number of couples
-    {
-        IFstream couplesFile(couplesFileName);
-
-        if (couplesFile.good())
-        {
-            Info<< "\nReading couples" << endl;
-
-            label matchLabel, nEntries, typeFlag;
-            label starMasterCell, rotXMasterFace;
-            label starSlaveCell, rotXSlaveFace;
-
-            // count the number of entries to read
-            while (!(couplesFile >> matchLabel).eof())
-            {
-                // read number of entries and match type flag.
-                couplesFile >> nEntries;
-
-                couplesFile >> typeFlag;
-
-                // read master cell and face
-                couplesFile >> starMasterCell >> rotXMasterFace;
-
-                // add number of couples from current match
-                label nSlavesToRead = nEntries - 1;
-
-                nCouples += nSlavesToRead;
-
-                for (int i = 0; i < nSlavesToRead; i++)
-                {
-                    couplesFile >> starSlaveCell >> rotXSlaveFace;
-                }
-            }
-
-            Info<< "Number of couples = " << nCouples << endl << endl;
-        }
-        else
-        {
-            Info<< endl << "No couple matches defined." << endl;
-        }
-    }
-
-    // Read couples
-    if (nCouples > 0)
-    {
-        // read couples
-        couples_.setSize(nCouples);
-        label couplei = 0;
-
-        // A mesh with couples cannot be a shape mesh
-        isShapeMesh_ = false;
-
-        IFstream couplesFile(couplesFileName);
-
-        label matchLabel, nEntries, typeFlag;
-        label starMasterCell, masterCell, rotXMasterFace, rotZeroMasterFace;
-        label starSlaveCell, slaveCell, rotXSlaveFace, rotZeroSlaveFace;
-
-        while (!(couplesFile >> matchLabel).eof())
-        {
-            // read number of entries and match type flag.
-            // Note. At the moment, only integral matches are supported
-            couplesFile >> nEntries;
-
-            couplesFile >> typeFlag;
-
-            // read master cell and face
-            couplesFile >> starMasterCell >> rotXMasterFace;
-
-            // translate the cell labels
-            masterCell = starCellLabelLookup_[starMasterCell];
-
-            // translate the master face into rotation zero if applicable
-            if (starCellPermutation_[masterCell] > -1)
-            {
-                const label curMasterPermutation =
-                    starCellPermutation_[masterCell];
-
-                rotZeroMasterFace =
-                    sammFacePermutationTable
-                        [curMasterPermutation]
-                        [rotXMasterFace];
-            }
-            else
-            {
-                rotZeroMasterFace = rotXMasterFace;
-            }
-
-            // get master face index
-            label masterFaceID =
-                shapeFaceLookup
-                    [cellShapes_[masterCell].model().index()]
-                    [rotZeroMasterFace];
-
-            // number of slave faces
-            label nSlavesToRead = nEntries - 1;
-
-            for (int i = 0; i < nSlavesToRead; i++)
-            {
-                couplesFile >> starSlaveCell >> rotXSlaveFace;
-
-                // translate the cell labels
-                slaveCell = starCellLabelLookup_[starSlaveCell];
-
-                // translate the slave face into rotation zero if applicable
-                if (starCellPermutation_[slaveCell] > -1)
-                {
-                    const label curSlavePermutation =
-                        starCellPermutation_[slaveCell];
-
-                    rotZeroSlaveFace =
-                        sammFacePermutationTable
-                            [curSlavePermutation]
-                            [rotXSlaveFace];
-                }
-                else
-                {
-                    rotZeroSlaveFace = rotXSlaveFace;
-                }
-
-                label slaveFaceID =
-                    shapeFaceLookup
-                        [cellShapes_[slaveCell].model().index()]
-                        [rotZeroSlaveFace];
-
-                // Set the couple
-                couples_.set
-                (
-                    couplei++,
-                    new coupledFacePair
-                    (
-                        matchLabel,
-                        masterCell, masterFaceID,
-                        slaveCell, slaveFaceID,
-                        typeFlag
-                    )
-                );
-            }
-        }
-
-        Info<< "finished reading couples" << endl;
-    }
-}
-
-
-// ************************************************************************* //
diff --git a/applications/utilities/mesh/conversion/star3ToFoam/readPoints.C b/applications/utilities/mesh/conversion/star3ToFoam/readPoints.C
deleted file mode 100644
index 818befe4a5..0000000000
--- a/applications/utilities/mesh/conversion/star3ToFoam/readPoints.C
+++ /dev/null
@@ -1,175 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2015 OpenFOAM Foundation
-     \\/     M anipulation  | Copyright (C) 2016 OpenCFD Ltd.
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-Description
-    Create intermediate mesh from PROSTAR files
-
-\*---------------------------------------------------------------------------*/
-
-#include "starMesh.H"
-#include "IFstream.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-Foam::label Foam::starMesh::readVtxLabel(IFstream& is)
-{
-    char lcs[16];
-
-    for (int i=0; i<15; i++)
-    {
-        if (!is.good())
-        {
-            return -1;
-        }
-
-        is.get(lcs[i]);
-    }
-
-    lcs[15] = '\0';
-
-    return atoi(lcs);
-}
-
-
-Foam::scalar Foam::starMesh::readVtxCmpt(IFstream& is)
-{
-    char lcs[17];
-
-    for (int i=0; i<16; i++)
-    {
-        is.get(lcs[i]);
-    }
-
-    lcs[16] = '\0';
-
-    return scalar(atof(lcs));
-}
-
-
-void Foam::starMesh::readToNl(IFstream& is)
-{
-    char c;
-    do
-    {
-        is.get(c);
-    } while (is && c != '\n');
-}
-
-
-void Foam::starMesh::readPoints(const scalar scaleFactor)
-{
-    label nPoints = 0;
-    label maxLabel = -1;
-
-    fileName pointsFileName(casePrefix_ + ".vrt");
-
-    {
-        IFstream pointsFile(pointsFileName);
-
-        // Pass 1: get # points and maximum vertex label
-
-        if (pointsFile.good())
-        {
-            maxLabel = -1;
-            while (pointsFile)
-            {
-                label pointLabel = readVtxLabel(pointsFile);
-
-                if (!pointsFile) break;
-
-                maxLabel = max(maxLabel, pointLabel);
-
-                readVtxCmpt(pointsFile);
-                readVtxCmpt(pointsFile);
-                readVtxCmpt(pointsFile);
-
-                readToNl(pointsFile);
-
-                nPoints++;
-            }
-        }
-        else
-        {
-            FatalErrorInFunction
-                << "Cannot read file " << pointsFileName
-                << abort(FatalError);
-        }
-    }
-
-    Info<< "Number of points = " << nPoints << endl << endl;
-
-    points_.setSize(nPoints);
-
-    #ifdef starMesh_H
-    starPointID_.setSize(nPoints);
-
-    // Reset STAR point ID, just in case
-    starPointID_ = -1;
-    #endif
-
-    starPointLabelLookup_.setSize(maxLabel+1);
-
-    // reset point labels to invalid value
-    starPointLabelLookup_ = -1;
-
-    if (nPoints > 0)
-    {
-        // Pass 2: construct pointlist and conversion table
-        // from Star vertex numbers to Foam pointLabels
-
-        IFstream pointsFile(pointsFileName);
-        label pointLabel;
-
-        forAll(points_, p)
-        {
-            pointLabel = readVtxLabel(pointsFile);
-            points_[p].x() = readVtxCmpt(pointsFile);
-            points_[p].y() = readVtxCmpt(pointsFile);
-            points_[p].z() = readVtxCmpt(pointsFile);
-
-            readToNl(pointsFile);
-
-            #ifdef starMesh_H
-            starPointID_[p] = pointLabel;
-            #endif
-
-            starPointLabelLookup_[pointLabel] = p;
-        }
-
-        if (scaleFactor > 1.0 + SMALL || scaleFactor < 1.0 - SMALL)
-        {
-            points_ *= scaleFactor;
-        }
-    }
-    else
-    {
-        FatalError
-            << "void starMesh::readPoints() : "
-            << "no points in file "
-            << pointsFileName
-            << abort(FatalError);
-    }
-}
-
-
-// ************************************************************************* //
diff --git a/applications/utilities/mesh/conversion/star3ToFoam/readSeparatedPoints.C b/applications/utilities/mesh/conversion/star3ToFoam/readSeparatedPoints.C
deleted file mode 100644
index 73782190c2..0000000000
--- a/applications/utilities/mesh/conversion/star3ToFoam/readSeparatedPoints.C
+++ /dev/null
@@ -1,116 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2015 OpenFOAM Foundation
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-Description
-    Create intermediate mesh from PROSTAR files
-
-\*---------------------------------------------------------------------------*/
-
-#include "starMesh.H"
-#include "IFstream.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-void Foam::starMesh::readPoints(const scalar scaleFactor)
-{
-    label nPoints = 0;
-    label maxLabel = -1;
-
-    fileName pointsFileName(casePrefix_ + ".vrt");
-
-    {
-        IFstream pointsFile(pointsFileName);
-
-        // Pass 1: get # points and maximum vertex label
-
-        if (pointsFile.good())
-        {
-            label pointLabel;
-            scalar x, y, z;
-
-            maxLabel = -1;
-            while ((pointsFile >> pointLabel).good())
-            {
-                nPoints++;
-                maxLabel = max(maxLabel, pointLabel);
-                pointsFile >> x >> y >> z;
-            }
-        }
-        else
-        {
-            FatalErrorInFunction
-                << "Cannot read file " << pointsFileName
-                << abort(FatalError);
-        }
-    }
-
-    Info<< "Number of points = " << nPoints << endl << endl;
-
-    points_.setSize(nPoints);
-    starPointID_.setSize(nPoints);
-
-    // Reset STAR point ID, just in case
-    starPointID_ = -1;
-
-    starPointLabelLookup_.setSize(maxLabel+1);
-
-    // reset point labels to invalid value
-    starPointLabelLookup_ = -1;
-
-    if (nPoints > 0)
-    {
-        // Pass 2: construct pointlist and conversion table
-        // from Star vertex numbers to Foam pointLabels
-
-        IFstream pointsFile(pointsFileName);
-        label pointLabel;
-
-        forAll(points_, p)
-        {
-            pointsFile
-                >> pointLabel
-                >> points_[p].x()
-                >> points_[p].y()
-                >> points_[p].z();
-
-            starPointID_[p] = pointLabel;
-            starPointLabelLookup_[pointLabel] = p;
-        }
-
-        if (scaleFactor > 1.0 + SMALL || scaleFactor < 1.0 - SMALL)
-        {
-            points_ *= scaleFactor;
-        }
-    }
-    else
-    {
-        FatalError
-            << "void starMesh::readPoints() : "
-            << "no points in file "
-            << pointsFileName
-            << abort(FatalError);
-    }
-}
-
-
-// ************************************************************************* //
diff --git a/applications/utilities/mesh/conversion/star3ToFoam/star3ToFoam.C b/applications/utilities/mesh/conversion/star3ToFoam/star3ToFoam.C
deleted file mode 100644
index 4e6449b9fd..0000000000
--- a/applications/utilities/mesh/conversion/star3ToFoam/star3ToFoam.C
+++ /dev/null
@@ -1,84 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2015 OpenFOAM Foundation
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-Application
-    star3ToFoam
-
-Group
-    grpMeshConversionUtilities
-
-Description
-    Converts a Star-CD (v3) pro-STAR mesh into OpenFOAM format.
-
-\*---------------------------------------------------------------------------*/
-
-#include "argList.H"
-#include "Time.H"
-#include "starMesh.H"
-
-using namespace Foam;
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-int main(int argc, char *argv[])
-{
-    argList::addNote
-    (
-        "convert pro-STAR (v3) mesh to OpenFOAM"
-    );
-
-    argList::noParallel();
-    argList::validArgs.append("pro-STAR prefix");
-    argList::addOption
-    (
-        "scale",
-        "factor",
-        "geometry scaling factor - default is 1"
-    );
-
-    argList args(argc, argv);
-
-    if (!args.check())
-    {
-        FatalError.exit();
-    }
-
-    const scalar scaleFactor = args.optionLookupOrDefault("scale", 1.0);
-
-    #include "createTime.H"
-
-    starMesh makeMesh(args[1], runTime, scaleFactor);
-
-    // Set the precision of the points data to 10
-    IOstream::defaultPrecision(max(10u, IOstream::defaultPrecision()));
-
-    Info<< "Writing mesh" << endl;
-    makeMesh.writeMesh();
-
-    Info<< "\nEnd\n" << endl;
-
-    return 0;
-}
-
-
-// ************************************************************************* //
diff --git a/applications/utilities/mesh/conversion/star3ToFoam/starMesh.C b/applications/utilities/mesh/conversion/star3ToFoam/starMesh.C
deleted file mode 100644
index 898c0c8f1d..0000000000
--- a/applications/utilities/mesh/conversion/star3ToFoam/starMesh.C
+++ /dev/null
@@ -1,295 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-\*---------------------------------------------------------------------------*/
-
-#include "starMesh.H"
-#include "emptyPolyPatch.H"
-#include "demandDrivenData.H"
-#include "cellModeller.H"
-
-// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
-
-// Merge tolerances
-const Foam::scalar Foam::starMesh::smallMergeTol_ = 1e-3;
-const Foam::scalar Foam::starMesh::cpMergePointTol_ = 1e-4;
-
-// Cell shape models
-const Foam::cellModel* Foam::starMesh::unknownPtr_ =
-    Foam::cellModeller::lookup("unknown");
-const Foam::cellModel* Foam::starMesh::tetPtr_ =
-    Foam::cellModeller::lookup("tet");
-const Foam::cellModel* Foam::starMesh::pyrPtr_ =
-    Foam::cellModeller::lookup("pyr");
-const Foam::cellModel* Foam::starMesh::tetWedgePtr_ =
-    Foam::cellModeller::lookup("tetWedge");
-const Foam::cellModel* Foam::starMesh::prismPtr_ =
-    Foam::cellModeller::lookup("prism");
-const Foam::cellModel* Foam::starMesh::wedgePtr_ =
-    Foam::cellModeller::lookup("wedge");
-const Foam::cellModel* Foam::starMesh::hexPtr_ =
-    Foam::cellModeller::lookup("hex");
-
-const Foam::cellModel* Foam::starMesh::sammTrim1Ptr_ =
-    Foam::cellModeller::lookup("sammTrim1");
-const Foam::cellModel* Foam::starMesh::sammTrim2Ptr_ =
-    Foam::cellModeller::lookup("sammTrim2");
-const Foam::cellModel* Foam::starMesh::sammTrim3Ptr_ =
-    Foam::cellModeller::lookup("sammTrim3");
-const Foam::cellModel* Foam::starMesh::sammTrim4Ptr_ =
-    Foam::cellModeller::lookup("sammTrim4");
-const Foam::cellModel* Foam::starMesh::sammTrim5Ptr_ =
-    Foam::cellModeller::lookup("sammTrim5");
-const Foam::cellModel* Foam::starMesh::sammTrim8Ptr_ =
-    Foam::cellModeller::lookup("hexagonalPrism");
-
-// Regular cell point addressing
-// SAMM point addressing
-const Foam::label Foam::starMesh::regularAddressingTable[6][8] =
-{
-    { 0,  1,  2,  4, -1, -1, -1, -1},    // tet
-    { 0,  1,  2,  3,  4, -1, -1, -1},    // pyramid
-    { 0,  1,  2,  4,  6, -1, -1, -1},    // tet wedge
-    { 0,  1,  2,  4,  5,  6, -1, -1},    // prism
-    { 7,  6,  5,  3,  2,  1,  0, -1},    // wedge
-    { 0,  1,  2,  3,  4,  5,  6,  7}     // hex
-};
-
-
-// SAMM point addressing
-const Foam::label Foam::starMesh::sammAddressingTable[9][12] =
-{
-    {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},    // samm0 - empty
-    { 3,  2,  6,  7, 11,  9,  1,  5,  4, 12, -1, -1},    // samm1+
-    {13,  5,  6,  2, 10, 12,  4,  7,  3, 11, -1, -1},    // samm2+
-    { 2,  3,  0,  1, 10, 11, 12,  4,  8,  9, -1, -1},    // samm3+
-    { 0,  1,  3,  4, 13,  8,  9, 10, 11, 12, -1, -1},    // samm4+
-    {12,  7,  6,  5,  8, 11, 10,  9, -1, -1, -1, -1},    // samm5+
-    {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},    // samm6 - empty
-    {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},    // samm7 - empty
-    {11,  3, 15, 12,  4,  8, 10,  2, 14, 13,  5,  9}     // samm8+
-};
-
-
-// lookup table giving OpenFOAM face number when looked up with shape index
-// (first index) and STAR face number
-// - first column is always -1
-// - last column is -1 for all but hexagonal prism
-// WARNING: Possible bug for sammTrim2
-// The lookup table for SAMM shapes is based on the rotation of the
-// shape. This would imply that the table below needs to be split between
-// the regular shapes (3-9), which are OK, and the SAMM shapes, for which
-// the face lookup needs to be done based on the rotation. Thus, for a samm
-// cell, firts find out the face index in the normal rotation using the cell
-// face permutation table and then use the index from the shape face lookup.
-// Additionally, have in mind that this silliness does not allow matches
-// on face 7 and 8 of the samm cell.
-
-const Foam::label Foam::starMesh::sammFacePermutationTable[24][8] =
-{
-  {-1, 1, 2, 3, 4, 5, 6, 7},    // permutation   0
-  {-1, 3, 4, 5, 6, 1, 2, 7},    // permutation   1
-  {-1, 5, 6, 1, 2, 3, 4, 7},    // permutation   2
-  {-1, 1, 2, 5, 6, 4, 3, 7},    // permutation   3
-  {-1, 3, 4, 1, 2, 6, 5, 7},    // permutation   4
-  {-1, 5, 6, 3, 4, 2, 1, 7},    // permutation   5
-  {-1, 1, 2, 4, 3, 6, 5, 7},    // permutation   6
-  {-1, 3, 4, 6, 5, 2, 1, 7},    // permutation   7
-  {-1, 5, 6, 2, 1, 4, 3, 7},    // permutation   8
-  {-1, 1, 2, 6, 5, 3, 4, 7},    // permutation   9
-  {-1, 3, 4, 2, 1, 5, 6, 7},    // permutation  10
-  {-1, 5, 6, 4, 3, 1, 2, 7},    // permutation  11
-  {-1, 2, 1, 5, 6, 3, 4, 7},    // permutation  12
-  {-1, 4, 3, 1, 2, 5, 6, 7},    // permutation  13
-  {-1, 6, 5, 3, 4, 1, 2, 7},    // permutation  14
-  {-1, 2, 1, 3, 4, 6, 5, 7},    // permutation  15
-  {-1, 4, 3, 5, 6, 2, 1, 7},    // permutation  16
-  {-1, 6, 5, 1, 2, 4, 3, 7},    // permutation  17
-  {-1, 2, 1, 6, 5, 4, 3, 7},    // permutation  18
-  {-1, 4, 3, 2, 1, 6, 5, 7},    // permutation  19
-  {-1, 6, 5, 4, 3, 2, 1, 7},    // permutation  20
-  {-1, 2, 1, 4, 3, 5, 6, 7},    // permutation  21
-  {-1, 4, 3, 6, 5, 1, 2, 7},    // permutation  22
-  {-1, 6, 5, 2, 1, 3, 4, 7}     // permutation  23
-};
-
-const Foam::label Foam::starMesh::shapeFaceLookup[19][9] =
-{
-    {-1, -1, -1, -1, -1, -1, -1, -1, -1},    // shape  0 - empty+
-    {-1, -1, -1, -1, -1, -1, -1, -1, -1},    // shape  1 - empty+
-    {-1, -1, -1, -1, -1, -1, -1, -1, -1},    // shape  2 - empty+
-    {-1,  4,  5,  2,  3,  0,  1, -1, -1},    // shape  3 - hex+
-    {-1,  1,  0,  5,  4,  2,  3, -1, -1},    // shape  4 - wedge+
-    {-1,  0,  1,  4, -1,  2,  3, -1, -1},    // shape  5 - prism+
-    {-1,  0, -1,  4,  2,  1,  3, -1, -1},    // shape  6 - pyr+
-    {-1,  3, -1,  2, -1,  1,  0, -1, -1},    // shape  7 - tet+
-    {-1, -1, -1, -1, -1, -1, -1, -1, -1},    // shape  8 - splitHex (empty)
-    {-1,  0, -1,  1, -1,  2,  3, -1, -1},    // shape  9 - tetWedge+
-    {-1, -1, -1, -1, -1, -1, -1, -1, -1},    // shape 10 - empty+
-    {-1,  1,  0,  3,  2,  5,  4,  6, -1},    // shape 11 - sammTrim1
-    {-1,  5,  4,  1,  0,  3,  2,  6, -1},    // shape 12 - sammTrim2
-    {-1,  2,  3,  0,  1,  4,  5,  6, -1},    // shape 13 - sammTrim3
-    {-1,  2,  3,  0,  1,  4,  5,  6, -1},    // shape 14 - sammTrim4
-    {-1,  5,  2,  4,  3,  1,  0, -1, -1},    // shape 15 - sammTrim5
-    {-1, -1, -1, -1, -1, -1, -1, -1, -1},    // shape 16 - empty
-    {-1, -1, -1, -1, -1, -1, -1, -1, -1},    // shape 17 - empty
-    {-1,  1,  0,  6,  7,  2,  3,  4,  5}     // shape 18 - sammTrim8
-};
-
-
-// The star to foam face order mapping tables are potentially incomplete
-// Currently available data is listed below.
-// 1) hex and degenerate hex: OK
-// samm trim 1:
-// star number: 1 2 3 4 5 6 7 8  In ROTATION 0
-// foam number: 5 4 1 0 3 2 6
-// confirmed:   1 0 3 2 5 4 6
-
-// samm trim 2:
-// star number: 1 2 3 4 5 6 7 8  In ROTATION 0
-// foam number: 5 4 1 0 3 2 6
-// confirmed:     4   0 3 2
-
-// samm trim 3:
-// star number: 1 2 3 4 5 6 7 8  In ROTATION 0
-// foam number: 2 3 0 1 4 5 6
-// confirmed:
-
-// samm trim 4:
-// star number: 1 2 3 4 5 6 7 8  In ROTATION 0
-// foam number: 2 3 0 1 4 5 6
-// confirmed:
-
-// samm trim 5:
-// star number: 1 2 3 4 5 6 7 8  In ROTATION 0
-// foam number: 2 4 3 1 0 5
-// confirmed:   5 2 4 3 1 0
-
-// samm trim 8:
-// star number: 1 2 3 4 5 6 7 8  In ROTATION 0
-// foam number: 2 5 4 7 1 0 3 6
-// confirmed:   1 0 6
-
-
-// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
-
-void Foam::starMesh::createPolyMeshData()
-{
-    Info<< "Creating a polyMesh" << endl;
-
-    createPolyCells();
-
-    Info<< "\nNumber of internal faces: "
-        << nInternalFaces_ << endl;
-
-    createPolyBoundary();
-}
-
-
-void Foam::starMesh::clearExtraStorage()
-{
-    Info<< "Clearing extra storage" << endl;
-
-    starPointLabelLookup_.setSize(0);
-    starPointID_.setSize(0);
-    starCellID_.setSize(0);
-    starCellLabelLookup_.setSize(0);
-    starCellPermutation_.setSize(0);
-    cellFaces_.setSize(0);
-    boundaryCellIDs_.setSize(0);
-    boundaryCellFaceIDs_.setSize(0);
-    couples_.clear();
-
-    deleteDemandDrivenData(pointCellsPtr_);
-}
-
-
-// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
-
-Foam::starMesh::starMesh
-(
-    const fileName& prefix,
-    const Time& rt,
-    const scalar scaleFactor
-)
-:
-    casePrefix_(prefix),
-    runTime_(rt),
-    points_(0),
-    cellShapes_(0),
-    boundary_(0),
-    patchTypes_(0),
-    defaultFacesName_("defaultFaces"),
-    defaultFacesType_(emptyPolyPatch::typeName),
-    patchNames_(0),
-    patchPhysicalTypes_(0),
-    starPointLabelLookup_(0),
-    starPointID_(0),
-    starCellID_(0),
-    starCellLabelLookup_(0),
-    starCellPermutation_(0),
-    cellFaces_(0),
-    boundaryCellIDs_(0),
-    boundaryCellFaceIDs_(0),
-    meshFaces_(0),
-    cellPolys_(0),
-    nInternalFaces_(0),
-    polyBoundaryPatchStartIndices_(0),
-    pointCellsPtr_(nullptr),
-    couples_(0),
-    isShapeMesh_(true)
-{
-    readPoints(scaleFactor);
-
-    readCells();
-
-    readBoundary();
-
-    fixCollapsedEdges();
-
-    readCouples();
-
-    if (couples_.size())
-    {
-        createCoupleMatches();
-    }
-
-    markBoundaryFaces();
-
-    mergeCoupleFacePoints();
-
-    purgeCellShapes();
-
-    collectBoundaryFaces();
-}
-
-
-// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
-
-Foam::starMesh::~starMesh()
-{
-    deleteDemandDrivenData(pointCellsPtr_);
-}
-
-
-// ************************************************************************* //
diff --git a/applications/utilities/mesh/conversion/star3ToFoam/starMesh.H b/applications/utilities/mesh/conversion/star3ToFoam/starMesh.H
deleted file mode 100644
index 1fbc8f6836..0000000000
--- a/applications/utilities/mesh/conversion/star3ToFoam/starMesh.H
+++ /dev/null
@@ -1,318 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2015 OpenFOAM Foundation
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-Class
-    Foam::starMesh
-
-Description
-    A messy mesh class which supports the possibility of creating a shapeMesh
-    for regular Star meshes (no arbitrary interfaces or collapsed SAMM cells).
-    If any of these special feateres exist, the mesh is created as polyMesh
-
-SourceFiles
-    calcPointCells.C
-    createBoundaryFaces.C
-    createCoupleMatches.C
-    createPolyBoundary.C
-    createPolyCells.C
-    fixCollapsedEdges.C
-    mergeCoupleFacePoints.C
-    readBoundary.C
-    readCells.C
-    readCouples.C
-    readPoints.C
-    starMesh.C
-    writeMesh.C
-
-\*---------------------------------------------------------------------------*/
-
-#ifndef starMesh_H
-#define starMesh_H
-
-#include "polyMesh.H"
-#include "cellShape.H"
-#include "cellList.H"
-#include "polyPatchList.H"
-#include "coupledFacePair.H"
-#include "IFstream.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-namespace Foam
-{
-
-/*---------------------------------------------------------------------------*\
-                           Class starMesh Declaration
-\*---------------------------------------------------------------------------*/
-
-class starMesh
-{
-    // Private data
-
-        //- Name of the case
-        fileName casePrefix_;
-
-        //- Database
-        const Time& runTime_;
-
-        //- Points supporting the mesh
-        pointField points_;
-
-        //- Cell shapes
-        cellShapeList cellShapes_;
-
-        //- Boundary faces
-        faceListList boundary_;
-
-        //- Boundary patch types
-        wordList patchTypes_;
-
-        //- Default boundary patch name
-        word defaultFacesName_;
-
-        //- Default boundary patch types
-        word defaultFacesType_;
-
-        //- Boundary patch names
-        wordList patchNames_;
-
-        //- Boundary patch physical types
-        wordList patchPhysicalTypes_;
-
-        //- Point labels (STAR point numbering is not necessarily contiguous)
-        labelList starPointLabelLookup_;
-
-        //- STAR point number for a given vertex
-        labelList starPointID_;
-
-        //- STAR Cell number for a given cell
-        labelList starCellID_;
-
-        //- Cell labels (STAR cell numbering is not necessarily contiguous)
-        labelList starCellLabelLookup_;
-
-        //- STAR Cell permutation label
-        labelList starCellPermutation_;
-
-        //- List of faces for every cell
-        faceListList cellFaces_;
-
-        //- Cell ID for every boundary face. Used in two-tier boundary
-        //  reconstruction
-        labelListList boundaryCellIDs_;
-
-        //- Cell face ID for every boundary face. Used in two-tier boundary
-        //  reconstruction
-        labelListList boundaryCellFaceIDs_;
-
-        //- Global face list for polyMesh
-        faceList meshFaces_;
-
-        //- Cells as polyhedra for polyMesh
-        cellList cellPolys_;
-
-        //- Number of internal faces for polyMesh
-        label nInternalFaces_;
-
-        //- Polyhedral mesh boundary patch start indices
-        labelList polyBoundaryPatchStartIndices_;
-
-        //- Point-cell addressing. Used for topological analysis
-        // Warning. This point cell addressing list potentially contains
-        // duplicate cell entries. Use additional checking
-        mutable labelListList* pointCellsPtr_;
-
-        //- List of face couples
-        PtrList<coupledFacePair> couples_;
-
-        //- Can the mesh be treated as a shapeMesh?
-        bool isShapeMesh_;
-
-    // Private static data members
-
-        //- Error on unity small tolerance
-        static const scalar smallMergeTol_;
-
-        //- Couple match relative point merge tolerance
-        static const scalar cpMergePointTol_;
-
-        //- Pointers to cell models
-        static const cellModel* unknownPtr_;
-        static const cellModel* tetPtr_;
-        static const cellModel* pyrPtr_;
-        static const cellModel* tetWedgePtr_;
-        static const cellModel* prismPtr_;
-        static const cellModel* wedgePtr_;
-        static const cellModel* hexPtr_;
-
-        static const cellModel* sammTrim1Ptr_;
-        static const cellModel* sammTrim2Ptr_;
-        static const cellModel* sammTrim3Ptr_;
-        static const cellModel* sammTrim4Ptr_;
-        static const cellModel* sammTrim5Ptr_;
-        static const cellModel* sammTrim8Ptr_;
-
-        //- Regular addressing data
-        static const label regularAddressingTable[6][8];
-
-        //- SAMM addressing data
-        static const label sammAddressingTable[9][12];
-
-        static const label sammFacePermutationTable[24][8];
-
-        static const label shapeFaceLookup[19][9];
-
-
-    // Private Member Functions
-
-        //- Disallow default bitwise copy construct
-        starMesh(const starMesh&);
-
-        //- Disallow default bitwise assignment
-        void operator=(const starMesh&);
-
-
-        //- Read fixed format vertex label
-        static label readVtxLabel(IFstream&);
-
-        //- Read fixed format vertex coordinate component
-        static scalar readVtxCmpt(IFstream&);
-
-        //- Read to nl
-        static void readToNl(IFstream&);
-
-        //- Read the points file
-        void readPoints(const scalar scaleFactor);
-
-        //- Read the cells file
-        void readCells();
-
-        void addRegularCell
-        (
-            const labelList& labels,
-            const label nCreatedCells
-        );
-
-        void addSAMMcell
-        (
-            const labelList& labels,
-            const label nCreatedCells
-        );
-
-        //- Read the boundary file
-        void readBoundary();
-
-        //- Check and correct collapsed edges on faces
-        // Note. If a collapsed edge is found, the mesh is no longer shapeMesh
-        void fixCollapsedEdges();
-
-        //- Read couples
-        void readCouples();
-
-        //- Create couple matches
-        void createCoupleMatches();
-
-        //- Calculate pointCells
-        void calcPointCells() const;
-
-        const labelListList& pointCells() const;
-
-        //- Mark boundary faces from the quads
-        void markBoundaryFaces();
-
-        //- Collect boundary faces from the quads
-        void collectBoundaryFaces();
-
-        //- Specialist version of face comparison to deal with
-        // PROSTAR boundary format idiosyncracies
-        bool starEqualFace
-        (
-            const face& boundaryFace,
-            const face& cellFace
-        ) const;
-
-        //- Merge couple face points
-        void mergeCoupleFacePoints();
-
-        //- Point indexing structure used by sort to keep track of
-        //  the point labels
-        struct pointIndex
-        {
-            label label_;
-            double index_;
-        };
-
-        //- Purge cell shapes
-        void purgeCellShapes();
-
-        //- Make polyhedral cells and global faces if the mesh is polyhedral
-        void createPolyCells();
-
-        //- Make polyhedral boundary from shape boundary
-        // (adds more faces to the face list)
-        void createPolyBoundary();
-
-        //- Make polyhedral mesh data (packing)
-        void createPolyMeshData();
-
-        //- Add polyhedral boundary
-        List<polyPatch*> polyBoundaryPatches(const polyMesh&);
-
-        //- Clear extra storage before creation of the mesh to remove
-        //  a memory peak
-        void clearExtraStorage();
-
-
-public:
-
-    // Constructors
-
-        //- Construct from case name
-        starMesh
-        (
-            const fileName& prefix,
-            const Time& rt,
-            const scalar scaleFactor
-        );
-
-
-    //- Destructor
-    ~starMesh();
-
-
-    // Member Functions
-
-        //- Write mesh
-        void writeMesh();
-};
-
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#endif
-
-// ************************************************************************* //
diff --git a/applications/utilities/mesh/conversion/star3ToFoam/writeMesh.C b/applications/utilities/mesh/conversion/star3ToFoam/writeMesh.C
deleted file mode 100644
index d78be00540..0000000000
--- a/applications/utilities/mesh/conversion/star3ToFoam/writeMesh.C
+++ /dev/null
@@ -1,98 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2015 OpenFOAM Foundation
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-Description
-    Create intermediate mesh files from PROSTAR files
-
-\*---------------------------------------------------------------------------*/
-
-#include "starMesh.H"
-#include "Time.H"
-#include "polyMesh.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-void Foam::starMesh::writeMesh()
-{
-    if (isShapeMesh_)
-    {
-        Info<< "This is a shapeMesh." << endl;
-
-        Info<< "Default patch type set to empty" << endl;
-
-        clearExtraStorage();
-
-        polyMesh pShapeMesh
-        (
-            IOobject
-            (
-                polyMesh::defaultRegion,
-                runTime_.constant(),
-                runTime_
-            ),
-            xferCopy(points_),           // we could probably re-use the data
-            cellShapes_,
-            boundary_,
-            patchNames_,
-            patchTypes_,
-            defaultFacesName_,
-            defaultFacesType_,
-            patchPhysicalTypes_
-        );
-
-        Info<< "Writing polyMesh" << endl;
-        pShapeMesh.write();
-    }
-    else
-    {
-        // This is a polyMesh.
-
-        createPolyMeshData();
-
-        Info<< "This is a polyMesh" << endl;
-
-        clearExtraStorage();
-
-        polyMesh pMesh
-        (
-            IOobject
-            (
-                polyMesh::defaultRegion,
-                runTime_.constant(),
-                runTime_
-            ),
-            xferCopy(points_),           // we could probably re-use the data
-            xferCopy(meshFaces_),
-            xferCopy(cellPolys_)
-        );
-
-        // adding patches also checks the mesh
-        pMesh.addPatches(polyBoundaryPatches(pMesh));
-
-        Info<< "Writing polyMesh" << endl;
-        pMesh.write();
-    }
-}
-
-
-// ************************************************************************* //
diff --git a/etc/cellModels b/etc/cellModels
index 9a2df33cf0..6c4f4e4111 100644
--- a/etc/cellModels
+++ b/etc/cellModels
@@ -10,7 +10,7 @@
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-14
+9
 (
 
 unknown
@@ -258,198 +258,8 @@ splitHex
 
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-// SAMM cell types
-sammTrim1
-{
-    index 11;
-    numberOfPoints 10;
+// Other somewhat exotic types
 
-    faces
-    7
-    (
-        4(2 3 8 7)        // x-min
-        5(0 1 6 5 4)      // x-max
-        4(2 1 0 3)        // y-min
-        5(7 8 9 5 6)      // y-max
-        4(2 7 6 1)        // z-min
-        5(3 0 4 9 8)      // z-max
-        3(4 5 9)          // cut
-    );
-
-    edges
-    15
-    (
-        (2 1)            // x-direction
-        (3 0)
-        (8 9)
-        (7 6)
-        (2 7)            // y-direction
-        (3 8)
-        (0 4)
-        (1 6)
-        (2 3)            // z-direction
-        (7 8)
-        (6 5)
-        (1 0)
-        (4 5)            // other
-        (5 9)
-        (10 5)
-    );
-}
-
-
-sammTrim2
-{
-    index 12;
-    numberOfPoints 10;
-
-    faces
-    7
-    (
-        4(2 3 8 7)        // x-min
-        4(1 6 5 0)        // x-max
-        5(2 1 0 4 3)      // y-min
-        5(7 8 9 5 6)      // y-max
-        4(2 7 6 1)        // z-min
-        4(3 4 9 8)        // z-max
-        4(0 5 9 4)        // other
-    );
-
-    edges
-    15
-    (
-        (2 1)            // x-direction
-        (3 4)
-        (8 9)
-        (7 6)
-        (2 7)            // y-direction
-        (3 8)
-        (4 9)
-        (0 5)
-        (1 6)
-        (2 3)            // z-direction
-        (7 8)
-        (6 5)
-        (1 0)
-        (9 5)            // other
-        (4 0)
-    );
-}
-
-
-sammTrim3
-{
-    index 13;
-    numberOfPoints 10;
-
-    faces
-    7
-    (
-        5(2 3 9 8 7)      // x-min
-        4(1 5 4 0)        // x-max
-        4(2 1 0 3)        // y-min
-        3(7 8 6)          // y-max
-        5(2 7 6 5 1)      // z-min
-        4(3 0 4 9)        // z-max
-        5(4 5 6 8 9)      // other
-    );
-
-    edges
-    15
-    (
-        (2 1)            // x-direction
-        (3 0)
-        (7 6)
-        (2 7)            // y-direction
-        (3 9)
-        (0 4)
-        (1 5)
-        (2 3)            // z-direction
-        (1 0)
-        (8 7)
-        (8 9)            // other
-        (9 4)
-        (4 5)
-        (5 6)
-        (6 8)
-    );
-}
-
-
-sammTrim4
-{
-    index 14;
-    numberOfPoints 10;
-
-    faces
-    7
-    (
-        5(0 2 6 5 1)      // x-min
-        3(3 9 8)          // x-max
-        5(0 3 8 7 2)      // y-min
-        3(1 5 4)          // y-max
-        5(0 1 4 9 3)      // z-min
-        3(2 7 6)          // z-max
-        6(4 5 6 7 8 9)    // other
-    );
-
-    edges
-    15
-    (
-        (0 3)            // x-direction
-        (1 4)
-        (2 7)
-        (0 1)            // y-direction
-        (2 6)
-        (3 9)
-        (0 2)            // z-direction
-        (3 8)
-        (1 5)
-        (4 5)            // other
-        (5 6)
-        (6 7)
-        (7 8)
-        (8 9)
-        (9 4)
-    );
-}
-
-
-sammTrim5
-{
-    index 15;
-    numberOfPoints 8;
-
-    faces
-    6
-    (
-        4(2 3 7 6)        // x-min
-        3(1 5 0)          // x-max
-        5(2 1 0 4 3)      // y-min
-        4(2 6 5 1)        // z-min
-        3(3 4 7)          // z-max
-        5(0 5 6 7 4)      // other
-    );
-
-    edges
-    12
-    (
-        (2 1)            // x-direction
-        (3 4)
-        (2 6)            // y-direction
-        (3 7)
-        (1 5)
-        (2 3)            // z-direction
-        (1 0)
-        (0 5)            // other
-        (5 6)
-        (6 7)
-        (7 4)
-        (4 0)
-    );
-}
-
-// Equal to sammTrim8
 hexagonalPrism
 {
     index 18;

From 7e4f200bd627af8fe7572efec99c57f26eedf3df Mon Sep 17 00:00:00 2001
From: Mark Olesen <Mark.Olesen@Germany>
Date: Thu, 4 Aug 2016 16:57:56 +0200
Subject: [PATCH 4/6] GIT: rearrange files for lib-conversion

- re-group according to file-format instead of reader/writer
---
 src/conversion/Make/files                     | 22 +++++++++----------
 .../{meshReader => common/reader}/README      |  0
 .../reader}/calcPointCells.C                  |  0
 .../reader}/createPolyBoundary.C              |  0
 .../reader}/createPolyCells.C                 |  0
 .../reader}/meshReader.C                      |  0
 .../reader}/meshReader.H                      |  0
 .../reader}/meshReaderAux.C                   |  0
 .../{meshTables => common/tables}/README      |  0
 .../tables}/boundaryRegion.C                  |  0
 .../tables}/boundaryRegion.H                  |  0
 .../{meshTables => common/tables}/cellTable.C |  0
 .../{meshTables => common/tables}/cellTable.H |  0
 .../tables}/remappingDict                     |  0
 .../writer}/meshWriter.C                      |  0
 .../writer}/meshWriter.H                      |  0
 .../starcd/STARCDMeshReader.C                 |  0
 .../starcd/STARCDMeshReader.H                 |  0
 .../starcd/STARCDMeshWriter.C                 |  0
 .../starcd/STARCDMeshWriter.H                 |  0
 20 files changed, 11 insertions(+), 11 deletions(-)
 rename src/conversion/{meshReader => common/reader}/README (100%)
 rename src/conversion/{meshReader => common/reader}/calcPointCells.C (100%)
 rename src/conversion/{meshReader => common/reader}/createPolyBoundary.C (100%)
 rename src/conversion/{meshReader => common/reader}/createPolyCells.C (100%)
 rename src/conversion/{meshReader => common/reader}/meshReader.C (100%)
 rename src/conversion/{meshReader => common/reader}/meshReader.H (100%)
 rename src/conversion/{meshReader => common/reader}/meshReaderAux.C (100%)
 rename src/conversion/{meshTables => common/tables}/README (100%)
 rename src/conversion/{meshTables => common/tables}/boundaryRegion.C (100%)
 rename src/conversion/{meshTables => common/tables}/boundaryRegion.H (100%)
 rename src/conversion/{meshTables => common/tables}/cellTable.C (100%)
 rename src/conversion/{meshTables => common/tables}/cellTable.H (100%)
 rename src/conversion/{meshTables => common/tables}/remappingDict (100%)
 rename src/conversion/{meshWriter => common/writer}/meshWriter.C (100%)
 rename src/conversion/{meshWriter => common/writer}/meshWriter.H (100%)
 rename src/conversion/{meshReader => }/starcd/STARCDMeshReader.C (100%)
 rename src/conversion/{meshReader => }/starcd/STARCDMeshReader.H (100%)
 rename src/conversion/{meshWriter => }/starcd/STARCDMeshWriter.C (100%)
 rename src/conversion/{meshWriter => }/starcd/STARCDMeshWriter.H (100%)

diff --git a/src/conversion/Make/files b/src/conversion/Make/files
index b4a38476a1..bbf86cf859 100644
--- a/src/conversion/Make/files
+++ b/src/conversion/Make/files
@@ -1,3 +1,12 @@
+common/reader/meshReader.C
+common/reader/meshReaderAux.C
+common/reader/calcPointCells.C
+common/reader/createPolyCells.C
+common/reader/createPolyBoundary.C
+common/writer/meshWriter.C
+common/tables/boundaryRegion.C
+common/tables/cellTable.C
+
 ensight/file/ensightFile.C
 ensight/file/ensightGeoFile.C
 ensight/readFile/ensightReadFile.C
@@ -7,18 +16,9 @@ ensight/part/ensightPartCells.C
 ensight/part/ensightPartFaces.C
 ensight/part/ensightParts.C
 
-meshTables/boundaryRegion.C
-meshTables/cellTable.C
 
-meshReader/meshReader.C
-meshReader/meshReaderAux.C
-meshReader/calcPointCells.C
-meshReader/createPolyCells.C
-meshReader/createPolyBoundary.C
-meshReader/starcd/STARCDMeshReader.C
-
-meshWriter/meshWriter.C
-meshWriter/starcd/STARCDMeshWriter.C
+starcd/STARCDMeshReader.C
+starcd/STARCDMeshWriter.C
 
 polyDualMesh/polyDualMesh.C
 
diff --git a/src/conversion/meshReader/README b/src/conversion/common/reader/README
similarity index 100%
rename from src/conversion/meshReader/README
rename to src/conversion/common/reader/README
diff --git a/src/conversion/meshReader/calcPointCells.C b/src/conversion/common/reader/calcPointCells.C
similarity index 100%
rename from src/conversion/meshReader/calcPointCells.C
rename to src/conversion/common/reader/calcPointCells.C
diff --git a/src/conversion/meshReader/createPolyBoundary.C b/src/conversion/common/reader/createPolyBoundary.C
similarity index 100%
rename from src/conversion/meshReader/createPolyBoundary.C
rename to src/conversion/common/reader/createPolyBoundary.C
diff --git a/src/conversion/meshReader/createPolyCells.C b/src/conversion/common/reader/createPolyCells.C
similarity index 100%
rename from src/conversion/meshReader/createPolyCells.C
rename to src/conversion/common/reader/createPolyCells.C
diff --git a/src/conversion/meshReader/meshReader.C b/src/conversion/common/reader/meshReader.C
similarity index 100%
rename from src/conversion/meshReader/meshReader.C
rename to src/conversion/common/reader/meshReader.C
diff --git a/src/conversion/meshReader/meshReader.H b/src/conversion/common/reader/meshReader.H
similarity index 100%
rename from src/conversion/meshReader/meshReader.H
rename to src/conversion/common/reader/meshReader.H
diff --git a/src/conversion/meshReader/meshReaderAux.C b/src/conversion/common/reader/meshReaderAux.C
similarity index 100%
rename from src/conversion/meshReader/meshReaderAux.C
rename to src/conversion/common/reader/meshReaderAux.C
diff --git a/src/conversion/meshTables/README b/src/conversion/common/tables/README
similarity index 100%
rename from src/conversion/meshTables/README
rename to src/conversion/common/tables/README
diff --git a/src/conversion/meshTables/boundaryRegion.C b/src/conversion/common/tables/boundaryRegion.C
similarity index 100%
rename from src/conversion/meshTables/boundaryRegion.C
rename to src/conversion/common/tables/boundaryRegion.C
diff --git a/src/conversion/meshTables/boundaryRegion.H b/src/conversion/common/tables/boundaryRegion.H
similarity index 100%
rename from src/conversion/meshTables/boundaryRegion.H
rename to src/conversion/common/tables/boundaryRegion.H
diff --git a/src/conversion/meshTables/cellTable.C b/src/conversion/common/tables/cellTable.C
similarity index 100%
rename from src/conversion/meshTables/cellTable.C
rename to src/conversion/common/tables/cellTable.C
diff --git a/src/conversion/meshTables/cellTable.H b/src/conversion/common/tables/cellTable.H
similarity index 100%
rename from src/conversion/meshTables/cellTable.H
rename to src/conversion/common/tables/cellTable.H
diff --git a/src/conversion/meshTables/remappingDict b/src/conversion/common/tables/remappingDict
similarity index 100%
rename from src/conversion/meshTables/remappingDict
rename to src/conversion/common/tables/remappingDict
diff --git a/src/conversion/meshWriter/meshWriter.C b/src/conversion/common/writer/meshWriter.C
similarity index 100%
rename from src/conversion/meshWriter/meshWriter.C
rename to src/conversion/common/writer/meshWriter.C
diff --git a/src/conversion/meshWriter/meshWriter.H b/src/conversion/common/writer/meshWriter.H
similarity index 100%
rename from src/conversion/meshWriter/meshWriter.H
rename to src/conversion/common/writer/meshWriter.H
diff --git a/src/conversion/meshReader/starcd/STARCDMeshReader.C b/src/conversion/starcd/STARCDMeshReader.C
similarity index 100%
rename from src/conversion/meshReader/starcd/STARCDMeshReader.C
rename to src/conversion/starcd/STARCDMeshReader.C
diff --git a/src/conversion/meshReader/starcd/STARCDMeshReader.H b/src/conversion/starcd/STARCDMeshReader.H
similarity index 100%
rename from src/conversion/meshReader/starcd/STARCDMeshReader.H
rename to src/conversion/starcd/STARCDMeshReader.H
diff --git a/src/conversion/meshWriter/starcd/STARCDMeshWriter.C b/src/conversion/starcd/STARCDMeshWriter.C
similarity index 100%
rename from src/conversion/meshWriter/starcd/STARCDMeshWriter.C
rename to src/conversion/starcd/STARCDMeshWriter.C
diff --git a/src/conversion/meshWriter/starcd/STARCDMeshWriter.H b/src/conversion/starcd/STARCDMeshWriter.H
similarity index 100%
rename from src/conversion/meshWriter/starcd/STARCDMeshWriter.H
rename to src/conversion/starcd/STARCDMeshWriter.H

From 762a20281009d521fcd45e462b0d03f5850b2111 Mon Sep 17 00:00:00 2001
From: mattijs <mattijs>
Date: Wed, 5 Oct 2016 17:52:54 +0100
Subject: [PATCH 5/6] BUG: snappyHexMesh: assing to boundaryField. Fixes #260.

---
 src/OpenFOAM/meshes/primitiveShapes/plane/plane.H      | 10 +++++-----
 .../snappyHexMeshDriver/snappyLayerDriver.C            |  3 ++-
 2 files changed, 7 insertions(+), 6 deletions(-)

diff --git a/src/OpenFOAM/meshes/primitiveShapes/plane/plane.H b/src/OpenFOAM/meshes/primitiveShapes/plane/plane.H
index ea31f0d86c..784b14c791 100644
--- a/src/OpenFOAM/meshes/primitiveShapes/plane/plane.H
+++ b/src/OpenFOAM/meshes/primitiveShapes/plane/plane.H
@@ -126,7 +126,7 @@ public:
     // Constructors
 
         //- Construct from normal vector through the origin
-        plane(const vector& normalVector);
+        explicit plane(const vector& normalVector);
 
         //- Construct from normal vector and point in plane
         plane
@@ -137,17 +137,17 @@ public:
         );
 
         //- Construct from three points in plane
-        plane(const point& point1, const point& point2, const point& point3);
+        plane(const point&, const point&, const point&);
 
         //- Construct from coefficients for the
         //  plane equation: ax + by + cz + d = 0
-        plane(const scalarList& C);
+        explicit plane(const scalarList& C);
 
         //- Construct from dictionary
-        plane(const dictionary& planeDict);
+        explicit plane(const dictionary& planeDict);
 
         //- Construct from Istream. Assumes the base + normal notation.
-        plane(Istream& is);
+        explicit plane(Istream& is);
 
 
     // Member Functions
diff --git a/src/mesh/snappyHexMesh/snappyHexMeshDriver/snappyLayerDriver.C b/src/mesh/snappyHexMesh/snappyHexMeshDriver/snappyLayerDriver.C
index 967f57cfc0..9cb5b6d8d6 100644
--- a/src/mesh/snappyHexMesh/snappyHexMeshDriver/snappyLayerDriver.C
+++ b/src/mesh/snappyHexMesh/snappyHexMeshDriver/snappyLayerDriver.C
@@ -2814,6 +2814,7 @@ bool Foam::snappyLayerDriver::writeLayerData
                 dimensionedScalar("zero", dimless, 0),
                 fixedValueFvPatchScalarField::typeName
             );
+            volScalarField::Boundary& fldBf = fld.boundaryFieldRef();
             const polyBoundaryMesh& pbm = mesh.boundaryMesh();
             forAll(patchIDs, i)
             {
@@ -2838,7 +2839,7 @@ bool Foam::snappyLayerDriver::writeLayerData
                     }
                 }
 
-                fld.boundaryField()[patchI] == pfld;
+                fldBf[patchI] == pfld;
             }
             Info<< indent << fld.name()
                 << " : overall layer thickness (fraction"

From 9b3f36d5932ed0b8397fa36e1ffc6a31df839394 Mon Sep 17 00:00:00 2001
From: Mark Olesen <Mark.Olesen@Germany>
Date: Fri, 7 Oct 2016 10:51:32 +0200
Subject: [PATCH 6/6] STYLE: reinstate targetType when building paraview
 modules (related to #258)

- potentially useful for static builds
---
 .../utilities/postProcessing/graphics/PV3Readers/Allwmake     | 4 ++--
 .../utilities/postProcessing/graphics/PVReaders/Allwmake      | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/applications/utilities/postProcessing/graphics/PV3Readers/Allwmake b/applications/utilities/postProcessing/graphics/PV3Readers/Allwmake
index 883ad4f135..c65150e0ed 100755
--- a/applications/utilities/postProcessing/graphics/PV3Readers/Allwmake
+++ b/applications/utilities/postProcessing/graphics/PV3Readers/Allwmake
@@ -51,8 +51,8 @@ case "$major" in
     then
     (
         wmake $targetType vtkPV3Readers
-        PV3blockMeshReader/Allwmake $*
-        PV3FoamReader/Allwmake $*
+        PV3blockMeshReader/Allwmake $targetType $*
+        PV3FoamReader/Allwmake $targetType $*
     )
     fi
     ;;
diff --git a/applications/utilities/postProcessing/graphics/PVReaders/Allwmake b/applications/utilities/postProcessing/graphics/PVReaders/Allwmake
index ebe8498e5d..20d389f5c9 100755
--- a/applications/utilities/postProcessing/graphics/PVReaders/Allwmake
+++ b/applications/utilities/postProcessing/graphics/PVReaders/Allwmake
@@ -52,8 +52,8 @@ case "$major" in
     then
     (
         wmake $targetType vtkPVReaders
-        PVblockMeshReader/Allwmake $*
-        PVFoamReader/Allwmake $*
+        PVblockMeshReader/Allwmake $targetType $*
+        PVFoamReader/Allwmake $targetType  $*
 
         # Dummy directory to trigger proper 'wclean all' behaviour
         # - the Allwclean will otherwise not be used