surfMesh streamlining

- all formats except ftr and gts are now read as MeshedSurface (thus sorted
   immediately). Avoid unnecessary sorting during construction though.
 - moved cleanup routines completely into PrimitiveMeshedSurface

src/surfMesh/MeshedSurface/MeshedSurface.C

@@ -99,14 +99,14 @@ bool Foam::MeshedSurface<Face>::canWriteType
 template<class Face>
 bool Foam::MeshedSurface<Face>::canRead
 (
-    const fileName& fName,
+    const fileName& name,
     const bool verbose
 )
 {
-    word ext = fName.ext();
+    word ext = name.ext();
     if (ext == "gz")
     {
-        ext = fName.lessExt().ext();
+        ext = name.lessExt().ext();
     }
     return canReadType(ext, verbose);
 }
@@ -115,7 +115,7 @@ bool Foam::MeshedSurface<Face>::canRead
 template<class Face>
 void Foam::MeshedSurface<Face>::write
 (
-    const fileName& fName,
+    const fileName& name,
     const MeshedSurface& surf
 )
 {
@@ -123,16 +123,16 @@ void Foam::MeshedSurface<Face>::write
     {
         Info<< "MeshedSurface::write"
             "(const fileName&, const MeshedSurface&) : "
-            "writing to " << fName
+            "writing to " << name
             << endl;
     }
 
-    word ext = fName.ext();
+    word ext = name.ext();
 
     // handle 'native' format directly
     if (isNative(ext))
     {
-        surf.write(OFstream(fName)());
+        surf.write(OFstream(name)());
         return;
     }
 
@@ -150,7 +150,7 @@ void Foam::MeshedSurface<Face>::write
             << exit(FatalError);
     }
 
-    mfIter()(fName, surf);
+    mfIter()(name, surf);
 }
 
 
@@ -180,100 +180,25 @@ Foam::MeshedSurface<Face>::MeshedSurface
     const xfer<pointField>& pointLst,
     const xfer<List<Face> >& faceLst,
     const UList<label>& patchSizes,
-    const UList<word>& patchNames,
+    const UList<word>& patchNames
-    const UList<word>& patchTypes
 )
 :
     ParentType(pointLst, faceLst)
 {
-    surfGroupList newPatches(patchSizes.size());
+    if (&patchSizes)
-
-    label start = 0;
-    forAll(newPatches, patchI)
     {
-        newPatches[patchI] = surfGroup
+        if (&patchNames)
-        (
-            patchNames[patchI],
-            patchSizes[patchI],
-            start,
-            patchI
-        );
-
-        start += patchSizes[patchI];
-    }
-
-    patches_.transfer(newPatches);
-}
-
-
-template<class Face>
-Foam::MeshedSurface<Face>::MeshedSurface
-(
-    const xfer<pointField>& pointLst,
-    const xfer<List<Face> >& faceLst,
-    const UList<label>& regionIds,
-    const Map<word>& regionNames
-)
-:
-    ParentType(pointLst, faceLst)
-{
-    if (&regionIds && regionIds.size() && regionIds.size() != size())
         {
-        FatalErrorIn
+            addPatches(patchSizes, patchNames);
-        (
-            "MeshedSurface::MeshedSurface(\n"
-            "(\n"
-            "    const xfer<pointField>&,\n"
-            "    const xfer<List<Face> >&,\n"
-            "    const UList<label>& regionIds,\n"
-            "    const Map<word>& regionNames\n"
-            " )\n"
-        )
-            << "size mismatch : region and face sizes"
-            << exit(FatalError);
         }
         else
         {
-        sortFacesByRegion(regionIds, regionNames);
+            addPatches(patchSizes);
         }
-}
-
-
-template<class Face>
-Foam::MeshedSurface<Face>::MeshedSurface
-(
-    const xfer<pointField>& pointLst,
-    const xfer<List<Face> >& faceLst,
-    const UList<label>& regionIds,
-    const HashTable<label>& nameToRegionMapping
-)
-:
-    ParentType(pointLst, faceLst)
-{
-    if (&regionIds && regionIds.size() && regionIds.size() != size())
-    {
-        FatalErrorIn
-        (
-            "MeshedSurface::MeshedSurface(\n"
-            "(\n"
-            "    const xfer<pointField>&,\n"
-            "    const xfer<List<Face> >&,\n"
-            "    const UList<label>& regionIds,\n"
-            "    const HashTable<label>& nameToRegionMapping\n"
-            " )\n"
-        )
-            << "size mismatch : region and face sizes"
-            << exit(FatalError);
     }
     else
     {
-        Map<word> regionNames;
+        onePatch();
-        forAllConstIter(HashTable<label>, nameToRegionMapping, iter)
-        {
-            regionNames.insert(iter(), iter.key());
-        }
-
-        sortFacesByRegion(regionIds, regionNames);
     }
 }
 
@@ -430,18 +355,18 @@ Foam::MeshedSurface<Face>::MeshedSurface
 template<class Face>
 Foam::MeshedSurface<Face>::MeshedSurface
 (
-    const fileName& fName,
+    const fileName& name,
     const word& ext
 )
 {
-    read(fName, ext);
+    read(name, ext);
 }
 
 
 template<class Face>
-Foam::MeshedSurface<Face>::MeshedSurface(const fileName& fName)
+Foam::MeshedSurface<Face>::MeshedSurface(const fileName& name)
 {
-    read(fName);
+    read(name);
 }
 
 
@@ -456,7 +381,6 @@ template<class Face>
 Foam::MeshedSurface<Face>::MeshedSurface(const Time& d)
 {
     read(IFstream(findMeshName(d))());
-    // setDefaultPatches();
 }
 
 
@@ -567,39 +491,40 @@ void Foam::MeshedSurface<Face>::checkPatches()
 
 
 template<class Face>
-void Foam::MeshedSurface<Face>::sortFacesByRegion
+void Foam::MeshedSurface<Face>::sortFacesAndStore
 (
-    const UList<label>& regionIds,
+    const xfer<List<Face> >& unsortedFaces,
-    const Map<word>& regionNames
+    const xfer<List<label> >& regionIds,
+    const bool sorted
 )
 {
-    const List<Face>& unsortedFaces = this->faces();
+    List<Face>  oldFaces(unsortedFaces);
+    List<label> regions(regionIds);
 
-    if (!&regionNames || !&regionIds || regionIds.size() == 0)
+    if (sorted)
     {
-        onePatch();
+        // already sorted - simply transfer faces
+        this->storedFaces().transfer(oldFaces);
     }
-    else if (regionIds.size() == unsortedFaces.size())
+    else
     {
-        labelList faceMap;
+        // unsorted - determine the sorted order:
-        surfGroupList newPatches = UnsortedMeshedSurface<Face>::sortedRegions
+        // avoid SortableList since we discard the main list anyhow
-        (
+        List<label> faceMap;
-            regionIds,
+        sortedOrder(regions, faceMap);
-            regionNames,
+        regions.clear();
-            faceMap
-        );
-        patches_.transfer(newPatches);
 
-        // this is somewhat like ListOps reorder and/or IndirectList
+        // sorted faces
-        List<Face> newFaces(unsortedFaces.size());
+        List<Face> newFaces(faceMap.size());
-        forAll(newFaces, faceI)
+        forAll(faceMap, faceI)
         {
-            newFaces[faceI] = unsortedFaces[faceMap[faceI]];
+            // use transfer to recover memory if possible
+            newFaces[faceI].transfer(oldFaces[faceMap[faceI]]);
         }
-        faceMap.clear();
-
         this->storedFaces().transfer(newFaces);
+
     }
+    regions.clear();
 }
 
 
@@ -634,8 +559,8 @@ void Foam::MeshedSurface<Face>::remapRegions(List<label>& faceMap)
             // adjust patch size
             p.size() = newFaceI - p.start();
         }
-        faceMap.clear();
     }
+    faceMap.clear();
 }
 
 // * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
@@ -662,6 +587,7 @@ Foam::MeshedSurface<Face> Foam::MeshedSurface<Face>::subsetMesh
     const pointField& locPoints = this->localPoints();
     const List<Face>& locFaces  = this->localFaces();
 
+
     // Fill pointMap, faceMap
     this->subsetMap(include, pointMap, faceMap);
 
@@ -751,58 +677,83 @@ Foam::MeshedSurface<Face> Foam::MeshedSurface<Face>::subsetMesh
 template<class Face>
 void Foam::MeshedSurface<Face>::addPatches
 (
-    const UList<surfGroup>& patchLst
+    const UList<surfGroup>& patches,
+    const bool cullEmpty
 )
 {
-    patches_ = patchLst;
+    label nPatch = 0;
+
+    patches_.setSize(patches.size());
+    forAll(patches_, patchI)
+    {
+        if (patches[patchI].size() || !cullEmpty)
+        {
+            patches_[nPatch] = surfGroup(patches[patchI], nPatch);
+            nPatch++;
+        }
+    }
+    patches_.setSize(nPatch);
 }
 
 
 template<class Face>
 void Foam::MeshedSurface<Face>::addPatches
 (
+    const UList<label>& sizes,
     const UList<word>& names,
-    const UList<label>& sizes
+    const bool cullEmpty
 )
 {
-    patches_.setSize(sizes.size());
-
     label start  = 0;
+    label nPatch = 0;
+
+    patches_.setSize(sizes.size());
     forAll(patches_, patchI)
     {
-        patches_[patchI] = surfGroup
+        if (sizes[patchI] || !cullEmpty)
+        {
+            patches_[nPatch] = surfGroup
             (
                 names[patchI],
                 sizes[patchI],
                 start,
-            patchI
+                nPatch
             );
-
             start += sizes[patchI];
+            nPatch++;
         }
+    }
+    patches_.setSize(nPatch);
 }
 
+
 template<class Face>
 void Foam::MeshedSurface<Face>::addPatches
 (
-    const UList<label>& sizes
+    const UList<label>& sizes,
+    const bool cullEmpty
 )
 {
-    patches_.setSize(sizes.size());
-
     label start  = 0;
+    label nPatch = 0;
+
+    patches_.setSize(sizes.size());
     forAll(patches_, patchI)
     {
-        patches_[patchI] = surfGroup
+        if (sizes[patchI] || !cullEmpty)
+        {
+            patches_[nPatch] = surfGroup
             (
-            word("patch") + ::Foam::name(patchI),
+                word("patch") + ::Foam::name(nPatch),
                 sizes[patchI],
                 start,
-            patchI
+                nPatch
             );
-
             start += sizes[patchI];
+            nPatch++;
         }
+    }
+    patches_.setSize(nPatch);
 }
 
 
@@ -829,39 +780,35 @@ void Foam::MeshedSurface<Face>::transfer
 
     labelList faceMap;
     surfGroupList patchLst = surf.sortedRegions(faceMap);
+    List<Face>& oldFaces = surf.storedFaces();
 
-    const List<Face>& oldFaces = surf.faces();
+    List<Face> newFaces(faceMap.size());
-    List<Face>  newFaces(oldFaces.size());
+    forAll(faceMap, faceI)
-
-    // this is somewhat like ListOps reorder and/or IndirectList
-    forAll(newFaces, faceI)
     {
-        newFaces[faceI] = oldFaces[faceMap[faceI]];
+        newFaces[faceI].transfer(oldFaces[faceMap[faceI]]);
     }
     faceMap.clear();
 
     reset(xferMove(surf.storedPoints()), xferMove(newFaces));
     patches_.transfer(patchLst);
 
-    surf.regions_.clear();
-    surf.patches_.clear();
     surf.clear();
 }
 
 
 // Read from file, determine format from extension
 template<class Face>
-bool Foam::MeshedSurface<Face>::read(const fileName& fName)
+bool Foam::MeshedSurface<Face>::read(const fileName& name)
 {
-    word ext = fName.ext();
+    word ext = name.ext();
     if (ext == "gz")
     {
-        fileName unzipName = fName.lessExt();
+        fileName unzipName = name.lessExt();
         return read(unzipName, unzipName.ext());
     }
     else
     {
-        return read(fName, ext);
+        return read(name, ext);
     }
 }
 
@@ -870,19 +817,19 @@ bool Foam::MeshedSurface<Face>::read(const fileName& fName)
 template<class Face>
 bool Foam::MeshedSurface<Face>::read
 (
-    const fileName& fName,
+    const fileName& name,
     const word& ext
 )
 {
     // handle 'native' format directly
     if (isNative(ext))
     {
-        return read(IFstream(fName)());
+        return read(IFstream(name)());
     }
     else
     {
         // use selector mechanism
-        transfer(New(fName, ext)());
+        transfer(New(name, ext)());
         return true;
     }
 }
@@ -912,7 +859,6 @@ void Foam::MeshedSurface<Face>::operator=(const MeshedSurface& surf)
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-#include "MeshedSurfaceCleanup.C"
 #include "MeshedSurfaceIO.C"
 #include "MeshedSurfaceNew.C"
 

src/surfMesh/MeshedSurface/MeshedSurface.H

@@ -28,7 +28,7 @@ Class
 Description
     A surface geometry mesh with patch information, not to be confused
     with a similarily named surfaceMesh, which actually refers to
-    the cell faces of a volume mesh!
+    the cell faces of a volume mesh.
 
    The MeshedSurface is intended to surfaces from a variety of sources.
    - A set of points and faces without any patch information.
@@ -94,12 +94,6 @@ private:
 
     // Private member functions
 
-        //- Sort faces by regionIds and set patches
-        void sortFacesByRegion(const UList<label>&, const Map<word>&);
-
-        //- Set new regions from faceMap
-        void remapRegions(List<label>& faceMap);
-
         //- Read OpenFOAM Surface format
         bool read(Istream&);
 
@@ -107,12 +101,20 @@ protected:
 
     // Protected Member functions
 
-        //- set a single patch
-        void onePatch();
-
         //- basic sanity check on patches
         void checkPatches();
 
+        //- sort faces by regions and store sorted faces
+        void sortFacesAndStore
+        (
+            const xfer<List<Face> >& unsortedFaces,
+            const xfer<List<label> >& regionIds,
+            const bool sorted
+        );
+
+        //- Set new regions from faceMap
+        virtual void remapRegions(List<label>& faceMap);
+
 public:
 
         //- Runtime type information
@@ -137,8 +139,7 @@ public:
         //- Construct null
         MeshedSurface();
 
-        //- Construct by transferring components
+        //- Construct by transferring components (points, faces, patches).
-        //  (points, faces and patches).
         MeshedSurface
         (
             const xfer<pointField>&,
@@ -146,35 +147,14 @@ public:
             const xfer<surfGroupList>&
         );
 
-        //- Construct from points, faces, and patch information
-        MeshedSurface
-        (
-            const xfer<pointField>&,
-            const xfer<List<Face> >&,
-            const UList<label>& patchSizes,
-            const UList<word>& patchNames,
-            const UList<word>& patchTypes
-        );
-
         //- Construct by transferring points, faces.
-        //  Sort faces according to regionIds with the names of the regions,
+        //  Use patch information, or set single default patch.
-        //  or jsut set a single default patch.
         MeshedSurface
         (
             const xfer<pointField>&,
             const xfer<List<Face> >&,
-            const UList<label>& regionIds = UList<label>::null(),
+            const UList<label>& patchSizes = UList<label>::null(),
-            const Map<word>& regionNames = Map<word>::null()
+            const UList<word>& patchNames = UList<word>::null()
-        );
-
-        //- Construct by transferring points, faces.
-        //  Sort faces according to regionIds with patch-names from hash
-        MeshedSurface
-        (
-            const xfer<pointField>&,
-            const xfer<List<Face> >&,
-            const UList<label>& regionIds,
-            const HashTable<label>& nameToRegionMapping
         );
 
         //- Construct from a boundary mesh with local points/faces
@@ -219,9 +199,9 @@ public:
             MeshedSurface,
             fileExtension,
             (
-                const fileName& fName
+                const fileName& name
             ),
-            (fName)
+            (name)
         );
 
     // Selectors
@@ -250,10 +230,10 @@ public:
             write,
             fileExtension,
             (
-                const fileName& fName,
+                const fileName& name,
                 const MeshedSurface<Face>& surf
             ),
