ENH: Move pointEdge sorting to PatchTools

src/OpenFOAM/meshes/primitiveMesh/PatchTools/PatchTools.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -30,6 +30,7 @@ License
 #include "PatchToolsGatherAndMerge.C"
 #include "PatchToolsSearch.C"
 #include "PatchToolsSortEdges.C"
+#include "PatchToolsSortPoints.C"
 #include "PatchToolsNormals.C"
 #include "PatchToolsMatch.C"
 

src/OpenFOAM/meshes/primitiveMesh/PatchTools/PatchTools.H

@@ -170,6 +170,18 @@ public:
         const PrimitivePatch<Face, FaceList, PointField, PointType>&
     );
 
+    //- Return point-edge addressing sorted by order around the point.
+    template
+    <
+        class Face,
+        template<class> class FaceList,
+        class PointField,
+        class PointType
+    >
+    static labelListList sortedPointEdges
+    (
+        const PrimitivePatch<Face, FaceList, PointField, PointType>&
+    );
 
     //- If 2 face neighbours: label of face where ordering of edge
     //  is consistent with righthand walk.

src/OpenFOAM/meshes/primitiveMesh/PatchTools/PatchToolsSortPoints.C

+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2013 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 "PatchTools.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+template
+<
+    class Face,
+    template<class> class FaceList,
+    class PointField,
+    class PointType
+>
+
+Foam::labelListList
+Foam::PatchTools::sortedPointEdges
+(
+    const PrimitivePatch<Face, FaceList, PointField, PointType>& p
+)
+{
+    // Now order the edges of each point according to whether they share a
+    // face
+    const labelListList& pointEdges = p.pointEdges();
+    const edgeList& edges = p.edges();
+    const labelListList& edgeFaces = p.edgeFaces();
+    const labelListList& faceEdges = p.faceEdges();
+
+    // create the lists for the various results. (resized on completion)
+    labelListList sortedPointEdges(pointEdges.size());
+
+    DynamicList<label> newEdgeList;
+
+    forAll(pointEdges, pointI)
+    {
+        const labelList& pEdges = pointEdges[pointI];
+
+        label edgeI = pEdges[0];
+
+        label prevFaceI = edgeFaces[edgeI][0];
+
+        newEdgeList.clear();
+        newEdgeList.setCapacity(pEdges.size());
+
+        do
+        {
+            newEdgeList.append(edgeI);
+
+            // Cross edge to next face
+            const labelList& eFaces = edgeFaces[edgeI];
+
+            if (eFaces.size() != 2)
+            {
+                break;
+            }
+
+            label faceI = eFaces[0];
+            if (faceI == prevFaceI)
+            {
+                faceI = eFaces[1];
+            }
+
+            // Cross face to next edge
+            const labelList& fEdges = faceEdges[faceI];
+
+            forAll(fEdges, feI)
+            {
+                const label nextEdgeI = fEdges[feI];
+                const edge& nextEdge = edges[nextEdgeI];
+
+                if
+                (
+                    nextEdgeI != edgeI
+                 && (nextEdge.start() == pointI || nextEdge.end() == pointI)
+                )
+                {
+                    edgeI = nextEdgeI;
+                    break;
+                }
+            }
+
+            prevFaceI = faceI;
+
+        } while (edgeI != pEdges[0]);
+
+        if (newEdgeList.size() == pEdges.size())
+        {
+            sortedPointEdges[pointI] = newEdgeList;
+        }
+    }
+
+    return sortedPointEdges;
+}
+
+
+// ************************************************************************* //

src/OpenFOAM/meshes/primitiveMesh/PrimitivePatch/PrimitivePatchPointAddressing.C

@@ -75,76 +75,6 @@ calcPointEdges() const
             << "calcPointEdges() finished calculating pointEdges"
             << endl;
     }
-
-    // Now order the edges of each point according to whether they share a
-    // face
-
-//    DynamicList<label> newEdgeList;
-
-//    forAll(pe, pointI)
-//    {
-//        const labelList& pEdges = pe[pointI];
-
-//        label edgeI = pEdges[0];
-
-//        label prevFaceI = edgeFaces()[edgeI][0];
-
-//        newEdgeList.clear();
-//        newEdgeList.setCapacity(pEdges.size());
-
-//        do
-//        {
-//            newEdgeList.append(edgeI);
-
-//            // Cross edge to next face
-//            const labelList& eFaces = edgeFaces()[edgeI];
-
-//            if (eFaces.size() != 2)
-//            {
-//                break;
-//            }
-
-//            label faceI = eFaces[0];
-//            if (faceI == prevFaceI)
-//            {
-//                faceI = eFaces[1];
-//            }
-
-//            // Cross face to next edge
-//            const labelList& fEdges = faceEdges()[faceI];
-
-//            forAll(fEdges, feI)
-//            {
-//                const label nextEdgeI = fEdges[feI];
-//                const edge& nextEdge = edges()[nextEdgeI];
-
-//                if
-//                (
-//                    nextEdgeI != edgeI
-//                 && (nextEdge.start() == pointI || nextEdge.end() == pointI)
-//                )
-//                {
-//                    edgeI = nextEdgeI;
-//                    break;
-//                }
-//            }
-
-//            prevFaceI = faceI;
-
-//        } while (edgeI != pEdges[0]);
-
-//        if (newEdgeList.size() == pEdges.size())
-//        {
-//            pe[pointI] = newEdgeList;
-//        }
-//    }
-
-//    if (debug)
-//    {
-//        Info<< "PrimitivePatch<Face, FaceList, PointField, PointType>::"
-//            << "calcPointEdges() finished ordering pointEdges"
-//            << endl;
-//    }
 }