ENH: use faceTraits for managing differences between face representations

src/surfMesh/MeshedSurface/MeshedSurface.C

@@ -33,24 +33,17 @@ License
 #include "polyMesh.H"
 #include "surfMesh.H"
 #include "primitivePatch.H"
+#include "faceTraits.H"
 #include "addToRunTimeSelectionTable.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-template<class Face>
-inline bool Foam::MeshedSurface<Face>::isTri()
-{
-    return false;
-}
-
-
 template<class Face>
 Foam::wordHashSet Foam::MeshedSurface<Face>::readTypes()
 {
     return wordHashSet(*fileExtensionConstructorTablePtr_);
 }
 
-
 template<class Face>
 Foam::wordHashSet Foam::MeshedSurface<Face>::writeTypes()
 {
@@ -116,25 +109,34 @@ void Foam::MeshedSurface<Face>::write
     const fileName& name,
     const MeshedSurface<Face>& surf
 )
+{
+    write(name, name.ext(), surf);
+}
+
+
+template<class Face>
+void Foam::MeshedSurface<Face>::write
+(
+    const fileName& name,
+    const word& ext,
+    const MeshedSurface<Face>& surf
+)
 {
     if (debug)
     {
         InfoInFunction << "Writing to " << name << endl;
     }
 
-    const word ext = name.ext();
-
-    typename writefileExtensionMemberFunctionTable::iterator mfIter =
-        writefileExtensionMemberFunctionTablePtr_->find(ext);
+    auto mfIter = writefileExtensionMemberFunctionTablePtr_->find(ext);
 
-    if (mfIter == writefileExtensionMemberFunctionTablePtr_->end())
+    if (!mfIter.found())
     {
         // No direct writer, delegate to proxy if possible
         const wordHashSet& delegate = ProxyType::writeTypes();
 
         if (delegate.found(ext))
         {
-            MeshedSurfaceProxy<Face>(surf).write(name);
+            MeshedSurfaceProxy<Face>(surf).write(name, ext);
         }
         else
         {
@@ -850,6 +852,11 @@ bool Foam::MeshedSurface<Face>::checkFaces
 template<class Face>
 Foam::label Foam::MeshedSurface<Face>::nTriangles() const
 {
+    if (faceTraits<Face>::isTri())
+    {
+        return ParentType::size();
+    }
+
     return nTriangles
     (
         const_cast<List<label>&>(List<label>::null())
@@ -905,10 +912,18 @@ Foam::label Foam::MeshedSurface<Face>::nTriangles
 template<class Face>
 Foam::label Foam::MeshedSurface<Face>::triangulate()
 {
-    return triangulate
-    (
-        const_cast<List<label>&>(List<label>::null())
-    );
+    if (faceTraits<Face>::isTri())
+    {
+        // Inplace triangulation of triFace/labelledTri surface = no-op
+        return 0;
+    }
+    else
+    {
+        return triangulate
+        (
+            const_cast<List<label>&>(List<label>::null())
+        );
+    }
 }
 
 
@@ -918,6 +933,17 @@ Foam::label Foam::MeshedSurface<Face>::triangulate
     List<label>& faceMapOut
 )
 {
+    if (faceTraits<Face>::isTri())
+    {
+        // Inplace triangulation of triFace/labelledTri surface = no-op
+        if (notNull(faceMapOut))
+        {
+            faceMapOut.clear();
+        }
+
+        return 0;
+    }
+
     label nTri = 0;
     label maxTri = 0;  // the maximum number of triangles for any single face
     List<Face>& faceLst = this->storedFaces();
@@ -966,7 +992,7 @@ Foam::label Foam::MeshedSurface<Face>::triangulate
             {
                 label fp1 = f.fcIndex(fp);
 
-                newFaces[nTri] = triFace(f[0], f[fp], f[fp1]);
+                newFaces[nTri] = Face{f[0], f[fp], f[fp1]};
                 faceMap[nTri] = facei;
                 nTri++;
             }

src/surfMesh/MeshedSurface/MeshedSurface.H

@@ -186,9 +186,6 @@ public:
 
     // Static
 
-        //- Face storage only handles triangulated faces
-        inline static bool isTri();
-
         //- Can we read this file format?
         static bool canRead(const fileName&, const bool verbose=false);
 
@@ -210,36 +207,36 @@ public:
         //- Construct by transferring components (points, faces, zones).
         MeshedSurface
         (
-            const Xfer<pointField>&,
-            const Xfer<List<Face>>&,
-            const Xfer<surfZoneList>&
+            const Xfer<pointField>& pointLst,
+            const Xfer<List<Face>>& faceLst,
+            const Xfer<surfZoneList>& zoneLst
         );
 
         //- Construct by transferring components (points, faces).
         //  Use zone information if available
         MeshedSurface
         (
-            const Xfer<pointField>&,
-            const Xfer<List<Face>>&,
+            const Xfer<pointField>& pointLst,
+            const Xfer<List<Face>>& faceLst,
             const labelUList& zoneSizes = labelUList(),
             const UList<word>& zoneNames = UList<word>()
         );
 
         //- Construct as copy
-        MeshedSurface(const MeshedSurface&);
+        MeshedSurface(const MeshedSurface& surf);
 
         //- Construct from a UnsortedMeshedSurface
-        MeshedSurface(const UnsortedMeshedSurface<Face>&);
+        MeshedSurface(const UnsortedMeshedSurface<Face>& surf);
 
         //- Construct from a boundary mesh with local points/faces
         MeshedSurface
         (
-            const polyBoundaryMesh&,
+            const polyBoundaryMesh& bMesh,
             const bool globalPoints=false
         );
 
         //- Construct from a surfMesh
-        MeshedSurface(const surfMesh&);
+        MeshedSurface(const surfMesh& mesh);
 
         //- Construct by transferring the contents from a UnsortedMeshedSurface
         MeshedSurface(const Xfer<UnsortedMeshedSurface<Face>>&);
@@ -248,18 +245,18 @@ public:
         MeshedSurface(const Xfer<MeshedSurface<Face>>&);
 
         //- Construct from file name (uses extension to determine type)
-        MeshedSurface(const fileName&);
+        MeshedSurface(const fileName& name);
 
         //- Construct from file name (uses extension to determine type)
-        MeshedSurface(const fileName&, const word& ext);
+        MeshedSurface(const fileName& name, const word& ext);
 
         //- Construct from Istream
-        MeshedSurface(Istream&);
+        MeshedSurface(Istream& is);
 
         //- Construct from database
         MeshedSurface
         (
-            const Time&,
+            const Time& t,
             const word& surfName = word::null
         );
 
@@ -283,7 +280,7 @@ public:
         //- Select constructed from filename (explicit extension)
         static autoPtr<MeshedSurface> New
         (
-            const fileName&,
+            const fileName& name,
             const word& ext
         );
 
@@ -310,11 +307,19 @@ public:
             (name, surf)
         );
 
-        //- Write to file
+        //- Write to file, selecting writer based on its extension
         static void write
         (
-            const fileName&,
-            const MeshedSurface<Face>&
+            const fileName& name,
+            const MeshedSurface<Face>& surf
+        );
+
+        //- Write to file, selecting writer based on the given extension
+        static void write
+        (
+            const fileName& name,
+            const word& ext,
+            const MeshedSurface<Face>& surf
         );
 
 
@@ -563,8 +568,6 @@ bool MeshedSurface<labelledTri>::addZonesToFaces();
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-#include "MeshedSurfaceI.H"
-
 #ifdef NoRepository
     #include "MeshedSurface.C"
 #endif

src/surfMesh/MeshedSurface/MeshedSurfaceCore.C

@@ -50,7 +50,7 @@ namespace Foam
     )
     {
         // First triangulate
-        // - slightly wasteful for space, but manages adjusts the zones too!
+        // - slightly wasteful for space, but adjusts the zones too!
         surf.triangulate();
         this->storedPoints().transfer(surf.storedPoints());
         this->storedZones().transfer(surf.storedZones());
@@ -81,12 +81,12 @@ namespace Foam
     )
     {
         // First triangulate
-        // - slightly wasteful for space, but manages adjusts the zones too!
+        // - slightly wasteful for space, but adjusts the zones too!
         surf.triangulate();
         this->storedPoints().transfer(surf.storedPoints());
         this->storedZones().transfer(surf.storedZones());
 
-        // transcribe from face -> triFace
+        // transcribe from face -> labelledTri (via triFace)
         const List<face>& origFaces = surf.surfFaces();
         List<labelledTri> newFaces(origFaces.size());
         forAll(origFaces, facei)

src/surfMesh/MeshedSurface/MeshedSurfaceI.H

-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2016 OpenCFD Ltd.
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 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/>.
-
-\*---------------------------------------------------------------------------*/
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-namespace Foam
-{
-
-// A triFace surface only handles triangulated faces
-template<>
-inline bool MeshedSurface<triFace>::isTri()
-{
-    return true;
-}
-
-
-// A labelledTri surface only handles triangulated faces
-template<>
-inline bool MeshedSurface<labelledTri>::isTri()
-{
-    return true;
-}
-
-
-// Number of triangles for a triFace surface
-template<>
-inline label MeshedSurface<triFace>::nTriangles() const
-{
-    return ParentType::size();
-}
-
-// Number of triangles for a labelledTri surface
-template<>
-inline label MeshedSurface<labelledTri>::nTriangles() const
-{
-    return ParentType::size();
-}
-
-
-// Inplace triangulation of triFace surface = no-op
-template<>
-inline label MeshedSurface<triFace>::triangulate()
-{
-    return 0;
-}
-
-// Inplace triangulation of labelledTri surface = no-op
-template<>
-inline label MeshedSurface<labelledTri>::triangulate()
-{
-    return 0;
-}
-
-// Inplace triangulation of triFace surface (with face map) = no-op
-template<>
-inline label MeshedSurface<triFace>::triangulate(List<label>& faceMap)
-{
-    if (notNull(faceMap))
-    {
-        faceMap.clear();
-    }
-    return 0;
-}
-
-// Inplace triangulation of labelledTri surface (with face map) = no-op
-template<>
-inline label MeshedSurface<labelledTri>::triangulate(List<label>& faceMap)
-{
-    if (notNull(faceMap))
-    {
-        faceMap.clear();
-    }
-    return 0;
-}
-
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
-
-// ************************************************************************* //

src/surfMesh/MeshedSurface/MeshedSurfaceIO.C

@@ -3,7 +3,7 @@
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
     \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
-     \\/     M anipulation  | Copyright (C) 2016 OpenCFD Ltd.
+     \\/     M anipulation  | Copyright (C) 2016-2017 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -25,6 +25,7 @@ License
 
 #include "MeshedSurface.H"
 #include "boundBox.H"
+#include "faceTraits.H"
 #include "Istream.H"
 #include "Ostream.H"
 
@@ -58,7 +59,7 @@ template<class Face>
 void Foam::MeshedSurface<Face>::writeStats(Ostream& os) const
 {
     os  << "points      : " << this->points().size() << nl;
-    if (MeshedSurface<Face>::isTri())
+    if (faceTraits<Face>::isTri())
     {
         os << "triangles   : " << this->size() << nl;
     }
@@ -82,7 +83,7 @@ void Foam::MeshedSurface<Face>::writeStats(Ostream& os) const
 
         os  << "faces       : " << this->size()
             << "  (tri:" << nTri << " quad:" << nQuad
-            << " poly:" << (this->size() - nTri - nQuad ) << ")" << nl;
+            << " poly:" << (this->size() - nTri - nQuad) << ")" << nl;
     }
 
     os  << "boundingBox : " << boundBox(this->points()) << endl;

src/surfMesh/MeshedSurface/MeshedSurfaceNew.C

@@ -38,10 +38,9 @@ Foam::MeshedSurface<Face>::New(const fileName& name, const word& ext)
         InfoInFunction << "Constructing MeshedSurface" << endl;
     }
 
-    typename fileExtensionConstructorTable::iterator cstrIter =
-        fileExtensionConstructorTablePtr_->find(ext);
+    auto cstrIter = fileExtensionConstructorTablePtr_->find(ext);
 
-    if (cstrIter == fileExtensionConstructorTablePtr_->end())
+    if (!cstrIter.found())
     {
         // No direct reader, delegate to friend if possible
         const wordHashSet& delegate = FriendType::readTypes();

src/surfMesh/MeshedSurfaceProxy/MeshedSurfaceProxy.C

@@ -29,6 +29,7 @@ License
 #include "ListOps.H"
 #include "surfMesh.H"
 #include "OFstream.H"
+#include "faceTraits.H"
 
 // * * * * * * * * * * * * * Static Member Functions * * * * * * * * * * * * //
 
@@ -59,18 +60,27 @@ void Foam::MeshedSurfaceProxy<Face>::write
     const fileName& name,
     const MeshedSurfaceProxy& surf
 )
+{
+    write(name, name.ext(), surf);
+}
+
+
+template<class Face>
+void Foam::MeshedSurfaceProxy<Face>::write
+(
+    const fileName& name,
+    const word& ext,
+    const MeshedSurfaceProxy& surf
+)
 {
     if (debug)
     {
         InfoInFunction << "Writing to " << name << endl;
     }
 
-    const word ext = name.ext();
+    auto mfIter = writefileExtensionMemberFunctionTablePtr_->find(ext);
 
-    typename writefileExtensionMemberFunctionTable::iterator mfIter =
-        writefileExtensionMemberFunctionTablePtr_->find(ext);
-
-    if (mfIter == writefileExtensionMemberFunctionTablePtr_->end())
+    if (!mfIter.found())
     {
         FatalErrorInFunction
             << "Unknown file extension " << ext << nl << nl
@@ -237,38 +247,24 @@ Foam::MeshedSurfaceProxy<Face>::~MeshedSurfaceProxy()
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
-
-namespace Foam
-{
-
-// Number of triangles for a triFace surface
-template<>
-inline label MeshedSurfaceProxy<triFace>::nTriangles() const
-{
-    return this->size();
-}
-
-// Number of triangles for a labelledTri surface
-template<>
-inline label MeshedSurfaceProxy<labelledTri>::nTriangles() const
-{
-    return this->size();
-}
-
-}
-
-
 template<class Face>
 inline Foam::label Foam::MeshedSurfaceProxy<Face>::nTriangles() const
 {
-    label nTri = 0;
-    const List<Face>& faceLst = this->surfFaces();
-    forAll(faceLst, facei)
+    if (faceTraits<Face>::isTri())
     {
-        nTri += faceLst[facei].nTriangles();
+        return this->size();
     }
+    else
+    {
+        label nTri = 0;
+        const List<Face>& faceLst = this->surfFaces();
+        forAll(faceLst, facei)
+        {
+            nTri += faceLst[facei].nTriangles();
+        }
 
-    return nTri;
+        return nTri;
+    }
 }
 
 

src/surfMesh/MeshedSurfaceProxy/MeshedSurfaceProxy.H

@@ -3,7 +3,7 @@
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
     \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
-     \\/     M anipulation  | Copyright (C) 2016 OpenCFD Ltd.
+     \\/     M anipulation  | Copyright (C) 2016-2017 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -100,9 +100,9 @@ public:
         //- Construct from component references
         MeshedSurfaceProxy
         (
-            const pointField&,
-            const List<Face>&,
-            const List<surfZone>& = List<surfZone>(),
+            const pointField& pointLst,
+            const List<Face>& faceLst,
+            const List<surfZone>& zoneLst = List<surfZone>(),
             const List<label>& faceMap = List<label>()
         );
 
@@ -126,11 +126,19 @@ public:
             (name, surf)
         );
 
-        //- Write to file
+        //- Write to file, selected based on its extension
         static void write
         (
-            const fileName&,
-            const MeshedSurfaceProxy<Face>&
+            const fileName& name,
+            const MeshedSurfaceProxy& surf
+        );
+
+        //- Write to file, selected based on given extension
+        static void write
+        (
+            const fileName& name,
+            const word& ext,
+            const MeshedSurfaceProxy& surf
         );
 
 
@@ -188,10 +196,16 @@ public:
                 write(name, *this);
             }
 
+            //- Generic write routine. Chooses writer based on extension.
+            virtual void write(const fileName& name, const word& ext) const
+            {
+                write(name, ext, *this);
+            }
+
             //- Write to database
             virtual void write
             (
-                const Time&,
+                const Time& t,
                 const word& surfName = word::null
             ) const;
 };

src/surfMesh/UnsortedMeshedSurface/UnsortedMeshedSurface.C

@@ -113,17 +113,16 @@ void Foam::UnsortedMeshedSurface<Face>::write
 
     const word ext = name.ext();
 
-    typename writefileExtensionMemberFunctionTable::iterator mfIter =
-        writefileExtensionMemberFunctionTablePtr_->find(ext);
+    auto mfIter = writefileExtensionMemberFunctionTablePtr_->find(ext);
 
-    if (mfIter == writefileExtensionMemberFunctionTablePtr_->end())
+    if (!mfIter.found())
     {
         // No direct writer, delegate to proxy if possible
         const wordHashSet& delegate = ProxyType::writeTypes();
 
         if (delegate.found(ext))
         {
-            MeshedSurfaceProxy<Face>(surf).write(name);
+            MeshedSurfaceProxy<Face>(surf).write(name, ext);
         }
         else
         {

src/surfMesh/UnsortedMeshedSurface/UnsortedMeshedSurfaceNew.C

@@ -37,10 +37,9 @@ Foam::UnsortedMeshedSurface<Face>::New(const fileName& name, const word& ext)
         InfoInFunction << "Constructing UnsortedMeshedSurface" << endl;
     }
 
-    typename fileExtensionConstructorTable::iterator cstrIter =
-        fileExtensionConstructorTablePtr_->find(ext);
+    auto cstrIter = fileExtensionConstructorTablePtr_->find(ext);
 
-    if (cstrIter == fileExtensionConstructorTablePtr_->end())
+    if (!cstrIter.found())
     {
         // No direct reader, delegate to parent if possible
         const wordHashSet& delegate = ParentType::readTypes();