-            (fName, surf)
+            (name, surf)
         );
 
         //- Write to file
@@ -275,35 +255,36 @@ public:
             return patches_;
         }
 
-        void addPatches(const UList<surfGroup>&);
+        //- set a single patch
+        void onePatch();
 
-        void addPatches(const UList<word>& names, const UList<label>& sizes);
+        //- add patches
-        void addPatches(const UList<label>& sizes);
+        void addPatches
+        (
+            const UList<surfGroup>&,
+            const bool cullEmpty=false
+        );
 
+        //- add patches
+        void addPatches
+        (
+            const UList<label>& sizes,
+            const UList<word>& names,
+            const bool cullEmpty=false
+        );
+
+        //- add patches
+        void addPatches
+        (
+            const UList<label>& sizes,
+            const bool cullEmpty=false
+        );
 
     // Edit
 
         //- Clear all storage
         virtual void clear();
 
-        //- Remove invalid faces
-        void cleanup(const bool verbose);
-
-        //- Check/fix duplicate/degenerate faces
-        virtual bool checkFaces(const bool verbose);
-
-        //- Join the faces by removing duplicate points.
-        //  Returns true if any points merged
-        virtual bool stitchFaces
-        (
-            const scalar tol=SMALL,
-            const bool verbose=false
-        );
-
-        //- Triangulate the surface, return the number of added faces.
-        //  The patch list will be adjusted accordingly.
-        virtual label triangulate();
-
         //- Return new surface.
         //  Returns return pointMap, faceMap from subsetMeshMap
         MeshedSurface subsetMesh
@@ -341,9 +322,9 @@ public:
         virtual void write(Ostream&) const;
 
         //- Generic write routine. Chooses writer based on extension.
-        virtual void write(const fileName& fName) const
+        virtual void write(const fileName& name) const
         {
-            write(fName, *this);
+            write(name, *this);
         }
 
         //- Write to database
@@ -365,15 +346,6 @@ public:
 };
 
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-//- Specialization for holding triangulated information
-template<>
-inline label MeshedSurface<triFace>::triangulate()
-{
-    return 0;
-}
-
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 } // End namespace Foam

src/surfMesh/MeshedSurface/MeshedSurfaceCleanup.C

@@ -1,82 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software; you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by the
-    Free Software Foundation; either version 2 of the License, or (at your
-    option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM; if not, write to the Free Software Foundation,
-    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
-
-\*---------------------------------------------------------------------------*/
-
-#include "MeshedSurface.H"
-#include "mergePoints.H"
-
-// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
-
-// Remove badly degenerate faces, double faces.
-template<class Face>
-void Foam::MeshedSurface<Face>::cleanup(const bool verbose)
-{
-    // merge points (already done for STL, TRI)
-    stitchFaces(SMALL, verbose);
-
-    checkFaces(verbose);
-    ParentType::checkEdges(verbose);
-}
-
-
-template<class Face>
-bool Foam::MeshedSurface<Face>::stitchFaces
-(
-    const scalar tol,
-    const bool verbose
-)
-{
-    List<label> faceMap;
-    bool hasMerged = ParentType::stitchFaces(faceMap, tol, verbose);
-
-    remapRegions(faceMap);
-    return hasMerged;
-}
-
-
-
-// Remove badly degenerate faces and double faces.
-template<class Face>
-bool Foam::MeshedSurface<Face>::checkFaces(const bool verbose)
-{
-    List<label> faceMap;
-    bool changed = ParentType::checkFaces(faceMap, verbose);
-
-    remapRegions(faceMap);
-    return changed;
-}
-
-
-template<class Face>
-Foam::label Foam::MeshedSurface<Face>::triangulate()
-{
-    List<label> faceMap;
-    label nTri = ParentType::triangulate(this->storedFaces(), faceMap);
-
-    remapRegions(faceMap);
-    return nTri;
-}
-
-// ************************************************************************* //

src/surfMesh/MeshedSurface/MeshedSurfaceNew.C

@@ -29,14 +29,10 @@ License
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
-// all input is indirect via UnsortedMeshedSurface
+
 template<class Face>
 Foam::autoPtr<Foam::MeshedSurface<Face> >
-Foam::MeshedSurface<Face>::New
+Foam::MeshedSurface<Face>::New(const fileName& name, const word& ext)
-(
-    const fileName& fName,
-    const word& ext
-)
 {
     if (debug)
     {
@@ -56,7 +52,7 @@ Foam::MeshedSurface<Face>::New
         {
             // create indirectly
             autoPtr<MeshedSurface<Face> > surf(new MeshedSurface<Face>);
-            surf().transfer(SiblingType::New(fName, ext)());
+            surf().transfer(SiblingType::New(name, ext)());
 
             return surf;
         }
@@ -67,8 +63,7 @@ Foam::MeshedSurface<Face>::New
 
         FatalErrorIn
         (
-            "MeshedSurface<Face>::New"
+            "MeshedSurface<Face>::New(const fileName&, const word&) : "
-            "(const fileName&, const word&) : "
             "constructing MeshedSurface"
         )   << "Unknown file extension " << ext << nl << nl
             << "Valid types are :" << nl
@@ -76,23 +71,20 @@ Foam::MeshedSurface<Face>::New
             << exit(FatalError);
     }
 
-    return autoPtr<MeshedSurface<Face> >(cstrIter()(fName));
+    return autoPtr<MeshedSurface<Face> >(cstrIter()(name));
 }
 
 
 template<class Face>
 Foam::autoPtr<Foam::MeshedSurface<Face> >
-Foam::MeshedSurface<Face>::New
+Foam::MeshedSurface<Face>::New(const fileName& name)
-(
-    const fileName& fName
-)
 {
-    word ext = fName.ext();
+    word ext = name.ext();
     if (ext == "gz")
     {
-        ext = fName.lessExt().ext();
+        ext = name.lessExt().ext();
     }
-    return New(fName, ext);
+    return New(name, ext);
 }
 
 // ************************************************************************* //

src/surfMesh/PrimitiveMeshedSurface/PrimitiveMeshedSurface.C

@@ -36,75 +36,6 @@ inline bool Foam::PrimitiveMeshedSurface<Face>::isTri()
 }
 
 
-template<class Face>
-Foam::label Foam::PrimitiveMeshedSurface<Face>::triangulate
-(
-    List<Face>& faceLst,
-    List<label>& faceMap
-)
-{
-    label nTri = 0;
-
-    // determine how many triangles are needed
-    forAll(faceLst, faceI)
-    {
-        nTri += faceLst[faceI].size() - 2;
-    }
-
-    // nothing to do
-    if (nTri <= faceLst.size())
-    {
-        if (&faceMap)
-        {
-            faceMap.clear();
-        }
-        return 0;
-    }
-
-    List<Face>  newFaces(nTri);
-    List<label> fMap(nTri);
-
-    // remember the number of *additional* faces
-    nTri -= faceLst.size();
-
-    label newFaceI = 0;
-    forAll(faceLst, faceI)
-    {
-        const Face& f = faceLst[faceI];
-        triFace fTri;
-
-        // Do simple face triangulation around f[0].
-        // we could also use face::triangulation, but that requires points
-        // and doesn't currently template nicely
-        fTri[0] = f[0];
-        for (label fp = 1; fp < f.size() - 1; ++fp)
-        {
-            label fp1 = (fp + 1) % f.size();
-
-            fTri[1] = f[fp];
-            fTri[2] = f[fp1];
-
-            newFaces[newFaceI] = fTri;
-            fMap[newFaceI] = faceI;
-            newFaceI++;
-        }
-    }
-
-    faceLst.transfer(newFaces);
-    if (&faceMap)
-    {
-        faceMap.transfer(fMap);
-    }
-    else
-    {
-        fMap.clear();
-    }
-
-    return nTri;
-}
-
-
-
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
 template<class Face>
@@ -200,10 +131,21 @@ void Foam::PrimitiveMeshedSurface<Face>::reset
 }
 
 
+// Remove badly degenerate faces, double faces.
+template<class Face>
+void Foam::PrimitiveMeshedSurface<Face>::cleanup(const bool verbose)
+{
+    // merge points (already done for STL, TRI)
+    stitchFaces(SMALL, verbose);
+
+    checkFaces(verbose);
+    this->checkEdges(verbose);
+}
+
+
 template<class Face>
 bool Foam::PrimitiveMeshedSurface<Face>::stitchFaces
 (
-    List<label>& faceMap,
     const scalar tol,
     const bool verbose
 )
@@ -218,10 +160,6 @@ bool Foam::PrimitiveMeshedSurface<Face>::stitchFaces
 
     if (!hasMerged)
     {
-        if (&faceMap)
-        {
-            faceMap.clear();
-        }
         return false;
     }
 
@@ -236,13 +174,7 @@ bool Foam::PrimitiveMeshedSurface<Face>::stitchFaces
 
     List<Face>& faceLst = this->storedFaces();
 
-    // local copy
+    List<label> faceMap(faceLst.size());
-    List<label> fMap;
-    if (&faceMap)
-    {
-        fMap.transfer(faceMap);
-    }
-    fMap.setSize(faceLst.size());
 
     // Reset the point labels to the unique points array
     label newFaceI = 0;
@@ -261,7 +193,7 @@ bool Foam::PrimitiveMeshedSurface<Face>::stitchFaces
             {
                 faceLst[newFaceI] = f;
             }
-            fMap[newFaceI] = faceI;
+            faceMap[newFaceI] = faceI;
             newFaceI++;
         }
         else if (verbose)
@@ -282,18 +214,12 @@ bool Foam::PrimitiveMeshedSurface<Face>::stitchFaces
                 << " faces" << endl;
         }
         faceLst.setSize(newFaceI);
-        if (&faceMap)
+        remapRegions(faceMap);
-        {
-            faceMap.transfer(fMap);
-            faceMap.setSize(newFaceI);
     }
-    }
+    faceMap.clear();
-    fMap.clear();
-
 
     // Merging points might have changed geometric factors
     ParentType::clearOut();
-
     return true;
 }
 
@@ -302,20 +228,13 @@ bool Foam::PrimitiveMeshedSurface<Face>::stitchFaces
 template<class Face>
 bool Foam::PrimitiveMeshedSurface<Face>::checkFaces
 (
-    List<label>& faceMap,
     const bool verbose
 )
 {
     bool changed = false;
     List<Face>& faceLst = this->storedFaces();
 
-    // local copy
+    List<label> faceMap(faceLst.size());
-    List<label> fMap;
-    if (&faceMap)
-    {
-        fMap.transfer(faceMap);
-    }
-    fMap.setSize(faceLst.size());
 
     label newFaceI = 0;
     // Detect badly labelled faces and mark degenerate faces
@@ -339,13 +258,13 @@ bool Foam::PrimitiveMeshedSurface<Face>::checkFaces
                 }
             }
 
-            fMap[faceI] = faceI;
+            faceMap[faceI] = faceI;
             newFaceI++;
         }
         else
         {
             // mark as bad face
-            fMap[faceI] = -1;
+            faceMap[faceI] = -1;
 
             changed = true;
             if (verbose)
@@ -366,7 +285,7 @@ bool Foam::PrimitiveMeshedSurface<Face>::checkFaces
     forAll(faceLst, faceI)
     {
         // skip already collapsed faces:
-        if (fMap[faceI] < 0)
+        if (faceMap[faceI] < 0)
         {
             continue;
         }
@@ -383,7 +302,7 @@ bool Foam::PrimitiveMeshedSurface<Face>::checkFaces
         {
             const label neiFaceI = neighbours[neighI];
 
-            if (neiFaceI <= faceI || fMap[neiFaceI] < 0)
+            if (neiFaceI <= faceI || faceMap[neiFaceI] < 0)
             {
                 // lower numbered faces already checked
                 // skip neighbours that are themselves collapsed
@@ -414,12 +333,12 @@ bool Foam::PrimitiveMeshedSurface<Face>::checkFaces
 
         if (okay)
         {
-            fMap[faceI] = faceI;
+            faceMap[faceI] = faceI;
             newFaceI++;
         }
         else
         {
-            fMap[faceI] = -1;
+            faceMap[faceI] = -1;
         }
     }
 
@@ -443,33 +362,94 @@ bool Foam::PrimitiveMeshedSurface<Face>::checkFaces
         newFaceI = 0;
         forAll(faceLst, faceI)
         {
-            if (fMap[faceI] >= 0)
+            if (faceMap[faceI] >= 0)
             {
                 if (newFaceI != faceI)
                 {
                     faceLst[newFaceI] = faceLst[faceI];
                 }
-                fMap[newFaceI] = faceI;
+                faceMap[newFaceI] = faceI;
                 newFaceI++;
             }
         }
 
         faceLst.setSize(newFaceI);
-        if (&faceMap)
+        remapRegions(faceMap);
-        {
-            faceMap.transfer(fMap);
-            faceMap.setSize(newFaceI);
     }
-    }
+    faceMap.clear();
-    fMap.clear();
 
     // Topology can change because of renumbering
     ParentType::clearOut();
-
     return changed;
 }
 
 
+template<class Face>
+Foam::label Foam::PrimitiveMeshedSurface<Face>::triangulate()
+{
+    label nTri = 0;
+    List<Face>& faceLst = this->storedFaces();
+
+    // determine how many triangles are needed
+    forAll(faceLst, faceI)
+    {
+        nTri += faceLst[faceI].size() - 2;
+    }
+
+    // nothing to do
+    if (nTri <= faceLst.size())
+    {
+        return 0;
+    }
+
+    List<Face>  newFaces(nTri);
+    List<label> faceMap(nTri);
+
+    // remember the number of *additional* faces
+    nTri -= faceLst.size();
+
+    label newFaceI = 0;
+    forAll(faceLst, faceI)
+    {
+        const Face& f = faceLst[faceI];
+        triFace fTri;
+
+        // Do simple face triangulation around f[0].
+        // we could also use face::triangulation, but that requires points
+        // and doesn't currently template nicely
+        fTri[0] = f[0];
+        for (label fp = 1; fp < f.size() - 1; ++fp)
+        {
+            label fp1 = (fp + 1) % f.size();
+
+            fTri[1] = f[fp];
+            fTri[2] = f[fp1];
+
+            newFaces[newFaceI] = fTri;
+            faceMap[newFaceI] = faceI;
+            newFaceI++;
+        }
+    }
+
+    faceLst.transfer(newFaces);
+    remapRegions(faceMap);
+    faceMap.clear();
+
+    // Topology can change because of renumbering
+    ParentType::clearOut();
+    return nTri;
+}
+
+
+// dummy implementation to avoid a pure virtual class
+template<class Face>
+void Foam::PrimitiveMeshedSurface<Face>::remapRegions(List<label>& faceMap)
+{
+    faceMap.clear();
+}
+
+
+
 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
 
 // * * * * * * * * * * * * * * * IOstream Operators  * * * * * * * * * * * * //

src/surfMesh/PrimitiveMeshedSurface/PrimitiveMeshedSurface.H

@@ -84,6 +84,9 @@ protected:
             return static_cast<List<Face> &>(*this);
         }
 
+        //- Set new regions/patches from faceMap
+        virtual void remapRegions(List<label>& faceMap);
+
 public:
 
     // Static
@@ -91,15 +94,6 @@ public:
         //- Face storage only handles triangulated faces
         inline static bool isTri();
 
-        //- Triangulate faceLst in-place
-        //  Returning the number of triangles added and a map to the
-        //  the original face Ids
-        static label triangulate
-        (
-            List<Face>& faceLst,
-            List<label>& faceMap=const_cast<List<label>&>(List<label>::null())
-        );
-
     // Constructors
 
         //- Construct null
@@ -144,19 +138,24 @@ public:
             const xfer<List<Face> >&
         );
 
+        //- Remove invalid faces
+        virtual void cleanup(const bool verbose);
+
         virtual bool stitchFaces
         (
-            List<label>& faceMap=const_cast<List<label>&>(List<label>::null()),
             const scalar tol=SMALL,
             const bool verbose=false
         );
 
         virtual bool checkFaces
         (
-            List<label>& faceMap=const_cast<List<label>&>(List<label>::null()),
             const bool verbose=false
         );
 
+        //- Triangulate in-place
+        //  Returning the number of triangles added
+        virtual label triangulate();
+
 };
 
 
