diff --git a/applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/conformalVoronoiMesh/conformalVoronoiMeshCalcDualMesh.C b/applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/conformalVoronoiMesh/conformalVoronoiMeshCalcDualMesh.C
index 94dabef0fa..db0a2a5f7b 100644
--- a/applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/conformalVoronoiMesh/conformalVoronoiMeshCalcDualMesh.C
+++ b/applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/conformalVoronoiMesh/conformalVoronoiMeshCalcDualMesh.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2012-2019 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2012-2020 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -26,7 +26,7 @@ License
 #include "conformalVoronoiMesh.H"
 #include "motionSmoother.H"
 #include "backgroundMeshDecomposition.H"
-#include "polyMeshGeometry.H"
+#include "polyMeshCheck.H"
 #include "indexedCellChecks.H"
 #include "OBJstream.H"
 #include "indexedCellOps.H"
@@ -846,7 +846,7 @@ void Foam::conformalVoronoiMesh::checkCellSizing()
 
     if (maxNonOrtho < 180.0 - small)
     {
-        polyMeshGeometry::checkFaceDotProduct
+        polyMeshCheck::checkFaceDotProduct
         (
             false,
             maxNonOrtho,
diff --git a/etc/controlDict b/etc/controlDict
index e1439fa790..82e5ab27d1 100644
--- a/etc/controlDict
+++ b/etc/controlDict
@@ -711,7 +711,6 @@ DebugSwitches
     pointZone           0;
     polyBoundaryMesh    0;
     polyMesh            0;
-    polyMeshGeometry    0;
     polyMeshInfo        0;
     polyTopoChange      0;
     polyTopoChanger     0;
@@ -724,7 +723,6 @@ DebugSwitches
     pressureNormalInletOutletVelocity 0;
     pressureSwirlInjector 0;
     primitiveMesh       0;
-    primitiveMeshGeometry 0;
     probes              0;
     processor           0;
     processorLduInterface 0;
diff --git a/src/dynamicMesh/Make/files b/src/dynamicMesh/Make/files
index 56c811f168..88e7c088ad 100644
--- a/src/dynamicMesh/Make/files
+++ b/src/dynamicMesh/Make/files
@@ -94,7 +94,7 @@ motionSmoother/motionSmoother.C
 motionSmoother/motionSmootherAlgo.C
 motionSmoother/motionSmootherAlgoCheck.C
 motionSmoother/motionSmootherData.C
-motionSmoother/polyMeshGeometry/polyMeshGeometry.C
+motionSmoother/polyMeshCheck/polyMeshCheck.C
 motionSmoother/badQualityToCell/badQualityToCell.C
 motionSmoother/badQualityToFace/badQualityToFace.C
 
diff --git a/src/dynamicMesh/motionSmoother/motionSmootherAlgo.H b/src/dynamicMesh/motionSmoother/motionSmootherAlgo.H
index ffb2267f3b..e58171fca3 100644
--- a/src/dynamicMesh/motionSmoother/motionSmootherAlgo.H
+++ b/src/dynamicMesh/motionSmoother/motionSmootherAlgo.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2019 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2020 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -87,7 +87,6 @@ SourceFiles
 namespace Foam
 {
 
-class polyMeshGeometry;
 class faceSet;
 
 /*---------------------------------------------------------------------------*\
@@ -460,31 +459,6 @@ public:
                 labelHashSet& wrongFaces
             );
 
-            //- Check part of mesh with mesh settings in dict.
-            //  Collects incorrect faces in set. Returns true if one or
-            //  more faces in error. Parallel ok.
-            static bool checkMesh
-            (
-                const bool report,
-                const dictionary& dict,
-                const polyMeshGeometry&,
-                const labelList& checkFaces,
-                labelHashSet& wrongFaces
-            );
-
-            //- Check part of mesh including baffles with mesh settings in dict.
-            //  Collects incorrect faces in set. Returns true if one or
-            //  more faces in error. Parallel ok.
-            static bool checkMesh
-            (
-                const bool report,
-                const dictionary& dict,
-                const polyMeshGeometry&,
-                const labelList& checkFaces,
-                const List<labelPair>& baffles,
-                labelHashSet& wrongFaces
-            );
-
             // Helper functions to manipulate displacement vector.
 
                 //- Fully explicit smoothing of fields (not positions)
diff --git a/src/dynamicMesh/motionSmoother/motionSmootherAlgoCheck.C b/src/dynamicMesh/motionSmoother/motionSmootherAlgoCheck.C
index dc617e2209..d002c35953 100644
--- a/src/dynamicMesh/motionSmoother/motionSmootherAlgoCheck.C
+++ b/src/dynamicMesh/motionSmoother/motionSmootherAlgoCheck.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2019 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2020 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -24,7 +24,7 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "motionSmootherAlgo.H"
-#include "polyMeshGeometry.H"
+#include "polyMeshCheck.H"
 #include "IOmanip.H"
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
@@ -117,7 +117,7 @@ bool Foam::motionSmootherAlgo::checkMesh
 
     if (maxNonOrtho < 180.0-small)
     {
-        polyMeshGeometry::checkFaceDotProduct
+        polyMeshCheck::checkFaceDotProduct
         (
             report,
             maxNonOrtho,
@@ -141,7 +141,7 @@ bool Foam::motionSmootherAlgo::checkMesh
 
     if (minVol > -great)
     {
-        polyMeshGeometry::checkFacePyramids
+        polyMeshCheck::checkFacePyramids
         (
             report,
             minVol,
@@ -164,7 +164,7 @@ bool Foam::motionSmootherAlgo::checkMesh
 
     if (minTetQuality > -great)
     {
-        polyMeshGeometry::checkFaceTets
+        polyMeshCheck::checkFaceTets
         (
             report,
             minTetQuality,
@@ -188,7 +188,7 @@ bool Foam::motionSmootherAlgo::checkMesh
 
     if (maxConcave < 180.0-small)
     {
-        polyMeshGeometry::checkFaceAngles
+        polyMeshCheck::checkFaceAngles
         (
             report,
             maxConcave,
@@ -211,7 +211,7 @@ bool Foam::motionSmootherAlgo::checkMesh
 
     if (minArea > -small)
     {
-        polyMeshGeometry::checkFaceArea
+        polyMeshCheck::checkFaceArea
         (
             report,
             minArea,
@@ -233,7 +233,7 @@ bool Foam::motionSmootherAlgo::checkMesh
 
     if (maxIntSkew > 0 || maxBounSkew > 0)
     {
-        polyMeshGeometry::checkFaceSkewness
+        polyMeshCheck::checkFaceSkewness
         (
             report,
             maxIntSkew,
@@ -260,7 +260,7 @@ bool Foam::motionSmootherAlgo::checkMesh
 
     if (minWeight >= 0 && minWeight < 1)
     {
-        polyMeshGeometry::checkFaceWeights
+        polyMeshCheck::checkFaceWeights
         (
             report,
             minWeight,
@@ -285,7 +285,7 @@ bool Foam::motionSmootherAlgo::checkMesh
 
     if (minVolRatio >= 0)
     {
-        polyMeshGeometry::checkVolRatio
+        polyMeshCheck::checkVolRatio
         (
             report,
             minVolRatio,
@@ -310,7 +310,7 @@ bool Foam::motionSmootherAlgo::checkMesh
     {
         // Pout<< "Checking face twist: dot product of face normal "
         //    << "with face triangle normals" << endl;
-        polyMeshGeometry::checkFaceTwist
+        polyMeshCheck::checkFaceTwist
         (
             report,
             minTwist,
@@ -337,7 +337,7 @@ bool Foam::motionSmootherAlgo::checkMesh
     {
         // Pout<< "Checking triangle twist: dot product of consecutive triangle"
         //    << " normals resulting from face-centre decomposition" << endl;
-        polyMeshGeometry::checkTriangleTwist
+        polyMeshCheck::checkTriangleTwist
         (
             report,
             minTriangleTwist,
@@ -361,7 +361,7 @@ bool Foam::motionSmootherAlgo::checkMesh
 
     if (minFaceFlatness > -small)
     {
-        polyMeshGeometry::checkFaceFlatness
+        polyMeshCheck::checkFaceFlatness
         (
             report,
             minFaceFlatness,
@@ -385,14 +385,13 @@ bool Foam::motionSmootherAlgo::checkMesh
 
     if (minDet > -1)
     {
-        polyMeshGeometry::checkCellDeterminant
+        polyMeshCheck::checkCellDeterminant
         (
             report,
             minDet,
             mesh,
             mesh.faceAreas(),
             checkFaces,
-            polyMeshGeometry::affectedCells(mesh, checkFaces),
             &wrongFaces
         );
 
@@ -429,351 +428,5 @@ bool Foam::motionSmootherAlgo::checkMesh
     );
 }
 
-bool Foam::motionSmootherAlgo::checkMesh
-(
-    const bool report,
-    const dictionary& dict,
-    const polyMeshGeometry& meshGeom,
-    const labelList& checkFaces,
-    labelHashSet& wrongFaces
-)
-{
-    List<labelPair> emptyBaffles;
-
-    return checkMesh
-    (
-        report,
-        dict,
-        meshGeom,
-        checkFaces,
-        emptyBaffles,
-        wrongFaces
-     );
-}
-
-
-bool Foam::motionSmootherAlgo::checkMesh
-(
-    const bool report,
-    const dictionary& dict,
-    const polyMeshGeometry& meshGeom,
-    const labelList& checkFaces,
-    const List<labelPair>& baffles,
-    labelHashSet& wrongFaces
-)
-{
-    const scalar maxNonOrtho
-    (
-        dict.lookup<scalar>("maxNonOrtho", true)
-    );
-    const scalar minVol
-    (
-        dict.lookup<scalar>("minVol", true)
-    );
-    const scalar minTetQuality
-    (
-        dict.lookup<scalar>("minTetQuality", true)
-    );
-    const scalar maxConcave
-    (
-        dict.lookup<scalar>("maxConcave", true)
-    );
-    const scalar minArea
-    (
-        dict.lookup<scalar>("minArea", true)
-    );
-    // const scalar maxIntSkew
-    //(
-    //    dict.lookup<scalar>("maxInternalSkewness", true)
-    //);
-    // const scalar maxBounSkew
-    //(
-    //    dict.lookup<scalar>("maxBoundarySkewness", true)
-    //);
-    const scalar minWeight
-    (
-        dict.lookup<scalar>("minFaceWeight", true)
-    );
-    const scalar minVolRatio
-    (
-        dict.lookup<scalar>("minVolRatio", true)
-    );
-    const scalar minTwist
-    (
-        dict.lookup<scalar>("minTwist", true)
-    );
-    const scalar minTriangleTwist
-    (
-        dict.lookup<scalar>("minTriangleTwist", true)
-    );
-    scalar minFaceFlatness = -1.0;
-    dict.readIfPresent("minFaceFlatness", minFaceFlatness, true);
-    const scalar minDet
-    (
-        dict.lookup<scalar>("minDeterminant", true)
-    );
-
-    label nWrongFaces = 0;
-
-    Info<< "Checking faces in error :" << endl;
-    // Pout.setf(ios_base::left);
-
-    if (maxNonOrtho < 180.0-small)
-    {
-        meshGeom.checkFaceDotProduct
-        (
-            report,
-            maxNonOrtho,
-            checkFaces,
-            baffles,
-            &wrongFaces
-        );
-
-        label nNewWrongFaces = returnReduce(wrongFaces.size(), sumOp<label>());
-
-        Info<< "    non-orthogonality > "
-            << setw(3) << maxNonOrtho
-            << " degrees                        : "
-            << nNewWrongFaces-nWrongFaces << endl;
-
-        nWrongFaces = nNewWrongFaces;
-    }
-
-    if (minVol > -great)
-    {
-        meshGeom.checkFacePyramids
-        (
-            report,
-            minVol,
-            meshGeom.mesh().points(),
-            checkFaces,
-            baffles,
-            &wrongFaces
-        );
-
-        label nNewWrongFaces = returnReduce(wrongFaces.size(), sumOp<label>());
-
-        Info<< "    faces with face pyramid volume < "
-            << setw(5) << minVol << "                 : "
-            << nNewWrongFaces-nWrongFaces << endl;
-
-        nWrongFaces = nNewWrongFaces;
-    }
-
-    if (minTetQuality > -great)
-    {
-        meshGeom.checkFaceTets
-        (
-            report,
-            minTetQuality,
-            meshGeom.mesh().points(),
-            checkFaces,
-            baffles,
-            &wrongFaces
-        );
-
-        label nNewWrongFaces = returnReduce(wrongFaces.size(), sumOp<label>());
-
-        Info<< "    faces with face-decomposition tet quality < "
-            << setw(5) << minTetQuality << "                : "
-            << nNewWrongFaces-nWrongFaces << endl;
-
-        nWrongFaces = nNewWrongFaces;
-    }
-
-    if (maxConcave < 180.0-small)
-    {
-        meshGeom.checkFaceAngles
-        (
-            report,
-            maxConcave,
-            meshGeom.mesh().points(),
-            checkFaces,
-            &wrongFaces
-        );
-
-        label nNewWrongFaces = returnReduce(wrongFaces.size(), sumOp<label>());
-
-        Info<< "    faces with concavity > "
-            << setw(3) << maxConcave
-            << " degrees                     : "
-            << nNewWrongFaces-nWrongFaces << endl;
-
-        nWrongFaces = nNewWrongFaces;
-    }
-
-    if (minArea > -small)
-    {
-        meshGeom.checkFaceArea(report, minArea, checkFaces, &wrongFaces);
-
-        label nNewWrongFaces = returnReduce(wrongFaces.size(), sumOp<label>());
-
-        Info<< "    faces with area < "
-            << setw(5) << minArea
-            << " m^2                            : "
-            << nNewWrongFaces-nWrongFaces << endl;
-
-        nWrongFaces = nNewWrongFaces;
-    }
-
-
-    //- Note: cannot check the skewness without the points and don't want
-    //  to store them on polyMeshGeometry.
-    // if (maxIntSkew > 0 || maxBounSkew > 0)
-    //{
-    //    meshGeom.checkFaceSkewness
-    //    (
-    //        report,
-    //        maxIntSkew,
-    //        maxBounSkew,
-    //        checkFaces,
-    //        baffles,
-    //        &wrongFaces
-    //    );
-    //
-    //    label nNewWrongFaces = returnReduce(wrongFaces.size(),sumOp<label>());
-    //
-    //    Info<< "    faces with skewness > "
-    //        << setw(3) << maxIntSkew
-    //        << " (internal) or " << setw(3) << maxBounSkew
-    //        << " (boundary) : " << nNewWrongFaces-nWrongFaces << endl;
-    //
-    //    nWrongFaces = nNewWrongFaces;
-    //}
-
-    if (minWeight >= 0 && minWeight < 1)
-    {
-        meshGeom.checkFaceWeights
-        (
-            report,
-            minWeight,
-            checkFaces,
-            baffles,
-            &wrongFaces
-        );
-
-        label nNewWrongFaces = returnReduce(wrongFaces.size(), sumOp<label>());
-
-        Info<< "    faces with interpolation weights (0..1)  < "
-            << setw(5) << minWeight
-            << "       : "
-            << nNewWrongFaces-nWrongFaces << endl;
-
-        nWrongFaces = nNewWrongFaces;
-    }
-
-    if (minVolRatio >= 0)
-    {
-        meshGeom.checkVolRatio
-        (
-            report,
-            minVolRatio,
-            checkFaces,
-            baffles,
-            &wrongFaces
-        );
-
-        label nNewWrongFaces = returnReduce(wrongFaces.size(), sumOp<label>());
-
-        Info<< "    faces with volume ratio of neighbour cells < "
-            << setw(5) << minVolRatio
-            << "     : "
-            << nNewWrongFaces-nWrongFaces << endl;
-
-        nWrongFaces = nNewWrongFaces;
-    }
-
-    if (minTwist > -1)
-    {
-        // Pout<< "Checking face twist: dot product of face normal "
-        //    << "with face triangle normals" << endl;
-        meshGeom.checkFaceTwist
-        (
-            report,
-            minTwist,
-            meshGeom.mesh().points(),
-            checkFaces,
-            &wrongFaces
-        );
-
-        label nNewWrongFaces = returnReduce(wrongFaces.size(), sumOp<label>());
-
-        Info<< "    faces with face twist < "
-            << setw(5) << minTwist
-            << "                          : "
-            << nNewWrongFaces-nWrongFaces << endl;
-
-        nWrongFaces = nNewWrongFaces;
-    }
-
-    if (minTriangleTwist > -1)
-    {
-        // Pout<< "Checking triangle twist: dot product of consecutive triangle"
-        //    << " normals resulting from face-centre decomposition" << endl;
-        meshGeom.checkTriangleTwist
-        (
-            report,
-            minTriangleTwist,
-            meshGeom.mesh().points(),
-            checkFaces,
-            &wrongFaces
-        );
-
-        label nNewWrongFaces = returnReduce(wrongFaces.size(), sumOp<label>());
-
-        Info<< "    faces with triangle twist < "
-            << setw(5) << minTriangleTwist
-            << "                      : "
-            << nNewWrongFaces-nWrongFaces << endl;
-
-        nWrongFaces = nNewWrongFaces;
-    }
-
-    if (minFaceFlatness > -1)
-    {
-        meshGeom.checkFaceFlatness
-        (
-            report,
-            minFaceFlatness,
-            meshGeom.mesh().points(),
-            checkFaces,
-            &wrongFaces
-        );
-
-        label nNewWrongFaces = returnReduce(wrongFaces.size(), sumOp<label>());
-
-        Info<< "    faces with flatness < "
-            << setw(5) << minFaceFlatness
-            << "                      : "
-            << nNewWrongFaces-nWrongFaces << endl;
-
-        nWrongFaces = nNewWrongFaces;
-    }
-
-    if (minDet > -1)
-    {
-        meshGeom.checkCellDeterminant
-        (
-            report,
-            minDet,
-            checkFaces,
-            meshGeom.affectedCells(meshGeom.mesh(), checkFaces),
-            &wrongFaces
-        );
-
-        label nNewWrongFaces = returnReduce(wrongFaces.size(), sumOp<label>());
-
-        Info<< "    faces on cells with determinant < "
-            << setw(5) << minDet << "                : "
-            << nNewWrongFaces-nWrongFaces << endl;
-
-        nWrongFaces = nNewWrongFaces;
-    }
-
-    // Pout.setf(ios_base::right);
-
-    return nWrongFaces > 0;
-}
-
 
 // ************************************************************************* //
diff --git a/src/dynamicMesh/motionSmoother/polyMeshGeometry/polyMeshGeometry.C b/src/dynamicMesh/motionSmoother/polyMeshCheck/polyMeshCheck.C
similarity index 81%
rename from src/dynamicMesh/motionSmoother/polyMeshGeometry/polyMeshGeometry.C
rename to src/dynamicMesh/motionSmoother/polyMeshCheck/polyMeshCheck.C
index d0dcef4751..416d0f6ea2 100644
--- a/src/dynamicMesh/motionSmoother/polyMeshGeometry/polyMeshGeometry.C
+++ b/src/dynamicMesh/motionSmoother/polyMeshCheck/polyMeshCheck.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2018 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2020 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -23,7 +23,7 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-#include "polyMeshGeometry.H"
+#include "polyMeshCheck.H"
 #include "polyMeshTetDecomposition.H"
 #include "pyramidPointFaceRef.H"
 #include "tetPointRef.H"
@@ -31,188 +31,16 @@ License
 #include "unitConversion.H"
 #include "primitiveMeshTools.H"
 
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
 namespace Foam
 {
-    defineTypeNameAndDebug(polyMeshGeometry, 0);
-}
-
-
-// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
-
-void Foam::polyMeshGeometry::updateFaceCentresAndAreas
-(
-    const pointField& p,
-    const labelList& changedFaces
-)
+namespace polyMeshCheck
 {
-    const faceList& fs = mesh_.faces();
 
-    forAll(changedFaces, i)
-    {
-        label facei = changedFaces[i];
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-        const labelList& f = fs[facei];
-        label nPoints = f.size();
-
-        // If the face is a triangle, do a direct calculation for efficiency
-        // and to avoid round-off error-related problems
-        if (nPoints == 3)
-        {
-            faceCentres_[facei] = (1.0/3.0)*(p[f[0]] + p[f[1]] + p[f[2]]);
-            faceAreas_[facei] = 0.5*((p[f[1]] - p[f[0]])^(p[f[2]] - p[f[0]]));
-        }
-        else
-        {
-            vector sumN = Zero;
-            scalar sumA = 0.0;
-            vector sumAc = Zero;
-
-            point fCentre = p[f[0]];
-            for (label pi = 1; pi < nPoints; pi++)
-            {
-                fCentre += p[f[pi]];
-            }
-
-            fCentre /= nPoints;
-
-            for (label pi = 0; pi < nPoints; pi++)
-            {
-                const point& nextPoint = p[f[(pi + 1) % nPoints]];
-
-                vector c = p[f[pi]] + nextPoint + fCentre;
-                vector n = (nextPoint - p[f[pi]])^(fCentre - p[f[pi]]);
-                scalar a = mag(n);
-
-                sumN += n;
-                sumA += a;
-                sumAc += a*c;
-            }
-
-            faceCentres_[facei] = (1.0/3.0)*sumAc/(sumA + vSmall);
-            faceAreas_[facei] = 0.5*sumN;
-        }
-    }
-}
-
-
-void Foam::polyMeshGeometry::updateCellCentresAndVols
-(
-    const labelList& changedCells,
-    const labelList& changedFaces
-)
-{
-    // Clear the fields for accumulation
-    UIndirectList<vector>(cellCentres_, changedCells) = Zero;
-    UIndirectList<scalar>(cellVolumes_, changedCells) = 0.0;
-
-    const labelList& own = mesh_.faceOwner();
-    const labelList& nei = mesh_.faceNeighbour();
-
-    // first estimate the approximate cell centre as the average of face centres
-
-    vectorField cEst(mesh_.nCells());
-    UIndirectList<vector>(cEst, changedCells) = Zero;
-    scalarField nCellFaces(mesh_.nCells());
-    UIndirectList<scalar>(nCellFaces, changedCells) = 0.0;
-
-    forAll(changedFaces, i)
-    {
-        label facei = changedFaces[i];
-        cEst[own[facei]] += faceCentres_[facei];
-        nCellFaces[own[facei]] += 1;
-
-        if (mesh_.isInternalFace(facei))
-        {
-            cEst[nei[facei]] += faceCentres_[facei];
-            nCellFaces[nei[facei]] += 1;
-        }
-    }
-
-    forAll(changedCells, i)
-    {
-        label celli = changedCells[i];
-        cEst[celli] /= nCellFaces[celli];
-    }
-
-    forAll(changedFaces, i)
-    {
-        label facei = changedFaces[i];
-
-        // Calculate 3*face-pyramid volume
-        scalar pyr3Vol = max
-        (
-            faceAreas_[facei] & (faceCentres_[facei] - cEst[own[facei]]),
-            vSmall
-        );
-
-        // Calculate face-pyramid centre
-        vector pc = (3.0/4.0)*faceCentres_[facei] + (1.0/4.0)*cEst[own[facei]];
-
-        // Accumulate volume-weighted face-pyramid centre
-        cellCentres_[own[facei]] += pyr3Vol*pc;
-
-        // Accumulate face-pyramid volume
-        cellVolumes_[own[facei]] += pyr3Vol;
-
-        if (mesh_.isInternalFace(facei))
-        {
-            // Calculate 3*face-pyramid volume
-            scalar pyr3Vol = max
-            (
-                faceAreas_[facei] & (cEst[nei[facei]] - faceCentres_[facei]),
-                vSmall
-            );
-
-            // Calculate face-pyramid centre
-            vector pc =
-                (3.0/4.0)*faceCentres_[facei]
-              + (1.0/4.0)*cEst[nei[facei]];
-
-            // Accumulate volume-weighted face-pyramid centre
-            cellCentres_[nei[facei]] += pyr3Vol*pc;
-
-            // Accumulate face-pyramid volume
-            cellVolumes_[nei[facei]] += pyr3Vol;
-        }
-    }
-
-    forAll(changedCells, i)
-    {
-        label celli = changedCells[i];
-
-        cellCentres_[celli] /= cellVolumes_[celli] + vSmall;
-        cellVolumes_[celli] *= (1.0/3.0);
-    }
-}
-
-
-Foam::labelList Foam::polyMeshGeometry::affectedCells
-(
-    const polyMesh& mesh,
-    const labelList& changedFaces
-)
-{
-    const labelList& own = mesh.faceOwner();
-    const labelList& nei = mesh.faceNeighbour();
-
-    labelHashSet affectedCells(2*changedFaces.size());
-
-    forAll(changedFaces, i)
-    {
-        label facei = changedFaces[i];
-
-        affectedCells.insert(own[facei]);
-
-        if (mesh.isInternalFace(facei))
-        {
-            affectedCells.insert(nei[facei]);
-        }
-    }
-    return affectedCells.toc();
-}
-
-
-Foam::scalar Foam::polyMeshGeometry::checkNonOrtho
+scalar checkNonOrtho
 (
     const polyMesh& mesh,
     const bool report,
@@ -279,8 +107,7 @@ Foam::scalar Foam::polyMeshGeometry::checkNonOrtho
 }
 
 
-// Create the neighbour pyramid - it will have positive volume
-bool Foam::polyMeshGeometry::checkFaceTet
+bool checkFaceTet
 (
     const polyMesh& mesh,
     const bool report,
@@ -309,7 +136,7 @@ bool Foam::polyMeshGeometry::checkFaceTet
         {
             if (report)
             {
-                Pout<< "bool polyMeshGeometry::checkFaceTets("
+                Pout<< "bool polyMeshCheck::checkFaceTets("
                     << "const bool, const scalar, const pointField&"
                     << ", const pointField&"
                     << ", const labelList&, labelHashSet*) : "
@@ -332,42 +159,39 @@ bool Foam::polyMeshGeometry::checkFaceTet
 }
 
 
-// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
-
-// Construct from components
-Foam::polyMeshGeometry::polyMeshGeometry(const polyMesh& mesh)
-:
-    mesh_(mesh)
-{
-    correct();
-}
-
-
-// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
-
-void Foam::polyMeshGeometry::correct()
-{
-    faceAreas_ = mesh_.faceAreas();
-    faceCentres_ = mesh_.faceCentres();
-    cellCentres_ = mesh_.cellCentres();
-    cellVolumes_ = mesh_.cellVolumes();
-}
-
-
-void Foam::polyMeshGeometry::correct
+labelList getAffectedCells
 (
-    const pointField& p,
+    const polyMesh& mesh,
     const labelList& changedFaces
 )
 {
-    // Update face quantities
-    updateFaceCentresAndAreas(p, changedFaces);
-    // Update cell quantities from face quantities
-    updateCellCentresAndVols(affectedCells(mesh_, changedFaces), changedFaces);
+    const labelList& own = mesh.faceOwner();
+    const labelList& nei = mesh.faceNeighbour();
+
+    labelHashSet affectedCells(2*changedFaces.size());
+
+    forAll(changedFaces, i)
+    {
+        label facei = changedFaces[i];
+
+        affectedCells.insert(own[facei]);
+
+        if (mesh.isInternalFace(facei))
+        {
+            affectedCells.insert(nei[facei]);
+        }
+    }
+    return affectedCells.toc();
 }
 
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-bool Foam::polyMeshGeometry::checkFaceDotProduct
+} // End namespace polyMeshCheck
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+bool Foam::polyMeshCheck::checkFaceDotProduct
 (
     const bool report,
     const scalar orthWarn,
@@ -549,7 +373,7 @@ bool Foam::polyMeshGeometry::checkFaceDotProduct
 }
 
 
-bool Foam::polyMeshGeometry::checkFacePyramids
+bool Foam::polyMeshCheck::checkFacePyramids
 (
     const bool report,
     const scalar minPyrVol,
@@ -584,7 +408,7 @@ bool Foam::polyMeshGeometry::checkFacePyramids
         {
             if (report)
             {
-                Pout<< "bool polyMeshGeometry::checkFacePyramids("
+                Pout<< "bool polyMeshCheck::checkFacePyramids("
                     << "const bool, const scalar, const pointField&"
                     << ", const labelList&, labelHashSet*): "
                     << "face " << facei << " points the wrong way. " << endl
@@ -615,7 +439,7 @@ bool Foam::polyMeshGeometry::checkFacePyramids
             {
                 if (report)
                 {
-                    Pout<< "bool polyMeshGeometry::checkFacePyramids("
+                    Pout<< "bool polyMeshCheck::checkFacePyramids("
                         << "const bool, const scalar, const pointField&"
                         << ", const labelList&, labelHashSet*): "
                         << "face " << facei << " points the wrong way. " << endl
@@ -655,7 +479,7 @@ bool Foam::polyMeshGeometry::checkFacePyramids
         {
             if (report)
             {
-                Pout<< "bool polyMeshGeometry::checkFacePyramids("
+                Pout<< "bool polyMeshCheck::checkFacePyramids("
                     << "const bool, const scalar, const pointField&"
                     << ", const labelList&, labelHashSet*): "
                     << "face " << face0 << " points the wrong way. " << endl
@@ -684,7 +508,7 @@ bool Foam::polyMeshGeometry::checkFacePyramids
         {
             if (report)
             {
-                Pout<< "bool polyMeshGeometry::checkFacePyramids("
+                Pout<< "bool polyMeshCheck::checkFacePyramids("
                     << "const bool, const scalar, const pointField&"
                     << ", const labelList&, labelHashSet*): "
                     << "face " << face0 << " points the wrong way. " << endl
@@ -730,7 +554,7 @@ bool Foam::polyMeshGeometry::checkFacePyramids
 }
 
 
-bool Foam::polyMeshGeometry::checkFaceTets
+bool Foam::polyMeshCheck::checkFaceTets
 (
     const bool report,
     const scalar minTetQuality,
@@ -959,7 +783,7 @@ bool Foam::polyMeshGeometry::checkFaceTets
 }
 
 
-bool Foam::polyMeshGeometry::checkFaceSkewness
+bool Foam::polyMeshCheck::checkFaceSkewness
 (
     const bool report,
     const scalar internalSkew,
@@ -1172,7 +996,7 @@ bool Foam::polyMeshGeometry::checkFaceSkewness
 }
 
 
-bool Foam::polyMeshGeometry::checkFaceWeights
+bool Foam::polyMeshCheck::checkFaceWeights
 (
     const bool report,
     const scalar warnWeight,
@@ -1327,7 +1151,7 @@ bool Foam::polyMeshGeometry::checkFaceWeights
 }
 
 
-bool Foam::polyMeshGeometry::checkVolRatio
+bool Foam::polyMeshCheck::checkVolRatio
 (
     const bool report,
     const scalar warnRatio,
@@ -1465,11 +1289,7 @@ bool Foam::polyMeshGeometry::checkVolRatio
 }
 
 
-// Check convexity of angles in a face. Allow a slight non-convexity.
-// E.g. maxDeg = 10 allows for angles < 190 (or 10 degrees concavity)
-// (if truly concave and points not visible from face centre the face-pyramid
-//  check in checkMesh will fail)
-bool Foam::polyMeshGeometry::checkFaceAngles
+bool Foam::polyMeshCheck::checkFaceAngles
 (
     const bool report,
     const scalar maxDeg,
@@ -1600,9 +1420,7 @@ bool Foam::polyMeshGeometry::checkFaceAngles
 }
 
 
-// Check twist of faces. Is calculated as the difference between normals of
-// individual triangles and the cell-cell centre edge.
-bool Foam::polyMeshGeometry::checkFaceTwist
+bool Foam::polyMeshCheck::checkFaceTwist
 (
     const bool report,
     const scalar minTwist,
@@ -1786,8 +1604,7 @@ bool Foam::polyMeshGeometry::checkFaceTwist
 }
 
 
-// Like checkFaceTwist but compares normals of consecutive triangles.
-bool Foam::polyMeshGeometry::checkTriangleTwist
+bool Foam::polyMeshCheck::checkTriangleTwist
 (
     const bool report,
     const scalar minTwist,
@@ -1937,7 +1754,7 @@ bool Foam::polyMeshGeometry::checkTriangleTwist
 }
 
 
-bool Foam::polyMeshGeometry::checkFaceFlatness
+bool Foam::polyMeshCheck::checkFaceFlatness
 (
     const bool report,
     const scalar minFlatness,
@@ -2035,7 +1852,7 @@ bool Foam::polyMeshGeometry::checkFaceFlatness
 }
 
 
-bool Foam::polyMeshGeometry::checkFaceArea
+bool Foam::polyMeshCheck::checkFaceArea
 (
     const bool report,
     const scalar minArea,
@@ -2096,14 +1913,13 @@ bool Foam::polyMeshGeometry::checkFaceArea
 }
 
 
-bool Foam::polyMeshGeometry::checkCellDeterminant
+bool Foam::polyMeshCheck::checkCellDeterminant
 (
     const bool report,
     const scalar warnDet,
     const polyMesh& mesh,
     const vectorField& faceAreas,
     const labelList& checkFaces,
-    const labelList& affectedCells,
     labelHashSet* setPtr
 )
 {
@@ -2114,6 +1930,8 @@ bool Foam::polyMeshGeometry::checkCellDeterminant
     label nSumDet = 0;
     label nWarnDet = 0;
 
+    const labelList affectedCells(getAffectedCells(mesh, checkFaces));
+
     forAll(affectedCells, i)
     {
         const cell& cFaces = cells[affectedCells[i]];
@@ -2197,282 +2015,4 @@ bool Foam::polyMeshGeometry::checkCellDeterminant
 }
 
 
-bool Foam::polyMeshGeometry::checkFaceDotProduct
-(
-    const bool report,
-    const scalar orthWarn,
-    const labelList& checkFaces,
-    const List<labelPair>& baffles,
-    labelHashSet* setPtr
-) const
-{
-    return checkFaceDotProduct
-    (
-        report,
-        orthWarn,
-        mesh_,
-        cellCentres_,
-        faceAreas_,
-        checkFaces,
-        baffles,
-        setPtr
-    );
-}
-
-
-bool Foam::polyMeshGeometry::checkFacePyramids
-(
-    const bool report,
-    const scalar minPyrVol,
-    const pointField& p,
-    const labelList& checkFaces,
-    const List<labelPair>& baffles,
-    labelHashSet* setPtr
-) const
-{
-    return checkFacePyramids
-    (
-        report,
-        minPyrVol,
-        mesh_,
-        cellCentres_,
-        p,
-        checkFaces,
-        baffles,
-        setPtr
-    );
-}
-
-
-bool Foam::polyMeshGeometry::checkFaceTets
-(
-    const bool report,
-    const scalar minTetQuality,
-    const pointField& p,
-    const labelList& checkFaces,
-    const List<labelPair>& baffles,
-    labelHashSet* setPtr
-) const
-{
-    return checkFaceTets
-    (
-        report,
-        minTetQuality,
-        mesh_,
-        cellCentres_,
-        faceCentres_,
-        p,
-        checkFaces,
-        baffles,
-        setPtr
-    );
-}
-
-
-//bool Foam::polyMeshGeometry::checkFaceSkewness
-//(
-//    const bool report,
-//    const scalar internalSkew,
-//    const scalar boundarySkew,
-//    const labelList& checkFaces,
-//    const List<labelPair>& baffles,
-//    labelHashSet* setPtr
-//) const
-//{
-//    return checkFaceSkewness
-//    (
-//        report,
-//        internalSkew,
-//        boundarySkew,
-//        mesh_,
-//        cellCentres_,
-//        faceCentres_,
-//        faceAreas_,
-//        checkFaces,
-//        baffles,
-//        setPtr
-//    );
-//}
-
-
-bool Foam::polyMeshGeometry::checkFaceWeights
-(
-    const bool report,
-    const scalar warnWeight,
-    const labelList& checkFaces,
-    const List<labelPair>& baffles,
-    labelHashSet* setPtr
-) const
-{
-    return checkFaceWeights
-    (
-        report,
-        warnWeight,
-        mesh_,
-        cellCentres_,
-        faceCentres_,
-        faceAreas_,
-        checkFaces,
-        baffles,
-        setPtr
-    );
-}
-
-
-bool Foam::polyMeshGeometry::checkVolRatio
-(
-    const bool report,
-    const scalar warnRatio,
-    const labelList& checkFaces,
-    const List<labelPair>& baffles,
-    labelHashSet* setPtr
-) const
-{
-    return checkVolRatio
-    (
-        report,
-        warnRatio,
-        mesh_,
-        cellVolumes_,
-        checkFaces,
-        baffles,
-        setPtr
-    );
-}
-
-
-bool Foam::polyMeshGeometry::checkFaceAngles
-(
-    const bool report,
-    const scalar maxDeg,
-    const pointField& p,
-    const labelList& checkFaces,
-    labelHashSet* setPtr
-) const
-{
-    return checkFaceAngles
-    (
-        report,
-        maxDeg,
-        mesh_,
-        faceAreas_,
-        p,
-        checkFaces,
-        setPtr
-    );
-}
-
-
-bool Foam::polyMeshGeometry::checkFaceTwist
-(
-    const bool report,
-    const scalar minTwist,
-    const pointField& p,
-    const labelList& checkFaces,
-    labelHashSet* setPtr
-) const
-{
-    return checkFaceTwist
-    (
-        report,
-        minTwist,
-        mesh_,
-        cellCentres_,
-        faceAreas_,
-        faceCentres_,
-        p,
-        checkFaces,
-        setPtr
-    );
-}
-
-
-bool Foam::polyMeshGeometry::checkTriangleTwist
-(
-    const bool report,
-    const scalar minTwist,
-    const pointField& p,
-    const labelList& checkFaces,
-    labelHashSet* setPtr
-) const
-{
-    return checkTriangleTwist
-    (
-        report,
-        minTwist,
-        mesh_,
-        faceAreas_,
-        faceCentres_,
-        p,
-        checkFaces,
-        setPtr
-    );
-}
-
-
-bool Foam::polyMeshGeometry::checkFaceFlatness
-(
-    const bool report,
-    const scalar minFlatness,
-    const pointField& p,
-    const labelList& checkFaces,
-    labelHashSet* setPtr
-) const
-{
-    return checkFaceFlatness
-    (
-        report,
-        minFlatness,
-        mesh_,
-        faceAreas_,
-        faceCentres_,
-        p,
-        checkFaces,
-        setPtr
-    );
-}
-
-
-bool Foam::polyMeshGeometry::checkFaceArea
-(
-    const bool report,
-    const scalar minArea,
-    const labelList& checkFaces,
-    labelHashSet* setPtr
-) const
-{
-    return checkFaceArea
-    (
-        report,
-        minArea,
-        mesh_,
-        faceAreas_,
-        checkFaces,
-        setPtr
-    );
-}
-
-
-bool Foam::polyMeshGeometry::checkCellDeterminant
-(
-    const bool report,
-    const scalar warnDet,
-    const labelList& checkFaces,
-    const labelList& affectedCells,
-    labelHashSet* setPtr
-) const
-{
-    return checkCellDeterminant
-    (
-        report,
-        warnDet,
-        mesh_,
-        faceAreas_,
-        checkFaces,
-        affectedCells,
-        setPtr
-    );
-}
-
-
 // ************************************************************************* //
diff --git a/src/dynamicMesh/motionSmoother/polyMeshCheck/polyMeshCheck.H b/src/dynamicMesh/motionSmoother/polyMeshCheck/polyMeshCheck.H
new file mode 100644
index 0000000000..d48a500084
--- /dev/null
+++ b/src/dynamicMesh/motionSmoother/polyMeshCheck/polyMeshCheck.H
@@ -0,0 +1,214 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2011-2020 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
+    PolyMesh checking routines. Checks various criteria for a mesh and supplied
+    geometry, with the mesh only used for topology. Coupled patch aware (i.e.,
+    coupled faces are treated as internal).
+
+SourceFiles
+    polyMeshCheck.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef polyMeshCheck_H
+#define polyMeshCheck_H
+
+#include "pointFields.H"
+#include "HashSet.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace polyMeshCheck
+{
+
+//- Check face non-orthogonality
+bool checkFaceDotProduct
+(
+    const bool report,
+    const scalar orthWarn,
+    const polyMesh&,
+    const vectorField& cellCentres,
+    const vectorField& faceAreas,
+    const labelList& checkFaces,
+    const List<labelPair>& baffles,
+    labelHashSet* setPtr
+);
+
+//- Check face pyramid volumes
+bool checkFacePyramids
+(
+    const bool report,
+    const scalar minPyrVol,
+    const polyMesh&,
+    const vectorField& cellCentres,
+    const pointField& p,
+    const labelList& checkFaces,
+    const List<labelPair>& baffles,
+    labelHashSet*
+);
+
+//- Check face tetrahedra volumes
+bool checkFaceTets
+(
+    const bool report,
+    const scalar minPyrVol,
+    const polyMesh&,
+    const vectorField& cellCentres,
+    const vectorField& faceCentres,
+    const pointField& p,
+    const labelList& checkFaces,
+    const List<labelPair>& baffles,
+    labelHashSet*
+);
+
+//- Check face skewness
+bool checkFaceSkewness
+(
+    const bool report,
+    const scalar internalSkew,
+    const scalar boundarySkew,
+    const polyMesh& mesh,
+    const pointField& points,
+    const vectorField& cellCentres,
+    const vectorField& faceCentres,
+    const vectorField& faceAreas,
+    const labelList& checkFaces,
+    const List<labelPair>& baffles,
+    labelHashSet* setPtr
+);
+
+//- Check interpolation weights (0.5 for regular mesh)
+bool checkFaceWeights
+(
+    const bool report,
+    const scalar warnWeight,
+    const polyMesh& mesh,
+    const vectorField& cellCentres,
+    const vectorField& faceCentres,
+    const vectorField& faceAreas,
+    const labelList& checkFaces,
+    const List<labelPair>& baffles,
+    labelHashSet* setPtr
+);
+
+//- Cell volume ratio of neighbouring cells (1 for regular mesh)
+bool checkVolRatio
+(
+    const bool report,
+    const scalar warnRatio,
+    const polyMesh& mesh,
+    const scalarField& cellVolumes,
+    const labelList& checkFaces,
+    const List<labelPair>& baffles,
+    labelHashSet* setPtr
+);
+
+//- Check convexity of angles in a face. See primitiveMesh for explanation.
+bool checkFaceAngles
+(
+    const bool report,
+    const scalar maxDeg,
+    const polyMesh& mesh,
+    const vectorField& faceAreas,
+    const pointField& p,
+    const labelList& checkFaces,
+    labelHashSet* setPtr
+);
+
+// Check the difference between normals of individual face-triangles (from
+// face-centre decomposition) and the cell-cell centre vector
+bool checkFaceTwist
+(
+    const bool report,
+    const scalar minTwist,
+    const polyMesh&,
+    const vectorField& cellCentres,
+    const vectorField& faceAreas,
+    const vectorField& faceCentres,
+    const pointField& p,
+    const labelList& checkFaces,
+    labelHashSet* setPtr
+);
+
+//- Check consecutive face-triangle (from face-centre decomposition) normals
+bool checkTriangleTwist
+(
+    const bool report,
+    const scalar minTwist,
+    const polyMesh&,
+    const vectorField& faceAreas,
+    const vectorField& faceCentres,
+    const pointField& p,
+    const labelList& checkFaces,
+    labelHashSet* setPtr
+);
+
+//- Check for face areas v.s. sum of face-triangle (from face-centre
+//  decomposition) areas
+bool checkFaceFlatness
+(
+    const bool report,
+    const scalar minFlatness,
+    const polyMesh&,
+    const vectorField& faceAreas,
+    const vectorField& faceCentres,
+    const pointField& p,
+    const labelList& checkFaces,
+    labelHashSet* setPtr
+);
+
+//- Check for small faces
+bool checkFaceArea
+(
+    const bool report,
+    const scalar minArea,
+    const polyMesh&,
+    const vectorField& faceAreas,
+    const labelList& checkFaces,
+    labelHashSet* setPtr
+);
+
+//- Check the area of internal faces v.s. boundary faces
+bool checkCellDeterminant
+(
+    const bool report,
+    const scalar minDet,
+    const polyMesh&,
+    const vectorField& faceAreas,
+    const labelList& checkFaces,
+    labelHashSet* setPtr
+);
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace polyMeshCheck
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/dynamicMesh/motionSmoother/polyMeshGeometry/polyMeshGeometry.H b/src/dynamicMesh/motionSmoother/polyMeshGeometry/polyMeshGeometry.H
deleted file mode 100644
index e161411643..0000000000
--- a/src/dynamicMesh/motionSmoother/polyMeshGeometry/polyMeshGeometry.H
+++ /dev/null
@@ -1,456 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2018 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::polyMeshGeometry
-
-Description
-    Updateable mesh geometry and checking routines.
-
-    - non-ortho done across coupled faces.
-    - faceWeight (delta factors) done across coupled faces.
-
-SourceFiles
-    polyMeshGeometry.C
-
-\*---------------------------------------------------------------------------*/
-
-#ifndef polyMeshGeometry_H
-#define polyMeshGeometry_H
-
-#include "pointFields.H"
-#include "HashSet.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-namespace Foam
-{
-
-/*---------------------------------------------------------------------------*\
-                           Class polyMeshGeometry Declaration
-\*---------------------------------------------------------------------------*/
-
-class polyMeshGeometry
-{
-        //- Reference to polyMesh.
-        const polyMesh& mesh_;
-
-        //- Uptodate copy of face areas
-        vectorField faceAreas_;
-
-        //- Uptodate copy of face centres
-        vectorField faceCentres_;
-
-        //- Uptodate copy of cell centres
-        vectorField cellCentres_;
-
-        //- Uptodate copy of cell volumes
-        scalarField cellVolumes_;
-
-
-    // Private Member Functions
-
-        //- Update face areas and centres on selected faces.
-        void updateFaceCentresAndAreas
-        (
-            const pointField& p,
-            const labelList& changedFaces
-        );
-
-        //- Update cell volumes and centres on selected cells. Requires
-        //  cells and faces to be consistent set.
-        void updateCellCentresAndVols
-        (
-            const labelList& changedCells,
-            const labelList& changedFaces
-        );
-
-        //- Detect&report non-ortho error for single face.
-        static scalar checkNonOrtho
-        (
-            const polyMesh& mesh,
-            const bool report,
-            const scalar severeNonorthogonalityThreshold,
-            const label facei,
-            const vector& s,    // face area vector
-            const vector& d,    // cc-cc vector
-
-            label& severeNonOrth,
-            label& errorNonOrth,
-            labelHashSet* setPtr
-        );
-
-        //- Calculate skewness given two cell centres and one face centre.
-        static scalar calcSkewness
-        (
-            const point& ownCc,
-            const point& neiCc,
-            const point& fc
-        );
-
-        //- Detect&report incorrect face-triangle orientation
-        static bool checkFaceTet
-        (
-            const polyMesh&,
-            const bool report,
-            const scalar minTetQuality,
-            const pointField& p,
-            const label facei,
-            const point& fc,    // face centre
-            const point& cc,    // cell centre
-            labelHashSet* setPtr
-        );
-
-
-public:
-
-    ClassName("polyMeshGeometry");
-
-    // Constructors
-
-        //- Construct from mesh
-        polyMeshGeometry(const polyMesh&);
-
-
-    // Member Functions
-
-        // Access
-
-            const polyMesh& mesh() const
-            {
-                return mesh_;
-            }
-
-            const vectorField& faceAreas() const
-            {
-                return faceAreas_;
-            }
-            const vectorField& faceCentres() const
-            {
-                return faceCentres_;
-            }
-            const vectorField& cellCentres() const
-            {
-                return cellCentres_;
-            }
-            const scalarField& cellVolumes() const
-            {
-                return cellVolumes_;
-            }
-
-        // Edit
-
-            //- Take over properties from mesh
-            void correct();
-
-            //- Recalculate on selected faces. Recalculates cell properties
-            //  on owner and neighbour of these cells.
-            void correct
-            (
-                const pointField& p,
-                const labelList& changedFaces
-            );
-
-            //- Helper function: get affected cells from faces
-            static labelList affectedCells
-            (
-                const polyMesh&,
-                const labelList& changedFaces
-            );
-
-
-        // Checking of selected faces with supplied geometry (mesh only used for
-        // topology). Coupled aware (coupled faces treated as internal ones)
-
-            //- See primitiveMesh
-            static bool checkFaceDotProduct
-            (
-                const bool report,
-                const scalar orthWarn,
-                const polyMesh&,
-                const vectorField& cellCentres,
-                const vectorField& faceAreas,
-                const labelList& checkFaces,
-                const List<labelPair>& baffles,
-                labelHashSet* setPtr
-            );
-
-            //- See primitiveMesh
-            static bool checkFacePyramids
-            (
-                const bool report,
-                const scalar minPyrVol,
-                const polyMesh&,
-                const vectorField& cellCentres,
-                const pointField& p,
-                const labelList& checkFaces,
-                const List<labelPair>& baffles,
-                labelHashSet*
-            );
-
-            //- See primitiveMesh
-            static bool checkFaceTets
-            (
-                const bool report,
-                const scalar minPyrVol,
-                const polyMesh&,
-                const vectorField& cellCentres,
-                const vectorField& faceCentres,
-                const pointField& p,
-                const labelList& checkFaces,
-                const List<labelPair>& baffles,
-                labelHashSet*
-            );
-
-            //- See primitiveMesh
-            static bool checkFaceSkewness
-            (
-                const bool report,
-                const scalar internalSkew,
-                const scalar boundarySkew,
-                const polyMesh& mesh,
-                const pointField& points,
-                const vectorField& cellCentres,
-                const vectorField& faceCentres,
-                const vectorField& faceAreas,
-                const labelList& checkFaces,
-                const List<labelPair>& baffles,
-                labelHashSet* setPtr
-            );
-
-            //- Interpolation weights (0.5 for regular mesh)
-            static bool checkFaceWeights
-            (
-                const bool report,
-                const scalar warnWeight,
-                const polyMesh& mesh,
-                const vectorField& cellCentres,
-                const vectorField& faceCentres,
-                const vectorField& faceAreas,
-                const labelList& checkFaces,
-                const List<labelPair>& baffles,
-                labelHashSet* setPtr
-            );
-
-            //- Cell volume ratio of neighbouring cells (1 for regular mesh)
-            static bool checkVolRatio
-            (
-                const bool report,
-                const scalar warnRatio,
-                const polyMesh& mesh,
-                const scalarField& cellVolumes,
-                const labelList& checkFaces,
-                const List<labelPair>& baffles,
-                labelHashSet* setPtr
-            );
-
-            //- See primitiveMesh
-            static bool checkFaceAngles
-            (
-                const bool report,
-                const scalar maxDeg,
-                const polyMesh& mesh,
-                const vectorField& faceAreas,
-                const pointField& p,
-                const labelList& checkFaces,
-                labelHashSet* setPtr
-            );
-
-            //- Triangle (from face-centre decomposition) normal v.s.
-            //  average face normal
-            static bool checkFaceTwist
-            (
-                const bool report,
-                const scalar minTwist,
-                const polyMesh&,
-                const vectorField& cellCentres,
-                const vectorField& faceAreas,
-                const vectorField& faceCentres,
-                const pointField& p,
-                const labelList& checkFaces,
-                labelHashSet* setPtr
-            );
-
-            //- Consecutive triangle (from face-centre decomposition) normals
-            static bool checkTriangleTwist
-            (
-                const bool report,
-                const scalar minTwist,
-                const polyMesh&,
-                const vectorField& faceAreas,
-                const vectorField& faceCentres,
-                const pointField& p,
-                const labelList& checkFaces,
-                labelHashSet* setPtr
-            );
-
-            //- Area of faces v.s. sum of triangle areas
-            static bool checkFaceFlatness
-            (
-                const bool report,
-                const scalar minFlatness,
-                const polyMesh&,
-                const vectorField& faceAreas,
-                const vectorField& faceCentres,
-                const pointField& p,
-                const labelList& checkFaces,
-                labelHashSet* setPtr
-            );
-
-            //- Small faces
-            static bool checkFaceArea
-            (
-                const bool report,
-                const scalar minArea,
-                const polyMesh&,
-                const vectorField& faceAreas,
-                const labelList& checkFaces,
-                labelHashSet* setPtr
-            );
-
-            //- Area of internal faces v.s. boundary faces
-            static bool checkCellDeterminant
-            (
-                const bool report,
-                const scalar minDet,
-                const polyMesh&,
-                const vectorField& faceAreas,
-                const labelList& checkFaces,
-                const labelList& affectedCells,
-                labelHashSet* setPtr
-            );
-
-
-        // Checking of selected faces with local geometry. Uses above static
-        // functions. Parallel aware.
-
-            bool checkFaceDotProduct
-            (
-                const bool report,
-                const scalar orthWarn,
-                const labelList& checkFaces,
-                const List<labelPair>& baffles,
-                labelHashSet* setPtr
-            ) const;
-
-            bool checkFacePyramids
-            (
-                const bool report,
-                const scalar minPyrVol,
-                const pointField& p,
-                const labelList& checkFaces,
-                const List<labelPair>& baffles,
-                labelHashSet* setPtr
-            ) const;
-
-            bool checkFaceTets
-            (
-                const bool report,
-                const scalar minTetQuality,
-                const pointField& p,
-                const labelList& checkFaces,
-                const List<labelPair>& baffles,
-                labelHashSet* setPtr
-            ) const;
-
-            bool checkFaceWeights
-            (
-                const bool report,
-                const scalar warnWeight,
-                const labelList& checkFaces,
-                const List<labelPair>& baffles,
-                labelHashSet* setPtr
-            ) const;
-
-            bool checkVolRatio
-            (
-                const bool report,
-                const scalar warnRatio,
-                const labelList& checkFaces,
-                const List<labelPair>& baffles,
-                labelHashSet* setPtr
-            ) const;
-
-            bool checkFaceAngles
-            (
-                const bool report,
-                const scalar maxDeg,
-                const pointField& p,
-                const labelList& checkFaces,
-                labelHashSet* setPtr
-            ) const;
-
-            bool checkFaceTwist
-            (
-                const bool report,
-                const scalar minTwist,
-                const pointField& p,
-                const labelList& checkFaces,
-                labelHashSet* setPtr
-            ) const;
-
-            bool checkTriangleTwist
-            (
-                const bool report,
-                const scalar minTwist,
-                const pointField& p,
-                const labelList& checkFaces,
-                labelHashSet* setPtr
-            ) const;
-
-            bool checkFaceFlatness
-            (
-                const bool report,
-                const scalar minFlatness,
-                const pointField& p,
-                const labelList& checkFaces,
-                labelHashSet* setPtr
-            ) const;
-
-            bool checkFaceArea
-            (
-                const bool report,
-                const scalar minArea,
-                const labelList& checkFaces,
-                labelHashSet* setPtr
-            ) const;
-
-            bool checkCellDeterminant
-            (
-                const bool report,
-                const scalar warnDet,
-                const labelList& checkFaces,
-                const labelList& affectedCells,
-                labelHashSet* setPtr
-            ) const;
-};
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#endif
-
-// ************************************************************************* //
diff --git a/src/mesh/snappyHexMesh/meshRefinement/meshRefinementProblemCells.C b/src/mesh/snappyHexMesh/meshRefinement/meshRefinementProblemCells.C
index 376e52cb21..354a1d13ef 100644
--- a/src/mesh/snappyHexMesh/meshRefinement/meshRefinementProblemCells.C
+++ b/src/mesh/snappyHexMesh/meshRefinement/meshRefinementProblemCells.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2019 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2020 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -33,7 +33,7 @@ License
 #include "indirectPrimitivePatch.H"
 #include "cellSet.H"
 #include "searchableSurfaces.H"
-#include "polyMeshGeometry.H"
+#include "polyMeshCheck.H"
 #include "IOmanip.H"
 #include "unitConversion.H"
 #include "snappySnapDriver.H"
@@ -1213,7 +1213,7 @@ Foam::labelList Foam::meshRefinement::markFacesOnProblemCellsGeometric
             // const scalar minV(motionDict.lookup<scalar>("minVol", true));
             // if (minV > -great)
             //{
-            //    polyMeshGeometry::checkFacePyramids
+            //    polyMeshCheck::checkFacePyramids
             //    (
             //        false,
             //        minV,
@@ -1242,7 +1242,7 @@ Foam::labelList Foam::meshRefinement::markFacesOnProblemCellsGeometric
             scalar minArea(motionDict.lookup<scalar>("minArea"));
             if (minArea > -small)
             {
-                polyMeshGeometry::checkFaceArea
+                polyMeshCheck::checkFaceArea
                 (
                     false,
                     minArea,
@@ -1269,14 +1269,13 @@ Foam::labelList Foam::meshRefinement::markFacesOnProblemCellsGeometric
             scalar minDet(motionDict.lookup<scalar>("minDeterminant"));
             if (minDet > -1)
             {
-                polyMeshGeometry::checkCellDeterminant
+                polyMeshCheck::checkCellDeterminant
                 (
                     false,
                     minDet,
                     mesh_,
                     mesh_.faceAreas(),
                     allFaces,
-                    polyMeshGeometry::affectedCells(mesh_, allFaces),
                     &wrongFaces
                 );
 
diff --git a/src/meshTools/Make/files b/src/meshTools/Make/files
index 1be27710a7..19c1ba64a3 100644
--- a/src/meshTools/Make/files
+++ b/src/meshTools/Make/files
@@ -66,7 +66,6 @@ $(csys)/coordinateRotation/cylindrical.C
 edgeFaceCirculator/edgeFaceCirculator.C
 
 polyMeshZipUpCells/polyMeshZipUpCells.C
-primitiveMeshGeometry/primitiveMeshGeometry.C
 
 meshSearch/meshSearch.C
 meshSearch/meshSearchFACE_CENTRE_TRISMeshObject.C
diff --git a/src/meshTools/primitiveMeshGeometry/primitiveMeshGeometry.C b/src/meshTools/primitiveMeshGeometry/primitiveMeshGeometry.C
deleted file mode 100644
index 988f2793fe..0000000000
--- a/src/meshTools/primitiveMeshGeometry/primitiveMeshGeometry.C
+++ /dev/null
@@ -1,1468 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2018 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 "primitiveMeshGeometry.H"
-#include "pyramidPointFaceRef.H"
-#include "unitConversion.H"
-#include "triPointRef.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-namespace Foam
-{
-    defineTypeNameAndDebug(primitiveMeshGeometry, 0);
-}
-
-
-// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
-
-void Foam::primitiveMeshGeometry::updateFaceCentresAndAreas
-(
-    const pointField& p,
-    const labelList& changedFaces
-)
-{
-    const faceList& fs = mesh_.faces();
-
-    forAll(changedFaces, i)
-    {
-        label facei = changedFaces[i];
-
-        const labelList& f = fs[facei];
-        label nPoints = f.size();
-
-        // If the face is a triangle, do a direct calculation for efficiency
-        // and to avoid round-off error-related problems
-        if (nPoints == 3)
-        {
-            faceCentres_[facei] = (1.0/3.0)*(p[f[0]] + p[f[1]] + p[f[2]]);
-            faceAreas_[facei] = 0.5*((p[f[1]] - p[f[0]])^(p[f[2]] - p[f[0]]));
-        }
-        else
-        {
-            vector sumN = Zero;
-            scalar sumA = 0.0;
-            vector sumAc = Zero;
-
-            point fCentre = p[f[0]];
-            for (label pi = 1; pi < nPoints; pi++)
-            {
-                fCentre += p[f[pi]];
-            }
-
-            fCentre /= nPoints;
-
-            for (label pi = 0; pi < nPoints; pi++)
-            {
-                const point& nextPoint = p[f[(pi + 1) % nPoints]];
-
-                vector c = p[f[pi]] + nextPoint + fCentre;
-                vector n = (nextPoint - p[f[pi]])^(fCentre - p[f[pi]]);
-                scalar a = mag(n);
-
-                sumN += n;
-                sumA += a;
-                sumAc += a*c;
-            }
-
-            faceCentres_[facei] = (1.0/3.0)*sumAc/(sumA + vSmall);
-            faceAreas_[facei] = 0.5*sumN;
-        }
-    }
-}
-
-
-void Foam::primitiveMeshGeometry::updateCellCentresAndVols
-(
-    const labelList& changedCells,
-    const labelList& changedFaces
-)
-{
-    // Clear the fields for accumulation
-    UIndirectList<vector>(cellCentres_, changedCells) = Zero;
-    UIndirectList<scalar>(cellVolumes_, changedCells) = 0.0;
-
-    const labelList& own = mesh_.faceOwner();
-    const labelList& nei = mesh_.faceNeighbour();
-
-    // first estimate the approximate cell centre as the average of face centres
-
-    vectorField cEst(mesh_.nCells());
-    UIndirectList<vector>(cEst, changedCells) = Zero;
-    scalarField nCellFaces(mesh_.nCells());
-    UIndirectList<scalar>(nCellFaces, changedCells) = 0.0;
-
-    forAll(changedFaces, i)
-    {
-        label facei = changedFaces[i];
-        cEst[own[facei]] += faceCentres_[facei];
-        nCellFaces[own[facei]] += 1;
-
-        if (mesh_.isInternalFace(facei))
-        {
-            cEst[nei[facei]] += faceCentres_[facei];
-            nCellFaces[nei[facei]] += 1;
-        }
-    }
-
-    forAll(changedCells, i)
-    {
-        label celli = changedCells[i];
-        cEst[celli] /= nCellFaces[celli];
-    }
-
-    forAll(changedFaces, i)
-    {
-        label facei = changedFaces[i];
-
-        // Calculate 3*face-pyramid volume
-        scalar pyr3Vol = max
-        (
-            faceAreas_[facei] & (faceCentres_[facei] - cEst[own[facei]]),
-            vSmall
-        );
-
-        // Calculate face-pyramid centre
-        vector pc = (3.0/4.0)*faceCentres_[facei] + (1.0/4.0)*cEst[own[facei]];
-
-        // Accumulate volume-weighted face-pyramid centre
-        cellCentres_[own[facei]] += pyr3Vol*pc;
-
-        // Accumulate face-pyramid volume
-        cellVolumes_[own[facei]] += pyr3Vol;
-
-        if (mesh_.isInternalFace(facei))
-        {
-            // Calculate 3*face-pyramid volume
-            scalar pyr3Vol = max
-            (
-                faceAreas_[facei] & (cEst[nei[facei]] - faceCentres_[facei]),
-                vSmall
-            );
-
-            // Calculate face-pyramid centre
-            vector pc =
-                (3.0/4.0)*faceCentres_[facei]
-              + (1.0/4.0)*cEst[nei[facei]];
-
-            // Accumulate volume-weighted face-pyramid centre
-            cellCentres_[nei[facei]] += pyr3Vol*pc;
-
-            // Accumulate face-pyramid volume
-            cellVolumes_[nei[facei]] += pyr3Vol;
-        }
-    }
-
-    forAll(changedCells, i)
-    {
-        label celli = changedCells[i];
-
-        cellCentres_[celli] /= cellVolumes_[celli];
-        cellVolumes_[celli] *= (1.0/3.0);
-    }
-}
-
-
-Foam::labelList Foam::primitiveMeshGeometry::affectedCells
-(
-    const labelList& changedFaces
-) const
-{
-    const labelList& own = mesh_.faceOwner();
-    const labelList& nei = mesh_.faceNeighbour();
-
-    labelHashSet affectedCells(2*changedFaces.size());
-
-    forAll(changedFaces, i)
-    {
-        label facei = changedFaces[i];
-
-        affectedCells.insert(own[facei]);
-
-        if (mesh_.isInternalFace(facei))
-        {
-            affectedCells.insert(nei[facei]);
-        }
-    }
-    return affectedCells.toc();
-}
-
-
-
-// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
-
-// Construct from components
-Foam::primitiveMeshGeometry::primitiveMeshGeometry
-(
-    const primitiveMesh& mesh
-)
-:
-    mesh_(mesh)
-{
-    correct();
-}
-
-
-// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
-
-
-// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
-
-void Foam::primitiveMeshGeometry::correct()
-{
-    faceAreas_ = mesh_.faceAreas();
-    faceCentres_ = mesh_.faceCentres();
-    cellCentres_ = mesh_.cellCentres();
-    cellVolumes_ = mesh_.cellVolumes();
-}
-
-
-void Foam::primitiveMeshGeometry::correct
-(
-    const pointField& p,
-    const labelList& changedFaces
-)
-{
-    // Update face quantities
-    updateFaceCentresAndAreas(p, changedFaces);
-    // Update cell quantities from face quantities
-    updateCellCentresAndVols(affectedCells(changedFaces), changedFaces);
-}
-
-
-bool Foam::primitiveMeshGeometry::checkFaceDotProduct
-(
-    const bool report,
-    const scalar orthWarn,
-    const primitiveMesh& mesh,
-    const vectorField& cellCentres,
-    const vectorField& faceAreas,
-    const labelList& checkFaces,
-    labelHashSet* setPtr
-)
-{
-    // for all internal faces check theat the d dot S product is positive
-
-    const labelList& own = mesh.faceOwner();
-    const labelList& nei = mesh.faceNeighbour();
-
-    // Severe nonorthogonality threshold
-    const scalar severeNonorthogonalityThreshold = ::cos(degToRad(orthWarn));
-
-    scalar minDDotS = great;
-
-    scalar sumDDotS = 0;
-
-    label severeNonOrth = 0;
-
-    label errorNonOrth = 0;
-
-    forAll(checkFaces, i)
-    {
-        label facei = checkFaces[i];
-
-        if (mesh.isInternalFace(facei))
-        {
-            vector d = cellCentres[nei[facei]] - cellCentres[own[facei]];
-            const vector& s = faceAreas[facei];
-
-            scalar dDotS = (d & s)/(mag(d)*mag(s) + vSmall);
-
-            if (dDotS < severeNonorthogonalityThreshold)
-            {
-                if (dDotS > small)
-                {
-                    if (report)
-                    {
-                        // Severe non-orthogonality but mesh still OK
-                        Pout<< "Severe non-orthogonality for face " << facei
-                            << " between cells " << own[facei]
-                            << " and " << nei[facei]
-                            << ": Angle = " << radToDeg(::acos(dDotS))
-                            << " deg." << endl;
-                    }
-
-                    if (setPtr)
-                    {
-                        setPtr->insert(facei);
-                    }
-
-                    severeNonOrth++;
-                }
-                else
-                {
-                    // Non-orthogonality greater than 90 deg
-                    if (report)
-                    {
-                        WarningInFunction
-                            << "Severe non-orthogonality detected for face "
-                            << facei
-                            << " between cells " << own[facei] << " and "
-                            << nei[facei]
-                            << ": Angle = " << radToDeg(::acos(dDotS))
-                            << " deg." << endl;
-                    }
-
-                    errorNonOrth++;
-
-                    if (setPtr)
-                    {
-                        setPtr->insert(facei);
-                    }
-                }
-            }
-
-            if (dDotS < minDDotS)
-            {
-                minDDotS = dDotS;
-            }
-
-            sumDDotS += dDotS;
-        }
-    }
-
-    reduce(minDDotS, minOp<scalar>());
-    reduce(sumDDotS, sumOp<scalar>());
-    reduce(severeNonOrth, sumOp<label>());
-    reduce(errorNonOrth, sumOp<label>());
-
-    label neiSize = nei.size();
-    reduce(neiSize, sumOp<label>());
-
-    // Only report if there are some internal faces
-    if (neiSize > 0)
-    {
-        if (report && minDDotS < severeNonorthogonalityThreshold)
-        {
-            Info<< "Number of non-orthogonality errors: " << errorNonOrth
-                << ". Number of severely non-orthogonal faces: "
-                << severeNonOrth  << "." << endl;
-        }
-    }
-
-    if (report)
-    {
-        if (neiSize > 0)
-        {
-            Info<< "Mesh non-orthogonality Max: "
-                << radToDeg(::acos(minDDotS))
-                << " average: " << radToDeg(::acos(sumDDotS/neiSize))
-                << endl;
-        }
-    }
-
-    if (errorNonOrth > 0)
-    {
-        if (report)
-        {
-            SeriousErrorInFunction
-                << "Error in non-orthogonality detected" << endl;
-        }
-
-        return true;
-    }
-    else
-    {
-        if (report)
-        {
-            Info<< "Non-orthogonality check OK.\n" << endl;
-        }
-
-        return false;
-    }
-}
-
-
-bool Foam::primitiveMeshGeometry::checkFacePyramids
-(
-    const bool report,
-    const scalar minPyrVol,
-    const primitiveMesh& mesh,
-    const vectorField& cellCentres,
-    const pointField& p,
-    const labelList& checkFaces,
-    labelHashSet* setPtr
-)
-{
-    // check whether face area vector points to the cell with higher label
-    const labelList& own = mesh.faceOwner();
-    const labelList& nei = mesh.faceNeighbour();
-
-    const faceList& f = mesh.faces();
-
-    label nErrorPyrs = 0;
-
-    forAll(checkFaces, i)
-    {
-        label facei = checkFaces[i];
-
-        // Create the owner pyramid - it will have negative volume
-        scalar pyrVol = pyramidPointFaceRef
-        (
-            f[facei],
-            cellCentres[own[facei]]
-        ).mag(p);
-
-        if (pyrVol > -minPyrVol)
-        {
-            if (report)
-            {
-                Pout<< "bool primitiveMeshGeometry::checkFacePyramids("
-                    << "const bool, const scalar, const pointField&"
-                    << ", const labelList&, labelHashSet*): "
-                    << "face " << facei << " points the wrong way. " << endl
-                    << "Pyramid volume: " << -pyrVol
-                    << " Face " << f[facei] << " area: " << f[facei].mag(p)
-                    << " Owner cell: " << own[facei] << endl
-                    << "Owner cell vertex labels: "
-                    << mesh.cells()[own[facei]].labels(f)
-                    << endl;
-            }
-
-
-            if (setPtr)
-            {
-                setPtr->insert(facei);
-            }
-
-            nErrorPyrs++;
-        }
-
-        if (mesh.isInternalFace(facei))
-        {
-            // Create the neighbour pyramid - it will have positive volume
-            scalar pyrVol =
-                pyramidPointFaceRef(f[facei], cellCentres[nei[facei]]).mag(p);
-
-            if (pyrVol < minPyrVol)
-            {
-                if (report)
-                {
-                    Pout<< "bool primitiveMeshGeometry::checkFacePyramids("
-                        << "const bool, const scalar, const pointField&"
-                        << ", const labelList&, labelHashSet*): "
-                        << "face " << facei << " points the wrong way. " << endl
-                        << "Pyramid volume: " << -pyrVol
-                        << " Face " << f[facei] << " area: " << f[facei].mag(p)
-                        << " Neighbour cell: " << nei[facei] << endl
-                        << "Neighbour cell vertex labels: "
-                        << mesh.cells()[nei[facei]].labels(f)
-                        << endl;
-                }
-
-                if (setPtr)
-                {
-                    setPtr->insert(facei);
-                }
-
-                nErrorPyrs++;
-            }
-        }
-    }
-
-    reduce(nErrorPyrs, sumOp<label>());
-
-    if (nErrorPyrs > 0)
-    {
-        if (report)
-        {
-            SeriousErrorInFunction
-                << "Error in face pyramids: faces pointing the wrong way!"
-                << endl;
-        }
-
-        return true;
-    }
-    else
-    {
-        if (report)
-        {
-            Info<< "Face pyramids OK.\n" << endl;
-        }
-
-        return false;
-    }
-}
-
-
-bool Foam::primitiveMeshGeometry::checkFaceSkewness
-(
-    const bool report,
-    const scalar internalSkew,
-    const scalar boundarySkew,
-    const primitiveMesh& mesh,
-    const vectorField& cellCentres,
-    const vectorField& faceCentres,
-    const vectorField& faceAreas,
-    const labelList& checkFaces,
-    labelHashSet* setPtr
-)
-{
-    // Warn if the skew correction vector is more than skew times
-    // larger than the face area vector
-
-    const labelList& own = mesh.faceOwner();
-    const labelList& nei = mesh.faceNeighbour();
-
-    scalar maxSkew = 0;
-
-    label nWarnSkew = 0;
-
-    forAll(checkFaces, i)
-    {
-        label facei = checkFaces[i];
-
-        if (mesh.isInternalFace(facei))
-        {
-            scalar dOwn = mag(faceCentres[facei] - cellCentres[own[facei]]);
-            scalar dNei = mag(faceCentres[facei] - cellCentres[nei[facei]]);
-
-            point faceIntersection =
-                cellCentres[own[facei]]*dNei/(dOwn+dNei)
-              + cellCentres[nei[facei]]*dOwn/(dOwn+dNei);
-
-            scalar skewness =
-                mag(faceCentres[facei] - faceIntersection)
-              / (
-                    mag(cellCentres[nei[facei]]-cellCentres[own[facei]])
-                  + vSmall
-                );
-
-            // Check if the skewness vector is greater than the PN vector.
-            // This does not cause trouble but is a good indication of a poor
-            // mesh.
-            if (skewness > internalSkew)
-            {
-                if (report)
-                {
-                    Pout<< "Severe skewness for face " << facei
-                        << " skewness = " << skewness << endl;
-                }
-
-                if (setPtr)
-                {
-                    setPtr->insert(facei);
-                }
-
-                nWarnSkew++;
-            }
-
-            if (skewness > maxSkew)
-            {
-                maxSkew = skewness;
-            }
-        }
-        else
-        {
-            // Boundary faces: consider them to have only skewness error.
-            // (i.e. treat as if mirror cell on other side)
-
-            vector faceNormal = faceAreas[facei];
-            faceNormal /= mag(faceNormal) + vSmall;
-
-            vector dOwn = faceCentres[facei] - cellCentres[own[facei]];
-
-            vector dWall = faceNormal*(faceNormal & dOwn);
-
-            point faceIntersection = cellCentres[own[facei]] + dWall;
-
-            scalar skewness =
-                mag(faceCentres[facei] - faceIntersection)
-                /(2*mag(dWall) + vSmall);
-
-            // Check if the skewness vector is greater than the PN vector.
-            // This does not cause trouble but is a good indication of a poor
-            // mesh.
-            if (skewness > boundarySkew)
-            {
-                if (report)
-                {
-                    Pout<< "Severe skewness for boundary face " << facei
-                        << " skewness = " << skewness << endl;
-                }
-
-                if (setPtr)
-                {
-                    setPtr->insert(facei);
-                }
-
-                nWarnSkew++;
-            }
-
-            if (skewness > maxSkew)
-            {
-                maxSkew = skewness;
-            }
-        }
-    }
-
-    reduce(maxSkew, maxOp<scalar>());
-    reduce(nWarnSkew, sumOp<label>());
-
-    if (nWarnSkew > 0)
-    {
-        if (report)
-        {
-            WarningInFunction
-                << 100*maxSkew
-                << " percent.\nThis may impair the quality of the result." << nl
-                << nWarnSkew << " highly skew faces detected."
-                << endl;
-        }
-
-        return true;
-    }
-    else
-    {
-        if (report)
-        {
-            Info<< "Max skewness = " << 100*maxSkew
-                << " percent.  Face skewness OK.\n" << endl;
-        }
-
-        return false;
-    }
-}
-
-
-bool Foam::primitiveMeshGeometry::checkFaceWeights
-(
-    const bool report,
-    const scalar warnWeight,
-    const primitiveMesh& mesh,
-    const vectorField& cellCentres,
-    const vectorField& faceCentres,
-    const vectorField& faceAreas,
-    const labelList& checkFaces,
-    labelHashSet* setPtr
-)
-{
-    // Warn if the delta factor (0..1) is too large.
-
-    const labelList& own = mesh.faceOwner();
-    const labelList& nei = mesh.faceNeighbour();
-
-    scalar minWeight = great;
-
-    label nWarnWeight = 0;
-
-    forAll(checkFaces, i)
-    {
-        label facei = checkFaces[i];
-
-        if (mesh.isInternalFace(facei))
-        {
-            const point& fc = faceCentres[facei];
-
-            scalar dOwn = mag(faceAreas[facei] & (fc-cellCentres[own[facei]]));
-            scalar dNei = mag(faceAreas[facei] & (cellCentres[nei[facei]]-fc));
-
-            scalar weight = min(dNei,dOwn)/(dNei+dOwn);
-
-            if (weight < warnWeight)
-            {
-                if (report)
-                {
-                    Pout<< "Small weighting factor for face " << facei
-                        << " weight = " << weight << endl;
-                }
-
-                if (setPtr)
-                {
-                    setPtr->insert(facei);
-                }
-
-                nWarnWeight++;
-            }
-
-            minWeight = min(minWeight, weight);
-        }
-    }
-
-    reduce(minWeight, minOp<scalar>());
-    reduce(nWarnWeight, sumOp<label>());
-
-    if (minWeight < warnWeight)
-    {
-        if (report)
-        {
-            WarningInFunction
-                << minWeight << '.' << nl
-                << nWarnWeight << " faces with small weights detected."
-                << endl;
-        }
-
-        return true;
-    }
-    else
-    {
-        if (report)
-        {
-            Info<< "Min weight = " << minWeight
-                << " percent.  Weights OK.\n" << endl;
-        }
-
-        return false;
-    }
-}
-
-
-// Check convexity of angles in a face. Allow a slight non-convexity.
-// E.g. maxDeg = 10 allows for angles < 190 (or 10 degrees concavity)
-// (if truly concave and points not visible from face centre the face-pyramid
-//  check in checkMesh will fail)
-bool Foam::primitiveMeshGeometry::checkFaceAngles
-(
-    const bool report,
-    const scalar maxDeg,
-    const primitiveMesh& mesh,
-    const vectorField& faceAreas,
-    const pointField& p,
-    const labelList& checkFaces,
-    labelHashSet* setPtr
-)
-{
-    if (maxDeg < -small || maxDeg > 180+small)
-    {
-        FatalErrorInFunction
-            << "maxDeg should be [0..180] but is now " << maxDeg
-            << abort(FatalError);
-    }
-
-    const scalar maxSin = Foam::sin(degToRad(maxDeg));
-
-    const faceList& fcs = mesh.faces();
-
-    scalar maxEdgeSin = 0.0;
-
-    label nConcave = 0;
-
-    label errorFacei = -1;
-
-    forAll(checkFaces, i)
-    {
-        label facei = checkFaces[i];
-
-        const face& f = fcs[facei];
-
-        vector faceNormal = faceAreas[facei];
-        faceNormal /= mag(faceNormal) + vSmall;
-
-        // Get edge from f[0] to f[size-1];
-        vector ePrev(p[f.first()] - p[f.last()]);
-        scalar magEPrev = mag(ePrev);
-        ePrev /= magEPrev + vSmall;
-
-        forAll(f, fp0)
-        {
-            // Get vertex after fp
-            label fp1 = f.fcIndex(fp0);
-
-            // Normalized vector between two consecutive points
-            vector e10(p[f[fp1]] - p[f[fp0]]);
-            scalar magE10 = mag(e10);
-            e10 /= magE10 + vSmall;
-
-            if (magEPrev > small && magE10 > small)
-            {
-                vector edgeNormal = ePrev ^ e10;
-                scalar magEdgeNormal = mag(edgeNormal);
-
-                if (magEdgeNormal < maxSin)
-                {
-                    // Edges (almost) aligned -> face is ok.
-                }
-                else
-                {
-                    // Check normal
-                    edgeNormal /= magEdgeNormal;
-
-                    if ((edgeNormal & faceNormal) < small)
-                    {
-                        if (facei != errorFacei)
-                        {
-                            // Count only one error per face.
-                            errorFacei = facei;
-                            nConcave++;
-                        }
-
-                        if (setPtr)
-                        {
-                            setPtr->insert(facei);
-                        }
-
-                        maxEdgeSin = max(maxEdgeSin, magEdgeNormal);
-                    }
-                }
-            }
-
-            ePrev = e10;
-            magEPrev = magE10;
-        }
-    }
-
-    reduce(nConcave, sumOp<label>());
-    reduce(maxEdgeSin, maxOp<scalar>());
-
-    if (report)
-    {
-        if (maxEdgeSin > small)
-        {
-            scalar maxConcaveDegr =
-                radToDeg(Foam::asin(Foam::min(1.0, maxEdgeSin)));
-
-            Info<< "There are " << nConcave
-                << " faces with concave angles between consecutive"
-                << " edges. Max concave angle = " << maxConcaveDegr
-                << " degrees.\n" << endl;
-        }
-        else
-        {
-            Info<< "All angles in faces are convex or less than "  << maxDeg
-                << " degrees concave.\n" << endl;
-        }
-    }
-
-    if (nConcave > 0)
-    {
-        if (report)
-        {
-            WarningInFunction
-                << nConcave  << " face points with severe concave angle (> "
-                << maxDeg << " deg) found.\n"
-                << endl;
-        }
-
-        return true;
-    }
-    else
-    {
-        return false;
-    }
-}
-
-
-//// Check warpage of faces. Is calculated as the difference between areas of
-//// individual triangles and the overall area of the face (which ifself is
-//// is the average of the areas of the individual triangles).
-//bool Foam::primitiveMeshGeometry::checkFaceFlatness
-//(
-//    const bool report,
-//    const scalar warnFlatness,
-//    const primitiveMesh& mesh,
-//    const vectorField& faceAreas,
-//    const vectorField& faceCentres,
-//    const pointField& p,
-//    const labelList& checkFaces,
-//    labelHashSet* setPtr
-//)
-//{
-//    if (warnFlatness < 0 || warnFlatness > 1)
-//    {
-//        FatalErrorInFunction
-//            << "warnFlatness should be [0..1] but is now " << warnFlatness
-//            << abort(FatalError);
-//    }
-//
-//
-//    const faceList& fcs = mesh.faces();
-//
-//    // Areas are calculated as the sum of areas. (see
-//    // primitiveMeshFaceCentresAndAreas.C)
-//
-//    label nWarped = 0;
-//
-//    scalar minFlatness = great;
-//    scalar sumFlatness = 0;
-//    label nSummed = 0;
-//
-//    forAll(checkFaces, i)
-//    {
-//        label facei = checkFaces[i];
-//
-//        const face& f = fcs[facei];
-//
-//        scalar magArea = mag(faceAreas[facei]);
-//
-//        if (f.size() > 3 && magArea > vSmall)
-//        {
-//            const point& fc = faceCentres[facei];
-//
-//            // Calculate the sum of magnitude of areas and compare to
-//            // magnitude of sum of areas.
-//
-//            scalar sumA = 0.0;
-//
-//            forAll(f, fp)
-//            {
-//                const point& thisPoint = p[f[fp]];
-//                const point& nextPoint = p[f.nextLabel(fp)];
-//
-//                // Triangle around fc.
-//                vector n = 0.5*((nextPoint - thisPoint)^(fc - thisPoint));
-//                sumA += mag(n);
-//            }
-//
-//            scalar flatness = magArea / (sumA+vSmall);
-//
-//            sumFlatness += flatness;
-//            nSummed++;
-//
-//            minFlatness = min(minFlatness, flatness);
-//
-//            if (flatness < warnFlatness)
-//            {
-//                nWarped++;
-//
-//                if (setPtr)
-//                {
-//                    setPtr->insert(facei);
-//                }
-//            }
-//        }
-//    }
-//
-//
-//    reduce(nWarped, sumOp<label>());
-//    reduce(minFlatness, minOp<scalar>());
-//
-//    reduce(nSummed, sumOp<label>());
-//    reduce(sumFlatness, sumOp<scalar>());
-//
-//    if (report)
-//    {
-//        if (nSummed > 0)
-//        {
-//            Info<< "Face flatness (1 = flat, 0 = butterfly) : average = "
-//                << sumFlatness / nSummed << "  min = " << minFlatness << endl;
-//        }
-//
-//        if (nWarped> 0)
-//        {
-//            Info<< "There are " << nWarped
-//                << " faces with ratio between projected and actual area < "
-//                << warnFlatness
-//                << ".\nMinimum ratio (minimum flatness, maximum warpage) = "
-//                << minFlatness << nl << endl;
-//        }
-//        else
-//        {
-//            Info<< "All faces are flat in that the ratio between projected"
-//                << " and actual area is > " << warnFlatness << nl << endl;
-//        }
-//    }
-//
-//    if (nWarped > 0)
-//    {
-//        if (report)
-//        {
-//            WarningInFunction
-//                << nWarped  << " faces with severe warpage (flatness < "
-//                << warnFlatness << ") found.\n"
-//                << endl;
-//        }
-//
-//        return true;
-//    }
-//    else
-//    {
-//        return false;
-//    }
-//}
-
-
-// Check twist of faces. Is calculated as the difference between areas of
-// individual triangles and the overall area of the face (which ifself is
-// is the average of the areas of the individual triangles).
-bool Foam::primitiveMeshGeometry::checkFaceTwist
-(
-    const bool report,
-    const scalar minTwist,
-    const primitiveMesh& mesh,
-    const vectorField& faceAreas,
-    const vectorField& faceCentres,
-    const pointField& p,
-    const labelList& checkFaces,
-    labelHashSet* setPtr
-)
-{
-    if (minTwist < -1-small || minTwist > 1+small)
-    {
-        FatalErrorInFunction
-            << "minTwist should be [-1..1] but is now " << minTwist
-            << abort(FatalError);
-    }
-
-
-    const faceList& fcs = mesh.faces();
-
-    // Areas are calculated as the sum of areas. (see
-    // primitiveMeshFaceCentresAndAreas.C)
-
-    label nWarped = 0;
-
-    forAll(checkFaces, i)
-    {
-        label facei = checkFaces[i];
-
-        const face& f = fcs[facei];
-
-        scalar magArea = mag(faceAreas[facei]);
-
-        if (f.size() > 3 && magArea > vSmall)
-        {
-            const vector nf = faceAreas[facei] / magArea;
-
-            const point& fc = faceCentres[facei];
-
-            forAll(f, fpI)
-            {
-                vector triArea
-                (
-                    triPointRef
-                    (
-                        p[f[fpI]],
-                        p[f.nextLabel(fpI)],
-                        fc
-                    ).area()
-                );
-
-                scalar magTri = mag(triArea);
-
-                if (magTri > vSmall && ((nf & triArea/magTri) < minTwist))
-                {
-                    nWarped++;
-
-                    if (setPtr)
-                    {
-                        setPtr->insert(facei);
-                    }
-                }
-            }
-        }
-    }
-
-
-    reduce(nWarped, sumOp<label>());
-
-    if (report)
-    {
-        if (nWarped> 0)
-        {
-            Info<< "There are " << nWarped
-                << " faces with cosine of the angle"
-                << " between triangle normal and face normal less than "
-                << minTwist << nl << endl;
-        }
-        else
-        {
-            Info<< "All faces are flat in that the cosine of the angle"
-                << " between triangle normal and face normal less than "
-                << minTwist << nl << endl;
-        }
-    }
-
-    if (nWarped > 0)
-    {
-        if (report)
-        {
-            WarningInFunction
-                << nWarped  << " faces with severe warpage "
-                << "(cosine of the angle between triangle normal and "
-                << "face normal < " << minTwist << ") found.\n"
-                << endl;
-        }
-
-        return true;
-    }
-    else
-    {
-        return false;
-    }
-}
-
-
-bool Foam::primitiveMeshGeometry::checkFaceArea
-(
-    const bool report,
-    const scalar minArea,
-    const primitiveMesh& mesh,
-    const vectorField& faceAreas,
-    const labelList& checkFaces,
-    labelHashSet* setPtr
-)
-{
-    label nZeroArea = 0;
-
-    forAll(checkFaces, i)
-    {
-        label facei = checkFaces[i];
-
-        if (mag(faceAreas[facei]) < minArea)
-        {
-            if (setPtr)
-            {
-                setPtr->insert(facei);
-            }
-            nZeroArea++;
-        }
-    }
-
-
-    reduce(nZeroArea, sumOp<label>());
-
-    if (report)
-    {
-        if (nZeroArea > 0)
-        {
-            Info<< "There are " << nZeroArea
-                << " faces with area < " << minArea << '.' << nl << endl;
-        }
-        else
-        {
-            Info<< "All faces have area > " << minArea << '.' << nl << endl;
-        }
-    }
-
-    if (nZeroArea > 0)
-    {
-        if (report)
-        {
-            WarningInFunction
-                << nZeroArea  << " faces with area < " << minArea
-                << " found.\n"
-                << endl;
-        }
-
-        return true;
-    }
-    else
-    {
-        return false;
-    }
-}
-
-
-bool Foam::primitiveMeshGeometry::checkCellDeterminant
-(
-    const bool report,
-    const scalar warnDet,
-    const primitiveMesh& mesh,
-    const vectorField& faceAreas,
-    const labelList& checkFaces,
-    const labelList& affectedCells,
-    labelHashSet* setPtr
-)
-{
-    const cellList& cells = mesh.cells();
-
-    scalar minDet = great;
-    scalar sumDet = 0.0;
-    label nSumDet = 0;
-    label nWarnDet = 0;
-
-    forAll(affectedCells, i)
-    {
-        const cell& cFaces = cells[affectedCells[i]];
-
-        tensor areaSum(Zero);
-        scalar magAreaSum = 0;
-
-        forAll(cFaces, cFacei)
-        {
-            label facei = cFaces[cFacei];
-
-            scalar magArea = mag(faceAreas[facei]);
-
-            magAreaSum += magArea;
-            areaSum += faceAreas[facei]*(faceAreas[facei]/magArea);
-        }
-
-        scalar scaledDet = det(areaSum/magAreaSum)/0.037037037037037;
-
-        minDet = min(minDet, scaledDet);
-        sumDet += scaledDet;
-        nSumDet++;
-
-        if (scaledDet < warnDet)
-        {
-            if (setPtr)
-            {
-                // Insert all faces of the cell.
-                forAll(cFaces, cFacei)
-                {
-                    label facei = cFaces[cFacei];
-                    setPtr->insert(facei);
-                }
-            }
-            nWarnDet++;
-        }
-    }
-
-    reduce(minDet, minOp<scalar>());
-    reduce(sumDet, sumOp<scalar>());
-    reduce(nSumDet, sumOp<label>());
-    reduce(nWarnDet, sumOp<label>());
-
-    if (report)
-    {
-        if (nSumDet > 0)
-        {
-            Info<< "Cell determinant (1 = uniform cube) : average = "
-                << sumDet / nSumDet << "  min = " << minDet << endl;
-        }
-
-        if (nWarnDet > 0)
-        {
-            Info<< "There are " << nWarnDet
-                << " cells with determinant < " << warnDet << '.' << nl
-                << endl;
-        }
-        else
-        {
-            Info<< "All faces have determinant > " << warnDet << '.' << nl
-                << endl;
-        }
-    }
-
-    if (nWarnDet > 0)
-    {
-        if (report)
-        {
-            WarningInFunction
-                << nWarnDet << " cells with determinant < " << warnDet
-                << " found.\n"
-                << endl;
-        }
-
-        return true;
-    }
-    else
-    {
-        return false;
-    }
-}
-
-
-bool Foam::primitiveMeshGeometry::checkFaceDotProduct
-(
-    const bool report,
-    const scalar orthWarn,
-    const labelList& checkFaces,
-    labelHashSet* setPtr
-) const
-{
-    return checkFaceDotProduct
-    (
-        report,
-        orthWarn,
-        mesh_,
-        cellCentres_,
-        faceAreas_,
-        checkFaces,
-        setPtr
-    );
-}
-
-
-bool Foam::primitiveMeshGeometry::checkFacePyramids
-(
-    const bool report,
-    const scalar minPyrVol,
-    const pointField& p,
-    const labelList& checkFaces,
-    labelHashSet* setPtr
-) const
-{
-    return checkFacePyramids
-    (
-        report,
-        minPyrVol,
-        mesh_,
-        cellCentres_,
-        p,
-        checkFaces,
-        setPtr
-    );
-}
-
-
-bool Foam::primitiveMeshGeometry::checkFaceSkewness
-(
-    const bool report,
-    const scalar internalSkew,
-    const scalar boundarySkew,
-    const labelList& checkFaces,
-    labelHashSet* setPtr
-) const
-{
-    return checkFaceSkewness
-    (
-        report,
-        internalSkew,
-        boundarySkew,
-        mesh_,
-        cellCentres_,
-        faceCentres_,
-        faceAreas_,
-        checkFaces,
-        setPtr
-    );
-}
-
-
-bool Foam::primitiveMeshGeometry::checkFaceWeights
-(
-    const bool report,
-    const scalar warnWeight,
-    const labelList& checkFaces,
-    labelHashSet* setPtr
-) const
-{
-    return checkFaceWeights
-    (
-        report,
-        warnWeight,
-        mesh_,
-        cellCentres_,
-        faceCentres_,
-        faceAreas_,
-        checkFaces,
-        setPtr
-    );
-}
-
-
-bool Foam::primitiveMeshGeometry::checkFaceAngles
-(
-    const bool report,
-    const scalar maxDeg,
-    const pointField& p,
-    const labelList& checkFaces,
-    labelHashSet* setPtr
-) const
-{
-    return checkFaceAngles
-    (
-        report,
-        maxDeg,
-        mesh_,
-        faceAreas_,
-        p,
-        checkFaces,
-        setPtr
-    );
-}
-
-
-//bool Foam::primitiveMeshGeometry::checkFaceFlatness
-//(
-//    const bool report,
-//    const scalar warnFlatness,
-//    const pointField& p,
-//    const labelList& checkFaces,
-//    labelHashSet* setPtr
-//) const
-//{
-//    return checkFaceFlatness
-//    (
-//        report,
-//        warnFlatness,
-//        mesh_,
-//        faceAreas_,
-//        faceCentres_,
-//        p,
-//        checkFaces,
-//        setPtr
-//    );
-//}
-
-
-bool Foam::primitiveMeshGeometry::checkFaceTwist
-(
-    const bool report,
-    const scalar minTwist,
-    const pointField& p,
-    const labelList& checkFaces,
-    labelHashSet* setPtr
-) const
-{
-    return checkFaceTwist
-    (
-        report,
-        minTwist,
-        mesh_,
-        faceAreas_,
-        faceCentres_,
-        p,
-        checkFaces,
-        setPtr
-    );
-}
-
-
-bool Foam::primitiveMeshGeometry::checkFaceArea
-(
-    const bool report,
-    const scalar minArea,
-    const labelList& checkFaces,
-    labelHashSet* setPtr
-) const
-{
-    return checkFaceArea
-    (
-        report,
-        minArea,
-        mesh_,
-        faceAreas_,
-        checkFaces,
-        setPtr
-    );
-}
-
-
-bool Foam::primitiveMeshGeometry::checkCellDeterminant
-(
-    const bool report,
-    const scalar warnDet,
-    const labelList& checkFaces,
-    const labelList& affectedCells,
-    labelHashSet* setPtr
-) const
-{
-    return checkCellDeterminant
-    (
-        report,
-        warnDet,
-        mesh_,
-        faceAreas_,
-        checkFaces,
-        affectedCells,
-        setPtr
-    );
-}
-
-
-// ************************************************************************* //
diff --git a/src/meshTools/primitiveMeshGeometry/primitiveMeshGeometry.H b/src/meshTools/primitiveMeshGeometry/primitiveMeshGeometry.H
deleted file mode 100644
index ecbacabbde..0000000000
--- a/src/meshTools/primitiveMeshGeometry/primitiveMeshGeometry.H
+++ /dev/null
@@ -1,335 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2018 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::primitiveMeshGeometry
-
-Description
-    Updateable mesh geometry + checking routines.
-
-SourceFiles
-    primitiveMeshGeometry.C
-
-\*---------------------------------------------------------------------------*/
-
-#ifndef primitiveMeshGeometry_H
-#define primitiveMeshGeometry_H
-
-#include "pointFields.H"
-#include "HashSet.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-namespace Foam
-{
-
-/*---------------------------------------------------------------------------*\
-                           Class primitiveMeshGeometry Declaration
-\*---------------------------------------------------------------------------*/
-
-class primitiveMeshGeometry
-{
-        //- Reference to primitiveMesh.
-        const primitiveMesh& mesh_;
-
-        //- Uptodate copy of face areas
-        vectorField faceAreas_;
-
-        //- Uptodate copy of face centres
-        vectorField faceCentres_;
-
-        //- Uptodate copy of cell centres
-        vectorField cellCentres_;
-
-        //- Uptodate copy of cell volumes
-        scalarField cellVolumes_;
-
-
-    // Private Member Functions
-
-        //- Update face areas and centres on selected faces.
-        void updateFaceCentresAndAreas
-        (
-            const pointField& p,
-            const labelList& changedFaces
-        );
-
-        //- Update cell volumes and centres on selected cells. Requires
-        //  cells and faces to be consistent set.
-        void updateCellCentresAndVols
-        (
-            const labelList& changedCells,
-            const labelList& changedFaces
-        );
-
-public:
-
-    ClassName("primitiveMeshGeometry");
-
-    // Constructors
-
-        //- Construct from mesh
-        primitiveMeshGeometry(const primitiveMesh&);
-
-
-    // Member Functions
-
-        // Access
-
-            const primitiveMesh& mesh() const
-            {
-                return mesh_;
-            }
-
-            const vectorField& faceAreas() const
-            {
-                return faceAreas_;
-            }
-            const vectorField& faceCentres() const
-            {
-                return faceCentres_;
-            }
-            const vectorField& cellCentres() const
-            {
-                return cellCentres_;
-            }
-            const scalarField& cellVolumes() const
-            {
-                return cellVolumes_;
-            }
-
-        // Edit
-
-            //- Take over properties from mesh
-            void correct();
-
-            //- Recalculate on selected faces. Recalculates cell properties
-            //  on owner and neighbour of these cells.
-            void correct
-            (
-                const pointField& p,
-                const labelList& changedFaces
-            );
-
-            //- Helper function: get affected cells from faces
-            labelList affectedCells(const labelList& changedFaces) const;
-
-
-        // Checking of selected faces with supplied geometry (mesh only used for
-        // topology). Parallel aware.
-
-            static bool checkFaceDotProduct
-            (
-                const bool report,
-                const scalar orthWarn,
-                const primitiveMesh&,
-                const vectorField& cellCentres,
-                const vectorField& faceAreas,
-                const labelList& checkFaces,
-                labelHashSet* setPtr
-            );
-
-            static bool checkFacePyramids
-            (
-                const bool report,
-                const scalar minPyrVol,
-                const primitiveMesh&,
-                const vectorField& cellCentres,
-                const pointField& p,
-                const labelList& checkFaces,
-                labelHashSet*
-            );
-
-            static bool checkFaceSkewness
-            (
-                const bool report,
-                const scalar internalSkew,
-                const scalar boundarySkew,
-                const primitiveMesh& mesh,
-                const vectorField& cellCentres,
-                const vectorField& faceCentres,
-                const vectorField& faceAreas,
-                const labelList& checkFaces,
-                labelHashSet* setPtr
-            );
-
-            static bool checkFaceWeights
-            (
-                const bool report,
-                const scalar warnWeight,
-                const primitiveMesh& mesh,
-                const vectorField& cellCentres,
-                const vectorField& faceCentres,
-                const vectorField& faceAreas,
-                const labelList& checkFaces,
-                labelHashSet* setPtr
-            );
-
-            static bool checkFaceAngles
-            (
-                const bool report,
-                const scalar maxDeg,
-                const primitiveMesh& mesh,
-                const vectorField& faceAreas,
-                const pointField& p,
-                const labelList& checkFaces,
-                labelHashSet* setPtr
-            );
-
-            // static bool checkFaceFlatness
-            //(
-            //    const bool report,
-            //    const scalar warnFlatness,
-            //    const primitiveMesh&,
-            //    const vectorField& faceAreas,
-            //    const vectorField& faceCentres,
-            //    const pointField& p,
-            //    const labelList& checkFaces,
-            //    labelHashSet* setPtr
-            //);
-
-            static bool checkFaceTwist
-            (
-                const bool report,
-                const scalar minTwist,
-                const primitiveMesh&,
-                const vectorField& faceAreas,
-                const vectorField& faceCentres,
-                const pointField& p,
-                const labelList& checkFaces,
-                labelHashSet* setPtr
-            );
-
-            static bool checkFaceArea
-            (
-                const bool report,
-                const scalar minArea,
-                const primitiveMesh&,
-                const vectorField& faceAreas,
-                const labelList& checkFaces,
-                labelHashSet* setPtr
-            );
-
-            static bool checkCellDeterminant
-            (
-                const bool report,
-                const scalar minDet,
-                const primitiveMesh&,
-                const vectorField& faceAreas,
-                const labelList& checkFaces,
-                const labelList& affectedCells,
-                labelHashSet* setPtr
-            );
-
-
-        // Checking of selected faces with local geometry. Uses above static
-        // functions. Parallel aware.
-
-            bool checkFaceDotProduct
-            (
-                const bool report,
-                const scalar orthWarn,
-                const labelList& checkFaces,
-                labelHashSet* setPtr
-            ) const;
-
-            bool checkFacePyramids
-            (
-                const bool report,
-                const scalar minPyrVol,
-                const pointField& p,
-                const labelList& checkFaces,
-                labelHashSet* setPtr
-            ) const;
-
-            bool checkFaceSkewness
-            (
-                const bool report,
-                const scalar internalSkew,
-                const scalar boundarySkew,
-                const labelList& checkFaces,
-                labelHashSet* setPtr
-            ) const;
-
-            bool checkFaceWeights
-            (
-                const bool report,
-                const scalar warnWeight,
-                const labelList& checkFaces,
-                labelHashSet* setPtr
-            ) const;
-
-            bool checkFaceAngles
-            (
-                const bool report,
-                const scalar maxDeg,
-                const pointField& p,
-                const labelList& checkFaces,
-                labelHashSet* setPtr
-            ) const;
-
-            // bool checkFaceFlatness
-            //(
-            //    const bool report,
-            //    const scalar warnFlatness,
-            //    const pointField& p,
-            //    const labelList& checkFaces,
-            //    labelHashSet* setPtr
-            //) const;
-
-            bool checkFaceTwist
-            (
-                const bool report,
-                const scalar minTwist,
-                const pointField& p,
-                const labelList& checkFaces,
-                labelHashSet* setPtr
-            ) const;
-
-            bool checkFaceArea
-            (
-                const bool report,
-                const scalar minArea,
-                const labelList& checkFaces,
-                labelHashSet* setPtr
-            ) const;
-
-            bool checkCellDeterminant
-            (
-                const bool report,
-                const scalar warnDet,
-                const labelList& checkFaces,
-                const labelList& affectedCells,
-                labelHashSet* setPtr
-            ) const;
-};
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#endif
-
-// ************************************************************************* //