@@ -169,6 +168,13 @@ inline bool PrimitiveMeshedSurface<triFace>::isTri()
     return true;
 }
 
+//- Specialization for holding triangulated information
+template<>
+inline label PrimitiveMeshedSurface<triFace>::triangulate()
+{
+    return 0;
+}
+
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 } // End namespace Foam

src/surfMesh/UnsortedMeshedSurface/UnsortedMeshedSurface.C

@@ -95,14 +95,14 @@ bool Foam::UnsortedMeshedSurface<Face>::canWriteType
 template<class Face>
 bool Foam::UnsortedMeshedSurface<Face>::canRead
 (
-    const fileName& fName,
+    const fileName& name,
     const bool verbose
 )
 {
-    word ext = fName.ext();
+    word ext = name.ext();
     if (ext == "gz")
     {
-        ext = fName.lessExt().ext();
+        ext = name.lessExt().ext();
     }
     return canReadType(ext, verbose);
 }
@@ -111,7 +111,7 @@ bool Foam::UnsortedMeshedSurface<Face>::canRead
 template<class Face>
 void Foam::UnsortedMeshedSurface<Face>::write
 (
-    const fileName& fName,
+    const fileName& name,
     const UnsortedMeshedSurface<Face>& surf
 )
 {
@@ -119,16 +119,16 @@ void Foam::UnsortedMeshedSurface<Face>::write
     {
         Info<< "UnsortedMeshedSurface::write"
             "(const fileName&, const UnsortedMeshedSurface&) : "
-            "writing to " << fName
+            "writing to " << name
             << endl;
     }
 
-    const word ext = fName.ext();
+    const word ext = name.ext();
 
     // handle 'native' format directly
     if (isNative(ext))
     {
-        surf.write(OFstream(fName)());
+        surf.write(OFstream(name)());
         return;
     }
 
@@ -147,7 +147,7 @@ void Foam::UnsortedMeshedSurface<Face>::write
             << exit(FatalError);
     }
 
-    mfIter()(fName, surf);
+    mfIter()(name, surf);
 }
 
 
@@ -178,53 +178,27 @@ Foam::UnsortedMeshedSurface<Face>::UnsortedMeshedSurface
 (
     const xfer<pointField>& pointLst,
     const xfer<List<Face> >& faceLst,
-    const xfer<List<label> >& regionIds,
+    const UList<label>& patchSizes,
-    const Map<word>& regionNames
+    const UList<word>& patchNames
-)
-:
-    ParentType(pointLst, faceLst),
-    regions_(regionIds)
-{
-    if (&regionNames)
-    {
-        // set patch names from (id => name) mapping
-        setPatches(regionNames);
-    }
-    else
-    {
-        // find highest region ID and set patch names automatically
-        setPatches();
-    }
-}
-
-
-template<class Face>
-Foam::UnsortedMeshedSurface<Face>::UnsortedMeshedSurface
-(
-    const xfer<pointField>& pointLst,
-    const xfer<List<Face> >& faceLst,
-    const xfer<List<label> >& regionIds,
-    const HashTable<label>& labelToRegion
-)
-:
-    ParentType(pointLst, faceLst),
-    regions_(regionIds)
-{
-    // set patch names from (name => id) mapping
-    setPatches(labelToRegion);
-}
-
-
-template<class Face>
-Foam::UnsortedMeshedSurface<Face>::UnsortedMeshedSurface
-(
-    const xfer<pointField>& pointLst,
-    const xfer<List<Face> >& faceLst
 )
 :
     ParentType(pointLst, faceLst)
 {
+    if (&patchSizes)
+    {
+        if (&patchNames)
+        {
+            setPatches(patchSizes, patchNames);
+        }
+        else
+        {
+            setPatches(patchSizes);
+        }
+    }
+    else
+    {
         onePatch();
+    }
 }
 
 
@@ -249,39 +223,25 @@ Foam::UnsortedMeshedSurface<Face>::UnsortedMeshedSurface
 :
     ParentType(xferCopy(surf.points()), xferCopy(surf.faces()))
 {
-    const surfGroupList& patchLst = surf.patches();
+    setPatches(surf.patches());
-
-    regions_.setSize(size());
-    patches_.setSize(patchLst.size());
-
-    label faceI = 0;
-    forAll(patchLst, patchI)
-    {
-        patches_[patchI] = patchLst[patchI];
-
-        forAll(patchLst[patchI], patchFaceI)
-        {
-            regions_[faceI++] = patchI;
-        }
-    }
 }
 
 
 template<class Face>
 Foam::UnsortedMeshedSurface<Face>::UnsortedMeshedSurface
 (
-    const fileName& fName,
+    const fileName& name,
     const word& ext
 )
 {
-    read(fName, ext);
+    read(name, ext);
 }
 
 
 template<class Face>
-Foam::UnsortedMeshedSurface<Face>::UnsortedMeshedSurface(const fileName& fName)
+Foam::UnsortedMeshedSurface<Face>::UnsortedMeshedSurface(const fileName& name)
 {
-    read(fName);
+    read(name);
 }
 
 
@@ -348,92 +308,27 @@ void Foam::UnsortedMeshedSurface<Face>::onePatch()
 
     // set single default patch
     patches_.setSize(1);
-    patches_[0] = PatchRegionType("patch0", 0);
+    patches_[0] = surfPatchIdentifier("patch0", 0);
-}
-
-
-template<class Face>
-void Foam::UnsortedMeshedSurface<Face>::setPatches(const label maxPatch)
-{
-    patches_.setSize(maxPatch+1);
-
-    forAll(patches_, patchI)
-    {
-        patches_[patchI] = PatchRegionType
-        (
-            "patch" + ::Foam::name(patchI),
-            patchI
-        );
-    }
-}
-
-
-template<class Face>
-void Foam::UnsortedMeshedSurface<Face>::setPatches()
-{
-    label maxPatch = 0;
-
-    // find the max region that occurs
-    forAll(regions_, faceI)
-    {
-        const label regId = regions_[faceI];
-
-        if (maxPatch < regId)
-        {
-            maxPatch = regId;
-        }
-    }
-
-    setPatches(maxPatch);
 }
 
 
 template<class Face>
 void Foam::UnsortedMeshedSurface<Face>::setPatches
 (
-    const Map<word>& regionNames,
+    const surfGroupList& patches
-    const label maxPatchHint
 )
 {
-    label maxPatch = maxPatchHint;
+    regions_.setSize(size());
+    patches_.setSize(patches.size());
 
-    // determine max patch ID if required
+    forAll(patches, patchI)
-    if (maxPatchHint < 0)
     {
-        maxPatch = 0;
+        const surfGroup& p = patches[patchI];
-        forAllConstIter(Map<word>, regionNames, iter)
-        {
-            if (maxPatch < iter.key())
-            {
-                maxPatch = iter.key();
-            }
-        }
-    }
 
+        patches_[patchI] = p;
 
-    // Info<< "setPatches with maxPatch: " << maxPatch << endl;
+        SubList<label> subRegion(regions_, p.size(), p.start());
-
+        subRegion = patchI;
-    patches_.setSize(maxPatch+1);
-
-    forAll(patches_, patchI)
-    {
-        Map<word>::const_iterator findPatch = regionNames.find(patchI);
-        word patchName;
-
-        if (findPatch != regionNames.end())
-        {
-            patchName = findPatch();
-        }
-        else
-        {
-            patchName = "patch" + ::Foam::name(patchI);
-        }
-
-        patches_[patchI] = PatchRegionType
-        (
-            patchName,
-            patchI
-        );
     }
 }
 
@@ -441,23 +336,49 @@ void Foam::UnsortedMeshedSurface<Face>::setPatches
 template<class Face>
 void Foam::UnsortedMeshedSurface<Face>::setPatches
 (
-    const HashTable<label>& groupToPatch
+    const UList<label>& sizes,
+    const UList<word>& names
 )
 {
-    // determine max patch Id
+    regions_.setSize(size());
-    label maxPatch = 0;
+    patches_.setSize(sizes.size());
-    Map<word> regionNames;
 
-    forAllConstIter(HashTable<label>, groupToPatch, iter)
+    label start = 0;
+    forAll(patches_, patchI)
     {
-        regionNames.insert(iter(), iter.key());
+        patches_[patchI] = surfPatchIdentifier(names[patchI], patchI);
-        if (maxPatch < iter())
-        {
-            maxPatch = iter();
-        }
-    }
 
-    setPatches(regionNames, maxPatch);
+        SubList<label> subRegion(regions_, sizes[patchI], start);
+        subRegion = patchI;
+
+        start += sizes[patchI];
+    }
+}
+
+
+template<class Face>
+void Foam::UnsortedMeshedSurface<Face>::setPatches
+(
+    const UList<label>& sizes
+)
+{
+    regions_.setSize(size());
+    patches_.setSize(sizes.size());
+
+    label start = 0;
+    forAll(patches_, patchI)
+    {
+        patches_[patchI] = surfPatchIdentifier
+        (
+            word("patch") + ::Foam::name(patchI),
+            patchI
+        );
+
+        SubList<label> subRegion(regions_, sizes[patchI], start);
+        subRegion = patchI;
+
+        start += sizes[patchI];
+    }
 }
 
 
@@ -473,10 +394,10 @@ void Foam::UnsortedMeshedSurface<Face>::remapRegions(List<label>& faceMap)
         }
         regions_.transfer(faceMap);
     }
+    faceMap.clear();
 }
 
 
-
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
 template<class Face>
@@ -620,43 +541,25 @@ void Foam::UnsortedMeshedSurface<Face>::transfer
     MeshedSurface<Face>& surf
 )
 {
-    surfGroupList& patchLst = surf.patches_;
-
     reset(xferMove(surf.storedPoints()), xferMove(surf.storedFaces()));
-
+    setPatches(surf.patches());
-    regions_.setSize(size());
-    patches_.setSize(patchLst.size());
-
-    label faceIndex = 0;
-    forAll(patchLst, patchI)
-    {
-        // copy info
-        patches_[patchI] = patchLst[patchI];
-
-        forAll(patchLst[patchI], patchFaceI)
-        {
-            regions_[faceIndex++] = patchI;
-        }
-    }
-
-    patchLst.clear();
     surf.clear();
 }
 
 
 // Read from file, determine format from extension
 template<class Face>
-bool Foam::UnsortedMeshedSurface<Face>::read(const fileName& fName)
+bool Foam::UnsortedMeshedSurface<Face>::read(const fileName& name)
 {
-    word ext = fName.ext();
+    word ext = name.ext();
     if (ext == "gz")
     {
-        fileName unzipName = fName.lessExt();
+        fileName unzipName = name.lessExt();
         return read(unzipName, unzipName.ext());
     }
     else
     {
-        return read(fName, ext);
+        return read(name, ext);
     }
 }
 
@@ -665,19 +568,19 @@ bool Foam::UnsortedMeshedSurface<Face>::read(const fileName& fName)
 template<class Face>
 bool Foam::UnsortedMeshedSurface<Face>::read
 (
-    const fileName& fName,
+    const fileName& name,
     const word& ext
 )
 {
     // handle 'native' format directly
     if (isNative(ext))
     {
-        return read(IFstream(fName)());
+        return read(IFstream(name)());
     }
     else
     {
         // use selector mechanism
-        transfer(New(fName, ext)());
+        transfer(New(name, ext)());
         return true;
     }
 }
@@ -713,7 +616,6 @@ void Foam::UnsortedMeshedSurface<Face>::operator=
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-#include "UnsortedMeshedSurfaceCleanup.C"
 #include "UnsortedMeshedSurfaceIO.C"
 #include "UnsortedMeshedSurfaceNew.C"
 

src/surfMesh/UnsortedMeshedSurface/UnsortedMeshedSurface.H

@@ -91,9 +91,6 @@ private:
         typedef PrimitiveMeshedSurface<Face> ParentType;
         typedef MeshedSurface<Face> SiblingType;
 
-        //- Typedef for type holding the region (patch) informationm
-        typedef surfPatchIdentifier PatchRegionType;
-
     // Private Member Data
 
         //- The regions associated with the faces
@@ -101,7 +98,7 @@ private:
 
         //- Patch information (face ordering nFaces/startFace only used
         //  during reading and writing)
-        List<PatchRegionType> patches_;
+        List<surfPatchIdentifier> patches_;
 
     // Private member functions
 
@@ -111,38 +108,25 @@ private:
         //- Read OpenFOAM Surface format
         bool read(Istream&);
 
-        //- Set new regions from faceMap
-        void remapRegions(List<label>& faceMap);
-
 protected:
 
     // Protected Member functions
 
-        //- Set a single patch
-        void onePatch();
-
-        //- Sets default patch names based on the maximum patch number
-        void setPatches(const label maxPatch);
-
-        //- Finds maximum patch number and sets default patch names
-        void setPatches();
-
-        //- Sets patch names from hashed values (id -> name)
-        void setPatches
-        (
-            const Map<word>& regionNames,
-            const label maxPatch = -1
-        );
-
-        //- Sets patch names from hashed values (name -> id)
-        void setPatches(const HashTable<label>& groupToPatch);
-
         //- Return non-const access to the faces
         List<label>& storedRegions()
         {
             return regions_;
         }
 
+        //- Return non-const access to the patches
+        List<surfPatchIdentifier>& storedPatches()
+        {
+            return patches_;
+        }
+
+        //- Set new regions from faceMap
+        virtual void remapRegions(List<label>& faceMap);
+
 public:
 
         //- Runtime type information
@@ -177,32 +161,14 @@ public:
             const xfer<surfPatchIdentifierList>&
         );
 
-        //- Construct by transferring points, faces and regionIds
-        //  with region names per map or set to default.
-        UnsortedMeshedSurface
-        (
-            const xfer<pointField>&,
-            const xfer<List<Face> >&,
-            const xfer<List<label> >& regionIds,
-            const Map<word>& regionNames = Map<word>::null()
-        );
-
-        //- Construct by transferring points, faces and regionIds
-        //  with patch-names from hash
-        UnsortedMeshedSurface
-        (
-            const xfer<pointField>&,
-            const xfer<List<Face> >&,
-            const xfer<List<label> >& regionIds,
-            const HashTable<label>& labelToRegion
-        );
-
         //- Construct by transferring points, faces.
-        //  Set single default patch.
+        //  Use patch information, or set single default patch
         UnsortedMeshedSurface
         (
             const xfer<pointField>&,
-            const xfer<List<Face> >&
+            const xfer<List<Face> >&,
+            const UList<label>& patchSizes = UList<label>::null(),
+            const UList<word>& patchNames = UList<word>::null()
         );
 
         //- Construct from a boundary mesh with local points/faces
@@ -244,9 +210,9 @@ public:
             UnsortedMeshedSurface,
             fileExtension,
             (
-                const fileName& fName
+                const fileName& name
             ),
-            (fName)
+            (name)
         );
 
     // Selectors
@@ -275,10 +241,10 @@ public:
             write,
             fileExtension,
             (
-                const fileName& fName,
+                const fileName& name,
                 const UnsortedMeshedSurface<Face>& surf
             ),
-            (fName, surf)
+            (name, surf)
         );
 
         //- Write to file
@@ -314,29 +280,24 @@ public:
         //  Returns patch list and sets faceMap to index within faces()
         List<surfGroup> sortedRegions(labelList& faceMap) const;
 
+        //- Set regions to 0 and set a single patch
+        void onePatch();
+
+        //- Set regions and patches
+        void setPatches(const surfGroupList&);
+
+        //- Set regions and patches
+        void setPatches(const UList<label>& sizes, const UList<word>& names);
+
+        //- Set regions and patches with default names
+        void setPatches(const UList<label>& sizes);
+
 
     // Edit
 
         //- Clear all storage
         virtual void clear();
 
-        //- Remove invalid faces
-        void cleanup(const bool verbose);
-
-        //- Check/fix duplicate/degenerate faces
-        virtual bool checkFaces(const bool verbose);
-
-        //- Join the faces by removing duplicate points.
-        //  Returns true if any points merged
-        virtual bool stitchFaces
-        (
-            const scalar tol=SMALL,
-            const bool verbose=false
-        );
-
-        //- Triangulate the surface, return the number of added faces.
-        virtual label triangulate();
-
         //- Return new surface.
         //  Returns return pointMap, faceMap from subsetMeshMap
         UnsortedMeshedSurface subsetMesh
@@ -382,9 +343,9 @@ public:
         virtual void write(Ostream&) const;
 
         //- Generic write routine. Chooses writer based on extension.
-        virtual void write(const fileName& fName) const
+        virtual void write(const fileName& name) const
         {
-            write(fName, *this);
+            write(name, *this);
         }
 
         //- Write to database
@@ -408,15 +369,6 @@ public:
 };
 
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-//- Specialization for holding triangulated information
-template<>
-inline label UnsortedMeshedSurface<triFace>::triangulate()
-{
-    return 0;
-}
-
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 } // End namespace Foam

src/surfMesh/UnsortedMeshedSurface/UnsortedMeshedSurfaceCleanup.C

@@ -1,81 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software; you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by the
-    Free Software Foundation; either version 2 of the License, or (at your
-    option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM; if not, write to the Free Software Foundation,
-    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
-
-\*---------------------------------------------------------------------------*/
-
-#include "UnsortedMeshedSurface.H"
-#include "mergePoints.H"
-
-// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
-
-// Remove badly degenerate faces, double faces.
-template<class Face>
-void Foam::UnsortedMeshedSurface<Face>::cleanup(const bool verbose)
-{
-    // merge points (already done for STL, TRI)
-    stitchFaces(SMALL, verbose);
-
-    checkFaces(verbose);
-    ParentType::checkEdges(verbose);
-}
-
-
-template<class Face>
-bool Foam::UnsortedMeshedSurface<Face>::stitchFaces
-(
-    const scalar tol,
-    const bool verbose
-)
-{
-    List<label> faceMap;
-    bool hasMerged = ParentType::stitchFaces(faceMap, tol, verbose);
-
-    remapRegions(faceMap);
-    return hasMerged;
-}
-
-
-// Remove badly degenerate faces and double faces.
-template<class Face>
-bool Foam::UnsortedMeshedSurface<Face>::checkFaces(const bool verbose)
-{
-    List<label> faceMap;
-    bool changed = ParentType::checkFaces(faceMap, verbose);
-
-    remapRegions(faceMap);
-    return changed;
-}
-
-
-template<class Face>
-Foam::label Foam::UnsortedMeshedSurface<Face>::triangulate()
-{
-    List<label> faceMap;
-    label nTri = ParentType::triangulate(this->storedFaces(), faceMap);
-
-    remapRegions(faceMap);
-    return nTri;
-}
-
-// ************************************************************************* //

src/surfMesh/UnsortedMeshedSurface/UnsortedMeshedSurfaceNew.C

@@ -31,16 +31,11 @@ License
 
 template<class Face>
 Foam::autoPtr<Foam::UnsortedMeshedSurface<Face> >
-Foam::UnsortedMeshedSurface<Face>::New
+Foam::UnsortedMeshedSurface<Face>::New(const fileName& name, const word& ext)
-(
-    const fileName& fName,
-    const word& ext
-)
 {
     if (debug)
     {
-        Info<< "UnsortedMeshedSurface<Face>::New"
+        Info<< "UnsortedMeshedSurface::New(const fileName&, const word&) : "
-            "(const fileName&, const word&) : "
             "constructing UnsortedMeshedSurface"
             << endl;
     }
@@ -59,7 +54,7 @@ Foam::UnsortedMeshedSurface<Face>::New
             (
                 new UnsortedMeshedSurface<Face>
             );
-            surf().transfer(SiblingType::New(fName, ext)());
+            surf().transfer(SiblingType::New(name, ext)());
 
             return surf;
         }
@@ -79,24 +74,21 @@ Foam::UnsortedMeshedSurface<Face>::New
             << exit(FatalError);
     }
 
-    return autoPtr<UnsortedMeshedSurface<Face> >(cstrIter()(fName));
+    return autoPtr<UnsortedMeshedSurface<Face> >(cstrIter()(name));
 }
 
 
 template<class Face>
 Foam::autoPtr<Foam::UnsortedMeshedSurface<Face> >
-Foam::UnsortedMeshedSurface<Face>::New
+Foam::UnsortedMeshedSurface<Face>::New(const fileName& name)
-(
-    const fileName& fName
-)
 {
-    word ext = fName.ext();
+    word ext = name.ext();
     if (ext == "gz")
     {
-        ext = fName.lessExt().ext();
+        ext = name.lessExt().ext();
     }
 
-    return New(fName, ext);
+    return New(name, ext);
 }
 
 // ************************************************************************* //

src/surfMesh/surfaceFormats/ac3d/AC3DsurfaceFormat.C

@@ -41,10 +41,10 @@ License
 template<class Face>
 Foam::fileFormats::AC3DsurfaceFormat<Face>::AC3DsurfaceFormat
 (
-    const fileName& fName
+    const fileName& filename
 )
 {
-    read(fName);
+    read(filename);
 }
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
@@ -52,20 +52,20 @@ Foam::fileFormats::AC3DsurfaceFormat<Face>::AC3DsurfaceFormat
 template<class Face>
 bool Foam::fileFormats::AC3DsurfaceFormat<Face>::read
 (
-    const fileName& fName
+    const fileName& filename
 )
 {
     const bool mustTriangulate = this->isTri();
     this->clear();
 
-    IFstream is(fName);
+    IFstream is(filename);
     if (!is.good())
     {
         FatalErrorIn
         (
             "fileFormats::AC3DsurfaceFormat::read(const fileName&)"
         )
-            << "Cannot read file " << fName
+            << "Cannot read file " << filename
             << exit(FatalError);
     }
 
@@ -81,7 +81,7 @@ bool Foam::fileFormats::AC3DsurfaceFormat<Face>::read
         (
             "fileFormats::AC3DsurfaceFormat::read(const fileName&)"
         )
-            << "When reading AC3D file " << fName
+            << "When reading AC3D file " << filename
             << " read header " << line << " with version "
             << version << endl
             << "Only tested reading with version 'b'."
@@ -95,7 +95,7 @@ bool Foam::fileFormats::AC3DsurfaceFormat<Face>::read
         (
             "fileFormats::AC3DsurfaceFormat::read(const fileName&)"
         )
-            << "Cannot find \"OBJECT world\" in file " << fName
+            << "Cannot find \"OBJECT world\" in file " << filename
             << exit(FatalError);
     }
 
@@ -108,13 +108,14 @@ bool Foam::fileFormats::AC3DsurfaceFormat<Face>::read
 
     DynamicList<point> dynPoints;
     DynamicList<Face>  dynFaces;
+    List<word>         names(nPatches);
     List<label>        sizes(nPatches, 0);
 
     for (label patchI = 0; patchI < nPatches; ++patchI)
     {
-        word patchName = word("patch") + Foam::name(patchI);
+        names[patchI] = word("patch") + Foam::name(patchI);
         
-        args = cueToOrDie(is, "OBJECT", "while reading " + patchName);
+        args = cueToOrDie(is, "OBJECT", "while reading " + names[patchI]);
 
         // number of vertices for this patch
         label  nPatchPoints = 0;
@@ -133,7 +134,7 @@ bool Foam::fileFormats::AC3DsurfaceFormat<Face>::read
                     "fileFormats::AC3DsurfaceFormat::read(const fileName&)"
                 )
                     << "Did not read up to \"kids 0\" while reading patch "
-                    << patchI << " from file " << fName
+                    << patchI << " from file " << filename
                     << exit(FatalError);
             }
 
@@ -143,7 +144,7 @@ bool Foam::fileFormats::AC3DsurfaceFormat<Face>::read
                 string str = parse<string>(args);
                 string::stripInvalid<word>(str);
 
-                patchName = str;
+                names[patchI] = str;
             }
             else if (cmd == "rot")
             {
@@ -203,7 +204,7 @@ bool Foam::fileFormats::AC3DsurfaceFormat<Face>::read
                         string(" while reading face ")
                             + Foam::name(faceI) + " on patch "
                             + Foam::name(patchI)
-                            + " from file " + fName;
+                            + " from file " + filename;
 
                     cueToOrDie(is, "SURF", errorMsg);
                     cueToOrDie(is, "mat", errorMsg);
@@ -277,7 +278,8 @@ bool Foam::fileFormats::AC3DsurfaceFormat<Face>::read
     this->storedPoints().transfer(dynPoints);
     this->storedFaces().transfer(dynFaces);
 
-    this->addPatches(sizes);
+    // add patches, culling empty groups
+    this->addPatches(sizes, names, true);
     this->stitchFaces(SMALL);
     return true;
 }

src/surfMesh/surfaceFormats/ac3d/AC3DsurfaceFormat.H

@@ -83,14 +83,11 @@ public:
     // Selectors
 
         //- Read file and return surface
-        static autoPtr<MeshedSurface<Face> > New
+        static autoPtr<MeshedSurface<Face> > New(const fileName& name)
-        (
-            const fileName& fName
-        )
         {
             return autoPtr<MeshedSurface<Face> >
             (
-                new AC3DsurfaceFormat<Face>(fName)
+                new AC3DsurfaceFormat<Face>(name)
             );
         }
 
@@ -115,11 +112,11 @@ public:
         //- Write MeshedSurface
         static void write
         (
-            const fileName& fName,
+            const fileName& name,
             const MeshedSurface<Face>& surf
         )
         {
-            write(OFstream(fName)(), surf);
+            write(OFstream(name)(), surf);
         }
 
         //- Write UnsortedMeshedSurface
@@ -134,11 +131,11 @@ public:
         //  The output is always sorted by regions.
         static void write
         (
-            const fileName& fName,
+            const fileName& name,
             const UnsortedMeshedSurface<Face>& surf
         )
         {
-            write(OFstream(fName)(), surf);
+            write(OFstream(name)(), surf);
         }
 
         //- Write object

src/surfMesh/surfaceFormats/ftr/FTRsurfaceFormat.C

@@ -35,10 +35,10 @@ License
 template<class Face>
 Foam::fileFormats::FTRsurfaceFormat<Face>::FTRsurfaceFormat
 (
-    const fileName& fName
+    const fileName& filename
 )
 {
-    read(fName);
+    read(filename);
 }
 
 
@@ -47,19 +47,19 @@ Foam::fileFormats::FTRsurfaceFormat<Face>::FTRsurfaceFormat
 template<class Face>
 bool Foam::fileFormats::FTRsurfaceFormat<Face>::read
 (
-    const fileName& fName
+    const fileName& filename
 )
 {
     this->clear();
 
-    IFstream is(fName);
+    IFstream is(filename);
     if (!is.good())
     {
         FatalErrorIn
         (
             "fileFormats::FTRsurfaceFormat::read(const fileName&)"
         )
-            << "Cannot read file " << fName
+            << "Cannot read file " << filename
             << exit(FatalError);
     }
 
@@ -85,13 +85,18 @@ bool Foam::fileFormats::FTRsurfaceFormat<Face>::read
     this->storedFaces().transfer(faceLst);
     this->storedRegions().transfer(regionLst);
 
-    Map<word> regionNames;
+    // cast ftrPatch into new form
-    forAll(readPatches, patchI)
+    List<surfPatchIdentifier> newPatches(readPatches.size());
+    forAll(newPatches, patchI)
     {
-        regionNames.insert(patchI, readPatches[patchI].name());
+        newPatches[patchI] = surfPatchIdentifier
+        (
+            readPatches[patchI].name(),
+            patchI
+        );
     }
 
-    this->setPatches(regionNames, readPatches.size() - 1);
+    this->storedPatches().transfer(newPatches);
     return true;
 }
 

src/surfMesh/surfaceFormats/ftr/FTRsurfaceFormat.H

@@ -99,14 +99,11 @@ public:
     // Selectors
 
         //- Read file and return surface
-        static autoPtr<UnsortedMeshedSurface<Face> > New
+        static autoPtr<UnsortedMeshedSurface<Face> > New(const fileName& name)
-        (
-            const fileName& fName
-        )
         {
             return autoPtr<UnsortedMeshedSurface<Face> >
             (
-                new FTRsurfaceFormat<Face>(fName)
+                new FTRsurfaceFormat<Face>(name)
             );
         }
 

src/surfMesh/surfaceFormats/gts/GTSsurfaceFormat.C

@@ -38,10 +38,10 @@ License
 template<class Face>
 Foam::fileFormats::GTSsurfaceFormat<Face>::GTSsurfaceFormat
 (
-    const fileName& fName
+    const fileName& filename
 )
 {
-    read(fName);
+    read(filename);
 }
 
 
@@ -50,19 +50,19 @@ Foam::fileFormats::GTSsurfaceFormat<Face>::GTSsurfaceFormat
 template<class Face>
 bool Foam::fileFormats::GTSsurfaceFormat<Face>::read
 (
-    const fileName& fName
+    const fileName& filename
 )
 {
     this->clear();
 
-    IFstream is(fName);
+    IFstream is(filename);
     if (!is.good())
     {
         FatalErrorIn
         (
             "fileFormats::GTSsurfaceFormat::read(const fileName&)"
         )
-            << "Cannot read file " << fName
+            << "Cannot read file " << filename
             << exit(FatalError);
     }
 
@@ -205,108 +205,19 @@ bool Foam::fileFormats::GTSsurfaceFormat<Face>::read
         regionLst[faceI] = regionI;
     }
 
-    this->setPatches(maxPatch);
-    // this->stitchFaces(SMALL);
-    return true;
-}
 
-
+    List<surfPatchIdentifier> newPatches(maxPatch+1);
-template<class Face>
+    forAll(newPatches, patchI)
-void Foam::fileFormats::GTSsurfaceFormat<Face>::write
-(
-    Ostream& os,
-    const UnsortedMeshedSurface<Face>& surf
-)
-{
-    const pointField& pointLst = surf.points();
-    const List<Face>& faceLst  = surf.faces();
-
-    // check if output triangulation would be required
-    // It is too annoying to triangulate on-the-fly
-    // just issue a warning and get out
-    if (!surf.isTri())
     {
-        label nNonTris = 0;
+        newPatches[patchI] = surfPatchIdentifier
-        forAll(faceLst, faceI)
-        {
-            if (faceLst[faceI].size() != 3)
-            {
-                ++nNonTris;
-            }
-        }
-
-        if (nNonTris)
-        {
-            FatalErrorIn
         (
-                "fileFormats::GTSsurfaceFormat::write"
+            "patch" + ::Foam::name(patchI),
-                "(Ostream&, const UnsortedMeshedSurfaces<Face>&)"
+            patchI
-            )
+        );
-                << "Surface has " << nNonTris << "/" << faceLst.size()
-                << " non-triangulated faces - not writing!" << endl;
-            return;
-        }
     }
 
-
+    this->storedPatches().transfer(newPatches);
-    labelList faceMap;
+    return true;
-    List<surfGroup> patchLst = surf.sortedRegions(faceMap);
-
-
-    // Write header, print patch names as comment
-    os  << "# GTS file" << nl
-        << "# Regions:" << nl;
-
-    forAll(patchLst, patchI)
-    {
-        os  << "#     " << patchI << "    "
-            << patchLst[patchI].name() << nl;
-    }
-    os  << "#" << endl;
-
-
-    os  << "# nPoints  nEdges  nTriangles" << nl
-        << pointLst.size() << ' ' << surf.nEdges() << ' '
-        << surf.size() << endl;
-
-
-    // Write vertex coords
-    forAll(pointLst, pointI)
-    {
-        os  << pointLst[pointI].x() << ' '
-            << pointLst[pointI].y() << ' '
-            << pointLst[pointI].z() << endl;
-    }
-
-
-    // Write edges.
-    // Note: edges are in local point labels so convert
-    const edgeList& es = surf.edges();
-    const labelList& meshPts = surf.meshPoints();
-
-    forAll(es, edgeI)
-    {
-        os  << meshPts[es[edgeI].start()] + 1 << ' '
-            << meshPts[es[edgeI].end()] + 1 << endl;
-    }
-
-
-    // Write faces in terms of edges.
-    const labelListList& faceEs = surf.faceEdges();
-
-    label faceIndex = 0;
-    forAll(patchLst, patchI)
-    {
-        forAll(patchLst[patchI], patchFaceI)
-        {
-            const labelList& fEdges = faceEs[faceMap[faceIndex++]];
-
-            os  << fEdges[0] + 1 << ' '
-                << fEdges[1] + 1 << ' '
-                << fEdges[2] + 1 << ' '
-                << patchI << endl;
-        }
-    }
 }
 
 
@@ -406,4 +317,101 @@ void Foam::fileFormats::GTSsurfaceFormat<Face>::write
     }
 }
 
+
+template<class Face>
+void Foam::fileFormats::GTSsurfaceFormat<Face>::write
+(
+    Ostream& os,
+    const UnsortedMeshedSurface<Face>& surf
+)
+{
+    const pointField& pointLst   = surf.points();
+    const List<Face>& faceLst    = surf.faces();
+    const List<label>& regionLst = surf.regions();
+    const List<surfPatchIdentifier>& patchInfo = surf.patches();
+
+    // check if output triangulation would be required
+    // It is too annoying to triangulate on-the-fly
+    // just issue a warning and get out
+    if (!surf.isTri())
+    {
+        label nNonTris = 0;
+        forAll(faceLst, faceI)
+        {
+            if (faceLst[faceI].size() != 3)
+            {
+                ++nNonTris;
+            }
+        }
+
+        if (nNonTris)
+        {
+            FatalErrorIn
+            (
+                "fileFormats::GTSsurfaceFormat::write"
+                "(Ostream&, const UnsortedMeshedSurfaces<Face>&)"
+            )
+                << "Surface has " << nNonTris << "/" << faceLst.size()
+                << " non-triangulated faces - not writing!" << endl;
+            return;
+        }
+    }
+
+    labelList faceMap;
+    List<surfGroup> patchLst = surf.sortedRegions(faceMap);
+
+
+    // Write header, print patch names as comment
+    os  << "# GTS file" << nl
+        << "# Regions:" << nl;
+
+    forAll(patchInfo, patchI)
+    {
+        os  << "#     " << patchI << "    "
+            << patchInfo[patchI].name() << nl;
+    }
+    os  << "#" << endl;
+
+
+    os  << "# nPoints  nEdges  nTriangles" << nl
+        << pointLst.size() << ' ' << surf.nEdges() << ' '
+        << surf.size() << endl;
+
+
+    // Write vertex coords
+    forAll(pointLst, pointI)
+    {
+        os  << pointLst[pointI].x() << ' '
+            << pointLst[pointI].y() << ' '
+            << pointLst[pointI].z() << endl;
+    }
+
+
+    // Write edges.
+    // Note: edges are in local point labels so convert
+    const edgeList& es = surf.edges();
+    const labelList& meshPts = surf.meshPoints();
+
+    forAll(es, edgeI)
+    {
+        os  << meshPts[es[edgeI].start()] + 1 << ' '
+            << meshPts[es[edgeI].end()] + 1 << endl;
+    }
+
+
+    // Write faces in terms of edges.
+    const labelListList& faceEs = surf.faceEdges();
+
+    forAll(faceLst, faceI)
+    {
+        const labelList& fEdges = faceEs[faceI];
+
+        os  << fEdges[0] + 1 << ' '
+            << fEdges[1] + 1 << ' '
+            << fEdges[2] + 1 << ' '
+            << regionLst[faceI] << endl;
+    }
+}
+
+
 // ************************************************************************* //

src/surfMesh/surfaceFormats/gts/GTSsurfaceFormat.H

@@ -27,6 +27,7 @@ Class
 
 Description
     Provide a means of reading/writing GTS format.
+    The output is never sorted by patch.
 
 SourceFiles
     GTSsurfaceFormat.C
@@ -75,14 +76,11 @@ public:
     // Selectors
 
         //- Read file and return surface
-        static autoPtr<UnsortedMeshedSurface<Face> > New
+        static autoPtr<UnsortedMeshedSurface<Face> > New(const fileName& name)
-        (
-            const fileName& fName
-        )
         {
             return autoPtr<UnsortedMeshedSurface<Face> >
             (
-                new GTSsurfaceFormat<Face>(fName)
+                new GTSsurfaceFormat<Face>(name)
             );
         }
 
@@ -105,15 +103,15 @@ public:
         //- Write MeshedSurface
         static void write
         (
-            const fileName& fName,
+            const fileName& name,
             const MeshedSurface<Face>& surf
         )
         {
-            write(OFstream(fName)(), surf);
+            write(OFstream(name)(), surf);
         }
 
         //- Write UnsortedMeshedSurface
-        //  The output is sorted by regions
+        //  The output remains unsorted
         static void write
         (
             Ostream&,
@@ -121,14 +119,14 @@ public:
         );
 
         //- Write UnsortedMeshedSurface
-        //  The output is sorted by regions
+        //  The output remains unsorted
         static void write
         (
-            const fileName& fName,
+            const fileName& name,
             const UnsortedMeshedSurface<Face>& surf
         )
         {
-            write(OFstream(fName)(), surf);
+            write(OFstream(name)(), surf);
         }
 
         //- Write object

src/surfMesh/surfaceFormats/nas/NASsurfaceFormat.C

@@ -38,10 +38,10 @@ License
 template<class Face>
 Foam::fileFormats::NASsurfaceFormat<Face>::NASsurfaceFormat
 (
-    const fileName& fName
+    const fileName& filename
 )
 {
-    read(fName);
+    read(filename);
 }
 
 
@@ -50,43 +50,44 @@ Foam::fileFormats::NASsurfaceFormat<Face>::NASsurfaceFormat
 template<class Face>
 bool Foam::fileFormats::NASsurfaceFormat<Face>::read
 (
-    const fileName& fName
+    const fileName& filename
 )
 {
     const bool mustTriangulate = this->isTri();
     this->clear();
 
-    IFstream is(fName);
+    IFstream is(filename);
     if (!is.good())
     {
         FatalErrorIn
         (
             "fileFormats::NASsurfaceFormat::read(const fileName&)"
         )
-            << "Cannot read file " << fName
+            << "Cannot read file " << filename
             << exit(FatalError);
     }
 
-    DynamicList<point>  pointLst;
     // Nastran index of points
     DynamicList<label>  pointId;
-    DynamicList<Face>   faceLst;
+    DynamicList<point>  dynPoints;
-    DynamicList<label>  regionLst;
+    DynamicList<Face>   dynFaces;
-    HashTable<label>    groupToPatch;
+    DynamicList<label>  dynRegions;
+    DynamicList<label>  dynSizes;
+    Map<label>          lookup;
 
-    // From face groupId to patchId
+    // assume the types are not intermixed
-    Map<label> groupIdToPatchId;
+    bool sorted = true;
-    label nPatches = 0;
+    label regionI = 0;
 
     // Name for face group
-    Map<word> groupIdToName;
+    Map<word> nameLookup;
 
-    // Ansa tags. Denoted by $ANSA_NAME. These will appear just before the
+    // Ansa tags. Denoted by $ANSA_NAME.
-    // first use of a type. We read them and store the pshell types which
+    // These will appear just before the first use of a type.
-    // are used to name the patches.
+    // We read them and store the PSHELL types which are used to name
+    // the patches.
     label ansaId = -1;
-    word ansaType;
+    word  ansaType, ansaName;
-    word ansaName;
 
     // leave faces that didn't have a group in 0
     //    label groupID = 0;
@@ -134,7 +135,7 @@ bool Foam::fileFormats::NASsurfaceFormat<Face>::read
                 string::stripInvalid<word>(rawName);
                 ansaName = rawName;
 
-                // Info<< "ANSA tag for NastranID:" << ansaID
+                // Info<< "ANSA tag for NastranID:" << ansaId
                 //     << " of type " << ansaType
                 //     << " name " << ansaName << endl;
             }
@@ -161,9 +162,9 @@ bool Foam::fileFormats::NASsurfaceFormat<Face>::read
             string::stripInvalid<word>(rawName);
 
             word groupName(rawName);
-            groupIdToName.insert(groupId, groupName);
+            nameLookup.insert(groupId, groupName);
 
-            Info<< "group " << groupId << " => " << groupName << endl;
+            // Info<< "group " << groupId << " => " << groupName << endl;
         }
 
 
@@ -173,7 +174,6 @@ bool Foam::fileFormats::NASsurfaceFormat<Face>::read
             continue;
         }
 
-
         // Check if character 72 is continuation
         if (line.size() > 72 && line[72] == '+')
         {
@@ -212,22 +212,27 @@ bool Foam::fileFormats::NASsurfaceFormat<Face>::read
             fTri[2] = readLabel(IStringStream(line.substr(40,8))());
 
             // Convert groupID into patchID
-            Map<label>::const_iterator iter = groupIdToPatchId.find(groupId);
+            Map<label>::const_iterator fnd = lookup.find(groupId);
-
+            if (fnd != lookup.end())
-            label patchI;
-            if (iter == groupIdToPatchId.end())
             {
-                patchI = nPatches++;
+                if (regionI != fnd())
-                groupIdToPatchId.insert(groupId, patchI);
+                {
-                Info<< "patch " << patchI << " => group " << groupId << endl;
+                    // pshell types are intermixed
+                    sorted = false;
+                }
+                regionI = fnd();
             }
             else
             {
-                patchI = iter();
+                regionI = dynSizes.size();
+                lookup.insert(groupId, regionI);
+                dynSizes.append(0);
+                // Info<< "patch" << regionI << " => group " << groupId <<endl;
             }
 
-            faceLst.append(fTri);
+            dynFaces.append(fTri);
-            regionLst.append(patchI);
+            dynRegions.append(regionI);
+            dynSizes[regionI]++;
         }
         else if (cmd == "CQUAD4")
         {
@@ -240,43 +245,39 @@ bool Foam::fileFormats::NASsurfaceFormat<Face>::read
             fQuad[2] = readLabel(IStringStream(line.substr(40,8))());
             fQuad[3] = readLabel(IStringStream(line.substr(48,8))());
 
-            // Convert group into patch
+            // Convert groupID into patchID
-            Map<label>::const_iterator iter = groupIdToPatchId.find(groupId);
+            Map<label>::const_iterator fnd = lookup.find(groupId);
-
+            if (fnd != lookup.end())
-            label patchI;
-            if (iter == groupIdToPatchId.end())
             {
-                patchI = nPatches++;
+                if (regionI != fnd())
-                groupIdToPatchId.insert(groupId, patchI);
+                {
-                Info<< "patch " << patchI << " => group " << groupId << endl;
+                    // pshell types are intermixed
+                    sorted = false;
+                }
+                regionI = fnd();
             }
             else
             {
-                patchI = iter();
+                regionI = dynSizes.size();
+                lookup.insert(groupId, regionI);
+                dynSizes.append(0);
+                // Info<< "patch" << regionI << " => group " << groupId <<endl;
             }
 
+
             if (mustTriangulate)
             {
-                faceLst.append(triFace(f[0], f[1], f[2]));
+                dynFaces.append(triFace(f[0], f[1], f[2]));
-                faceLst.append(triFace(f[0], f[2], f[3]));
+                dynFaces.append(triFace(f[0], f[2], f[3]));
-                regionLst.append(patchI);
+                dynRegions.append(regionI);
-                regionLst.append(patchI);
+                dynRegions.append(regionI);
+                dynSizes[regionI] += 2;
             }
             else
             {
-                faceLst.append(Face(f));
+                dynFaces.append(Face(f));
-                regionLst.append(patchI);
+                dynRegions.append(regionI);
-            }
+                dynSizes[regionI]++;
-        }
-        else if (cmd == "PSHELL")
-        {
-            // Read shell type since group gives patchnames.
-            label groupId = readLabel(IStringStream(line.substr(8,8))());
-
-            if (groupId == ansaId && ansaType == "PSHELL")
-            {
-                groupIdToName.insert(groupId, ansaName);
-                Info<< "group " << groupId << " => " << ansaName << endl;
             }
         }
         else if (cmd == "GRID")
@@ -287,7 +288,7 @@ bool Foam::fileFormats::NASsurfaceFormat<Face>::read
             scalar z = parseNASCoord(line.substr(40, 8));
 
             pointId.append(index);
-            pointLst.append(point(x, y, z));
+            dynPoints.append(point(x, y, z));
         }
         else if (cmd == "GRID*")
         {
@@ -309,76 +310,95 @@ bool Foam::fileFormats::NASsurfaceFormat<Face>::read
                     "fileFormats::NASsurfaceFormat::read(const fileName&)"
                 )
                     << "Expected continuation symbol '*' when reading GRID*"
-                    << " (double precision coordinate) output" << nl
+                    << " (double precision coordinate) format" << nl
                     << "Read:" << line << nl
-                    << "File:" << is.name()
+                    << "File:" << is.name() << " line:" << is.lineNumber()
-                    << " line:" << is.lineNumber()
                     << exit(FatalError);
             }
             scalar z = parseNASCoord(line.substr(8, 16));
 
             pointId.append(index);
-            pointLst.append(point(x, y, z));
+            dynPoints.append(point(x, y, z));
+        }
+        else if (cmd == "PSHELL")
+        {
+            // pshell type for patch names with the Ansa extension
+            label groupId = readLabel(IStringStream(line.substr(8,8))());
+
+            if (groupId == ansaId && ansaType == "PSHELL")
+            {
+                nameLookup.insert(ansaId, ansaName);
+                // Info<< "group " << groupId << " => " << ansaName << endl;
+            }
         }
         else if (unhandledCmd.insert(cmd))
         {
             Info<< "Unhandled Nastran command " << line << nl
-                << "File:" << is.name()
+                << "File:" << is.name() << " line:" << is.lineNumber()
-                << " line:" << is.lineNumber()
                 << endl;
         }
     }
 
-    Info<< "Read faces:" << faceLst.size()
+    //    Info<< "Read faces:" << dynFaces.size()
-        << " points:" << pointLst.size()
+    //        << " points:" << dynPoints.size()
-        << endl;
+    //        << endl;
-
 
     // transfer to normal lists
-    this->storedPoints().transfer(pointLst);
+    this->storedPoints().transfer(dynPoints);
-    this->storedRegions().transfer(regionLst);
 
     pointId.shrink();
-    faceLst.shrink();
+    dynFaces.shrink();
 
-    {
+    // Build inverse mapping (NASTRAN pointId -> index)
-        // Build inverse mapping (index to point)
+    Map<label> mapPointId(2*pointId.size());
-        Map<label> nasToFoamPoint(2*pointId.size());
     forAll(pointId, i)
     {
-            nasToFoamPoint.insert(pointId[i], i);
+        mapPointId.insert(pointId[i], i);
     }
-        pointId.clearStorage();
-
 
     // Relabel faces
-        forAll(faceLst, i)
+    // ~~~~~~~~~~~~~
+    forAll(dynFaces, i)
     {
-            Face& f = faceLst[i];
+        Face& f = dynFaces[i];
         forAll(f, fp)
         {
-                f[fp] = nasToFoamPoint[f[fp]];
+            f[fp] = mapPointId[f[fp]];
-            }
         }
     }
+    pointId.clearStorage();
+    mapPointId.clear();
 
 
-    // convert Nastran groupId => name to patchId => name
+    // create default patch names, or from ANSA/Hypermesh information
-    Map<word> regionNames;
+    List<word> names(dynSizes.size());
-    forAllConstIter(Map<word>, groupIdToName, iter)
+    forAllConstIter(Map<label>, lookup, iter)
     {
-        Map<label>::const_iterator iter2 = groupIdToPatchId.find(iter.key());
+        const label patchI = iter();
+        const label groupI = iter.key();
 
-        if (iter2 != groupIdToPatchId.end())
+        Map<word>::const_iterator fnd = nameLookup.find(groupI);
+        if (fnd != nameLookup.end())
         {
-            regionNames.insert(iter2.key(), iter());
+            names[patchI] = fnd();
+        }
+        else
+        {
+            names[patchI] = word("patch") + ::Foam::name(patchI);
         }
     }
 
-    // transfer to normal lists
-    this->storedFaces().transfer(faceLst);
 
-    this->setPatches(regionNames);
+    sortFacesAndStore
+    (
+        xferMoveTo<List<Face> >(dynFaces),
+        xferMoveTo<List<label> >(dynRegions),
+        sorted
+    );
+
+    // add patches, culling empty groups
+    this->addPatches(dynSizes, names, true);
+
     return true;
 }
 

src/surfMesh/surfaceFormats/nas/NASsurfaceFormat.H

@@ -64,7 +64,7 @@ namespace fileFormats
 template<class Face>
 class NASsurfaceFormat
 :
-    public UnsortedMeshedSurface<Face>,
+    public MeshedSurface<Face>,
     public NASsurfaceFormatCore
 {
     // Private Member Functions
@@ -85,14 +85,11 @@ public:
     // Selectors
 
         //- Read file and return surface
-        static autoPtr<UnsortedMeshedSurface<Face> > New
+        static autoPtr<MeshedSurface<Face> > New(const fileName& name)
-        (
-            const fileName& fName
-        )
         {
-            return autoPtr<UnsortedMeshedSurface<Face> >
+            return autoPtr<MeshedSurface<Face> >
             (
-                new NASsurfaceFormat<Face>(fName)
+                new NASsurfaceFormat<Face>(name)
             );
         }
 

src/surfMesh/surfaceFormats/nas/NASsurfaceFormatRunTime.C

@@ -37,9 +37,10 @@ namespace fileFormats
 {
 
 // .bdf (Bulk Data Format)
+// .nas (Nastran)
 addNamedTemplatedToRunTimeSelectionTable
 (
-    UnsortedMeshedSurface,
+    MeshedSurface,
     NASsurfaceFormat,
     face,
     fileExtension,
@@ -47,25 +48,24 @@ addNamedTemplatedToRunTimeSelectionTable
 );
 addNamedTemplatedToRunTimeSelectionTable
 (
-    UnsortedMeshedSurface,
+    MeshedSurface,
-    NASsurfaceFormat,
-    triFace,
-    fileExtension,
-    bdf
-);
-
-// .nas (Nastran)
-addNamedTemplatedToRunTimeSelectionTable
-(
-    UnsortedMeshedSurface,
     NASsurfaceFormat,
     face,
     fileExtension,
     nas
 );
+
 addNamedTemplatedToRunTimeSelectionTable
 (
-    UnsortedMeshedSurface,
+    MeshedSurface,
+    NASsurfaceFormat,
+    triFace,
+    fileExtension,
+    bdf
+);
+addNamedTemplatedToRunTimeSelectionTable
+(
+    MeshedSurface,
     NASsurfaceFormat,
     triFace,
     fileExtension,

src/surfMesh/surfaceFormats/obj/OBJsurfaceFormat.C

@@ -27,6 +27,7 @@ License
 #include "OBJsurfaceFormat.H"
 #include "IFstream.H"
 #include "IStringStream.H"
+#include "ListOps.H"
 
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 
@@ -35,10 +36,10 @@ License
 template<class Face>
 Foam::fileFormats::OBJsurfaceFormat<Face>::OBJsurfaceFormat
 (
-    const fileName& fName
+    const fileName& filename
 )
 {
-    read(fName);
+    read(filename);
 }
 
 
@@ -47,31 +48,38 @@ Foam::fileFormats::OBJsurfaceFormat<Face>::OBJsurfaceFormat
 template<class Face>
 bool Foam::fileFormats::OBJsurfaceFormat<Face>::read
 (
-    const fileName& fName
+    const fileName& filename
 )
 {
     const bool mustTriangulate = this->isTri();
     this->clear();
 
-    IFstream is(fName);
+    IFstream is(filename);
     if (!is.good())
     {
         FatalErrorIn
         (
             "fileFormats::OBJsurfaceFormat::read(const fileName&)"
         )
-            << "Cannot read file " << fName
+            << "Cannot read file " << filename
             << exit(FatalError);
     }
 
-    DynamicList<point>    pointLst;
+    // assume that the groups are not intermixed
-    DynamicList<Face>     faceLst;
+    bool sorted = true;
-    DynamicList<label>    regionLst;
-    HashTable<label>      groupToPatch;
 
-    // leave faces that didn't have a group in 0
+    DynamicList<point> dynPoints;
-    label groupID = 0;
+    DynamicList<Face>  dynFaces;
-    label maxGroupID = -1;
+    DynamicList<label> dynRegions;
+    DynamicList<word>  dynNames;
+    DynamicList<label> dynSizes;
+    HashTable<label>   lookup;
+
+    // place faces without a group in patch0
+    label regionI = 0;
+    lookup.insert("patch0", regionI);
+    dynNames.append("patch0");
+    dynSizes.append(0);
 
     while (is.good())
     {
@@ -93,30 +101,29 @@ bool Foam::fileFormats::OBJsurfaceFormat<Face>::read
         {
             scalar x, y, z;
             lineStream >> x >> y >> z;
-            pointLst.append(point(x, y, z));
+            dynPoints.append(point(x, y, z));
         }
         else if (cmd == "g")
         {
-            word groupName;
+            word name;
-            lineStream >> groupName;
+            lineStream >> name;
 
-            HashTable<label>::const_iterator findGroup =
+            HashTable<label>::const_iterator fnd = lookup.find(name);
-                groupToPatch.find(groupName);
+            if (fnd != lookup.end())
-
-            if (findGroup != groupToPatch.end())
             {
-                groupID = findGroup();
+                if (regionI != fnd())
+                {
+                    // group appeared out of order
+                    sorted = false;
+                }
+                regionI = fnd();
             }
             else
             {
-                // special treatment if any initial faces were not in a group
+                regionI = dynSizes.size();
-                if (maxGroupID == -1 && faceLst.size())
+                lookup.insert(name, regionI);
-                {
+                dynNames.append(name);
-                    groupToPatch.insert("patch0", 0);
+                dynSizes.append(0);
-                    maxGroupID = 0;
-                }
-                groupID = ++maxGroupID;
-                groupToPatch.insert(groupName, groupID);
             }
         }
         else if (cmd == "f")
@@ -183,28 +190,72 @@ bool Foam::fileFormats::OBJsurfaceFormat<Face>::read
                     fTri[1] = f[fp1];
                     fTri[2] = f[fp2];
 
-                    faceLst.append(fTri);
+                    dynFaces.append(fTri);
-                    regionLst.append(groupID);
+                    dynRegions.append(regionI);
+                    dynSizes[regionI]++;
                 }
             }
             else
             {
-                faceLst.append(Face(f));
+                dynFaces.append(Face(f));
-                regionLst.append(groupID);
+                dynRegions.append(regionI);
+                dynSizes[regionI]++;
             }
         }
     }
 
+
     // transfer to normal lists
-    this->storedPoints().transfer(pointLst);
+    this->storedPoints().transfer(dynPoints);
-    this->storedFaces().transfer(faceLst);
-    this->storedRegions().transfer(regionLst);
 
-    this->setPatches(groupToPatch);
+    sortFacesAndStore
+    (
+        xferMoveTo<List<Face> >(dynFaces),
+        xferMoveTo<List<label> >(dynRegions),
+        sorted
+    );
+
+    // add patches, culling empty groups
+    this->addPatches(dynSizes, dynNames, true);
     return true;
 }
 
 
+template<class Face>
+void Foam::fileFormats::OBJsurfaceFormat<Face>::write
+(
+    Ostream& os,
+    const MeshedSurface<Face>& surf
+)
+{
+    const List<Face>& faceLst = surf.faces();
+    const List<surfGroup>& patchLst = surf.patches();
+
+    writeHeader(os, surf.points(), faceLst.size(), patchLst);
+
+    label faceIndex = 0;
+    forAll(patchLst, patchI)
+    {
+        const surfGroup& patch = patchLst[patchI];
+
+        os << "g " << patch.name() << endl;
+
+        forAll(patch, patchFaceI)
+        {
+            const Face& f = faceLst[faceIndex++];
+
+            os << 'f';
+            forAll(f, fp)
+            {
+                os << ' ' << f[fp] + 1;
+            }
+            os << endl;
+        }
+    }
+    os << "# </faces>" << endl;
+}
+
+
 template<class Face>
 void Foam::fileFormats::OBJsurfaceFormat<Face>::write
 (
@@ -243,39 +294,4 @@ void Foam::fileFormats::OBJsurfaceFormat<Face>::write
     os << "# </faces>" << endl;
 }
 
-
-template<class Face>
-void Foam::fileFormats::OBJsurfaceFormat<Face>::write
-(
-    Ostream& os,
-    const MeshedSurface<Face>& surf
-)
-{
-    const List<Face>& faceLst = surf.faces();
-    const List<surfGroup>& patchLst = surf.patches();
-
-    writeHeader(os, surf.points(), faceLst.size(), patchLst);
-
-    label faceIndex = 0;
-    forAll(patchLst, patchI)
-    {
-        const surfGroup& patch = patchLst[patchI];
-
-        os << "g " << patch.name() << endl;
-
-        forAll(patch, patchFaceI)
-        {
-            const Face& f = faceLst[faceIndex++];
-
-            os << 'f';
-            forAll(f, fp)
-            {
-                os << ' ' << f[fp] + 1;
-            }
-            os << endl;
-        }
-    }
-    os << "# </faces>" << endl;
-}
-
 // ************************************************************************* //

src/surfMesh/surfaceFormats/obj/OBJsurfaceFormat.H

@@ -58,7 +58,7 @@ namespace fileFormats
 template<class Face>
 class OBJsurfaceFormat
 :
-    public UnsortedMeshedSurface<Face>,
+    public MeshedSurface<Face>,
     public OBJsurfaceFormatCore
 {
     // Private Member Functions
@@ -87,14 +87,11 @@ public:
     // Selectors
 
         //- Read file and return surface
-        static autoPtr<UnsortedMeshedSurface<Face> > New
+        static autoPtr<MeshedSurface<Face> > New(const fileName& name)
-        (
-            const fileName& fName
-        )
         {
-            return autoPtr<UnsortedMeshedSurface<Face> >
+            return autoPtr<MeshedSurface<Face> >
             (
-                new OBJsurfaceFormat<Face>(fName)
+                new OBJsurfaceFormat<Face>(name)
             );
         }
 
@@ -119,11 +116,11 @@ public:
         //- Write MeshedSurface
         static void write
         (
-            const fileName& fName,
+            const fileName& name,
             const MeshedSurface<Face>& surf
         )
         {
-            write(OFstream(fName)(), surf);
+            write(OFstream(name)(), surf);
         }
 
         //- Write UnsortedMeshedSurface
@@ -138,11 +135,11 @@ public:
         //  The output is sorted by regions
         static void write
         (
-            const fileName& fName,
+            const fileName& name,
             const UnsortedMeshedSurface<Face>& surf
         )
         {
-            write(OFstream(fName)(), surf);
+            write(OFstream(name)(), surf);
         }
 
         //- Write object

src/surfMesh/surfaceFormats/obj/OBJsurfaceFormatRunTime.C

@@ -38,7 +38,7 @@ namespace fileFormats
 
 addNamedTemplatedToRunTimeSelectionTable
 (
-    UnsortedMeshedSurface,
+    MeshedSurface,
     OBJsurfaceFormat,
     face,
     fileExtension,
@@ -46,7 +46,7 @@ addNamedTemplatedToRunTimeSelectionTable
 );
 addNamedTemplatedToRunTimeSelectionTable
 (
-    UnsortedMeshedSurface,
+    MeshedSurface,
     OBJsurfaceFormat,
     triFace,
     fileExtension,

src/surfMesh/surfaceFormats/off/OFFsurfaceFormat.C

@@ -37,10 +37,10 @@ License
 template<class Face>
 Foam::fileFormats::OFFsurfaceFormat<Face>::OFFsurfaceFormat
 (
-    const fileName& fName
+    const fileName& filename
 )
 {
-    read(fName);
+    read(filename);
 }
 
 
@@ -49,20 +49,20 @@ Foam::fileFormats::OFFsurfaceFormat<Face>::OFFsurfaceFormat
 template<class Face>
 bool Foam::fileFormats::OFFsurfaceFormat<Face>::read
 (
-    const fileName& fName
+    const fileName& filename
 )
 {
     const bool mustTriangulate = this->isTri();
     this->clear();
 
-    IFstream is(fName);
+    IFstream is(filename);
     if (!is.good())
     {
         FatalErrorIn
         (
             "fileFormats::OFFsurfaceFormat<Face>::read(const fileName&)"
         )
-            << "Cannot read file " << fName
+            << "Cannot read file " << filename
             << exit(FatalError);
     }
 
@@ -74,7 +74,7 @@ bool Foam::fileFormats::OFFsurfaceFormat<Face>::read
         (
             "fileFormats::OFFsurfaceFormat<Face>::read(const fileName&)"
         )
-            << "OFF file " << fName << " does not start with 'OFF'"
+            << "OFF file " << filename << " does not start with 'OFF'"
             << exit(FatalError);
     }
 
@@ -103,7 +103,7 @@ bool Foam::fileFormats::OFFsurfaceFormat<Face>::read
 
     // Read faces - ignore optional region information
     // use a DynamicList for possible on-the-fly triangulation
-    DynamicList<Face>  faceLst(nElems);
+    DynamicList<Face>  dynFaces(nElems);
 
     for (label faceI = 0; faceI < nElems; ++faceI)
     {
@@ -137,12 +137,12 @@ bool Foam::fileFormats::OFFsurfaceFormat<Face>::read
                     fTri[1] = f[fp1];
                     fTri[2] = f[fp2];
 
-                    faceLst.append(fTri);
+                    dynFaces.append(fTri);
                 }
             }
             else
             {
-                faceLst.append(Face(f));
+                dynFaces.append(Face(f));
             }
         }
     }
@@ -151,7 +151,7 @@ bool Foam::fileFormats::OFFsurfaceFormat<Face>::read
     reset
     (
         xferMove(pointLst),
-        xferMoveTo<List<Face> >(faceLst)
+        xferMoveTo<List<Face> >(dynFaces)
     );
 
     // no region information

src/surfMesh/surfaceFormats/off/OFFsurfaceFormat.H

@@ -95,14 +95,11 @@ public:
     // Selectors
 
         //- Read file and return surface
-        static autoPtr<MeshedSurface<Face> > New
+        static autoPtr<MeshedSurface<Face> > New(const fileName& name)
-        (
-            const fileName& fName
-        )
         {
             return autoPtr<MeshedSurface<Face> >
             (
-                new OFFsurfaceFormat(fName)
+                new OFFsurfaceFormat(name)
             );
         }
 
@@ -125,11 +122,11 @@ public:
         //- Write MeshedSurface
         static void write
         (
-            const fileName& fName,
+            const fileName& name,
             const MeshedSurface<Face>& surf
         )
         {
-            write(OFstream(fName)(), surf);
+            write(OFstream(name)(), surf);
         }
 
         //- Write UnsortedMeshedSurface
@@ -144,11 +141,11 @@ public:
         //  The output is sorted by region.
         static void write
         (
-            const fileName& fName,
+            const fileName& name,
             const UnsortedMeshedSurface<Face>& surf
         )
         {
-            write(OFstream(fName)(), surf);
+            write(OFstream(name)(), surf);
         }
 
         //- Write object

src/surfMesh/surfaceFormats/smesh/SMESHsurfaceFormat.C

@@ -38,6 +38,38 @@ Foam::fileFormats::SMESHsurfaceFormat<Face>::SMESHsurfaceFormat()
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
+template<class Face>
+void Foam::fileFormats::SMESHsurfaceFormat<Face>::write
+(
+    Ostream& os,
+    const MeshedSurface<Face>& surf
+)
+{
+    const List<Face>& faceLst = surf.faces();
+    const List<surfGroup>& patchLst = surf.patches();
+
+    writeHeader(os, surf.points(), faceLst.size());
+
+    label faceIndex = 0;
+    forAll(patchLst, patchI)
+    {
+        forAll(patchLst[patchI], patchFaceI)
+        {
+            const Face& f = faceLst[faceIndex++];
+
+            os << f.size();
+            forAll(f, fp)
+            {
+                os << ' ' << f[fp];
+            }
+            os << ' ' << patchI << endl;
+        }
+    }
+
+    writeTail(os);
+}
+
+
 template<class Face>
 void Foam::fileFormats::SMESHsurfaceFormat<Face>::write
 (
@@ -72,35 +104,4 @@ void Foam::fileFormats::SMESHsurfaceFormat<Face>::write
 }
 
 
-template<class Face>
-void Foam::fileFormats::SMESHsurfaceFormat<Face>::write
-(
-    Ostream& os,
-    const MeshedSurface<Face>& surf
-)
-{
-    const List<Face>& faceLst = surf.faces();
-    const List<surfGroup>& patchLst = surf.patches();
-
-    writeHeader(os, surf.points(), faceLst.size());
-
-    label faceIndex = 0;
-    forAll(patchLst, patchI)
-    {
-        forAll(patchLst[patchI], patchFaceI)
-        {
-            const Face& f = faceLst[faceIndex++];
-
-            os << f.size();
-            forAll(f, fp)
-            {
-                os << ' ' << f[fp];
-            }
-            os << ' ' << patchI << endl;
-        }
-    }
-
-    writeTail(os);
-}
-
 // ************************************************************************* //

src/surfMesh/surfaceFormats/smesh/SMESHsurfaceFormat.H

@@ -63,7 +63,7 @@ namespace fileFormats
 template<class Face>
 class SMESHsurfaceFormat
 :
-    public UnsortedMeshedSurface<Face>,
+    public MeshedSurface<Face>,
     public SMESHsurfaceFormatCore
 {
     // Private Member Functions
@@ -101,11 +101,11 @@ public:
         //- Write MeshedSurface
         static void write
         (
-            const fileName& fName,
+            const fileName& name,
             const MeshedSurface<Face>& surf
         )
         {
-            write(OFstream(fName)(), surf);
+            write(OFstream(name)(), surf);
         }
 
         //- Write UnsortedMeshedSurface
@@ -120,11 +120,11 @@ public:
         //  The output is sorted by region.
         static void write
         (
-            const fileName& fName,
+            const fileName& name,
             const UnsortedMeshedSurface<Face>& surf
         )
         {
-            write(OFstream(fName)(), surf);
+            write(OFstream(name)(), surf);
         }
 
         //- Write object

src/surfMesh/surfaceFormats/starcd/STARCDsurfaceFormat.C

@@ -25,6 +25,7 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "STARCDsurfaceFormat.H"
+#include "ListOps.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
@@ -69,10 +70,10 @@ inline void Foam::fileFormats::STARCDsurfaceFormat<Face>::writeShell
 template<class Face>
 Foam::fileFormats::STARCDsurfaceFormat<Face>::STARCDsurfaceFormat
 (
-    const fileName& fName
+    const fileName& filename
 )
 {
-    read(fName);
+    read(filename);
 }
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
@@ -80,93 +81,65 @@ Foam::fileFormats::STARCDsurfaceFormat<Face>::STARCDsurfaceFormat
 template<class Face>
 bool Foam::fileFormats::STARCDsurfaceFormat<Face>::read
 (
-    const fileName& fName
+    const fileName& filename
 )
 {
     const bool mustTriangulate = this->isTri();
     this->clear();
 
-    fileName baseName = fName.lessExt();
+    fileName baseName = filename.lessExt();
-    autoPtr<IFstream> isPtr;
 
-
-    DynamicList<point> pointLst;
     // STAR-CD index of points
-    DynamicList<label> pointId;
+    List<label> pointId;
 
-    //
+    // read points from .vrt file
-    // read .vrt file
+    readPoints
-    // ~~~~~~~~~~~~~~
-    isPtr.reset(new IFstream(baseName + ".vrt"));
-
-    if (!isPtr().good())
-    {
-        FatalErrorIn
     (
-            "fileFormats::STARCDsurfaceFormat::read(const fileName&)"
+        IFstream(baseName + ".vrt")(),
-        )
+        this->storedPoints(),
-            << "Cannot read file " << (baseName + ".vrt")
+        pointId
-            << exit(FatalError);
+    );
-    }
 
-    readHeader(isPtr(), "PROSTAR_VERTEX");
+    // Build inverse mapping (STAR-CD pointId -> index)
-
+    Map<label> mapPointId(2*pointId.size());
-    label lineLabel;
-
-    while ((isPtr() >> lineLabel).good())
-    {
-        pointId.append(lineLabel);
-        scalar x, y, z;
-
-        isPtr() >> x >> y >> z;
-
-        pointLst.append(point(x, y, z));
-    }
-
-    // transfer to normal lists
-    this->storedPoints().transfer(pointLst);
-
-    // Build inverse mapping (index to point)
-    pointId.shrink();
-    Map<label> mapToFoamPointId(2*pointId.size());
     forAll(pointId, i)
     {
-        mapToFoamPointId.insert(pointId[i], i);
+        mapPointId.insert(pointId[i], i);
     }
     pointId.clear();
 
-
-    DynamicList<Face>  faceLst;
-    DynamicList<label> regionLst;
-
-    // From face cellTableId to patchId
-    Map<label> cellTableToPatchId;
-    label nPatches = 0;
-
-
     //
     // read .cel file
     // ~~~~~~~~~~~~~~
-    isPtr.reset(new IFstream(baseName + ".cel"));
+    IFstream is(baseName + ".cel");
-
+    if (!is.good())
-    if (!isPtr().good())
     {
         FatalErrorIn
         (
             "fileFormats::STARCDsurfaceFormat::read(const fileName&)"
         )
-            << "Cannot read file " << (baseName + ".cel")
+            << "Cannot read file " << is.name()
             << exit(FatalError);
     }
 
-    readHeader(isPtr(), "PROSTAR_CELL");
+    readHeader(is, "PROSTAR_CELL");
 
-    label shapeId, nLabels, cellTableId, typeId;
+    DynamicList<Face>  dynFaces;
+    DynamicList<label> dynRegions;
+    DynamicList<word>  dynNames;
+    DynamicList<label> dynSizes;
+    Map<label> lookup;
+
+    // assume the cellTableIds are not intermixed
+    bool sorted = true;
+    label regionI = 0;
+
+    label lineLabel, shapeId, nLabels, cellTableId, typeId;
     labelList starLabels(64);
 
-    while ((isPtr() >> lineLabel).good())
+    while ((is >> lineLabel).good())
     {
-        isPtr() >> shapeId >> nLabels >> cellTableId >> typeId;
+        is >> shapeId >> nLabels >> cellTableId >> typeId;
 
         if (nLabels > starLabels.size())
         {
@@ -179,42 +152,43 @@ bool Foam::fileFormats::STARCDsurfaceFormat<Face>::read
         {
             if ((i % 8) == 0)
             {
-               isPtr() >> lineLabel;
+               is >> lineLabel;
             }
-            isPtr() >> starLabels[i];
+            is >> starLabels[i];
         }
 
         if (typeId == starcdShellType_)
         {
             // Convert groupID into patchID
-            Map<label>::const_iterator iter =
+            Map<label>::const_iterator fnd = lookup.find(cellTableId);
-                cellTableToPatchId.find(cellTableId);
+            if (fnd != lookup.end())
-
-            label patchI;
-            if (iter == cellTableToPatchId.end())
             {
-                patchI = nPatches++;
+                if (regionI != fnd())
-
+                {
-                cellTableToPatchId.insert(cellTableId, patchI);
+                    // cellTableIds are intermixed
+                    sorted = false;
+                }
+                regionI = fnd();
             }
             else
             {
-                patchI = iter();
+                regionI = dynSizes.size();
+                lookup.insert(cellTableId, regionI);
+                dynNames.append(word("cellTable_") + ::Foam::name(regionI));
+                dynSizes.append(0);
             }
 
+            SubList<label> vertices(starLabels, nLabels);
 
             // convert orig vertex id to point label
-            for (label i=0; i < nLabels; ++i)
+            forAll(vertices, i)
             {
-                starLabels[i] = mapToFoamPointId[starLabels[i]];
+                vertices[i] = mapPointId[vertices[i]];
             }
 
             if (mustTriangulate && nLabels > 3)
             {
-                face f
+                face f(vertices);
-                (
-                    SubList<label>(starLabels, nLabels)
-                );
 
                 faceList triFaces(f.nTriangles(this->points()));
                 label nTri = 0;
@@ -222,47 +196,37 @@ bool Foam::fileFormats::STARCDsurfaceFormat<Face>::read
 
                 forAll(triFaces, faceI)
                 {
-                    // a triangle, but not yet a triFace
+                    // a triangular face, but not yet a triFace
-                    faceLst.append
+                    dynFaces.append
                     (
                         triFace
                         (
                             static_cast<UList<label>&>(triFaces[faceI])
                         )
                     );
-                    regionLst.append(patchI);
+                    dynRegions.append(regionI);
+                    dynSizes[regionI]++;
                 }
             }
             else
             {
-                faceLst.append
+                dynFaces.append(Face(vertices));
+                dynRegions.append(regionI);
+                dynSizes[regionI]++;
+            }
+        }
+    }
+    mapPointId.clear();
+
+    sortFacesAndStore
     (
-                    Face(SubList<label>(starLabels, nLabels))
+        xferMoveTo<List<Face> >(dynFaces),
+        xferMoveTo<List<label> >(dynRegions),
+        sorted
     );
-                regionLst.append(patchI);
-            }
-        }
-    }
-
-    mapToFoamPointId.clear();
-
-    // convert cellTable_N patchId => name
-    Map<word> regionNames;
-    forAllConstIter(Map<label>, cellTableToPatchId, iter)
-    {
-        regionNames.insert
-        (
-            iter(),
-            "cellTable_" + Foam::name(iter.key())
-        );
-    }
-
-    // transfer to normal lists
-    this->storedFaces().transfer(faceLst);
-    this->storedRegions().transfer(regionLst);
-
-    this->setPatches(regionNames);
 
+    // add patches, culling empty groups
+    this->addPatches(dynSizes, dynNames, true);
     return true;
 }
 
@@ -270,51 +234,11 @@ bool Foam::fileFormats::STARCDsurfaceFormat<Face>::read
 template<class Face>
 void Foam::fileFormats::STARCDsurfaceFormat<Face>::write
 (
-    const fileName& fName,
+    const fileName& filename,
-    const UnsortedMeshedSurface<Face>& surf
-)
-{
-    fileName baseName = fName.lessExt();
-
-    writePoints(OFstream(baseName + ".vrt")(), surf.points());
-    OFstream os(baseName + ".cel");
-    writeHeader(os, "CELL");
-
-    const List<Face>& faceLst = surf.faces();
-    labelList faceMap;
-    List<surfGroup> patchLst = surf.sortedRegions(faceMap);
-
-    label faceIndex = 0;
-    forAll(patchLst, patchI)
-    {
-        const surfGroup& patch = patchLst[patchI];
-
-        forAll(patch, patchFaceI)
-        {
-            const Face& f = faceLst[faceMap[faceIndex++]];
-            writeShell(os, f, faceIndex, patchI + 1);
-        }
-    }
-
-    // write simple .inp file
-    writeCase
-    (
-        OFstream(baseName + ".inp")(),
-        surf.points(),
-        surf.size(),
-        patchLst
-    );
-}
-
-
-template<class Face>
-void Foam::fileFormats::STARCDsurfaceFormat<Face>::write
-(
-    const fileName& fName,
     const MeshedSurface<Face>& surf
 )
 {
-    fileName baseName = fName.lessExt();
+    fileName baseName = filename.lessExt();
 
     writePoints(OFstream(baseName + ".vrt")(), surf.points());
     OFstream os(baseName + ".cel");
@@ -345,4 +269,45 @@ void Foam::fileFormats::STARCDsurfaceFormat<Face>::write
     );
 }
 
+
+template<class Face>
+void Foam::fileFormats::STARCDsurfaceFormat<Face>::write
+(
+    const fileName& filename,
+    const UnsortedMeshedSurface<Face>& surf
+)
+{
+    fileName baseName = filename.lessExt();
+
+    writePoints(OFstream(baseName + ".vrt")(), surf.points());
+
+    OFstream os(baseName + ".cel");
+    writeHeader(os, "CELL");
+
+    const List<Face>& faceLst = surf.faces();
+    labelList faceMap;
+    List<surfGroup> patchLst = surf.sortedRegions(faceMap);
+
+    label faceIndex = 0;
+    forAll(patchLst, patchI)
+    {
+        const surfGroup& patch = patchLst[patchI];
+
+        forAll(patch, patchFaceI)
+        {
+            const Face& f = faceLst[faceMap[faceIndex++]];
+            writeShell(os, f, faceIndex, patchI + 1);
+        }
+    }
+
+    // write simple .inp file
+    writeCase
+    (
+        OFstream(baseName + ".inp")(),
+        surf.points(),
+        surf.size(),
+        patchLst
+    );
+}
+
 // ************************************************************************* //

src/surfMesh/surfaceFormats/starcd/STARCDsurfaceFormat.H

@@ -62,7 +62,7 @@ namespace fileFormats
 template<class Face>
 class STARCDsurfaceFormat
 :
-    public UnsortedMeshedSurface<Face>,
+    public MeshedSurface<Face>,
     public STARCDsurfaceFormatCore
 {
     // Private Data
@@ -97,15 +97,12 @@ public:
 
     // Selectors
 
-        //- Read file and return keyedSurface
+        //- Read file and return surface
-        static autoPtr<UnsortedMeshedSurface<Face> > New
+        static autoPtr<MeshedSurface<Face> > New(const fileName& name)
-        (
-            const fileName& fName
-        )
         {
-            return autoPtr<UnsortedMeshedSurface<Face> >
+            return autoPtr<MeshedSurface<Face> >
             (
-                new STARCDsurfaceFormat<Face>(fName)
+                new STARCDsurfaceFormat<Face>(name)
             );
         }
 

src/surfMesh/surfaceFormats/starcd/STARCDsurfaceFormatCore.C

@@ -89,6 +89,52 @@ void Foam::fileFormats::STARCDsurfaceFormatCore::writeHeader
 }
 
 
+bool Foam::fileFormats::STARCDsurfaceFormatCore::readPoints
+(
+    IFstream& is,
+    pointField& points,
+    labelList& ids
+)
+{
+    //
+    // read .vrt file
+    // ~~~~~~~~~~~~~~
+
+    if (!is.good())
+    {
+        FatalErrorIn
+        (
+            "fileFormats::STARCDsurfaceFormatCore::readPoints(const fileName&)"
+        )
+            << "Cannot read file " << is.name()
+            << exit(FatalError);
+    }
+
+    readHeader(is, "PROSTAR_VERTEX");
+
+    DynamicList<point> dynPoints;
+    // STAR-CD index of points
+    DynamicList<label> dynPointId;
+
+    label lineLabel;
+    while ((is >> lineLabel).good())
+    {
+        scalar x, y, z;
+
+        is >> x >> y >> z;
+
+        dynPoints.append(point(x, y, z));
+        dynPointId.append(lineLabel);
+    }
+
+    points.transfer(dynPoints);
+    ids.transfer(dynPointId);
+
+    return true;
+}
+
+
+
 void Foam::fileFormats::STARCDsurfaceFormatCore::writePoints
 (
     Ostream& os,

src/surfMesh/surfaceFormats/starcd/STARCDsurfaceFormatCore.H

@@ -61,6 +61,8 @@ protected:
 
     static void writeHeader(Ostream&, const char* filetype);
 
+    static bool readPoints(IFstream&, pointField&, labelList& ids);
+
     static void writePoints(Ostream&, const pointField&);
 
     static void writeCase

src/surfMesh/surfaceFormats/starcd/STARCDsurfaceFormatRunTime.C

@@ -38,7 +38,7 @@ namespace fileFormats
 
 addNamedTemplatedToRunTimeSelectionTable
 (
-    UnsortedMeshedSurface,
+    MeshedSurface,
     STARCDsurfaceFormat,
     face,
     fileExtension,
@@ -46,7 +46,7 @@ addNamedTemplatedToRunTimeSelectionTable
 );
 addNamedTemplatedToRunTimeSelectionTable
 (
-    UnsortedMeshedSurface,
+    MeshedSurface,
     STARCDsurfaceFormat,
     triFace,
     fileExtension,

src/surfMesh/surfaceFormats/stl/STLsurfaceFormat.C

@@ -269,10 +269,10 @@ void Foam::fileFormats::STLsurfaceFormat<Face>::writeBINARY
 template<class Face>
 Foam::fileFormats::STLsurfaceFormat<Face>::STLsurfaceFormat
 (
-    const fileName& fName
+    const fileName& filename
 )
 {
-    read(fName);
+    read(filename);
 }
 
 
@@ -281,13 +281,13 @@ Foam::fileFormats::STLsurfaceFormat<Face>::STLsurfaceFormat
 template<class Face>
 bool Foam::fileFormats::STLsurfaceFormat<Face>::read
 (
-    const fileName& fName
+    const fileName& filename
 )
 {
     this->clear();
 
     // read in the values
-    STLsurfaceFormatCore reader(fName);
+    STLsurfaceFormatCore reader(filename);
 
     // transfer points
     this->storedPoints().transfer(reader.points());
@@ -330,11 +330,11 @@ bool Foam::fileFormats::STLsurfaceFormat<Face>::read
 
     if (names.size())
     {
-        this->addPatches(names, sizes);
+        this->addPatches(sizes, names);
     }
     else
     {
-        this->addPatches(names, sizes);
+        this->addPatches(sizes);
     }
 
     this->stitchFaces(SMALL);
@@ -367,21 +367,21 @@ void Foam::fileFormats::STLsurfaceFormat<Face>::write
 template<class Face>
 void Foam::fileFormats::STLsurfaceFormat<Face>::write
 (
-    const fileName& fName,
+    const fileName& filename,
     const UnsortedMeshedSurface<Face>& surf
 )
 {
-    word ext = fName.ext();
+    word ext = filename.ext();
 
     // handle 'stlb' as binary directly
     if (ext == "stlb")
     {
-        std::ofstream ofs(fName.c_str(), std::ios::binary);
+        std::ofstream ofs(filename.c_str(), std::ios::binary);
         writeBINARY(ofs, surf);
     }
     else
     {
-        writeASCII(OFstream(fName)(), surf);
+        writeASCII(OFstream(filename)(), surf);
     }
 }
 
@@ -389,21 +389,21 @@ void Foam::fileFormats::STLsurfaceFormat<Face>::write
 template<class Face>
 void Foam::fileFormats::STLsurfaceFormat<Face>::write
 (
-    const fileName& fName,
+    const fileName& filename,
     const MeshedSurface<Face>& surf
 )
 {
-    const word ext = fName.ext();
+    const word ext = filename.ext();
 
     // handle 'stlb' as binary directly
     if (ext == "stlb")
     {
-        std::ofstream ofs(fName.c_str(), std::ios::binary);
+        std::ofstream ofs(filename.c_str(), std::ios::binary);
         writeBINARY(ofs, surf);
     }
     else
     {
-        writeASCII(OFstream(fName)(), surf);
+        writeASCII(OFstream(filename)(), surf);
     }
 }
 

src/surfMesh/surfaceFormats/stl/STLsurfaceFormat.H

@@ -111,14 +111,11 @@ public:
     // Selectors
 
         //- Read file and return surface
-        static autoPtr<MeshedSurface<Face> > New
+        static autoPtr<MeshedSurface<Face> > New(const fileName& name)
-        (
-            const fileName& fName
-        )
         {
             return autoPtr<MeshedSurface<Face> >
             (
-                new STLsurfaceFormat<Face>(fName)
+                new STLsurfaceFormat<Face>(name)
             );
         }
 

src/surfMesh/surfaceFormats/stl/STLsurfaceFormatCore.C

@@ -42,12 +42,12 @@ License
 //   is detected ... this is not exactly what we want.
 int Foam::fileFormats::STLsurfaceFormatCore::detectBINARY
 (
-    const fileName& fName
+    const fileName& filename
 )
 {
-    off_t fileSize = Foam::size(fName);
+    off_t fileSize = Foam::size(filename);
 
-    IFstream ifs(fName, IOstream::BINARY);
+    IFstream ifs(filename, IOstream::BINARY);
     istream& is = ifs.stdStream();
 
     // Read the STL header
@@ -215,7 +215,7 @@ bool Foam::fileFormats::STLsurfaceFormatCore::readBINARY
 
 Foam::fileFormats::STLsurfaceFormatCore::STLsurfaceFormatCore
 (
-    const fileName& fName
+    const fileName& filename
 )
 :
     sorted_(true),
@@ -224,16 +224,16 @@ Foam::fileFormats::STLsurfaceFormatCore::STLsurfaceFormatCore
     names_(0),
     sizes_(0)
 {
-    off_t fileSize = Foam::size(fName);
+    off_t fileSize = Foam::size(filename);
 
     // auto-detect ascii/binary
-    if (detectBINARY(fName))
+    if (detectBINARY(filename))
     {
-        readBINARY(IFstream(fName, IOstream::BINARY)(), fileSize);
+        readBINARY(IFstream(filename, IOstream::BINARY)(), fileSize);
     }
     else
     {
-        readASCII(IFstream(fName)(), fileSize);
+        readASCII(IFstream(filename)(), fileSize);
     }
 }
 

src/surfMesh/surfaceFormats/surfaceFormatsCore.C

@@ -186,53 +186,53 @@ Foam::fileFormats::surfaceFormatsCore::sortedPatchRegions
     // number of items, just do it ourselves
 
     // step 1: get region sizes and store (regionId => patchI)
-    Map<label> regionLookup;
+    Map<label> lookup;
     forAll(regionLst, faceI)
     {
         const label regId = regionLst[faceI];
 
-        Map<label>::iterator iter = regionLookup.find(regId);
+        Map<label>::iterator fnd = lookup.find(regId);
-        if (iter == regionLookup.end())
+        if (fnd != lookup.end())
         {
-            regionLookup.insert(regId, 1);
+            fnd()++;
         }
         else
         {
-            iter()++;
+            lookup.insert(regId, 1);
         }
     }
 
     // step 2: assign start/size (and name) to the newPatches
     // re-use the lookup to map (regionId => patchI)
-    surfGroupList patchLst(regionLookup.size());
+    surfGroupList patchLst(lookup.size());
-    label patchStart = 0;
+    label start = 0;
     label patchI = 0;
-    forAllIter(Map<label>, regionLookup, iter)
+    forAllIter(Map<label>, lookup, iter)
     {
         label regId = iter.key();
 
-        word patchName;
+        word name;
-        Map<word>::const_iterator iter2 = patchNames.find(regId);
+        Map<word>::const_iterator fnd = patchNames.find(regId);
-        if (iter2 == patchNames.end())
+        if (fnd != patchNames.end())
         {
-            patchName = word("patch") + ::Foam::name(patchI);
+            name = fnd();
         }
         else
         {
-            patchName = iter2();
+            name = word("patch") + ::Foam::name(patchI);
         }
 
         patchLst[patchI] = surfGroup
         (
-            patchName,
+            name,
             0,           // initialize with zero size
-            patchStart,
+            start,
             patchI
         );
 
         // increment the start for the next patch
         // and save the (regionId => patchI) mapping
-        patchStart += iter();
+        start += iter();
         iter() = patchI++;
     }
 
@@ -242,7 +242,7 @@ Foam::fileFormats::surfaceFormatsCore::sortedPatchRegions
 
     forAll(regionLst, faceI)
     {
-        label patchI = regionLookup[regionLst[faceI]];
+        label patchI = lookup[regionLst[faceI]];
         faceMap[faceI] = patchLst[patchI].start() + patchLst[patchI].size()++;
     }
 
@@ -260,7 +260,6 @@ Foam::fileFormats::surfaceFormatsCore::checkSupport
     const word& functionName
 )
 {
-
     if (available.found(ext))
     {
         return true;

src/surfMesh/surfaceFormats/tri/TRIsurfaceFormat.C

@@ -64,10 +64,10 @@ inline void Foam::fileFormats::TRIsurfaceFormat<Face>::writeShell
 template<class Face>
 Foam::fileFormats::TRIsurfaceFormat<Face>::TRIsurfaceFormat
 (
-    const fileName& fName
+    const fileName& filename
 )
 {
-    read(fName);
+    read(filename);
 }
 
 
@@ -76,13 +76,13 @@ Foam::fileFormats::TRIsurfaceFormat<Face>::TRIsurfaceFormat
 template<class Face>
 bool Foam::fileFormats::TRIsurfaceFormat<Face>::read
 (
-    const fileName& fName
+    const fileName& filename
 )
 {
     this->clear();
 
     // read in the values
-    TRIsurfaceFormatCore reader(fName);
+    TRIsurfaceFormatCore reader(filename);
 
     // transfer points
     this->storedPoints().transfer(reader.points());

src/surfMesh/surfaceFormats/tri/TRIsurfaceFormat.H

@@ -88,14 +88,11 @@ public:
     // Selectors
 
         //- Read file and return surface
-        static autoPtr<MeshedSurface<Face> > New
+        static autoPtr<MeshedSurface<Face> > New(const fileName& name)
-        (
-            const fileName& fName
-        )
         {
             return autoPtr<MeshedSurface<Face> >
             (
-                new TRIsurfaceFormat<Face>(fName)
+                new TRIsurfaceFormat<Face>(name)
             );
         }
 
@@ -118,11 +115,11 @@ public:
         //- Write MeshedSurface
         static void write
         (
-            const fileName& fName,
+            const fileName& name,
             const MeshedSurface<Face>& surf
         )
         {
-            write(OFstream(fName)(), surf);
+            write(OFstream(name)(), surf);
         }
 
         //- Write UnsortedMeshedSurface
@@ -137,11 +134,11 @@ public:
         //  By default, the output is not sorted by regions
         static void write
         (
-            const fileName& fName,
+            const fileName& name,
             const UnsortedMeshedSurface<Face>& surf
         )
         {
-            write(OFstream(fName)(), surf);
+            write(OFstream(name)(), surf);
         }
 
         //- Write object

src/surfMesh/surfaceFormats/tri/TRIsurfaceFormatCore.C

@@ -38,7 +38,7 @@ License
 
 Foam::fileFormats::TRIsurfaceFormatCore::TRIsurfaceFormatCore
 (
-    const fileName& fName
+    const fileName& filename
 )
 :
     sorted_(true),
@@ -46,7 +46,7 @@ Foam::fileFormats::TRIsurfaceFormatCore::TRIsurfaceFormatCore
     regions_(0),
     sizes_(0)
 {
-    read(fName);
+    read(filename);
 }
 
 // * * * * * * * * * * * * * * * * Destructors * * * * * * * * * * * * * * * //
@@ -59,20 +59,20 @@ Foam::fileFormats::TRIsurfaceFormatCore::~TRIsurfaceFormatCore()
 
 bool Foam::fileFormats::TRIsurfaceFormatCore::read
 (
-    const fileName& fName
+    const fileName& filename
 )
 {
     this->clear();
     sorted_ = true;
 
-    IFstream is(fName);
+    IFstream is(filename);
     if (!is.good())
     {
         FatalErrorIn
         (
             "fileFormats::TRIsurfaceFormatCore::read(const fileName&)"
         )
-            << "Cannot read file " << fName
+            << "Cannot read file " << filename
             << exit(FatalError);
     }
 
@@ -161,19 +161,25 @@ bool Foam::fileFormats::TRIsurfaceFormatCore::read
         dynSizes[regionI]++;
     }
 
+    // skip empty groups
+    label nPatch = 0;
+    forAll(dynSizes, patchI)
+    {
+        if (dynSizes[patchI])
+        {
+            if (nPatch != patchI)
+            {
+                dynSizes[nPatch] = dynSizes[patchI];
+            }
+            nPatch++;
+        }
+    }
+    dynSizes.setSize(nPatch);
+
     // transfer to normal lists
     points_.transfer(dynPoints);
     regions_.transfer(dynRegions);
-
-    if (dynSizes[0] == 0)
-    {
-        // no ungrouped patches, copy sub-list
-        sizes_ = SubList<label>(dynSizes, dynSizes.size()-1, 1);
-    }
-    else
-    {
     sizes_.transfer(dynSizes);
-    }
 
     return true;
 }

src/surfMesh/surfaceFormats/vtk/VTKsurfaceFormat.C

@@ -58,72 +58,6 @@ Foam::fileFormats::VTKsurfaceFormat<Face>::VTKsurfaceFormat()
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
-template<class Face>
-void Foam::fileFormats::VTKsurfaceFormat<Face>::write
-(
-    Ostream& os,
-    const UnsortedMeshedSurface<Face>& surf
-)
-{
-    const List<Face>& faceLst = surf.faces();
-
-    writeHeader(os, surf.points());
-    writeHeaderPolygons(os, faceLst);
-
-    bool doSort = false;
-    // a single region needs no sorting
-    if (surf.patches().size() == 1)
-    {
-        doSort = false;
-    }
-
-    if (doSort)
-    {
-        labelList faceMap;
-        List<surfGroup> patchLst = surf.sortedRegions(faceMap);
-
-        label faceIndex = 0;
-        forAll(patchLst, patchI)
-        {
-            forAll(patchLst[patchI], patchFaceI)
-            {
-                const Face& f = faceLst[faceMap[faceIndex++]];
-
-                os << f.size();
-                forAll(f, fp)
-                {
-                    os << ' ' << f[fp];
-                }
-                os << ' ' << nl;
-            }
-        }
-
-        // Print region numbers
-        writeTail(os, patchLst);
-    }
-    else
-    {
-        labelList faceMap;
-        List<surfGroup> patchLst = surf.sortedRegions(faceMap);
-
-        forAll(faceLst, faceI)
-        {
-            const Face& f = faceLst[faceI];
-
-            os << f.size();
-            forAll(f, fp)
-            {
-                os << ' ' << f[fp];
-            }
-            os << ' ' << nl;
-        }
-
-        // Print region numbers
-        writeTail(os, surf.regions());
-    }
-}
-
-
 template<class Face>
 void Foam::fileFormats::VTKsurfaceFormat<Face>::write
 (
@@ -157,4 +91,34 @@ void Foam::fileFormats::VTKsurfaceFormat<Face>::write
     writeTail(os, patchLst);
 }
 
+
+template<class Face>
+void Foam::fileFormats::VTKsurfaceFormat<Face>::write
+(
+    Ostream& os,
+    const UnsortedMeshedSurface<Face>& surf
+)
+{
+    const List<Face>& faceLst = surf.faces();
+
+    writeHeader(os, surf.points());
+    writeHeaderPolygons(os, faceLst);
+
+    forAll(faceLst, faceI)
+    {
+        const Face& f = faceLst[faceI];
+
+        os << f.size();
+        forAll(f, fp)
+        {
+            os << ' ' << f[fp];
+        }
+        os << ' ' << nl;
+    }
+
+    // Print region numbers
+    writeTail(os, surf.regions());
+}
+
+
 // ************************************************************************* //

src/surfMesh/surfaceFormats/vtk/VTKsurfaceFormat.H

@@ -27,6 +27,7 @@ Class
 
 Description
     Provide a means of writing VTK legacy format.
+    The output is never sorted by patch.
 
 SourceFiles
     VTKsurfaceFormat.C
@@ -56,7 +57,7 @@ namespace fileFormats
 template<class Face>
 class VTKsurfaceFormat
 :
-    public UnsortedMeshedSurface<Face>,
+    public MeshedSurface<Face>,
     public VTKsurfaceFormatCore
 {
     // Private Member Functions
@@ -98,15 +99,15 @@ public:
         //- Write MeshedSurface
         static void write
         (
-            const fileName& fName,
+            const fileName& name,
             const MeshedSurface<Face>& surf
         )
         {
-            write(OFstream(fName)(), surf);
+            write(OFstream(name)(), surf);
         }
 
         //- Write UnsortedMeshedSurface
-        //  By default, the output is not sorted by regions.
+        //  The output remains unsorted
         static void write
         (
             Ostream&,
@@ -114,14 +115,14 @@ public:
         );
 
         //- Write UnsortedMeshedSurface
-        //  By default, the output is not sorted by regions.
+        //  The output remains unsorted
         static void write
         (
-            const fileName& fName,
+            const fileName& name,
             const UnsortedMeshedSurface<Face>& surf
         )
         {
-            write(OFstream(fName)(), surf);
+            write(OFstream(name)(), surf);
         }
 
         //- Write object