diff --git a/applications/utilities/surface/surfaceMeshConvertTesting/surfaceMeshConvertTesting.C b/applications/utilities/surface/surfaceMeshConvertTesting/surfaceMeshConvertTesting.C
index ccd85d8e5a..daece06c1d 100644
--- a/applications/utilities/surface/surfaceMeshConvertTesting/surfaceMeshConvertTesting.C
+++ b/applications/utilities/surface/surfaceMeshConvertTesting/surfaceMeshConvertTesting.C
@@ -271,13 +271,40 @@ int main(int argc, char *argv[])
                 args.caseName()
             );
 
+            // start with "constant"
+            runTime.setTime(instant(0, runTime.constant()), 0);
+
+            Info<< "runTime.instance() = " << runTime.instance() << endl;
+            Info<< "runTime.timeName() = " << runTime.timeName() << endl;
+
+
+            surfMesh surfIn
+            (
+                IOobject
+                (
+                    "default",
+                    runTime.timeName(),
+                    runTime,
+                    IOobject::MUST_READ,
+                    IOobject::NO_WRITE
+                )
+            );
+
+
+            Info<< "surfIn = " << surfIn.nFaces() << endl;
+
+            Info<< "runTime.instance() = " << runTime.instance() << endl;
+
             surfMesh surfOut
             (
                 IOobject
                 (
                     "mySurf",
                     runTime.instance(),
-                    runTime
+                    runTime,
+                    IOobject::NO_READ,
+                    IOobject::NO_WRITE,
+                    false
                 ),
                 surf.xfer()
             );
@@ -299,6 +326,25 @@ int main(int argc, char *argv[])
                 dimless
             );
 
+            Info<<" surf name= " << surfOut.name() <<nl;
+            Info<< "rename to anotherSurf" << endl;
+            surfOut.rename("anotherSurf");
+
+            Info<<" surf name= " << surfOut.name() <<nl;
+
+            // advance time to 1
+            runTime.setTime(instant(1), 1);
+            surfOut.setInstance(runTime.timeName());
+
+
+
+            Info<< "writing surfMesh again well: " << surfOut.objectPath() << endl;
+            surfOut.write();
+
+            // write directly
+            surfOut.write("someName.ofs");
+
+#if 1
             const surfZoneList& zones = surfOut.surfZones();
             forAll(zones, zoneI)
             {
@@ -318,9 +364,10 @@ int main(int argc, char *argv[])
             (
                 IOobject
                 (
-                    "pointIds",
+                    "zoneIds.",
+//                    "pointIds",
                     surfOut.instance(),
-                    "pointFields",
+//                    "pointFields",
                     surfOut,
                     IOobject::NO_READ,
                     IOobject::NO_WRITE
@@ -337,6 +384,10 @@ int main(int argc, char *argv[])
             Info<< "write pointIds (for testing only): "
                 << pointIds.objectPath() << endl;
             pointIds.write();
+
+            Info<<"surfMesh with these names: " << surfOut.names() << endl;
+
+#endif
         }
     }
 
diff --git a/src/sampling/cuttingPlane/cuttingPlane.H b/src/sampling/cuttingPlane/cuttingPlane.H
index b7e31ef906..6804a9ab18 100644
--- a/src/sampling/cuttingPlane/cuttingPlane.H
+++ b/src/sampling/cuttingPlane/cuttingPlane.H
@@ -62,10 +62,10 @@ class primitiveMesh;
 class cuttingPlane
 :
     public plane,
-    public BasicMeshedSurface<face>
+    public MeshedSurface<face>
 {
     //- Private typedefs for convenience
-        typedef BasicMeshedSurface<face> MeshStorage;
+        typedef MeshedSurface<face> MeshStorage;
 
     // Private data
 
diff --git a/src/sampling/sampledSurface/sampledPatch/sampledPatch.H b/src/sampling/sampledSurface/sampledPatch/sampledPatch.H
index fbc0b56ebe..2890a7bd34 100644
--- a/src/sampling/sampledSurface/sampledPatch/sampledPatch.H
+++ b/src/sampling/sampledSurface/sampledPatch/sampledPatch.H
@@ -50,11 +50,11 @@ namespace Foam
 
 class sampledPatch
 :
-    public BasicMeshedSurface<face>,
+    public MeshedSurface<face>,
     public sampledSurface
 {
     //- Private typedefs for convenience
-        typedef BasicMeshedSurface<face> MeshStorage;
+        typedef MeshedSurface<face> MeshStorage;
 
     // Private data
 
diff --git a/src/surfMesh/BasicMeshedSurface/BasicMeshedSurface.C b/src/surfMesh/BasicMeshedSurface/BasicMeshedSurface.C
deleted file mode 100644
index 41295b44b6..0000000000
--- a/src/surfMesh/BasicMeshedSurface/BasicMeshedSurface.C
+++ /dev/null
@@ -1,572 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 1991-2009 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 "BasicMeshedSurface.H"
-#include "boundBox.H"
-#include "mergePoints.H"
-
-// * * * * * * * * * * * * * Static Member Functions * * * * * * * * * * * * //
-
-template<class Face>
-inline bool Foam::BasicMeshedSurface<Face>::isTri()
-{
-    return false;
-}
-
-
-// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
-
-template<class Face>
-Foam::BasicMeshedSurface<Face>::BasicMeshedSurface()
-:
-    ParentType(List<Face>(), pointField())
-{}
-
-
-template<class Face>
-Foam::BasicMeshedSurface<Face>::BasicMeshedSurface
-(
-    const Xfer< pointField >& pointLst,
-    const Xfer< List<Face> >& faceLst
-)
-:
-    ParentType(List<Face>(), pointField())
-{
-    reset(pointLst, faceLst);
-}
-
-
-// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
-
-template<class Face>
-Foam::BasicMeshedSurface<Face>::~BasicMeshedSurface()
-{}
-
-
-// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
-
-template<class Face>
-void Foam::BasicMeshedSurface<Face>::clear()
-{
-    ParentType::clearOut();
-
-    storedPoints().clear();
-    storedFaces().clear();
-}
-
-
-template<class Face>
-void Foam::BasicMeshedSurface<Face>::movePoints(const pointField& newPoints)
-{
-    // Remove all geometry dependent data
-    ParentType::clearTopology();
-
-    // Adapt for new point position
-    ParentType::movePoints(newPoints);
-
-    // Copy new points
-    storedPoints() = newPoints;
-}
-
-
-template<class Face>
-void Foam::BasicMeshedSurface<Face>::scalePoints(const scalar& scaleFactor)
-{
-    // avoid bad scaling
-    if (scaleFactor > 0 && scaleFactor != 1.0)
-    {
-        // Remove all geometry dependent data
-        ParentType::clearTopology();
-
-        // Adapt for new point position
-        ParentType::movePoints(pointField());
-
-        storedPoints() *= scaleFactor;
-    }
-}
-
-
-template<class Face>
-void Foam::BasicMeshedSurface<Face>::reset
-(
-    const Xfer< pointField >& pointLst,
-    const Xfer< List<Face> >& faceLst
-)
-{
-    ParentType::clearOut();
-
-    // Take over new primitive data.
-    // Optimized to avoid overwriting data at all
-    if (&pointLst)
-    {
-        storedPoints().transfer(pointLst());
-    }
-
-    if (&faceLst)
-    {
-        storedFaces().transfer(faceLst());
-    }
-}
-
-
-template<class Face>
-void Foam::BasicMeshedSurface<Face>::reset
-(
-    const Xfer< List<point> >& pointLst,
-    const Xfer< List<Face> >& faceLst
-)
-{
-    ParentType::clearOut();
-
-    // Take over new primitive data.
-    // Optimized to avoid overwriting data at all
-    if (&pointLst)
-    {
-        storedPoints().transfer(pointLst());
-    }
-
-    if (&faceLst)
-    {
-        storedFaces().transfer(faceLst());
-    }
-}
-
-
-// Remove badly degenerate faces, double faces.
-template<class Face>
-void Foam::BasicMeshedSurface<Face>::cleanup(const bool verbose)
-{
-    // merge points (already done for STL, TRI)
-    stitchFaces(SMALL, verbose);
-
-    checkFaces(verbose);
-    this->checkTopology(verbose);
-}
-
-
-template<class Face>
-bool Foam::BasicMeshedSurface<Face>::stitchFaces
-(
-    const scalar tol,
-    const bool verbose
-)
-{
-    pointField& pointLst = this->storedPoints();
-
-    // Merge points
-    labelList  pointMap(pointLst.size());
-    pointField newPoints(pointLst.size());
-
-    bool hasMerged = mergePoints(pointLst, tol, verbose, pointMap, newPoints);
-
-    if (!hasMerged)
-    {
-        return false;
-    }
-
-    if (verbose)
-    {
-        Info<< "BasicMeshedSurface::stitchFaces : Renumbering all faces"
-            << endl;
-    }
-
-    // Set the coordinates to the merged ones
-    pointLst.transfer(newPoints);
-
-    List<Face>& faceLst = this->storedFaces();
-
-    List<label> faceMap(faceLst.size());
-
-    // Reset the point labels to the unique points array
-    label newFaceI = 0;
-    forAll(faceLst, faceI)
-    {
-        Face& f = faceLst[faceI];
-        forAll(f, fp)
-        {
-            f[fp] = pointMap[f[fp]];
-        }
-
-        // for extra safety: collapse face as well
-        if (f.collapse() >= 3)
-        {
-            if (newFaceI != faceI)
-            {
-                faceLst[newFaceI] = f;
-            }
-            faceMap[newFaceI] = faceI;
-            newFaceI++;
-        }
-        else if (verbose)
-        {
-            Pout<< "BasicMeshedSurface::stitchFaces : "
-                << "Removing collapsed face " << faceI << endl
-                << "    vertices   :" << f << endl;
-        }
-    }
-    pointMap.clear();
-
-    if (newFaceI != faceLst.size())
-    {
-        if (verbose)
-        {
-            Pout<< "BasicMeshedSurface::stitchFaces : "
-                << "Removed " << faceLst.size() - newFaceI
-                << " faces" << endl;
-        }
-        faceLst.setSize(newFaceI);
-        remapFaces(faceMap);
-    }
-    faceMap.clear();
-
-    // Merging points might have changed geometric factors
-    ParentType::clearOut();
-    return true;
-}
-
-
-// Remove badly degenerate faces and double faces.
-template<class Face>
-bool Foam::BasicMeshedSurface<Face>::checkFaces
-(
-    const bool verbose
-)
-{
-    bool changed = false;
-    List<Face>& faceLst = this->storedFaces();
-
-    List<label> faceMap(faceLst.size());
-
-    label newFaceI = 0;
-    // Detect badly labelled faces and mark degenerate faces
-    const label maxPointI = this->points().size() - 1;
-    forAll(faceLst, faceI)
-    {
-        Face& f = faceLst[faceI];
-
-        // avoid degenerate faces
-        if (f.collapse() >= 3)
-        {
-            forAll(f, fp)
-            {
-                if (f[fp] < 0 || f[fp] > maxPointI)
-                {
-                    FatalErrorIn("BasicMeshedSurface::checkFaces(bool)")
-                        << "face " << f
-                        << " uses point indices outside point range 0.."
-                    << maxPointI
-                        << exit(FatalError);
-                }
-            }
-
-            faceMap[faceI] = faceI;
-            newFaceI++;
-        }
-        else
-        {
-            // mark as bad face
-            faceMap[faceI] = -1;
-
-            changed = true;
-            if (verbose)
-            {
-                WarningIn
-                (
-                    "BasicMeshedSurface::checkFaces(bool verbose)"
-                )   << "face[" << faceI << "] = " << f
-                    << " does not have three unique vertices" << endl;
-            }
-        }
-    }
-
-    // Detect doubled faces
-    // do not touch the faces
-    const labelListList& fFaces = this->faceFaces();
-    newFaceI = 0;
-    forAll(faceLst, faceI)
-    {
-        // skip already collapsed faces:
-        if (faceMap[faceI] < 0)
-        {
-            continue;
-        }
-
-        const Face& f = faceLst[faceI];
-
-        // duplicate face check
-        bool okay = true;
-        const labelList& neighbours = fFaces[faceI];
-
-        // Check if faceNeighbours use same points as this face.
-        // Note: discards normal information - sides of baffle are merged.
-        forAll(neighbours, neighI)
-        {
-            const label neiFaceI = neighbours[neighI];
-
-            if (neiFaceI <= faceI || faceMap[neiFaceI] < 0)
-            {
-                // lower numbered faces already checked
-                // skip neighbours that are themselves collapsed
-                continue;
-            }
-
-            const Face& nei = faceLst[neiFaceI];
-
-            if (f == nei)
-            {
-                okay = false;
-
-                if (verbose)
-                {
-                    WarningIn
-                    (
-                        "BasicMeshedSurface::checkFaces(bool verbose)"
-                    )   << "faces share the same vertices:" << nl
-                        << "    face[" << faceI << "] : " << f << nl
-                        << "    face[" << neiFaceI << "] : " << nei << endl;
-                    // printFace(Warning, "    ", f, points());
-                    // printFace(Warning, "    ", nei, points());
-                }
-
-                break;
-            }
-        }
-
-        if (okay)
-        {
-            faceMap[faceI] = faceI;
-            newFaceI++;
-        }
-        else
-        {
-            faceMap[faceI] = -1;
-        }
-    }
-
-    // Phase 1: pack
-    // Done to keep numbering constant in phase 1
-
-    if (changed || newFaceI < faceLst.size())
-    {
-        changed = true;
-
-        if (verbose)
-        {
-            WarningIn
-            (
-                "BasicMeshedSurface::checkFaces(bool verbose)"
-            )   << "Removed " << faceLst.size() - newFaceI
-                << " illegal faces." << endl;
-        }
-
-        // compress the face list
-        newFaceI = 0;
-        forAll(faceLst, faceI)
-        {
-            if (faceMap[faceI] >= 0)
-            {
-                if (newFaceI != faceI)
-                {
-                    faceLst[newFaceI] = faceLst[faceI];
-                }
-                faceMap[newFaceI] = faceI;
-                newFaceI++;
-            }
-        }
-
-        faceLst.setSize(newFaceI);
-        remapFaces(faceMap);
-    }
-    faceMap.clear();
-
-    // Topology can change because of renumbering
-    ParentType::clearOut();
-    return changed;
-}
-
-
-template<class Face>
-Foam::label Foam::BasicMeshedSurface<Face>::triangulate()
-{
-    return triangulate
-    (
-        const_cast<List<label>&>(List<label>::null())
-    );
-}
-
-
-template<class Face>
-Foam::label Foam::BasicMeshedSurface<Face>::triangulate
-(
-    List<label>& faceMapOut
-)
-{
-    label nTri = 0;
-    label maxTri = 0;  // the maximum number of triangles for any single face
-    List<Face>& faceLst = this->storedFaces();
-
-    // determine how many triangles will be needed
-    forAll(faceLst, faceI)
-    {
-        const label n = faceLst[faceI].nTriangles();
-        if (maxTri < n)
-        {
-            maxTri = n;
-        }
-        nTri += n;
-    }
-
-    // nothing to do
-    if (nTri <= faceLst.size())
-    {
-        if (&faceMapOut)
-        {
-            faceMapOut.clear();
-        }
-        return 0;
-    }
-
-    List<Face>  newFaces(nTri);
-    List<label> faceMap;
-
-    // reuse storage from optional faceMap
-    if (&faceMapOut)
-    {
-        faceMap.transfer(faceMapOut);
-    }
-    faceMap.setSize(nTri);
-
-    // remember the number of *additional* faces
-    nTri -= faceLst.size();
-
-    if (this->points().empty())
-    {
-        // triangulate without points
-        // simple face triangulation around f[0]
-        label newFaceI = 0;
-        forAll(faceLst, faceI)
-        {
-            const Face& f = faceLst[faceI];
-
-            for (label fp = 1; fp < f.size() - 1; ++fp)
-            {
-                label fp1 = f.fcIndex(fp);
-
-                newFaces[newFaceI] = triFace(f[0], f[fp], f[fp1]);
-                faceMap[newFaceI] = faceI;
-                newFaceI++;
-            }
-        }
-    }
-    else
-    {
-        // triangulate with points
-        List<face> tmpTri(maxTri);
-
-        label newFaceI = 0;
-        forAll(faceLst, faceI)
-        {
-            // 'face' not '<Face>'
-            const face& f = faceLst[faceI];
-
-            label nTmp;
-            f.triangles(this->points(), nTmp, tmpTri);
-            for (label triI = 0; triI < nTmp; triI++)
-            {
-                newFaces[newFaceI] = Face
-                (
-                    static_cast<UList<label>&>(tmpTri[triI])
-                );
-                faceMap[newFaceI] = faceI;
-                newFaceI++;
-            }
-        }
-    }
-
-    faceLst.transfer(newFaces);
-    remapFaces(faceMap);
-
-    // optionally return the faceMap
-    if (&faceMapOut)
-    {
-        faceMapOut.transfer(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::BasicMeshedSurface<Face>::remapFaces(const UList<label>&)
-{
-}
-
-
-template<class Face>
-void Foam::BasicMeshedSurface<Face>::writeStats(Ostream& os) const
-{
-    os  << "points      : " << this->points().size() << nl;
-    if (this->isTri())
-    {
-        os << "triangles   : " << this->size() << nl;
-    }
-    else
-    {
-        label nTri = 0;
-        label nQuad = 0;
-        forAll(*this, i)
-        {
-            const label n = this->operator[](i).size();
-
-            if (n == 3)
-            {
-                nTri++;
-            }
-            else if (n == 4)
-            {
-                nQuad++;
-            }
-        }
-
-        os  << "faces       : " << this->size()
-            << "  (tri:" << nTri << " quad:" << nQuad
-            << " poly:" << (this->size() - nTri - nQuad ) << ")" << nl;
-    }
-
-    os  << "boundingBox : " << boundBox(this->points()) << endl;
-}
-
-// * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
-
-// * * * * * * * * * * * * * * * IOstream Operators  * * * * * * * * * * * * //
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-// ************************************************************************* //
diff --git a/src/surfMesh/BasicMeshedSurface/BasicMeshedSurface.H b/src/surfMesh/BasicMeshedSurface/BasicMeshedSurface.H
deleted file mode 100644
index ab60baf93d..0000000000
--- a/src/surfMesh/BasicMeshedSurface/BasicMeshedSurface.H
+++ /dev/null
@@ -1,223 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 1991-2009 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
-
-Class
-    Foam::BasicMeshedSurface
-
-Description
-    Holds surfaces without any zone information
-
-SourceFiles
-    BasicMeshedSurface.C
-
-\*---------------------------------------------------------------------------*/
-
-#ifndef BasicMeshedSurface_H
-#define BasicMeshedSurface_H
-
-#include "PrimitivePatch.H"
-#include "PatchTools.H"
-#include "pointField.H"
-#include "face.H"
-#include "triFace.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-namespace Foam
-{
-
-// Forward declaration of friend functions and operators
-
-/*---------------------------------------------------------------------------*\
-                     Class BasicMeshedSurface Declaration
-\*---------------------------------------------------------------------------*/
-
-template<class Face>
-class BasicMeshedSurface
-:
-    public PrimitivePatch<Face, ::Foam::List, pointField, point>
-{
-
-    // Private typedefs
-
-        typedef PrimitivePatch
-        <
-            Face,
-            ::Foam::List,
-            pointField,
-            point
-        >
-        ParentType;
-
-protected:
-
-    // Protected Member Functions
-
-        //- Non-const access to global points
-        pointField& storedPoints()
-        {
-            return const_cast<pointField&>(ParentType::points());
-        }
-
-        //- Non-const access to the faces
-        List<Face>& storedFaces()
-        {
-            return static_cast<List<Face> &>(*this);
-        }
-
-        //- Set new zones from faceMap
-        virtual void remapFaces(const UList<label>& faceMap);
-
-public:
-
-    // Static
-
-        //- Face storage only handles triangulated faces
-        inline static bool isTri();
-
-
-    // Constructors
-
-        //- Construct null
-        BasicMeshedSurface();
-
-        //- Construct by transferring components (points, faces).
-        BasicMeshedSurface
-        (
-            const Xfer< pointField >&,
-            const Xfer< List<Face> >&
-        );
-
-    // Destructor
-
-        virtual ~BasicMeshedSurface();
-
-    // Member Functions
-
-    // Access
-
-        //- Return const access to the faces
-        inline const List<Face>& faces() const
-        {
-            return static_cast<const List<Face> &>(*this);
-        }
-
-    // Edit
-
-        //- Clear all storage
-        virtual void clear();
-
-        //- Move points
-        virtual void movePoints(const pointField&);
-
-        //- Scale points. A non-positive factor is ignored
-        virtual void scalePoints(const scalar&);
-
-        //- Transfer components (points, faces).
-        virtual void reset
-        (
-            const Xfer< pointField >&,
-            const Xfer< List<Face> >&
-        );
-
-        //- Transfer components (points, faces).
-        virtual void reset
-        (
-            const Xfer< List<point> >&,
-            const Xfer< List<Face> >&
-        );
-
-        //- Remove invalid faces
-        virtual void cleanup(const bool verbose);
-
-        virtual bool stitchFaces
-        (
-            const scalar tol=SMALL,
-            const bool verbose=false
-        );
-
-        virtual bool checkFaces
-        (
-            const bool verbose=false
-        );
-
-        //- Triangulate in-place, returning the number of triangles added
-        virtual label triangulate();
-
-        //- Triangulate in-place, returning the number of triangles added
-        //  and setting a map of original face Ids.
-        //  The faceMap is zero-sized when no triangulation was done.
-        virtual label triangulate(List<label>& faceMap);
-
-
-    // Write
-
-        void writeStats(Ostream& os) const;
-
-};
-
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-//- Specialization for holding triangulated information
-template<>
-inline bool BasicMeshedSurface<triFace>::isTri()
-{
-    return true;
-}
-
-//- Specialization for holding triangulated information
-template<>
-inline label BasicMeshedSurface<triFace>::triangulate()
-{
-    return 0;
-}
-
-//- Specialization for holding triangulated information
-template<>
-inline label BasicMeshedSurface<triFace>::triangulate(List<label>& faceMap)
-{
-    if (&faceMap)
-    {
-        faceMap.clear();
-    }
-
-    return 0;
-}
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#ifdef NoRepository
-#   include "BasicMeshedSurface.C"
-#endif
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#endif
-
-// ************************************************************************* //
diff --git a/src/surfMesh/Make/files b/src/surfMesh/Make/files
index 2a51d95fbf..63fecec718 100644
--- a/src/surfMesh/Make/files
+++ b/src/surfMesh/Make/files
@@ -2,16 +2,20 @@ surfZone/surfZone/surfZone.C
 surfZone/surfZone/surfZoneIOList.C
 surfZone/surfZoneIdentifier/surfZoneIdentifier.C
 
+MeshedSurfaceAllocator/MeshedSurfaceIOAllocator.C
+
 MeshedSurface/MeshedSurfaceCore.C
 MeshedSurface/MeshedSurfaces.C
 UnsortedMeshedSurface/UnsortedMeshedSurfaces.C
 
+MeshedSurfaceProxy/MeshedSurfaceProxyCore.C
+
 surfaceRegistry/surfaceRegistry.C
-surfFields/surfFields.C
-surfPointFields/surfPointFields.C
 surfMesh/surfMesh.C
 surfMesh/surfMeshClear.C
 surfMesh/surfMeshIO.C
+surfFields/surfFields/surfFields.C
+surfFields/surfPointFields/surfPointFields.C
 
 surfaceFormats = surfaceFormats
 $(surfaceFormats)/surfaceFormatsCore.C
@@ -22,11 +26,10 @@ $(surfaceFormats)/ftr/FTRsurfaceFormatRunTime.C
 $(surfaceFormats)/gts/GTSsurfaceFormatRunTime.C
 $(surfaceFormats)/nas/NASsurfaceFormatCore.C
 $(surfaceFormats)/nas/NASsurfaceFormatRunTime.C
-$(surfaceFormats)/obj/OBJsurfaceFormatCore.C
 $(surfaceFormats)/obj/OBJsurfaceFormatRunTime.C
-$(surfaceFormats)/off/OFFsurfaceFormatCore.C
 $(surfaceFormats)/off/OFFsurfaceFormatRunTime.C
-$(surfaceFormats)/smesh/SMESHsurfaceFormatCore.C
+$(surfaceFormats)/ofs/OFSsurfaceFormatCore.C
+$(surfaceFormats)/ofs/OFSsurfaceFormatRunTime.C
 $(surfaceFormats)/smesh/SMESHsurfaceFormatRunTime.C
 $(surfaceFormats)/starcd/STARCDsurfaceFormatCore.C
 $(surfaceFormats)/starcd/STARCDsurfaceFormatRunTime.C
diff --git a/src/surfMesh/MeshedSurface/MeshedSurface.C b/src/surfMesh/MeshedSurface/MeshedSurface.C
index b446f3c0ef..0a1440ff1f 100644
--- a/src/surfMesh/MeshedSurface/MeshedSurface.C
+++ b/src/surfMesh/MeshedSurface/MeshedSurface.C
@@ -26,6 +26,8 @@ License
 
 #include "MeshedSurface.H"
 #include "UnsortedMeshedSurface.H"
+#include "MeshedSurfaceProxy.H"
+#include "mergePoints.H"
 #include "IFstream.H"
 #include "OFstream.H"
 #include "Time.H"
@@ -38,6 +40,13 @@ License
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
+template<class Face>
+inline bool Foam::MeshedSurface<Face>::isTri()
+{
+    return false;
+}
+
+
 template<class Face>
 Foam::wordHashSet Foam::MeshedSurface<Face>::readTypes()
 {
@@ -61,21 +70,13 @@ bool Foam::MeshedSurface<Face>::canReadType
     const bool verbose
 )
 {
-    // handle 'native' format directly
-    if (isNative(ext))
-    {
-        return true;
-    }
-    else
-    {
-        return checkSupport
-        (
-            readTypes() | SiblingType::readTypes(),
-            ext,
-            verbose,
-            "reading"
-        );
-    }
+    return checkSupport
+    (
+        readTypes() | FriendType::readTypes(),
+        ext,
+        verbose,
+        "reading"
+   );
 }
 
 
@@ -86,13 +87,13 @@ bool Foam::MeshedSurface<Face>::canWriteType
     const bool verbose
 )
 {
-    // handle 'native' format directly
-    if (isNative(ext))
-    {
-        return true;
-    }
-
-    return checkSupport(writeTypes(), ext, verbose, "writing");
+    return checkSupport
+    (
+        writeTypes() | ProxyType::writeTypes(),
+        ext,
+        verbose,
+        "writing"
+    );
 }
 
 
@@ -116,7 +117,7 @@ template<class Face>
 void Foam::MeshedSurface<Face>::write
 (
     const fileName& name,
-    const MeshedSurface& surf
+    const MeshedSurface<Face>& surf
 )
 {
     if (debug)
@@ -127,30 +128,41 @@ void Foam::MeshedSurface<Face>::write
             << endl;
     }
 
-    word ext = name.ext();
-
-    // handle 'native' format directly
-    if (isNative(ext))
-    {
-        surf.write(OFstream(name)());
-        return;
-    }
+    const word ext = name.ext();
 
     typename writefileExtensionMemberFunctionTable::iterator mfIter =
         writefileExtensionMemberFunctionTablePtr_->find(ext);
 
     if (mfIter == writefileExtensionMemberFunctionTablePtr_->end())
     {
-        FatalErrorIn
-        (
-            "MeshedSurface::write(const fileName&)"
-        )   << "Unknown file extension " << ext << nl << nl
-            << "Valid types are :" << endl
-            << writeTypes()
-            << exit(FatalError);
-    }
+        // no direct writer, delegate to proxy if possible
+        wordHashSet supported = ProxyType::writeTypes();
 
-    mfIter()(name, surf);
+        if (supported.found(ext))
+        {
+            MeshedSurfaceProxy<Face>
+            (
+                surf.points(),
+                surf.faces(),
+                surf.surfZones()
+            ).write(name);
+        }
+        else
+        {
+            FatalErrorIn
+            (
+                "MeshedSurface::write"
+                "(const fileName&, const MeshedSurface&)"
+            )   << "Unknown file extension " << ext << nl << nl
+                << "Valid types are :" << endl
+                << (supported | writeTypes())
+                << exit(FatalError);
+        }
+    }
+    else
+    {
+        mfIter()(name, surf);
+    }
 }
 
 
@@ -158,36 +170,42 @@ void Foam::MeshedSurface<Face>::write
 
 template<class Face>
 Foam::MeshedSurface<Face>::MeshedSurface()
+:
+    ParentType(List<Face>(), pointField())
 {}
 
 
 template<class Face>
 Foam::MeshedSurface<Face>::MeshedSurface
 (
-    const Xfer<pointField>& pointLst,
-    const Xfer<List<Face> >& faceLst,
-    const Xfer<surfZoneList>& zoneLst
+    const Xfer< pointField >& pointLst,
+    const Xfer< List<Face> >& faceLst,
+    const Xfer< surfZoneList >& zoneLst
 )
 :
-    ParentType(pointLst, faceLst),
-    zones_(zoneLst)
-{}
+    ParentType(List<Face>(), pointField()),
+    zones_()
+{
+    reset(pointLst, faceLst, zoneLst);
+}
 
 
 template<class Face>
 Foam::MeshedSurface<Face>::MeshedSurface
 (
-    const Xfer<pointField>& pointLst,
-    const Xfer<List<Face> >& faceLst,
+    const Xfer< pointField >& pointLst,
+    const Xfer< List<Face> >& faceLst,
     const UList<label>& zoneSizes,
     const UList<word>& zoneNames
 )
 :
-    ParentType(pointLst, faceLst)
+    ParentType(List<Face>(), pointField())
 {
-    if (&zoneSizes)
+    reset(pointLst, faceLst, Xfer<surfZoneList>());
+
+    if (zoneSizes.size())
     {
-        if (&zoneNames)
+        if (zoneNames.size())
         {
             addZones(zoneSizes, zoneNames);
         }
@@ -196,10 +214,58 @@ Foam::MeshedSurface<Face>::MeshedSurface
             addZones(zoneSizes);
         }
     }
-    else
+}
+
+
+template<class Face>
+Foam::MeshedSurface<Face>::MeshedSurface
+(
+    const MeshedSurface<Face>& surf
+)
+:
+    ParentType(surf.faces(), surf.points()),
+    zones_(surf.surfZones())
+{}
+
+
+template<class Face>
+Foam::MeshedSurface<Face>::MeshedSurface
+(
+    const UnsortedMeshedSurface<Face>& surf
+)
+:
+    ParentType(List<Face>(), surf.points())
+{
+    labelList faceMap;
+    this->storedZones().transfer(surf.sortedZones(faceMap));
+
+    const List<Face>& origFaces = surf.faces();
+    List<Face> newFaces(origFaces.size());
+
+    // this is somewhat like ListOps reorder and/or IndirectList
+    forAll(newFaces, faceI)
     {
-        oneZone();
+        newFaces[faceI] = origFaces[faceMap[faceI]];
     }
+
+    this->storedFaces().transfer(newFaces);
+}
+
+
+template<class Face>
+Foam::MeshedSurface<Face>::MeshedSurface(const surfMesh& mesh)
+:
+    ParentType(List<Face>(), pointField())
+{
+    // same face type as surfMesh
+    MeshedSurface<face> surf
+    (
+        xferCopy(mesh.points()),
+        xferCopy(mesh.faces()),
+        xferCopy(mesh.surfZones())
+    );
+
+    this->transcribe(surf);
 }
 
 
@@ -209,6 +275,8 @@ Foam::MeshedSurface<Face>::MeshedSurface
     const polyBoundaryMesh& bMesh,
     const bool useGlobalPoints
 )
+:
+    ParentType(List<Face>(), pointField())
 {
     const polyMesh& mesh = bMesh.mesh();
     const polyPatchList& bPatches = bMesh;
@@ -276,50 +344,14 @@ Foam::MeshedSurface<Face>::MeshedSurface
 }
 
 
-template<class Face>
-Foam::MeshedSurface<Face>::MeshedSurface(const surfMesh& mesh)
-{
-    // same face type as surfMesh
-    MeshedSurface<face> surf
-    (
-        xferCopy(mesh.points()),
-        xferCopy(mesh.faces()),
-        xferCopy(mesh.surfZones())
-    );
-
-    this->transcribe(surf);
-}
-
-
-template<class Face>
-Foam::MeshedSurface<Face>::MeshedSurface
-(
-    const UnsortedMeshedSurface<Face>& surf
-)
-{
-    labelList faceMap;
-    surfZoneList zoneLst = surf.sortedZones(faceMap);
-    zones_.transfer(zoneLst);
-
-    const List<Face>& origFaces = surf.faces();
-    List<Face> newFaces(origFaces.size());
-
-    // this is somewhat like ListOps reorder and/or IndirectList
-    forAll(newFaces, faceI)
-    {
-        newFaces[faceI] = origFaces[faceMap[faceI]];
-    }
-
-    reset(xferCopy(surf.points()), xferMove(newFaces));
-}
-
-
 template<class Face>
 Foam::MeshedSurface<Face>::MeshedSurface
 (
     const fileName& name,
     const word& ext
 )
+:
+    ParentType(List<Face>(), pointField())
 {
     read(name, ext);
 }
@@ -327,45 +359,41 @@ Foam::MeshedSurface<Face>::MeshedSurface
 
 template<class Face>
 Foam::MeshedSurface<Face>::MeshedSurface(const fileName& name)
+:
+    ParentType(List<Face>(), pointField())
 {
     read(name);
 }
 
 
-template<class Face>
-Foam::MeshedSurface<Face>::MeshedSurface(Istream& is)
-{
-    read(is);
-}
-
-
 template<class Face>
 Foam::MeshedSurface<Face>::MeshedSurface(const Time& d, const word& surfName)
-{
-    read(IFstream(findMeshFile(d, surfName))());
-}
-
-
-template<class Face>
-Foam::MeshedSurface<Face>::MeshedSurface(const MeshedSurface& surf)
 :
-    ParentType(surf),
-    zones_(surf.zones_)
-{}
+    ParentType(List<Face>(), pointField())
+{
+    read(this->findMeshFile(d, surfName));
+}
 
 
 template<class Face>
 Foam::MeshedSurface<Face>::MeshedSurface
 (
-    const Xfer<UnsortedMeshedSurface<Face> >& surf
+    const Xfer< UnsortedMeshedSurface<Face> >& surf
 )
+:
+    ParentType(List<Face>(), pointField())
 {
     transfer(surf());
 }
 
 
 template<class Face>
-Foam::MeshedSurface<Face>::MeshedSurface(const Xfer<MeshedSurface>& surf)
+Foam::MeshedSurface<Face>::MeshedSurface
+(
+    const Xfer< MeshedSurface<Face> >& surf
+)
+:
+    ParentType(List<Face>(), pointField())
 {
     transfer(surf());
 }
@@ -384,115 +412,6 @@ Foam::MeshedSurface<Face>::~MeshedSurface()
 
 // * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
 
-template<class Face>
-void Foam::MeshedSurface<Face>::oneZone(const word& name)
-{
-    word zoneName(name);
-    if (zoneName.empty())
-    {
-        if (zones_.size())
-        {
-            zoneName = zones_[0].name();
-        }
-        if (zoneName.empty())
-        {
-            zoneName = "zone0";
-        }
-    }
-
-    // set single default zone
-    zones_.setSize(1);
-    zones_[0] = surfZone
-    (
-        zoneName,
-        this->size(),   // zone size
-        0,              // zone start
-        0               // zone index
-    );
-}
-
-
-template<class Face>
-void Foam::MeshedSurface<Face>::checkZones()
-{
-    // extra safety, ensure we have at some zones
-    // and they cover all the faces - fix start silently
-    if (zones_.size() <= 1)
-    {
-        oneZone();
-    }
-    else
-    {
-        label count = 0;
-        forAll(zones_, zoneI)
-        {
-            zones_[zoneI].start() = count;
-            count += zones_[zoneI].size();
-        }
-
-        if (count < size())
-        {
-            WarningIn
-            (
-                "MeshedSurface::checkZones()\n"
-            )
-                << "more faces " << size() << " than zones " << count
-                << " ... extending final zone"
-                << endl;
-
-            zones_[zones_.size()-1].size() += count - size();
-        }
-        else if (count > size())
-        {
-            FatalErrorIn
-            (
-                "MeshedSurface::checkZones()\n"
-            )
-                << "more zones " << count << " than faces " << size()
-                << exit(FatalError);
-        }
-    }
-}
-
-
-template<class Face>
-void Foam::MeshedSurface<Face>::sortFacesAndStore
-(
-    const Xfer<List<Face> >& unsortedFaces,
-    const Xfer<List<label> >& zoneIds,
-    const bool sorted
-)
-{
-    List<Face>  oldFaces(unsortedFaces);
-    List<label> zones(zoneIds);
-
-    if (sorted)
-    {
-        // already sorted - simply transfer faces
-        this->storedFaces().transfer(oldFaces);
-    }
-    else
-    {
-        // unsorted - determine the sorted order:
-        // avoid SortableList since we discard the main list anyhow
-        List<label> faceMap;
-        sortedOrder(zones, faceMap);
-        zones.clear();
-
-        // sorted faces
-        List<Face> newFaces(faceMap.size());
-        forAll(faceMap, faceI)
-        {
-            // use transfer to recover memory if possible
-            newFaces[faceI].transfer(oldFaces[faceMap[faceI]]);
-        }
-        this->storedFaces().transfer(newFaces);
-
-    }
-    zones.clear();
-}
-
-
 template<class Face>
 void Foam::MeshedSurface<Face>::remapFaces
 (
@@ -502,22 +421,20 @@ void Foam::MeshedSurface<Face>::remapFaces
     // recalculate the zone start/size
     if (&faceMap && faceMap.size())
     {
-        if (zones_.empty())
-        {
-            oneZone();
-        }
-        else if (zones_.size() == 1)
+        surfZoneList& zones = storedZones();
+
+        if (zones.size() == 1)
         {
             // optimized for single zone case
-            zones_[0].size() = faceMap.size();
+            zones[0].size() = faceMap.size();
         }
-        else
+        else if (zones.size())
         {
             label newFaceI = 0;
             label origEndI = 0;
-            forAll(zones_, zoneI)
+            forAll(zones, zoneI)
             {
-                surfZone& zone = zones_[zoneI];
+                surfZone& zone = zones[zoneI];
 
                 // adjust zone start
                 zone.start() = newFaceI;
@@ -548,11 +465,472 @@ void Foam::MeshedSurface<Face>::remapFaces
 template<class Face>
 void Foam::MeshedSurface<Face>::clear()
 {
-    ParentType::clear();
-    zones_.clear();
+    ParentType::clearOut();
+
+    storedPoints().clear();
+    storedFaces().clear();
+    storedZones().clear();
 }
 
 
+template<class Face>
+void Foam::MeshedSurface<Face>::movePoints(const pointField& newPoints)
+{
+    // Remove all geometry dependent data
+    ParentType::clearTopology();
+
+    // Adapt for new point position
+    ParentType::movePoints(newPoints);
+
+    // Copy new points
+    storedPoints() = newPoints;
+}
+
+
+template<class Face>
+void Foam::MeshedSurface<Face>::scalePoints(const scalar& scaleFactor)
+{
+    // avoid bad scaling
+    if (scaleFactor > 0 && scaleFactor != 1.0)
+    {
+        // Remove all geometry dependent data
+        ParentType::clearTopology();
+
+        // Adapt for new point position
+        ParentType::movePoints(pointField());
+
+        storedPoints() *= scaleFactor;
+    }
+}
+
+
+template<class Face>
+void Foam::MeshedSurface<Face>::reset
+(
+    const Xfer< pointField >& pointLst,
+    const Xfer< List<Face> >& faceLst,
+    const Xfer< surfZoneList >& zoneLst
+)
+{
+    ParentType::clearOut();
+
+    // Take over new primitive data.
+    // Optimized to avoid overwriting data at all
+    if (&pointLst)
+    {
+        storedPoints().transfer(pointLst());
+    }
+
+    if (&faceLst)
+    {
+        storedFaces().transfer(faceLst());
+    }
+
+    if (&zoneLst)
+    {
+        storedZones().transfer(zoneLst());
+    }
+}
+
+
+template<class Face>
+void Foam::MeshedSurface<Face>::reset
+(
+    const Xfer< List<point> >& pointLst,
+    const Xfer< List<Face> >& faceLst,
+    const Xfer< surfZoneList >& zoneLst
+)
+{
+    ParentType::clearOut();
+
+    // Take over new primitive data.
+    // Optimized to avoid overwriting data at all
+    if (&pointLst)
+    {
+        storedPoints().transfer(pointLst());
+    }
+
+    if (&faceLst)
+    {
+        storedFaces().transfer(faceLst());
+    }
+
+    if (&zoneLst)
+    {
+        storedZones().transfer(zoneLst());
+    }
+}
+
+
+// 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);
+    this->checkTopology(verbose);
+}
+
+
+template<class Face>
+bool Foam::MeshedSurface<Face>::stitchFaces
+(
+    const scalar tol,
+    const bool verbose
+)
+{
+    pointField& pointLst = this->storedPoints();
+
+    // Merge points
+    labelList  pointMap(pointLst.size());
+    pointField newPoints(pointLst.size());
+
+    bool hasMerged = mergePoints(pointLst, tol, verbose, pointMap, newPoints);
+
+    if (!hasMerged)
+    {
+        return false;
+    }
+
+    if (verbose)
+    {
+        Info<< "MeshedSurface::stitchFaces : Renumbering all faces"
+            << endl;
+    }
+
+    // Set the coordinates to the merged ones
+    pointLst.transfer(newPoints);
+
+    List<Face>& faceLst = this->storedFaces();
+
+    List<label> faceMap(faceLst.size());
+
+    // Reset the point labels to the unique points array
+    label newFaceI = 0;
+    forAll(faceLst, faceI)
+    {
+        Face& f = faceLst[faceI];
+        forAll(f, fp)
+        {
+            f[fp] = pointMap[f[fp]];
+        }
+
+        // for extra safety: collapse face as well
+        if (f.collapse() >= 3)
+        {
+            if (newFaceI != faceI)
+            {
+                faceLst[newFaceI] = f;
+            }
+            faceMap[newFaceI] = faceI;
+            newFaceI++;
+        }
+        else if (verbose)
+        {
+            Pout<< "MeshedSurface::stitchFaces : "
+                << "Removing collapsed face " << faceI << endl
+                << "    vertices   :" << f << endl;
+        }
+    }
+    pointMap.clear();
+
+    if (newFaceI != faceLst.size())
+    {
+        if (verbose)
+        {
+            Pout<< "MeshedSurface::stitchFaces : "
+                << "Removed " << faceLst.size() - newFaceI
+                << " faces" << endl;
+        }
+        faceLst.setSize(newFaceI);
+        remapFaces(faceMap);
+    }
+    faceMap.clear();
+
+    // Merging points might have changed geometric factors
+    ParentType::clearOut();
+    return true;
+}
+
+
+// Remove badly degenerate faces and double faces.
+template<class Face>
+bool Foam::MeshedSurface<Face>::checkFaces
+(
+    const bool verbose
+)
+{
+    bool changed = false;
+    List<Face>& faceLst = this->storedFaces();
+
+    List<label> faceMap(faceLst.size());
+
+    label newFaceI = 0;
+    // Detect badly labelled faces and mark degenerate faces
+    const label maxPointI = this->points().size() - 1;
+    forAll(faceLst, faceI)
+    {
+        Face& f = faceLst[faceI];
+
+        // avoid degenerate faces
+        if (f.collapse() >= 3)
+        {
+            forAll(f, fp)
+            {
+                if (f[fp] < 0 || f[fp] > maxPointI)
+                {
+                    FatalErrorIn("MeshedSurface::checkFaces(bool)")
+                        << "face " << f
+                        << " uses point indices outside point range 0.."
+                    << maxPointI
+                        << exit(FatalError);
+                }
+            }
+
+            faceMap[faceI] = faceI;
+            newFaceI++;
+        }
+        else
+        {
+            // mark as bad face
+            faceMap[faceI] = -1;
+
+            changed = true;
+            if (verbose)
+            {
+                WarningIn
+                (
+                    "MeshedSurface::checkFaces(bool verbose)"
+                )   << "face[" << faceI << "] = " << f
+                    << " does not have three unique vertices" << endl;
+            }
+        }
+    }
+
+    // Detect doubled faces
+    // do not touch the faces
+    const labelListList& fFaces = this->faceFaces();
+    newFaceI = 0;
+    forAll(faceLst, faceI)
+    {
+        // skip already collapsed faces:
+        if (faceMap[faceI] < 0)
+        {
+            continue;
+        }
+
+        const Face& f = faceLst[faceI];
+
+        // duplicate face check
+        bool okay = true;
+        const labelList& neighbours = fFaces[faceI];
+
+        // Check if faceNeighbours use same points as this face.
+        // Note: discards normal information - sides of baffle are merged.
+        forAll(neighbours, neighI)
+        {
+            const label neiFaceI = neighbours[neighI];
+
+            if (neiFaceI <= faceI || faceMap[neiFaceI] < 0)
+            {
+                // lower numbered faces already checked
+                // skip neighbours that are themselves collapsed
+                continue;
+            }
+
+            const Face& nei = faceLst[neiFaceI];
+
+            if (f == nei)
+            {
+                okay = false;
+
+                if (verbose)
+                {
+                    WarningIn
+                    (
+                        "MeshedSurface::checkFaces(bool verbose)"
+                    )   << "faces share the same vertices:" << nl
+                        << "    face[" << faceI << "] : " << f << nl
+                        << "    face[" << neiFaceI << "] : " << nei << endl;
+                    // printFace(Warning, "    ", f, points());
+                    // printFace(Warning, "    ", nei, points());
+                }
+
+                break;
+            }
+        }
+
+        if (okay)
+        {
+            faceMap[faceI] = faceI;
+            newFaceI++;
+        }
+        else
+        {
+            faceMap[faceI] = -1;
+        }
+    }
+
+    // Phase 1: pack
+    // Done to keep numbering constant in phase 1
+
+    if (changed || newFaceI < faceLst.size())
+    {
+        changed = true;
+
+        if (verbose)
+        {
+            WarningIn
+            (
+                "MeshedSurface::checkFaces(bool verbose)"
+            )   << "Removed " << faceLst.size() - newFaceI
+                << " illegal faces." << endl;
+        }
+
+        // compress the face list
+        newFaceI = 0;
+        forAll(faceLst, faceI)
+        {
+            if (faceMap[faceI] >= 0)
+            {
+                if (newFaceI != faceI)
+                {
+                    faceLst[newFaceI] = faceLst[faceI];
+                }
+                faceMap[newFaceI] = faceI;
+                newFaceI++;
+            }
+        }
+
+        faceLst.setSize(newFaceI);
+        remapFaces(faceMap);
+    }
+    faceMap.clear();
+
+    // Topology can change because of renumbering
+    ParentType::clearOut();
+    return changed;
+}
+
+
+template<class Face>
+Foam::label Foam::MeshedSurface<Face>::triangulate()
+{
+    return triangulate
+    (
+        const_cast<List<label>&>(List<label>::null())
+    );
+}
+
+
+template<class Face>
+Foam::label Foam::MeshedSurface<Face>::triangulate
+(
+    List<label>& faceMapOut
+)
+{
+    label nTri = 0;
+    label maxTri = 0;  // the maximum number of triangles for any single face
+    List<Face>& faceLst = this->storedFaces();
+
+    // determine how many triangles will be needed
+    forAll(faceLst, faceI)
+    {
+        const label n = faceLst[faceI].nTriangles();
+        if (maxTri < n)
+        {
+            maxTri = n;
+        }
+        nTri += n;
+    }
+
+    // nothing to do
+    if (nTri <= faceLst.size())
+    {
+        if (&faceMapOut)
+        {
+            faceMapOut.clear();
+        }
+        return 0;
+    }
+
+    List<Face>  newFaces(nTri);
+    List<label> faceMap;
+
+    // reuse storage from optional faceMap
+    if (&faceMapOut)
+    {
+        faceMap.transfer(faceMapOut);
+    }
+    faceMap.setSize(nTri);
+
+    // remember the number of *additional* faces
+    nTri -= faceLst.size();
+
+    if (this->points().empty())
+    {
+        // triangulate without points
+        // simple face triangulation around f[0]
+        label newFaceI = 0;
+        forAll(faceLst, faceI)
+        {
+            const Face& f = faceLst[faceI];
+
+            for (label fp = 1; fp < f.size() - 1; ++fp)
+            {
+                label fp1 = f.fcIndex(fp);
+
+                newFaces[newFaceI] = triFace(f[0], f[fp], f[fp1]);
+                faceMap[newFaceI] = faceI;
+                newFaceI++;
+            }
+        }
+    }
+    else
+    {
+        // triangulate with points
+        List<face> tmpTri(maxTri);
+
+        label newFaceI = 0;
+        forAll(faceLst, faceI)
+        {
+            // 'face' not '<Face>'
+            const face& f = faceLst[faceI];
+
+            label nTmp;
+            f.triangles(this->points(), nTmp, tmpTri);
+            for (label triI = 0; triI < nTmp; triI++)
+            {
+                newFaces[newFaceI] = Face
+                (
+                    static_cast<UList<label>&>(tmpTri[triI])
+                );
+                faceMap[newFaceI] = faceI;
+                newFaceI++;
+            }
+        }
+    }
+
+    faceLst.transfer(newFaces);
+    remapFaces(faceMap);
+
+    // optionally return the faceMap
+    if (&faceMapOut)
+    {
+        faceMapOut.transfer(faceMap);
+    }
+    faceMap.clear();
+
+    // Topology can change because of renumbering
+    ParentType::clearOut();
+    return nTri;
+}
+
+
+
+
 template<class Face>
 Foam::MeshedSurface<Face> Foam::MeshedSurface<Face>::subsetMesh
 (
@@ -578,7 +956,7 @@ Foam::MeshedSurface<Face> Foam::MeshedSurface<Face>::subsetMesh
     }
 
     // create/copy a new zones list, each zone with zero size
-    surfZoneList newZones(zones_);
+    surfZoneList newZones(this->surfZones());
     forAll(newZones, zoneI)
     {
         newZones[zoneI].size() = 0;
@@ -652,88 +1030,6 @@ Foam::MeshedSurface<Face>::subsetMesh
 }
 
 
-template<class Face>
-void Foam::MeshedSurface<Face>::addZones
-(
-    const UList<surfZone>& zones,
-    const bool cullEmpty
-)
-{
-    label nZone = 0;
-
-    zones_.setSize(zones.size());
-    forAll(zones_, zoneI)
-    {
-        if (zones[zoneI].size() || !cullEmpty)
-        {
-            zones_[nZone] = surfZone(zones[zoneI], nZone);
-            nZone++;
-        }
-    }
-    zones_.setSize(nZone);
-}
-
-
-template<class Face>
-void Foam::MeshedSurface<Face>::addZones
-(
-    const UList<label>& sizes,
-    const UList<word>& names,
-    const bool cullEmpty
-)
-{
-    label start   = 0;
-    label nZone = 0;
-
-    zones_.setSize(sizes.size());
-    forAll(zones_, zoneI)
-    {
-        if (sizes[zoneI] || !cullEmpty)
-        {
-            zones_[nZone] = surfZone
-            (
-                names[zoneI],
-                sizes[zoneI],
-                start,
-                nZone
-            );
-            start += sizes[zoneI];
-            nZone++;
-        }
-    }
-    zones_.setSize(nZone);
-}
-
-
-template<class Face>
-void Foam::MeshedSurface<Face>::addZones
-(
-    const UList<label>& sizes,
-    const bool cullEmpty
-)
-{
-    label start   = 0;
-    label nZone = 0;
-
-    zones_.setSize(sizes.size());
-    forAll(zones_, zoneI)
-    {
-        if (sizes[zoneI] || !cullEmpty)
-        {
-            zones_[nZone] = surfZone
-            (
-                word("zone") + ::Foam::name(nZone),
-                sizes[zoneI],
-                start,
-                nZone
-            );
-            start += sizes[zoneI];
-            nZone++;
-        }
-    }
-    zones_.setSize(nZone);
-}
-
 
 template<class Face>
 void Foam::MeshedSurface<Face>::transfer
@@ -741,10 +1037,12 @@ void Foam::MeshedSurface<Face>::transfer
     MeshedSurface<Face>& surf
 )
 {
-    reset(xferMove(surf.storedPoints()), xferMove(surf.storedFaces()));
-    zones_.transfer(surf.zones_);
-
-    surf.clear();
+    reset
+    (
+        xferMove(surf.storedPoints()),
+        xferMove(surf.storedFaces()),
+        xferMove(surf.storedZones())
+    );
 }
 
 
@@ -758,18 +1056,35 @@ void Foam::MeshedSurface<Face>::transfer
 
     labelList faceMap;
     surfZoneList zoneLst = surf.sortedZones(faceMap);
-    List<Face>& oldFaces = surf.storedFaces();
 
-    List<Face> newFaces(faceMap.size());
-    forAll(faceMap, faceI)
+    if (zoneLst.size() <= 1)
     {
-        newFaces[faceI].transfer(oldFaces[faceMap[faceI]]);
+        reset
+        (
+            xferMove(surf.storedPoints()),
+            xferMove(surf.storedFaces()),
+            Xfer<surfZoneList>()
+        );
     }
+    else
+    {
+        List<Face>& oldFaces = surf.storedFaces();
+        List<Face> newFaces(faceMap.size());
+
+        forAll(faceMap, faceI)
+        {
+            newFaces[faceI].transfer(oldFaces[faceMap[faceI]]);
+        }
+
+        reset
+        (
+            xferMove(surf.storedPoints()),
+            xferMove(newFaces),
+            xferMove(zoneLst)
+        );
+    }
+
     faceMap.clear();
-
-    reset(xferMove(surf.storedPoints()), xferMove(newFaces));
-    zones_.transfer(zoneLst);
-
     surf.clear();
 }
 
@@ -807,24 +1122,22 @@ bool Foam::MeshedSurface<Face>::read
     const word& ext
 )
 {
-    // handle 'native' format directly
-    if (isNative(ext))
-    {
-        return read(IFstream(name)());
-    }
-    else
-    {
-        // use selector mechanism
-        transfer(New(name, ext)());
-        return true;
-    }
+    clear();
+
+    // read via selector mechanism
+    transfer(New(name, ext)());
+    return true;
 }
 
 
 template<class Face>
-void Foam::MeshedSurface<Face>::write(const Time& d, const word& surfName) const
+void Foam::MeshedSurface<Face>::write
+(
+    const Time& d,
+    const word& surfName
+) const
 {
-    write(OFstream(findMeshFile(d, surfName))());
+    write(findMeshFile(d, surfName));
 }
 
 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
@@ -836,15 +1149,17 @@ void Foam::MeshedSurface<Face>::operator=(const MeshedSurface& surf)
 
     this->storedPoints() = surf.points();
     this->storedFaces()  = surf.faces();
-    zones_ = surf.zones_;
+    this->storedZones()  = surf.surfZones();
 }
 
+
 // * * * * * * * * * * * * * * * Friend Functions  * * * * * * * * * * * * * //
 
 // * * * * * * * * * * * * * * * IOstream Operators  * * * * * * * * * * * * //
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
+#include "MeshedSurfaceZones.C"
 #include "MeshedSurfaceIO.C"
 #include "MeshedSurfaceNew.C"
 
diff --git a/src/surfMesh/MeshedSurface/MeshedSurface.H b/src/surfMesh/MeshedSurface/MeshedSurface.H
index a3e8ed5758..51701bc499 100644
--- a/src/surfMesh/MeshedSurface/MeshedSurface.H
+++ b/src/surfMesh/MeshedSurface/MeshedSurface.H
@@ -26,15 +26,19 @@ Class
     Foam::MeshedSurface
 
 Description
-    A surface geometry mesh with zone information, not to be confused
-    with a similarily named surfaceMesh, which actually refers to
-    the cell faces of a volume mesh.
+    A surface geometry mesh with zone information, not to be confused with
+    the similarly named surfaceMesh, which actually refers to the cell faces
+    of a volume mesh.
 
-   The MeshedSurface is intended for surfaces from a variety of sources.
-   - A set of points and faces without any surface zone information.
-   - A set of points and faces with randomly ordered zone information.
-     This could arise, for example, from reading external file formats
-     such as STL, etc.
+    A MeshedSurface can have zero or more surface zones (roughly equivalent
+    to faceZones for a polyMesh). If surface zones are defined, they must
+    be contiguous and cover all of the faces.
+
+    The MeshedSurface is intended for surfaces from a variety of sources.
+    - A set of points and faces without any surface zone information.
+    - A set of points and faces with randomly ordered zone information.
+      This could arise, for example, from reading external file formats
+      such as STL, etc.
 
 SourceFiles
     MeshedSurface.C
@@ -44,7 +48,12 @@ SourceFiles
 #ifndef MeshedSurface_H
 #define MeshedSurface_H
 
-#include "BasicMeshedSurface.H"
+#include "PrimitivePatch.H"
+#include "PatchTools.H"
+#include "pointField.H"
+#include "face.H"
+#include "triFace.H"
+
 #include "surfZoneList.H"
 #include "surfaceFormatsCore.H"
 #include "runTimeSelectionTables.H"
@@ -60,14 +69,11 @@ namespace Foam
 
 class Time;
 class surfMesh;
-template<class Face> class MeshedSurface;
-template<class Face> class UnsortedMeshedSurface;
-
 class polyBoundaryMesh;
-class surfMesh;
 
-template<class Face>
-Ostream& operator<<(Ostream&, const MeshedSurface<Face>&);
+template<class Face> class MeshedSurface;
+template<class Face> class MeshedSurfaceProxy;
+template<class Face> class UnsortedMeshedSurface;
 
 /*---------------------------------------------------------------------------*\
                       Class MeshedSurface Declaration
@@ -76,7 +82,7 @@ Ostream& operator<<(Ostream&, const MeshedSurface<Face>&);
 template<class Face>
 class MeshedSurface
 :
-    public BasicMeshedSurface<Face>,
+    public PrimitivePatch<Face, ::Foam::List, pointField, point>,
     public fileFormats::surfaceFormatsCore
 {
     // friends despite different faces
@@ -92,8 +98,18 @@ class MeshedSurface
 private:
 
     //- Private typedefs for convenience
-        typedef BasicMeshedSurface<Face> ParentType;
-        typedef UnsortedMeshedSurface<Face>  SiblingType;
+
+        typedef PrimitivePatch
+        <
+            Face,
+            ::Foam::List,
+            pointField,
+            point
+        >
+        ParentType;
+
+        typedef UnsortedMeshedSurface<Face>  FriendType;
+        typedef MeshedSurfaceProxy<Face>     ProxyType;
 
     // Private Member Data
 
@@ -101,21 +117,31 @@ private:
         // (face ordering nFaces/startFace only used during reading/writing)
         List<surfZone> zones_;
 
+
     // Private member functions
 
-        //- Read OpenFOAM Surface format
-        bool read(Istream&);
-
-        //- Transfer points/zones and transcribe face -> triFace
-        void transcribe(MeshedSurface<face>&);
-
 protected:
 
     // Protected Member functions
 
+        //- Transfer points/zones and transcribe face -> triFace
+        void transcribe(MeshedSurface<face>&);
+
         //- basic sanity check on zones
         void checkZones();
 
+        //- Non-const access to global points
+        pointField& storedPoints()
+        {
+            return const_cast<pointField&>(ParentType::points());
+        }
+
+        //- Non-const access to the faces
+        List<Face>& storedFaces()
+        {
+            return static_cast<List<Face> &>(*this);
+        }
+
         //- Non-const access to the zones
         surfZoneList& storedZones()
         {
@@ -125,8 +151,8 @@ protected:
         //- sort faces by zones and store sorted faces
         void sortFacesAndStore
         (
-            const Xfer<List<Face> >& unsortedFaces,
-            const Xfer<List<label> >& zoneIds,
+            const Xfer< List<Face> >& unsortedFaces,
+            const Xfer< List<label> >& zoneIds,
             const bool sorted
         );
 
@@ -140,6 +166,9 @@ public:
 
     // Static
 
+        //- Face storage only handles triangulated faces
+        inline static bool isTri();
+
         //- Can we read this file format?
         static bool canRead(const fileName&, const bool verbose=false);
 
@@ -160,21 +189,27 @@ public:
         //- Construct by transferring components (points, faces, zones).
         MeshedSurface
         (
-            const Xfer<pointField>&,
-            const Xfer<List<Face> >&,
-            const Xfer<surfZoneList>&
+            const Xfer< pointField >&,
+            const Xfer< List<Face> >&,
+            const Xfer< surfZoneList >&
         );
 
-        //- Construct by transferring points, faces.
-        //  Use zone information, or set single default zone.
+        //- Construct by transferring components (points, faces).
+        //  Use zone information if available
         MeshedSurface
         (
-            const Xfer<pointField>&,
-            const Xfer<List<Face> >&,
-            const UList<label>& zoneSizes = UList<label>::null(),
-            const UList<word>& zoneNames = UList<word>::null()
+            const Xfer< pointField >&,
+            const Xfer< List<Face> >&,
+            const UList<label>& zoneSizes = UList<label>(),
+            const UList<word>& zoneNames = UList<word>()
         );
 
+        //- Construct as copy
+        MeshedSurface(const MeshedSurface&);
+
+        //- Construct from a UnsortedMeshedSurface
+        MeshedSurface(const UnsortedMeshedSurface<Face>&);
+
         //- Construct from a boundary mesh with local points/faces
         MeshedSurface
         (
@@ -182,9 +217,6 @@ public:
             const bool globalPoints=false
         );
 
-        //- Construct from a UnsortedMeshedSurface
-        MeshedSurface(const UnsortedMeshedSurface<Face>&);
-
         //- Construct from a surfMesh
         MeshedSurface(const surfMesh&);
 
@@ -200,15 +232,9 @@ public:
         //- Construct from file name (uses extension to determine type)
         MeshedSurface(const fileName&, const word& ext);
 
-        //- Construct from Istream
-        MeshedSurface(Istream&);
-
         //- Construct from objectRegistry
         MeshedSurface(const Time&, const word& surfName="");
 
-        //- Construct as copy
-        MeshedSurface(const MeshedSurface&);
-
     // Declare run-time constructor selection table
 
         declareRunTimeSelectionTable
@@ -244,7 +270,7 @@ public:
         declareMemberFunctionSelectionTable
         (
             void,
-            MeshedSurface,
+            UnsortedMeshedSurface,
             write,
             fileExtension,
             (
@@ -268,41 +294,98 @@ public:
             return ParentType::size();
         }
 
-        const List<surfZone>& zones() const
+        //- Return const access to the faces
+        inline const List<Face>& faces() const
+        {
+            return static_cast<const List<Face> &>(*this);
+        }
+
+        //- Const access to the surface zones.
+        //  If zones are defined, they must be contiguous and cover the entire
+        //  surface.
+        const List<surfZone>& surfZones() const
         {
             return zones_;
         }
 
-        //- set a single zone, optionally with a specific name
-        void oneZone(const word& name = word::null);
-
-        //- Add zones
-        void addZones
+        //- Add surface zones
+        virtual void addZones
         (
             const UList<surfZone>&,
             const bool cullEmpty=false
         );
 
-        //- Add zones
-        void addZones
+        //- Add surface zones
+        virtual void addZones
         (
             const UList<label>& sizes,
             const UList<word>& names,
             const bool cullEmpty=false
         );
 
-        //- Add zones
-        void addZones
+        //- Add surface zones
+        virtual void addZones
         (
             const UList<label>& sizes,
             const bool cullEmpty=false
         );
 
+        //- Remove surface zones
+        virtual void removeZones();
+
+
     // Edit
 
         //- Clear all storage
         virtual void clear();
 
+        //- Move points
+        virtual void movePoints(const pointField&);
+
+        //- Scale points. A non-positive factor is ignored
+        virtual void scalePoints(const scalar&);
+
+        //- Reset primitive data (points, faces and zones)
+        //  Note, optimized to avoid overwriting data (with Xfer::null)
+        virtual void reset
+        (
+            const Xfer< pointField >& points,
+            const Xfer< List<Face> >& faces,
+            const Xfer< surfZoneList >& zones
+        );
+
+        //- Reset primitive data (points, faces and zones)
+        //  Note, optimized to avoid overwriting data (with Xfer::null)
+        virtual void reset
+        (
+            const Xfer< List<point> >& points,
+            const Xfer< List<Face> >& faces,
+            const Xfer< surfZoneList >& zones
+        );
+
+        //- Remove invalid faces
+        virtual void cleanup(const bool verbose);
+
+        virtual bool stitchFaces
+        (
+            const scalar tol=SMALL,
+            const bool verbose=false
+        );
+
+        virtual bool checkFaces
+        (
+            const bool verbose=false
+        );
+
+        //- Triangulate in-place, returning the number of triangles added
+        virtual label triangulate();
+
+        //- Triangulate in-place, returning the number of triangles added
+        //  and setting a map of original face Ids.
+        //  The faceMap is zero-sized when no triangulation was done.
+        virtual label triangulate(List<label>& faceMap);
+
+
         //- Return new surface.
         //  Returns return pointMap, faceMap from subsetMeshMap
         MeshedSurface subsetMesh
@@ -338,8 +421,7 @@ public:
 
     // Write
 
-        //- Write to Ostream in simple FOAM format
-        virtual void write(Ostream&) const;
+        void writeStats(Ostream& os) const;
 
         //- Generic write routine. Chooses writer based on extension.
         virtual void write(const fileName& name) const
@@ -355,17 +437,37 @@ public:
 
         void operator=(const MeshedSurface<Face>&);
 
-    // Ostream Operator
-
-        friend Ostream& operator<<
-        <Face>
-        (
-            Ostream&,
-            const MeshedSurface<Face>&
-        );
 };
 
 
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+//- Specialization for holding triangulated information
+template<>
+inline bool MeshedSurface<triFace>::isTri()
+{
+    return true;
+}
+
+//- Specialization for holding triangulated information
+template<>
+inline label MeshedSurface<triFace>::triangulate()
+{
+    return 0;
+}
+
+//- Specialization for holding triangulated information
+template<>
+inline label MeshedSurface<triFace>::triangulate(List<label>& faceMap)
+{
+    if (&faceMap)
+    {
+        faceMap.clear();
+    }
+
+    return 0;
+}
+
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 } // End namespace Foam
diff --git a/src/surfMesh/MeshedSurface/MeshedSurfaceCore.C b/src/surfMesh/MeshedSurface/MeshedSurfaceCore.C
index 6a95b18b4a..1ad36955bd 100644
--- a/src/surfMesh/MeshedSurface/MeshedSurfaceCore.C
+++ b/src/surfMesh/MeshedSurface/MeshedSurfaceCore.C
@@ -38,7 +38,7 @@ namespace Foam
         // first triangulate
         surf.triangulate();
         this->storedPoints().transfer(surf.storedPoints());
-        zones_.transfer(surf.zones_);
+        this->storedZones().transfer(surf.storedZones());
 
         // transcribe from face -> triFace
         List<face>&    origFaces = surf.storedFaces();
diff --git a/src/surfMesh/MeshedSurface/MeshedSurfaceIO.C b/src/surfMesh/MeshedSurface/MeshedSurfaceIO.C
index 5beb33b045..bdf7c28c80 100644
--- a/src/surfMesh/MeshedSurface/MeshedSurfaceIO.C
+++ b/src/surfMesh/MeshedSurface/MeshedSurfaceIO.C
@@ -25,117 +25,44 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "MeshedSurface.H"
-#include "UnsortedMeshedSurface.H"
-#include "IFstream.H"
-#include "OFstream.H"
+#include "boundBox.H"
+#include "Ostream.H"
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
-// Read surf grouping, points, faces directly from Istream
 template<class Face>
-bool Foam::MeshedSurface<Face>::read(Istream& is)
+void Foam::MeshedSurface<Face>::writeStats(Ostream& os) const
 {
-    clear();
-
-    List<surfZone> newZones(is);
-
-    // copy and set the indices
-    zones_.setSize(newZones.size());
-    forAll(newZones, zoneI)
-    {
-        zones_[zoneI] = surfZone
-        (
-            newZones[zoneI],
-            zoneI
-        );
-    }
-
-    // read points:
-    is >> this->storedPoints();
-
-    // must triangulate?
+    os  << "points      : " << this->points().size() << nl;
     if (this->isTri())
     {
-        List<face> faceLst(is);
-
-        MeshedSurface<face> surf;
-        surf.reset
-        (
-            Xfer<pointField>::null(),
-            faceLst.xfer()
-        );
-        surf.addZones(zones_);
-
-        // this will break if the triangulation needed points
-        surf.triangulate();
-        zones_ = surf.zones();
-
-        // transcribe from face -> triFace (Face)
-        const List<face>& origFaces = surf.faces();
-        List<Face>  newFaces(origFaces.size());
-        forAll(origFaces, faceI)
-        {
-            newFaces[faceI] = Face
-            (
-                static_cast<const UList<label>&>(origFaces[faceI])
-            );
-        }
-        surf.clear();
-
-        this->storedFaces().transfer(newFaces);
+        os << "triangles   : " << this->size() << nl;
     }
     else
     {
-        // read faces:
-        is >> this->storedFaces();
+        label nTri = 0;
+        label nQuad = 0;
+        forAll(*this, i)
+        {
+            const label n = this->operator[](i).size();
+
+            if (n == 3)
+            {
+                nTri++;
+            }
+            else if (n == 4)
+            {
+                nQuad++;
+            }
+        }
+
+        os  << "faces       : " << this->size()
+            << "  (tri:" << nTri << " quad:" << nQuad
+            << " poly:" << (this->size() - nTri - nQuad ) << ")" << nl;
     }
 
-    return is.good();
+    os  << "boundingBox : " << boundBox(this->points()) << endl;
 }
 
 
-template<class Face>
-void Foam::MeshedSurface<Face>::write(Ostream& os) const
-{
-    // just emit some information until we get a nice IOobject
-    IOobject::writeBanner(os);
-    os  << "// OpenFOAM Surface Format" << nl
-        << "// ~~~~~~~~~~~~~~~~~~~~~~~" << nl
-        << "// zones:" << nl
-        << zones_.size() << nl << token::BEGIN_LIST << incrIndent << nl;
-
-    forAll(zones_, zoneI)
-    {
-        zones_[zoneI].writeDict(os);
-    }
-    os  << decrIndent << token::END_LIST << nl;
-
-    IOobject::writeDivider(os);
-
-    // Note: Write with global point numbering
-    os  << "\n// points:" << nl << this->points() << nl;
-
-    IOobject::writeDivider(os);
-    os  << "\n// faces:"  << nl << this->faces() << nl;
-
-    IOobject::writeDivider(os);
-
-    // Check state of Ostream
-    os.check("MeshedSurface::write(Ostream&)");
-}
-
-
-// * * * * * * * * * * * * * * * IOstream Operators  * * * * * * * * * * * * //
-
-template<class Face>
-Foam::Ostream& Foam::operator<<
-(
-    Ostream& os,
-    const MeshedSurface<Face>& surf
-)
-{
-    surf.write(os);
-    return os;
-}
-
 // ************************************************************************* //
diff --git a/src/surfMesh/MeshedSurface/MeshedSurfaceNew.C b/src/surfMesh/MeshedSurface/MeshedSurfaceNew.C
index 0655274f99..cd3f238c62 100644
--- a/src/surfMesh/MeshedSurface/MeshedSurfaceNew.C
+++ b/src/surfMesh/MeshedSurface/MeshedSurfaceNew.C
@@ -31,7 +31,7 @@ License
 
 
 template<class Face>
-Foam::autoPtr<Foam::MeshedSurface<Face> >
+Foam::autoPtr< Foam::MeshedSurface<Face> >
 Foam::MeshedSurface<Face>::New(const fileName& name, const word& ext)
 {
     if (debug)
@@ -47,19 +47,18 @@ Foam::MeshedSurface<Face>::New(const fileName& name, const word& ext)
     if (cstrIter == fileExtensionConstructorTablePtr_->end())
     {
         // no direct reader, delegate if possible
-        wordHashSet supported = SiblingType::readTypes();
+        wordHashSet supported = FriendType::readTypes();
         if (supported.found(ext))
         {
             // create indirectly
             autoPtr<MeshedSurface<Face> > surf(new MeshedSurface<Face>);
-            surf().transfer(SiblingType::New(name, ext)());
+            surf().transfer(FriendType::New(name, ext)());
 
             return surf;
         }
 
         // nothing left to try, issue error
         supported += readTypes();
-        supported.insert(nativeExt);
 
         FatalErrorIn
         (
@@ -76,7 +75,7 @@ Foam::MeshedSurface<Face>::New(const fileName& name, const word& ext)
 
 
 template<class Face>
-Foam::autoPtr<Foam::MeshedSurface<Face> >
+Foam::autoPtr< Foam::MeshedSurface<Face> >
 Foam::MeshedSurface<Face>::New(const fileName& name)
 {
     word ext = name.ext();
diff --git a/src/surfMesh/MeshedSurface/MeshedSurfaceZones.C b/src/surfMesh/MeshedSurface/MeshedSurfaceZones.C
new file mode 100644
index 0000000000..6b5915070f
--- /dev/null
+++ b/src/surfMesh/MeshedSurface/MeshedSurfaceZones.C
@@ -0,0 +1,214 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2009 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"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+// * * * * * * * * * * * * * Static Member Functions * * * * * * * * * * * * //
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+// * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
+
+template<class Face>
+void Foam::MeshedSurface<Face>::checkZones()
+{
+    // extra safety, ensure we have at some zones
+    // and they cover all the faces - fix start silently
+    surfZoneList& zones = storedZones();
+    if (zones.size())
+    {
+        label count = 0;
+        forAll(zones, zoneI)
+        {
+            zones[zoneI].start() = count;
+            count += zones[zoneI].size();
+        }
+
+        if (count < size())
+        {
+            WarningIn
+            (
+                "MeshedSurface::checkZones()\n"
+            )
+                << "more faces " << size() << " than zones " << count
+                << " ... extending final zone"
+                << endl;
+
+            zones[zones.size()-1].size() += count - size();
+        }
+        else if (count > size())
+        {
+            FatalErrorIn
+            (
+                "MeshedSurface::checkZones()\n"
+            )
+                << "more zones " << count << " than faces " << size()
+                << exit(FatalError);
+        }
+    }
+}
+
+
+template<class Face>
+void Foam::MeshedSurface<Face>::sortFacesAndStore
+(
+    const Xfer< List<Face> >& unsortedFaces,
+    const Xfer< List<label> >& zoneIds,
+    const bool sorted
+)
+{
+    List<Face>  oldFaces(unsortedFaces);
+    List<label> zones(zoneIds);
+
+    if (sorted)
+    {
+        // already sorted - simply transfer faces
+        this->storedFaces().transfer(oldFaces);
+    }
+    else
+    {
+        // unsorted - determine the sorted order:
+        // avoid SortableList since we discard the main list anyhow
+        List<label> faceMap;
+        sortedOrder(zones, faceMap);
+        zones.clear();
+
+        // sorted faces
+        List<Face> newFaces(faceMap.size());
+        forAll(faceMap, faceI)
+        {
+            // use transfer to recover memory if possible
+            newFaces[faceI].transfer(oldFaces[faceMap[faceI]]);
+        }
+        this->storedFaces().transfer(newFaces);
+    }
+    zones.clear();
+}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+template<class Face>
+void Foam::MeshedSurface<Face>::addZones
+(
+    const UList<surfZone>& srfZones,
+    const bool cullEmpty
+)
+{
+    label nZone = 0;
+
+    surfZoneList& zones = this->storedZones();
+    zones.setSize(zones.size());
+    forAll(zones, zoneI)
+    {
+        if (srfZones[zoneI].size() || !cullEmpty)
+        {
+            zones[nZone] = surfZone(srfZones[zoneI], nZone);
+            nZone++;
+        }
+    }
+    zones.setSize(nZone);
+}
+
+
+template<class Face>
+void Foam::MeshedSurface<Face>::addZones
+(
+    const UList<label>& sizes,
+    const UList<word>& names,
+    const bool cullEmpty
+)
+{
+    label start   = 0;
+    label nZone = 0;
+
+    surfZoneList& zones = this->storedZones();
+    zones.setSize(sizes.size());
+    forAll(zones, zoneI)
+    {
+        if (sizes[zoneI] || !cullEmpty)
+        {
+            zones[nZone] = surfZone
+            (
+                names[zoneI],
+                sizes[zoneI],
+                start,
+                nZone
+            );
+            start += sizes[zoneI];
+            nZone++;
+        }
+    }
+    zones.setSize(nZone);
+}
+
+
+template<class Face>
+void Foam::MeshedSurface<Face>::addZones
+(
+    const UList<label>& sizes,
+    const bool cullEmpty
+)
+{
+    label start   = 0;
+    label nZone = 0;
+
+    surfZoneList& zones = this->storedZones();
+    zones.setSize(sizes.size());
+    forAll(zones, zoneI)
+    {
+        if (sizes[zoneI] || !cullEmpty)
+        {
+            zones[nZone] = surfZone
+            (
+                word("zone") + ::Foam::name(nZone),
+                sizes[zoneI],
+                start,
+                nZone
+            );
+            start += sizes[zoneI];
+            nZone++;
+        }
+    }
+    zones.setSize(nZone);
+}
+
+
+template<class Face>
+void Foam::MeshedSurface<Face>::removeZones()
+{
+    this->storedZones().clear();
+}
+
+
+// * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
+// * * * * * * * * * * * * * * * Friend Functions  * * * * * * * * * * * * * //
+// * * * * * * * * * * * * * * * IOstream Operators  * * * * * * * * * * * * //
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+// ************************************************************************* //
diff --git a/src/surfMesh/MeshedSurfaceAllocator/MeshedSurfaceIOAllocator.C b/src/surfMesh/MeshedSurfaceAllocator/MeshedSurfaceIOAllocator.C
new file mode 100644
index 0000000000..abe193ce73
--- /dev/null
+++ b/src/surfMesh/MeshedSurfaceAllocator/MeshedSurfaceIOAllocator.C
@@ -0,0 +1,147 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2009 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 "MeshedSurfaceIOAllocator.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+
+Foam::MeshedSurfaceIOAllocator::MeshedSurfaceIOAllocator
+(
+    const IOobject& ioPoints,
+    const IOobject& ioFaces,
+    const IOobject& ioZones
+)
+:
+    points_(ioPoints),
+    faces_(ioFaces),
+    zones_(ioZones)
+{}
+
+
+Foam::MeshedSurfaceIOAllocator::MeshedSurfaceIOAllocator
+(
+    const IOobject& ioPoints,
+    const pointField& points,
+    const IOobject& ioFaces,
+    const faceList& faces,
+    const IOobject& ioZones,
+    const surfZoneList& zones
+)
+:
+    points_(ioPoints, points),
+    faces_(ioFaces, faces),
+    zones_(ioZones, zones)
+{}
+
+
+Foam::MeshedSurfaceIOAllocator::MeshedSurfaceIOAllocator
+(
+    const IOobject& ioPoints,
+    const Xfer< pointField >& points,
+    const IOobject& ioFaces,
+    const Xfer< faceList >& faces,
+    const IOobject& ioZones,
+    const Xfer< surfZoneList >& zones
+)
+:
+    points_(ioPoints, points),
+    faces_(ioFaces, faces),
+    zones_(ioZones, zones)
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+void Foam::MeshedSurfaceIOAllocator::clear()
+{
+    points_.clear();
+    faces_.clear();
+    zones_.clear();
+}
+
+
+void Foam::MeshedSurfaceIOAllocator::resetFaces
+(
+    const Xfer< List<face> >& faces,
+    const Xfer< surfZoneList >& zones
+)
+{
+    if (&faces)
+    {
+        faces_.transfer(faces());
+    }
+
+    if (&zones)
+    {
+        zones_.transfer(zones());
+    }
+}
+
+
+void Foam::MeshedSurfaceIOAllocator::reset
+(
+    const Xfer< pointField >& points,
+    const Xfer< faceList >& faces,
+    const Xfer< surfZoneList >& zones
+)
+{
+    // Take over new primitive data.
+    // Optimized to avoid overwriting data at all
+    if (&points)
+    {
+        points_.transfer(points());
+    }
+
+    resetFaces(faces, zones);
+}
+
+
+void Foam::MeshedSurfaceIOAllocator::reset
+(
+    const Xfer< List<point> >& points,
+    const Xfer< faceList >& faces,
+    const Xfer< surfZoneList >& zones
+)
+{
+    // Take over new primitive data.
+    // Optimized to avoid overwriting data at all
+    if (&points)
+    {
+        points_.transfer(points());
+    }
+
+    resetFaces(faces, zones);
+}
+
+
+// ************************************************************************* //
diff --git a/src/surfMesh/MeshedSurfaceAllocator/MeshedSurfaceIOAllocator.H b/src/surfMesh/MeshedSurfaceAllocator/MeshedSurfaceIOAllocator.H
new file mode 100644
index 0000000000..d3b6d5ff6a
--- /dev/null
+++ b/src/surfMesh/MeshedSurfaceAllocator/MeshedSurfaceIOAllocator.H
@@ -0,0 +1,194 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2009 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
+
+Class
+    Foam::MeshedSurfaceIOAllocator
+
+Description
+    A helper class for storing points, faces and zones with IO capabilities.
+
+SourceFiles
+    MeshedSurfaceIOAllocator.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef MeshedSurfaceIOAllocator_H
+#define MeshedSurfaceIOAllocator_H
+
+#include "pointIOField.H"
+#include "faceIOList.H"
+#include "surfZoneIOList.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                  Class MeshedSurfaceIOAllocator Declaration
+\*---------------------------------------------------------------------------*/
+
+//- A helper class for storing points, faces and zones
+class MeshedSurfaceIOAllocator
+{
+    // Private data
+
+        //- Points
+        pointIOField   points_;
+
+        //- Faces
+        faceIOList     faces_;
+
+        //- Surface zones
+        surfZoneIOList zones_;
+
+    // Private Member Functions
+
+        //- Disallow default bitwise copy construct
+        MeshedSurfaceIOAllocator(const MeshedSurfaceIOAllocator&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const MeshedSurfaceIOAllocator&);
+
+public:
+
+    // Constructors
+
+        //- Read construct from IOobjects
+        MeshedSurfaceIOAllocator
+        (
+            const IOobject& ioPoints,
+            const IOobject& ioFaces,
+            const IOobject& ioZones
+        );
+
+        //- Construct from IOobjects, copying components
+        MeshedSurfaceIOAllocator
+        (
+            const IOobject& ioPoints,
+            const pointField& points,
+            const IOobject& ioFaces,
+            const faceList& faces,
+            const IOobject& ioZones,
+            const surfZoneList& zones
+        );
+
+        //- Construct from IOobjects, possibly transferring components
+        MeshedSurfaceIOAllocator
+        (
+            const IOobject& ioPoints,
+            const Xfer< pointField >& points,
+            const IOobject& ioFaces,
+            const Xfer< faceList >& faces,
+            const IOobject& ioZones,
+            const Xfer< surfZoneList >& zones
+        );
+
+    // Destructor
+
+
+    // Member Functions
+
+        // Access
+
+            //- Non-const access to the points
+            pointIOField& storedIOPoints()
+            {
+                return points_;
+            }
+
+            //- Non-const access to the faces
+            faceIOList& storedIOFaces()
+            {
+                return faces_;
+            }
+
+            //- Non-const access to the zones
+            surfZoneIOList& storedIOZones()
+            {
+                return zones_;
+            }
+
+            //- Const access to the points
+            const pointIOField& storedIOPoints() const
+            {
+                return points_;
+            }
+
+            //- Const access to the faces
+            const faceIOList& storedIOFaces() const
+            {
+                return faces_;
+            }
+
+            //- Const access to the zones
+            const surfZoneIOList& storedIOZones() const
+            {
+                return zones_;
+            }
+
+
+        //  Storage management
+
+            //- Clear primitive data (points, faces and zones)
+            void clear();
+
+            //- Reset primitive data (points, faces and zones)
+            //  Note, optimized to avoid overwriting data (with Xfer::null)
+            void resetFaces
+            (
+                const Xfer< faceList >& faces,
+                const Xfer< surfZoneList >& zones
+            );
+
+            //- Reset primitive data (points, faces and zones)
+            //  Note, optimized to avoid overwriting data (with Xfer::null)
+            void reset
+            (
+                const Xfer< pointField >& points,
+                const Xfer< faceList >& faces,
+                const Xfer< surfZoneList >& zones
+            );
+
+            //- Reset primitive data (points, faces and zones)
+            //  Note, optimized to avoid overwriting data (with Xfer::null)
+            void reset
+            (
+                const Xfer< List<point> >& points,
+                const Xfer< faceList >& faces,
+                const Xfer< surfZoneList >& zones
+            );
+
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/surfMesh/MeshedSurfaceProxy/MeshedSurfaceProxy.C b/src/surfMesh/MeshedSurfaceProxy/MeshedSurfaceProxy.C
new file mode 100644
index 0000000000..95b7bb911c
--- /dev/null
+++ b/src/surfMesh/MeshedSurfaceProxy/MeshedSurfaceProxy.C
@@ -0,0 +1,153 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2009 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 "MeshedSurfaceProxy.H"
+#include "Time.H"
+#include "surfMesh.H"
+#include "MeshedSurface.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+template<class Face>
+Foam::wordHashSet Foam::MeshedSurfaceProxy<Face>::writeTypes()
+{
+    return wordHashSet(*writefileExtensionMemberFunctionTablePtr_);
+}
+
+
+// * * * * * * * * * * * * * Static Member Functions * * * * * * * * * * * * //
+
+template<class Face>
+bool Foam::MeshedSurfaceProxy<Face>::canWriteType
+(
+    const word& ext,
+    const bool verbose
+)
+{
+    return checkSupport(writeTypes(), ext, verbose, "writing");
+}
+
+
+template<class Face>
+void Foam::MeshedSurfaceProxy<Face>::write
+(
+    const fileName& name,
+    const MeshedSurfaceProxy& surf
+)
+{
+    if (debug)
+    {
+        Info<< "MeshedSurfaceProxy::write"
+            "(const fileName&, const MeshedSurfaceProxy&) : "
+            "writing to " << name
+            << endl;
+    }
+
+    word ext = name.ext();
+
+    typename writefileExtensionMemberFunctionTable::iterator mfIter =
+        writefileExtensionMemberFunctionTablePtr_->find(ext);
+
+    if (mfIter == writefileExtensionMemberFunctionTablePtr_->end())
+    {
+        FatalErrorIn
+        (
+            "MeshedSurfaceProxy::write(const fileName&)"
+        )   << "Unknown file extension " << ext << nl << nl
+            << "Valid types are :" << endl
+            << writeTypes()
+            << exit(FatalError);
+    }
+
+    mfIter()(name, surf);
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+template<class Face>
+Foam::MeshedSurfaceProxy<Face>::MeshedSurfaceProxy
+(
+    const pointField& pointLst,
+    const List<Face>& faceLst,
+    const List<surfZone>& zoneLst,
+    const List<label>& faceMap
+)
+:
+    points_(pointLst),
+    faces_(faceLst),
+    zones_(zoneLst),
+    faceMap_(faceMap)
+{}
+
+
+template<class Face>
+Foam::MeshedSurfaceProxy<Face>::MeshedSurfaceProxy
+(
+    const MeshedSurface<Face>& surf
+)
+:
+    points_(surf.points()),
+    faces_(surf.faces()),
+    zones_(surf.surfZones()),
+    faceMap_(List<label>())
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+template<class Face>
+Foam::MeshedSurfaceProxy<Face>::~MeshedSurfaceProxy()
+{}
+
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+// template<class Face>
+// void Foam::MeshedSurfaceProxy<Face>::write
+// (
+//     const Time& d,
+//     const word& surfName
+// ) const
+// {
+//     write(findMeshFile(d, surfName)());
+// }
+
+// * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * * Friend Functions  * * * * * * * * * * * * * //
+
+// * * * * * * * * * * * * * * * IOstream Operators  * * * * * * * * * * * * //
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+// ************************************************************************* //
diff --git a/src/surfMesh/MeshedSurfaceProxy/MeshedSurfaceProxy.H b/src/surfMesh/MeshedSurfaceProxy/MeshedSurfaceProxy.H
new file mode 100644
index 0000000000..69b65fdece
--- /dev/null
+++ b/src/surfMesh/MeshedSurfaceProxy/MeshedSurfaceProxy.H
@@ -0,0 +1,207 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2009 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
+
+Class
+    Foam::MeshedSurfaceProxy
+
+Description
+    A proxy for writing MeshedSurface, UnsortedMeshedSurface and surfMesh
+    to various file formats.
+
+SourceFiles
+    MeshedSurfaceProxy.C
+    MeshedSurfaceProxyCore.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef MeshedSurfaceProxy_H
+#define MeshedSurfaceProxy_H
+
+#include "pointField.H"
+#include "face.H"
+#include "triFace.H"
+
+#include "surfZoneList.H"
+#include "surfaceFormatsCore.H"
+#include "runTimeSelectionTables.H"
+#include "memberFunctionSelectionTables.H"
+#include "HashSet.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// Forward declaration of friend functions and operators
+
+template<class Face> class MeshedSurface;
+
+/*---------------------------------------------------------------------------*\
+                     Class MeshedSurfaceProxy Declaration
+\*---------------------------------------------------------------------------*/
+
+template<class Face>
+class MeshedSurfaceProxy
+:
+    public fileFormats::surfaceFormatsCore
+{
+    //- Private data
+
+        const pointField& points_;
+
+        const List<Face>& faces_;
+
+        const List<surfZone>& zones_;
+
+        const List<label>& faceMap_;
+
+
+    // Private Member Functions
+
+        //- Disallow default bitwise copy construct
+        MeshedSurfaceProxy(const MeshedSurfaceProxy&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const MeshedSurfaceProxy&);
+
+public:
+
+        //- Runtime type information
+        ClassName("MeshedSurfaceProxy");
+
+    // Static
+
+        //- Can we write this file format?
+        static bool canWriteType(const word& ext, const bool verbose=false);
+
+        static wordHashSet writeTypes();
+
+    // Constructors
+
+        //- Construct from component references
+        MeshedSurfaceProxy
+        (
+            const pointField&,
+            const List<Face>&,
+            const List<surfZone>&,
+            const List<label>& faceMap = List<label>()
+        );
+
+        //- Construct from MeshedSurface
+        explicit MeshedSurfaceProxy
+        (
+            const MeshedSurface<Face>&
+        );
+
+    // Destructor
+
+        virtual ~MeshedSurfaceProxy();
+
+
+    // Member Function Selectors
+
+        declareMemberFunctionSelectionTable
+        (
+            void,
+            MeshedSurfaceProxy,
+            write,
+            fileExtension,
+            (
+                const fileName& name,
+                const MeshedSurfaceProxy<Face>& surf
+            ),
+            (name, surf)
+        );
+
+        //- Write to file
+        static void write(const fileName&, const MeshedSurfaceProxy<Face>&);
+
+
+    // Member Functions
+
+    // Access
+
+        //- Return const access to the points
+        inline const pointField& points() const
+        {
+            return points_;
+        }
+
+        //- Return const access to the faces
+        inline const List<Face>& faces() const
+        {
+            return faces_;
+        }
+
+        //- Const access to the surface zones.
+        //  If zones are defined, they must be contiguous and cover the entire
+        //  surface.
+        inline const List<surfZone>& surfZones() const
+        {
+            return zones_;
+        }
+
+        //- Const access to the faceMap, zero-sized when unused
+        inline const List<label>& faceMap() const
+        {
+            return faceMap_;
+        }
+
+        //- Use faceMap?
+        inline bool useFaceMap() const
+        {
+            return faceMap_.size() == faces_.size();
+        }
+
+    // Write
+
+//??        void writeStats(Ostream& os) const;
+
+        //- Generic write routine. Chooses writer based on extension.
+        virtual void write(const fileName& name) const
+        {
+            write(name, *this);
+        }
+
+        //- Write to database
+//??        void write(const Time&, const word& surfName="") const;
+
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+#   include "MeshedSurfaceProxy.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/surfMesh/surfaceFormats/off/OFFsurfaceFormatCore.H b/src/surfMesh/MeshedSurfaceProxy/MeshedSurfaceProxyCore.C
similarity index 61%
rename from src/surfMesh/surfaceFormats/off/OFFsurfaceFormatCore.H
rename to src/surfMesh/MeshedSurfaceProxy/MeshedSurfaceProxyCore.C
index e72bc82ee7..41b360fd3e 100644
--- a/src/surfMesh/surfaceFormats/off/OFFsurfaceFormatCore.H
+++ b/src/surfMesh/MeshedSurfaceProxy/MeshedSurfaceProxyCore.C
@@ -22,60 +22,28 @@ License
     along with OpenFOAM; if not, write to the Free Software Foundation,
     Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 
-Class
-    Foam::fileFormats::OFFsurfaceFormatCore
-
-Description
-    Internal class used by the OFFsurfaceFormat
-
-SourceFiles
-    OFFsurfaceFormatCore.C
-
 \*---------------------------------------------------------------------------*/
 
-#ifndef OFFsurfaceFormatCore_H
-#define OFFsurfaceFormatCore_H
-
-#include "Ostream.H"
-#include "OFstream.H"
-#include "MeshedSurface.H"
-#include "UnsortedMeshedSurface.H"
+#include "MeshedSurfaceProxy.H"
+#include "addToRunTimeSelectionTable.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 namespace Foam
 {
-namespace fileFormats
-{
 
-/*---------------------------------------------------------------------------*\
-                    Class OFFsurfaceFormatCore Declaration
-\*---------------------------------------------------------------------------*/
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-class OFFsurfaceFormatCore
-{
-protected:
-    // Protected Member Functions
+#define makeSurface(surfType, faceType)                                       \
+    defineNamedTemplateTypeNameAndDebug(surfType<faceType>, 0);               \
+    defineTemplatedMemberFunctionSelectionTable(surfType,write,fileExtension,faceType);
 
-    //- Write header information with points
-    static void writeHeader
-    (
-        Ostream&,
-        const pointField&,
-        const label nFaces,
-        const UList<surfZone>&
-    );
-
-};
 
+makeSurface(MeshedSurfaceProxy, face)
+makeSurface(MeshedSurfaceProxy, triFace)
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-} // End namespace fileFormats
 } // End namespace Foam
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#endif
-
 // ************************************************************************* //
diff --git a/src/surfMesh/UnsortedMeshedSurface/UnsortedMeshedSurface.C b/src/surfMesh/UnsortedMeshedSurface/UnsortedMeshedSurface.C
index f74ccdae0b..2268448a10 100644
--- a/src/surfMesh/UnsortedMeshedSurface/UnsortedMeshedSurface.C
+++ b/src/surfMesh/UnsortedMeshedSurface/UnsortedMeshedSurface.C
@@ -57,21 +57,13 @@ bool Foam::UnsortedMeshedSurface<Face>::canReadType
     const bool verbose
 )
 {
-    // handle 'native' format directly
-    if (isNative(ext))
-    {
-        return true;
-    }
-    else
-    {
-        return checkSupport
-        (
-            readTypes() | SiblingType::readTypes(),
-            ext,
-            verbose,
-            "reading"
-        );
-    }
+   return checkSupport
+   (
+       readTypes() | ParentType::readTypes(),
+       ext,
+       verbose,
+       "reading"
+   );
 }
 
 
@@ -82,13 +74,13 @@ bool Foam::UnsortedMeshedSurface<Face>::canWriteType
     const bool verbose
 )
 {
-    // handle 'native' format directly
-    if (isNative(ext))
-    {
-        return true;
-    }
-
-    return checkSupport(writeTypes(), ext, verbose, "writing");
+    return checkSupport
+    (
+        writeTypes(),
+        ext,
+        verbose,
+        "writing"
+    );
 }
 
 
@@ -125,29 +117,43 @@ void Foam::UnsortedMeshedSurface<Face>::write
 
     const word ext = name.ext();
 
-    // handle 'native' format directly
-    if (isNative(ext))
-    {
-        surf.write(OFstream(name)());
-        return;
-    }
-
     typename writefileExtensionMemberFunctionTable::iterator mfIter =
         writefileExtensionMemberFunctionTablePtr_->find(ext);
 
     if (mfIter == writefileExtensionMemberFunctionTablePtr_->end())
     {
-        FatalErrorIn
-        (
-            "UnsortedMeshedSurface::write"
-            "(const fileName&, const UnsortedMeshedSurface&)"
-        )   << "Unknown file extension " << ext << nl << nl
-            << "Valid types are :" << endl
-            << writeTypes()
-            << exit(FatalError);
-    }
+        // no direct writer, delegate to proxy if possible
+        wordHashSet supported = ProxyType::writeTypes();
 
-    mfIter()(name, surf);
+        if (supported.found(ext))
+        {
+            labelList faceMap;
+            List<surfZone> zoneLst = surf.sortedZones(faceMap);
+
+            MeshedSurfaceProxy<Face>
+            (
+                surf.points(),
+                surf.faces(),
+                zoneLst,
+                faceMap
+            ).write(name);
+        }
+        else
+        {
+            FatalErrorIn
+            (
+                "UnsortedMeshedSurface::write"
+                "(const fileName&, const UnsortedMeshedSurface&)"
+            )   << "Unknown file extension " << ext << nl << nl
+                << "Valid types are :" << endl
+                << (supported | writeTypes())
+                << exit(FatalError);
+        }
+    }
+    else
+    {
+        mfIter()(name, surf);
+    }
 }
 
 
@@ -155,16 +161,18 @@ void Foam::UnsortedMeshedSurface<Face>::write
 
 template<class Face>
 Foam::UnsortedMeshedSurface<Face>::UnsortedMeshedSurface()
+:
+    ParentType()
 {}
 
 
 template<class Face>
 Foam::UnsortedMeshedSurface<Face>::UnsortedMeshedSurface
 (
-    const Xfer<pointField>& pointLst,
-    const Xfer<List<Face> >& faceLst,
-    const Xfer<List<label> >& zoneIds,
-    const Xfer<surfZoneIdentifierList>& zoneTofc
+    const Xfer< pointField >& pointLst,
+    const Xfer< List<Face> >& faceLst,
+    const Xfer< List<label> >& zoneIds,
+    const Xfer< surfZoneIdentifierList >& zoneTofc
 )
 :
     ParentType(pointLst, faceLst),
@@ -176,17 +184,17 @@ Foam::UnsortedMeshedSurface<Face>::UnsortedMeshedSurface
 template<class Face>
 Foam::UnsortedMeshedSurface<Face>::UnsortedMeshedSurface
 (
-    const Xfer<pointField>& pointLst,
-    const Xfer<List<Face> >& faceLst,
+    const Xfer< pointField >& pointLst,
+    const Xfer< List<Face> >& faceLst,
     const UList<label>& zoneSizes,
     const UList<word>& zoneNames
 )
 :
     ParentType(pointLst, faceLst)
 {
-    if (&zoneSizes)
+    if (zoneSizes.size())
     {
-        if (&zoneNames)
+        if (zoneNames.size())
         {
             setZones(zoneSizes, zoneNames);
         }
@@ -197,89 +205,50 @@ Foam::UnsortedMeshedSurface<Face>::UnsortedMeshedSurface
     }
     else
     {
-        oneZone();
+        setOneZone();
     }
 }
 
 
-template<class Face>
-Foam::UnsortedMeshedSurface<Face>::UnsortedMeshedSurface
-(
-    const polyBoundaryMesh& bMesh,
-    const bool useGlobalPoints
-)
-{
-    // creating via MeshedSurface is the easiest
-    MeshedSurface<Face> surf(bMesh, useGlobalPoints);
-    transfer(surf);
-}
-
-
-template<class Face>
-Foam::UnsortedMeshedSurface<Face>::UnsortedMeshedSurface
-(
-    const MeshedSurface<Face>& surf
-)
-:
-    ParentType(xferCopy(surf.points()), xferCopy(surf.faces()))
-{
-    setZones(surf.zones());
-}
-
-
-template<class Face>
-Foam::UnsortedMeshedSurface<Face>::UnsortedMeshedSurface
-(
-    const fileName& name,
-    const word& ext
-)
-{
-    read(name, ext);
-}
-
-
-template<class Face>
-Foam::UnsortedMeshedSurface<Face>::UnsortedMeshedSurface(const fileName& name)
-{
-    read(name);
-}
-
-
-template<class Face>
-Foam::UnsortedMeshedSurface<Face>::UnsortedMeshedSurface(Istream& is)
-{
-    read(is);
-}
-
-
-template<class Face>
-Foam::UnsortedMeshedSurface<Face>::UnsortedMeshedSurface
-(
-    const Time& d,
-    const word& surfName
-)
-{
-    read(IFstream(findMeshFile(d, surfName))());
-}
-
-
 template<class Face>
 Foam::UnsortedMeshedSurface<Face>::UnsortedMeshedSurface
 (
     const UnsortedMeshedSurface<Face>& surf
 )
 :
-    ParentType(xferCopy(surf.points()), xferCopy(surf.faces())),
-    zoneIds_(surf.zoneIds_),
-    zoneToc_(surf.zoneToc_)
+    ParentType
+    (
+        xferCopy(surf.points()),
+        xferCopy(surf.faces())
+    ),
+    zoneIds_(surf.zoneIds()),
+    zoneToc_(surf.zoneToc())
 {}
 
 
 template<class Face>
 Foam::UnsortedMeshedSurface<Face>::UnsortedMeshedSurface
 (
-    const Xfer<UnsortedMeshedSurface<Face> >& surf
+    const MeshedSurface<Face>& surf
 )
+:
+    ParentType
+    (
+        xferCopy(surf.points()),
+        xferCopy(surf.faces())
+    )
+{
+    setZones(surf.surfZones());
+}
+
+
+template<class Face>
+Foam::UnsortedMeshedSurface<Face>::UnsortedMeshedSurface
+(
+    const Xfer< UnsortedMeshedSurface<Face> >& surf
+)
+:
+    ParentType()
 {
     transfer(surf());
 }
@@ -288,12 +257,50 @@ Foam::UnsortedMeshedSurface<Face>::UnsortedMeshedSurface
 template<class Face>
 Foam::UnsortedMeshedSurface<Face>::UnsortedMeshedSurface
 (
-    const Xfer<MeshedSurface<Face> >& surf
+    const Xfer< MeshedSurface<Face> >& surf
 )
+:
+    ParentType()
 {
     transfer(surf());
 }
 
+
+template<class Face>
+Foam::UnsortedMeshedSurface<Face>::UnsortedMeshedSurface
+(
+    const fileName& name,
+    const word& ext
+)
+:
+    ParentType()
+{
+    read(name, ext);
+}
+
+
+template<class Face>
+Foam::UnsortedMeshedSurface<Face>::UnsortedMeshedSurface(const fileName& name)
+:
+    ParentType()
+{
+    read(name);
+}
+
+
+template<class Face>
+Foam::UnsortedMeshedSurface<Face>::UnsortedMeshedSurface
+(
+    const Time& d,
+    const word& surfName
+)
+:
+    ParentType()
+{
+    read(this->findMeshFile(d, surfName));
+}
+
+
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
 template<class Face>
@@ -308,22 +315,19 @@ Foam::UnsortedMeshedSurface<Face>::~UnsortedMeshedSurface()
 // * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
 
 template<class Face>
-void Foam::UnsortedMeshedSurface<Face>::oneZone(const word& name)
+void Foam::UnsortedMeshedSurface<Face>::setOneZone()
 {
     zoneIds_.setSize(size());
     zoneIds_ = 0;
 
-    word zoneName(name);
+    word zoneName;
+    if (zoneToc_.size())
+    {
+        zoneName = zoneToc_[0].name();
+    }
     if (zoneName.empty())
     {
-        if (zoneToc_.size())
-        {
-            zoneName = zoneToc_[0].name();
-        }
-        if (zoneName.empty())
-        {
-            zoneName = "zone0";
-        }
+        zoneName = "zone0";
     }
 
     // set single default zone
@@ -344,7 +348,6 @@ void Foam::UnsortedMeshedSurface<Face>::setZones
     forAll(zoneToc_, zoneI)
     {
         const surfZone& zone = zoneLst[zoneI];
-
         zoneToc_[zoneI] = zone;
 
         // assign sub-zone Ids
@@ -416,7 +419,7 @@ void Foam::UnsortedMeshedSurface<Face>::remapFaces
     {
         if (zoneToc_.empty())
         {
-            oneZone();
+            setOneZone();
         }
         else if (zoneToc_.size() == 1)
         {
@@ -442,7 +445,7 @@ void Foam::UnsortedMeshedSurface<Face>::remapFaces
 template<class Face>
 void Foam::UnsortedMeshedSurface<Face>::setSize(const label s)
 {
-    ParentType::setSize(s);
+    this->storedFaces().setSize(s);
     // if zones extend: set with last zoneId
     zoneIds_.setSize(s, zoneToc_.size() - 1);
 }
@@ -470,12 +473,13 @@ Foam::surfZoneList Foam::UnsortedMeshedSurface<Face>::sortedZones
         zoneNames.insert(zoneI, zoneToc_[zoneI].name());
     }
 
-    return sortedZonesById(zoneIds_, zoneNames, faceMap);
+    return this->sortedZonesById(zoneIds_, zoneNames, faceMap);
 }
 
 
 template<class Face>
-Foam::UnsortedMeshedSurface<Face> Foam::UnsortedMeshedSurface<Face>::subsetMesh
+Foam::UnsortedMeshedSurface<Face>
+Foam::UnsortedMeshedSurface<Face>::subsetMesh
 (
     const labelHashSet& include,
     labelList& pointMap,
@@ -542,12 +546,39 @@ Foam::UnsortedMeshedSurface<Face> Foam::UnsortedMeshedSurface<Face>::subsetMesh
 template<class Face>
 void Foam::UnsortedMeshedSurface<Face>::reset
 (
-    const Xfer<pointField>& pointLst,
-    const Xfer<List<Face> >& faceLst,
-    const Xfer<List<label> >& zoneIds
+    const Xfer< pointField >& pointLst,
+    const Xfer< List<Face> >& faceLst,
+    const Xfer< List<label> >& zoneIds
 )
 {
-    ParentType::reset(pointLst, faceLst);
+    ParentType::reset
+    (
+        pointLst,
+        faceLst,
+        Xfer<surfZoneList>()
+    );
+
+    if (&zoneIds)
+    {
+        zoneIds_.transfer(zoneIds());
+    }
+}
+
+
+template<class Face>
+void Foam::UnsortedMeshedSurface<Face>::reset
+(
+    const Xfer< List<point> >& pointLst,
+    const Xfer< List<Face> >& faceLst,
+    const Xfer< List<label> >& zoneIds
+)
+{
+    ParentType::reset
+    (
+        pointLst,
+        faceLst,
+        Xfer<surfZoneList>()
+    );
 
     if (&zoneIds)
     {
@@ -562,12 +593,14 @@ void Foam::UnsortedMeshedSurface<Face>::transfer
     UnsortedMeshedSurface<Face>& surf
 )
 {
-    reset
+    ParentType::reset
     (
         xferMove(surf.storedPoints()),
         xferMove(surf.storedFaces()),
-        xferMove(surf.zoneIds_)
+        Xfer<surfZoneList>()
     );
+
+    zoneIds_.transfer(surf.zoneIds_);
     zoneToc_.transfer(surf.zoneToc_);
 
     surf.clear();
@@ -580,8 +613,14 @@ void Foam::UnsortedMeshedSurface<Face>::transfer
     MeshedSurface<Face>& surf
 )
 {
-    reset(xferMove(surf.storedPoints()), xferMove(surf.storedFaces()));
-    setZones(surf.zones());
+    ParentType::reset
+    (
+        xferMove(surf.storedPoints()),
+        xferMove(surf.storedFaces()),
+        Xfer<surfZoneList>()
+    );
+
+    setZones(surf.surfZones());
     surf.clear();
 }
 
@@ -620,17 +659,11 @@ bool Foam::UnsortedMeshedSurface<Face>::read
     const word& ext
 )
 {
-    // handle 'native' format directly
-    if (isNative(ext))
-    {
-        return read(IFstream(name)());
-    }
-    else
-    {
-        // use selector mechanism
-        transfer(New(name, ext)());
-        return true;
-    }
+    clear();
+
+    // read via use selector mechanism
+    transfer(New(name, ext)());
+    return true;
 }
 
 
@@ -641,7 +674,7 @@ void Foam::UnsortedMeshedSurface<Face>::write
     const word& surfName
 ) const
 {
-    write(OFstream(findMeshFile(d, surfName))());
+    write(OFstream(this->findMeshFile(d, surfName))());
 }
 
 
@@ -668,7 +701,6 @@ void Foam::UnsortedMeshedSurface<Face>::operator=
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-#include "UnsortedMeshedSurfaceIO.C"
 #include "UnsortedMeshedSurfaceNew.C"
 
 // ************************************************************************* //
diff --git a/src/surfMesh/UnsortedMeshedSurface/UnsortedMeshedSurface.H b/src/surfMesh/UnsortedMeshedSurface/UnsortedMeshedSurface.H
index efecda798b..4056384db3 100644
--- a/src/surfMesh/UnsortedMeshedSurface/UnsortedMeshedSurface.H
+++ b/src/surfMesh/UnsortedMeshedSurface/UnsortedMeshedSurface.H
@@ -47,7 +47,7 @@ SourceFiles
 #ifndef UnsortedMeshedSurface_H
 #define UnsortedMeshedSurface_H
 
-#include "BasicMeshedSurface.H"
+#include "MeshedSurface.H"
 #include "surfZoneIdentifierList.H"
 #include "surfZoneList.H"
 #include "surfaceFormatsCore.H"
@@ -64,14 +64,10 @@ namespace Foam
 
 class Time;
 class IFstream;
-template<class Face> class UnsortedMeshedSurface;
+
 template<class Face> class MeshedSurface;
-
-class polyBoundaryMesh;
-
-template<class Face>
-Ostream& operator<<(Ostream&, const UnsortedMeshedSurface<Face>&);
-
+template<class Face> class MeshedSurfaceProxy;
+template<class Face> class UnsortedMeshedSurface;
 
 /*---------------------------------------------------------------------------*\
                    Class UnsortedMeshedSurface Declaration
@@ -80,8 +76,7 @@ Ostream& operator<<(Ostream&, const UnsortedMeshedSurface<Face>&);
 template<class Face>
 class UnsortedMeshedSurface
 :
-    public BasicMeshedSurface<Face>,
-    public fileFormats::surfaceFormatsCore
+    public MeshedSurface<Face>
 {
     // friends despite different faces
     template<class Face2>
@@ -95,9 +90,11 @@ class UnsortedMeshedSurface
 
 private:
 
-    //- Typedefs for convenience
-        typedef BasicMeshedSurface<Face> ParentType;
-        typedef MeshedSurface<Face> SiblingType;
+    //- Private typedefs for convenience
+
+        typedef MeshedSurface<Face>       ParentType;
+        typedef MeshedSurface<Face>       FriendType;
+        typedef MeshedSurfaceProxy<Face>  ProxyType;
 
     // Private Member Data
 
@@ -166,10 +163,10 @@ public:
         //  (points, faces, zone ids, zone info).
         UnsortedMeshedSurface
         (
-            const Xfer<pointField>&,
-            const Xfer<List<Face> >&,
-            const Xfer<List<label> >& zoneIds,
-            const Xfer<surfZoneIdentifierList>&
+            const Xfer< pointField >&,
+            const Xfer< List<Face> >&,
+            const Xfer< List<label> >& zoneIds,
+            const Xfer< surfZoneIdentifierList >&
         );
 
         //- Construct by transferring points, faces.
@@ -178,16 +175,12 @@ public:
         (
             const Xfer<pointField>&,
             const Xfer<List<Face> >&,
-            const UList<label>& zoneSizes = UList<label>::null(),
-            const UList<word>& zoneNames = UList<word>::null()
+            const UList<label>& zoneSizes = UList<label>(),
+            const UList<word>& zoneNames = UList<word>()
         );
 
-        //- Construct from a boundary mesh with local points/faces
-        UnsortedMeshedSurface
-        (
-            const polyBoundaryMesh&,
-            const bool globalPoints=false
-        );
+        //- Construct as copy
+        UnsortedMeshedSurface(const UnsortedMeshedSurface<Face>&);
 
         //- Construct from a meshedSurface
         UnsortedMeshedSurface(const MeshedSurface<Face>&);
@@ -210,9 +203,6 @@ public:
         //- Construct from objectRegistry
         UnsortedMeshedSurface(const Time&, const word& surfName="");
 
-        //- Construct as copy
-        UnsortedMeshedSurface(const UnsortedMeshedSurface<Face>&);
-
     // Declare run-time constructor selection table
 
         declareRunTimeSelectionTable
@@ -292,8 +282,7 @@ public:
         surfZoneList sortedZones(labelList& faceMap) const;
 
         //- Set zones to 0 and set a single zone
-        //  Optionally with a specific name
-        void oneZone(const word& name = word::null);
+        void setOneZone();
 
         //- Set zone ids and zones
         void setZones(const surfZoneList&);
@@ -328,9 +317,17 @@ public:
         //- Transfer components (points, faces, zone ids).
         virtual void reset
         (
-            const Xfer<pointField>&,
-            const Xfer<List<Face> >&,
-            const Xfer<List<label> >& zoneIds = Xfer<List<label> >::null()
+            const Xfer< pointField >&,
+            const Xfer< List<Face> >&,
+            const Xfer< List<label> >& zoneIds
+        );
+
+        //- Transfer components (points, faces, zone ids).
+        virtual void reset
+        (
+            const Xfer< List<point> >&,
+            const Xfer< List<Face> >&,
+            const Xfer< List<label> >& zoneIds
         );
 
         //- Transfer the contents of the argument and annull the argument
@@ -354,9 +351,6 @@ public:
 
     // Write
 
-        //- Write to Ostream in simple FOAM format
-        virtual void write(Ostream&) const;
-
         //- Generic write routine. Chooses writer based on extension.
         virtual void write(const fileName& name) const
         {
@@ -372,15 +366,6 @@ public:
         void operator=(const UnsortedMeshedSurface<Face>&);
 
 
-    // Ostream Operator
-
-        friend Ostream& operator<<
-        <Face>
-        (
-            Ostream&,
-            const UnsortedMeshedSurface<Face>&
-        );
-
 };
 
 
diff --git a/src/surfMesh/UnsortedMeshedSurface/UnsortedMeshedSurfaceIO.C b/src/surfMesh/UnsortedMeshedSurface/UnsortedMeshedSurfaceIO.C
deleted file mode 100644
index 391f0dc83b..0000000000
--- a/src/surfMesh/UnsortedMeshedSurface/UnsortedMeshedSurfaceIO.C
+++ /dev/null
@@ -1,108 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 1991-2009 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 "UnsortedMeshedSurface.H"
-#include "IFstream.H"
-#include "OFstream.H"
-
-// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
-
-// Read surf grouping, points, faces directly from Istream
-template<class Face>
-bool Foam::UnsortedMeshedSurface<Face>::read(Istream& is)
-{
-    MeshedSurface<Face> surf(is);
-
-    transfer(surf);
-    return is.good();
-}
-
-
-// write (sorted)
-template<class Face>
-void Foam::UnsortedMeshedSurface<Face>::write(Ostream& os) const
-{
-    const List<Face>& faceLst = this->faces();
-
-    labelList faceMap;
-    surfZoneList zoneLst = sortedZones(faceMap);
-
-    // just emit some information until we get a nice IOobject
-    IOobject::writeBanner(os);
-    os  << "// OpenFOAM Surface Format" << nl
-        << "// ~~~~~~~~~~~~~~~~~~~~~~~" << nl
-        << "// zones:" << nl
-        << zoneLst.size() << nl << token::BEGIN_LIST << incrIndent << nl;
-
-    forAll(zoneLst, zoneI)
-    {
-        zoneLst[zoneI].writeDict(os);
-    }
-    os  << decrIndent << token::END_LIST << nl;
-
-    IOobject::writeDivider(os);
-
-    // Note: Write with global point numbering
-    os  << "\n// points:" << nl << this->points() << nl;
-
-    IOobject::writeDivider(os);
-    os  << "\n// faces:"  << nl;
-    os  << faceLst.size() << nl << token::BEGIN_LIST << nl;
-
-    label faceI = 0;
-    forAll(zoneLst, zoneI)
-    {
-        // Print all faces belonging to this zone
-        const surfZone& zone = zoneLst[zoneI];
-
-        forAll(zone, localFaceI)
-        {
-            os << faceLst[faceMap[faceI++]] << nl;
-        }
-    }
-    os << token::END_LIST << nl;
-
-    IOobject::writeDivider(os);
-
-    // Check state of Ostream
-    os.check("UnsortedMeshedSurface::write(Ostream&)");
-}
-
-// * * * * * * * * * * * * * * * IOstream Operators  * * * * * * * * * * * * //
-
-template<class Face>
-Foam::Ostream& Foam::operator<<
-(
-    Ostream& os,
-    const UnsortedMeshedSurface<Face>& surf
-)
-{
-    surf.write(os);
-    return os;
-}
-
-// ************************************************************************* //
diff --git a/src/surfMesh/UnsortedMeshedSurface/UnsortedMeshedSurfaceNew.C b/src/surfMesh/UnsortedMeshedSurface/UnsortedMeshedSurfaceNew.C
index d57cce6608..222acc4055 100644
--- a/src/surfMesh/UnsortedMeshedSurface/UnsortedMeshedSurfaceNew.C
+++ b/src/surfMesh/UnsortedMeshedSurface/UnsortedMeshedSurfaceNew.C
@@ -30,7 +30,7 @@ License
 
 
 template<class Face>
-Foam::autoPtr<Foam::UnsortedMeshedSurface<Face> >
+Foam::autoPtr< Foam::UnsortedMeshedSurface<Face> >
 Foam::UnsortedMeshedSurface<Face>::New(const fileName& name, const word& ext)
 {
     if (debug)
@@ -45,8 +45,8 @@ Foam::UnsortedMeshedSurface<Face>::New(const fileName& name, const word& ext)
 
     if (cstrIter == fileExtensionConstructorTablePtr_->end())
     {
-        // no direct reader, delegate if possible
-        wordHashSet supported = SiblingType::readTypes();
+        // no direct reader, use the parent if possible
+        wordHashSet supported = ParentType::readTypes();
         if (supported.found(ext))
         {
             // create indirectly
@@ -54,14 +54,13 @@ Foam::UnsortedMeshedSurface<Face>::New(const fileName& name, const word& ext)
             (
                 new UnsortedMeshedSurface<Face>
             );
-            surf().transfer(SiblingType::New(name, ext)());
+            surf().transfer(ParentType::New(name, ext)());
 
             return surf;
         }
 
         // nothing left but to issue an error
         supported += readTypes();
-        supported.insert(nativeExt);
 
         FatalErrorIn
         (
@@ -79,7 +78,7 @@ Foam::UnsortedMeshedSurface<Face>::New(const fileName& name, const word& ext)
 
 
 template<class Face>
-Foam::autoPtr<Foam::UnsortedMeshedSurface<Face> >
+Foam::autoPtr< Foam::UnsortedMeshedSurface<Face> >
 Foam::UnsortedMeshedSurface<Face>::New(const fileName& name)
 {
     word ext = name.ext();
diff --git a/src/surfMesh/surfFields/surfFields.C b/src/surfMesh/surfFields/surfFields/surfFields.C
similarity index 100%
rename from src/surfMesh/surfFields/surfFields.C
rename to src/surfMesh/surfFields/surfFields/surfFields.C
diff --git a/src/surfMesh/surfFields/surfFields.H b/src/surfMesh/surfFields/surfFields/surfFields.H
similarity index 100%
rename from src/surfMesh/surfFields/surfFields.H
rename to src/surfMesh/surfFields/surfFields/surfFields.H
diff --git a/src/surfMesh/surfFields/surfFieldsFwd.H b/src/surfMesh/surfFields/surfFields/surfFieldsFwd.H
similarity index 100%
rename from src/surfMesh/surfFields/surfFieldsFwd.H
rename to src/surfMesh/surfFields/surfFields/surfFieldsFwd.H
diff --git a/src/surfMesh/surfFields/surfGeoMesh.H b/src/surfMesh/surfFields/surfFields/surfGeoMesh.H
similarity index 100%
rename from src/surfMesh/surfFields/surfGeoMesh.H
rename to src/surfMesh/surfFields/surfFields/surfGeoMesh.H
diff --git a/src/surfMesh/surfPointFields/surfPointFields.C b/src/surfMesh/surfFields/surfPointFields/surfPointFields.C
similarity index 100%
rename from src/surfMesh/surfPointFields/surfPointFields.C
rename to src/surfMesh/surfFields/surfPointFields/surfPointFields.C
diff --git a/src/surfMesh/surfPointFields/surfPointFields.H b/src/surfMesh/surfFields/surfPointFields/surfPointFields.H
similarity index 100%
rename from src/surfMesh/surfPointFields/surfPointFields.H
rename to src/surfMesh/surfFields/surfPointFields/surfPointFields.H
diff --git a/src/surfMesh/surfPointFields/surfPointFieldsFwd.H b/src/surfMesh/surfFields/surfPointFields/surfPointFieldsFwd.H
similarity index 100%
rename from src/surfMesh/surfPointFields/surfPointFieldsFwd.H
rename to src/surfMesh/surfFields/surfPointFields/surfPointFieldsFwd.H
diff --git a/src/surfMesh/surfPointFields/surfPointGeoMesh.H b/src/surfMesh/surfFields/surfPointFields/surfPointGeoMesh.H
similarity index 100%
rename from src/surfMesh/surfPointFields/surfPointGeoMesh.H
rename to src/surfMesh/surfFields/surfPointFields/surfPointGeoMesh.H
diff --git a/src/surfMesh/surfMesh/surfMesh.C b/src/surfMesh/surfMesh/surfMesh.C
index c6166345da..1f2d35a54f 100644
--- a/src/surfMesh/surfMesh/surfMesh.C
+++ b/src/surfMesh/surfMesh/surfMesh.C
@@ -25,6 +25,8 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "surfMesh.H"
+#include "MeshedSurfaceProxy.H"
+
 #include "Time.H"
 #include "cellIOList.H"
 #include "SubList.H"
@@ -40,29 +42,30 @@ Foam::word Foam::surfMesh::meshSubDir = "surfMesh";
 
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 
-void Foam::surfMesh::oneZone()
-{
-    word zoneName;
-
-    if (surfZones_.size())
-    {
-        zoneName = surfZones_[0].name();
-    }
-    if (zoneName.empty())
-    {
-        zoneName = "zone0";
-    }
-
-    // set single default zone
-    surfZones_.setSize(1);
-    surfZones_[0] = surfZone
-    (
-        zoneName,
-        nFaces(),       // zone size
-        0,              // zone start
-        0               // zone index
-    );
-}
+// void Foam::surfMesh::oneZone()
+// {
+//     word zoneName;
+//
+//     surfZoneList& zones = Allocator::storedIOZones();
+//     if (zones.size())
+//     {
+//         zoneName = zones[0].name();
+//     }
+//     if (zoneName.empty())
+//     {
+//         zoneName = "zone0";
+//     }
+//
+//     // set single default zone
+//     zones.setSize(1);
+//     zones[0] = surfZone
+//     (
+//         zoneName,
+//         nFaces(),       // zone size
+//         0,              // zone start
+//         0               // zone index
+//     );
+// }
 
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
@@ -71,7 +74,7 @@ void Foam::surfMesh::oneZone()
 Foam::surfMesh::surfMesh(const IOobject& io, const word& surfName)
 :
     surfaceRegistry(io.db(), (surfName.size() ? surfName : io.name())),
-    surfMeshAllocator
+    Allocator
     (
         IOobject
         (
@@ -90,11 +93,7 @@ Foam::surfMesh::surfMesh(const IOobject& io, const word& surfName)
             *this,
             IOobject::MUST_READ,
             IOobject::NO_WRITE
-        )
-    ),
-    MeshReference(storedFaces_, storedPoints_),
-    surfZones_
-    (
+        ),
         IOobject
         (
             "surfZones",
@@ -104,20 +103,21 @@ Foam::surfMesh::surfMesh(const IOobject& io, const word& surfName)
             IOobject::MUST_READ,
             IOobject::NO_WRITE
         )
-    )
+    ),
+    MeshReference(this->storedIOFaces(), this->storedIOPoints())
 {}
 
 
 Foam::surfMesh::surfMesh
 (
     const IOobject& io,
-    const Xfer<pointField>& pointLst,
-    const Xfer<faceList>& faceLst,
+    const Xfer< pointField >& pointLst,
+    const Xfer< faceList >& faceLst,
     const word& surfName
 )
 :
     surfaceRegistry(io.db(), (surfName.size() ? surfName : io.name())),
-    surfMeshAllocator
+    Allocator
     (
         IOobject
         (
@@ -138,11 +138,7 @@ Foam::surfMesh::surfMesh
             IOobject::NO_READ,
             IOobject::AUTO_WRITE
         ),
-        faceLst
-    ),
-    MeshReference(storedFaces_, storedPoints_),
-    surfZones_
-    (
+        faceLst,
         IOobject
         (
             "surfZones",
@@ -151,8 +147,10 @@ Foam::surfMesh::surfMesh
             *this,
             IOobject::NO_READ,
             IOobject::AUTO_WRITE
-        )
-    )
+        ),
+        Xfer<surfZoneList>()
+    ),
+    MeshReference(this->storedIOFaces(), this->storedIOPoints())
 {}
 
 
@@ -164,7 +162,7 @@ Foam::surfMesh::surfMesh
 )
 :
     surfaceRegistry(io.db(), (surfName.size() ? surfName : io.name())),
-    surfMeshAllocator
+    Allocator
     (
         IOobject
         (
@@ -185,11 +183,7 @@ Foam::surfMesh::surfMesh
             IOobject::NO_READ,
             IOobject::AUTO_WRITE
         ),
-        faceList()
-    ),
-    MeshReference(storedFaces_, storedPoints_),
-    surfZones_
-    (
+        faceList(),
         IOobject
         (
             "surfZones",
@@ -200,9 +194,21 @@ Foam::surfMesh::surfMesh
             IOobject::AUTO_WRITE
         ),
         surfZoneList()
-    )
+    ),
+    MeshReference(this->storedIOFaces(), this->storedIOPoints())
 {
-    // We can also send Xfer<..>::null just to force initialization
+    if (debug)
+    {
+        Info<<"IOobject: " << io.path() << nl
+            <<" name: " << io.name()
+            <<" instance: " << io.instance()
+            <<" local: " << io.local()
+            <<" dbDir: " << io.db().dbDir() << endl;
+        Info<<"creating surfMesh at instance " << instance() << endl;
+        Info<<"timeName: " << instance() << endl;
+    }
+
+    // We can also send Xfer<..>::null just to initialize without allocating
     if (&surf)
     {
         transfer(surf());
@@ -213,40 +219,50 @@ Foam::surfMesh::surfMesh
 
 Foam::surfMesh::~surfMesh()
 {
-    //    clearOut();
-    //    resetMotion();
+    // clearOut();
+    // resetMotion();
 }
 
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
+void Foam::surfMesh::updatePointsRef()
+{
+    // assign the reference to the points (this is truly ugly)
+    reinterpret_cast<SubField<point>&>
+    (
+        const_cast<Field<point>&>(MeshReference::points())
+    ) = reinterpret_cast<SubField<point>&>(this->storedPoints());
+}
+
+
+void Foam::surfMesh::updateFacesRef()
+{
+    // assign the reference to the faces
+    static_cast<UList<face>&>(*this) = this->storedFaces();
+}
+
+
+void Foam::surfMesh::updateRefs()
+{
+    this->updatePointsRef();
+    this->updateFacesRef();
+}
+
+
 void Foam::surfMesh::resetPrimitives
 (
-    const Xfer<pointField>& points,
-    const Xfer<faceList>& faces,
-    const Xfer<surfZoneList>& zones,
+    const Xfer< pointField >& points,
+    const Xfer< faceList >& faces,
+    const Xfer< surfZoneList >& zones,
     const bool validate
 )
 {
     // Clear addressing.
     MeshReference::clearGeom();
 
-    // Take over new primitive data.
-    // Optimized to avoid overwriting data at all
-    if (&points)
-    {
-        storedPoints_.transfer(points());
-    }
-
-    if (&faces)
-    {
-        storedFaces_.transfer(faces());
-    }
-
-    if (&zones)
-    {
-        surfZones_.transfer(zones());
-    }
+    Allocator::reset(points, faces, zones);
+    this->updateRefs();
 
     if (validate)
     {
@@ -255,6 +271,7 @@ void Foam::surfMesh::resetPrimitives
 }
 
 
+
 void Foam::surfMesh::transfer
 (
     MeshedSurface<face>& surf
@@ -263,9 +280,11 @@ void Foam::surfMesh::transfer
     // Clear addressing.
     MeshReference::clearGeom();
 
-    storedPoints_.transfer(surf.storedPoints());
-    storedFaces_.transfer(surf.storedFaces());
-    surfZones_.transfer(surf.storedZones());
+    this->storedIOPoints().transfer(surf.storedPoints());
+    this->storedIOFaces().transfer(surf.storedFaces());
+    this->storedIOZones().transfer(surf.storedZones());
+
+    this->updateRefs();
 }
 
 
@@ -274,9 +293,12 @@ Foam::surfMesh::xfer()
 {
     Xfer< MeshedSurface<face> > xf;
 
-    xf().storedPoints().transfer(storedPoints_);
-    xf().storedFaces().transfer(storedFaces_);
-    xf().storedZones().transfer(surfZones_);
+    xf().storedPoints().transfer(this->storedPoints());
+    xf().storedFaces().transfer(this->storedFaces());
+    xf().storedZones().transfer(this->storedZones());
+
+    // is this needed?
+    this->updateRefs();
 
     // Clear addressing.
     MeshReference::clearGeom();
@@ -285,17 +307,6 @@ Foam::surfMesh::xfer()
 }
 
 
-void Foam::surfMesh::rename(const word& newName)
-{
-    FatalErrorIn
-    (
-        "surfMesh::rename(const word&)\n"
-    )
-        << "rename does not work correctly\n";
-}
-
-
-
 Foam::fileName Foam::surfMesh::meshDir() const
 {
     return dbDir()/meshSubDir;
@@ -304,51 +315,53 @@ Foam::fileName Foam::surfMesh::meshDir() const
 
 const Foam::fileName& Foam::surfMesh::pointsInstance() const
 {
-    return storedPoints_.instance();
+    return this->storedIOPoints().instance();
 }
 
 
 const Foam::fileName& Foam::surfMesh::facesInstance() const
 {
-    return storedFaces_.instance();
+    return this->storedIOFaces().instance();
 }
 
 
 Foam::label Foam::surfMesh::nPoints() const
 {
-    return storedPoints_.size();
+    return this->points().size();
 }
 
 Foam::label Foam::surfMesh::nFaces() const
 {
-    return storedFaces_.size();
+    return this->faces().size();
 }
 
 const Foam::pointField& Foam::surfMesh::points() const
 {
-    return storedPoints_;
+    return this->storedIOPoints();
 }
 
 const Foam::faceList& Foam::surfMesh::faces() const
 {
-    return storedFaces_;
+    return this->storedIOFaces();
 }
 
 void Foam::surfMesh::checkZones()
 {
     // extra safety, ensure we have at some zones
     // and they cover all the faces - fix start silently
-    if (surfZones_.size() <= 1)
+    surfZoneList& zones = Allocator::storedIOZones();
+
+    if (zones.size() <= 1)
     {
-        oneZone();
+        removeZones();
     }
     else
     {
         label count = 0;
-        forAll(surfZones_, zoneI)
+        forAll(zones, zoneI)
         {
-            surfZones_[zoneI].start() = count;
-            count += surfZones_[zoneI].size();
+            zones[zoneI].start() = count;
+            count += zones[zoneI].size();
         }
 
         if (count < nFaces())
@@ -361,7 +374,7 @@ void Foam::surfMesh::checkZones()
                 << " ... extending final zone"
                 << endl;
 
-            surfZones_[surfZones_.size()-1].size() += count - nFaces();
+            zones[zones.size()-1].size() += count - nFaces();
         }
         else if (count > size())
         {
@@ -379,15 +392,15 @@ void Foam::surfMesh::checkZones()
 // Add boundary patches. Constructor helper
 void Foam::surfMesh::addZones
 (
-    const surfZoneList& zones,
+    const surfZoneList& srfZones,
     const bool validate
 )
 {
-    surfZones_.setSize(zones.size());
+    surfZoneList& zones = Allocator::storedIOZones();
 
-    forAll(surfZones_, zoneI)
+    forAll(zones, zoneI)
     {
-        surfZones_[zoneI] = surfZone(zones[zoneI], zoneI);
+        zones[zoneI] = surfZone(srfZones[zoneI], zoneI);
     }
 
     if (validate)
@@ -412,4 +425,22 @@ void Foam::surfMesh::removeFiles() const
     removeFiles(instance());
 }
 
+
+void Foam::surfMesh::write(const fileName& name, const surfMesh& surf)
+{
+    MeshedSurfaceProxy<face>
+    (
+        surf.points(),
+        surf.faces(),
+        surf.surfZones()
+    ).write(name);
+}
+
+
+void Foam::surfMesh::write(const fileName& name)
+{
+    write(name, *this);
+}
+
+
 // ************************************************************************* //
diff --git a/src/surfMesh/surfMesh/surfMesh.H b/src/surfMesh/surfMesh/surfMesh.H
index 358620fd61..7f41b7a95e 100644
--- a/src/surfMesh/surfMesh/surfMesh.H
+++ b/src/surfMesh/surfMesh/surfMesh.H
@@ -39,66 +39,16 @@ SourceFiles
 #define surfMesh_H
 
 #include "surfaceRegistry.H"
+#include "MeshedSurfaceIOAllocator.H"
 #include "PrimitivePatch.H"
-#include "pointField.H"
-#include "faceList.H"
-#include "pointIOField.H"
-#include "faceIOList.H"
-#include "labelIOList.H"
-#include "surfZoneIOList.H"
+#include "SubField.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 namespace Foam
 {
 
-template<class Face>
-class MeshedSurface;
-
-/*---------------------------------------------------------------------------*\
-                      Class surfMeshAllocator Declaration
-\*---------------------------------------------------------------------------*/
-
-//- A helper class for storing points and faces
-class surfMeshAllocator
-{
-protected:
-    pointIOField storedPoints_;
-    faceIOList   storedFaces_;
-
-    surfMeshAllocator(const IOobject& ioPoints, const IOobject& ioFaces)
-    :
-        storedPoints_(ioPoints),
-        storedFaces_(ioFaces)
-    {}
-
-    surfMeshAllocator
-    (
-        const IOobject& ioPoints,
-        const pointField& points,
-        const IOobject& ioFaces,
-        const faceList& faces
-    )
-    :
-        storedPoints_(ioPoints, points),
-        storedFaces_(ioFaces, faces)
-    {}
-
-    surfMeshAllocator
-    (
-        const IOobject& ioPoints,
-        const Xfer<pointField>& points,
-        const IOobject& ioFaces,
-        const Xfer<faceList>& faces
-    )
-    :
-        storedPoints_(ioPoints, points),
-        storedFaces_(ioFaces, faces)
-    {}
-
-};
-
-
+template<class Face> class MeshedSurface;
 
 /*---------------------------------------------------------------------------*\
                           Class surfMesh Declaration
@@ -106,9 +56,9 @@ protected:
 
 class surfMesh
 :
-    public surfaceRegistry,
-    public surfMeshAllocator,
-    public PrimitivePatch<face, ::Foam::UList, const pointField&, point>
+    public  surfaceRegistry,
+    private MeshedSurfaceIOAllocator,
+    public  PrimitivePatch<face, ::Foam::UList, ::Foam::SubField<point>, point>
 {
 
 public:
@@ -117,8 +67,7 @@ public:
 
         //- Enumeration defining the state of the mesh after a read update.
         //  Used for post-processing applications, where the mesh
-        //  needs to update based on the files written in time
-        //  directores
+        //  needs to update based on the files written in time directores
         enum readUpdateState
         {
             UNCHANGED,
@@ -132,28 +81,23 @@ private:
 
     // Private typedefs
 
+        typedef MeshedSurfaceIOAllocator Allocator;
+
         typedef PrimitivePatch
         <
             face,
             ::Foam::UList,
-            const pointField&,
+            ::Foam::SubField<point>,
             point
         >
         MeshReference;
 
+
     // Permanent data
 
-        // Zoning information
-
-           //- Face zones
-           surfZoneIOList surfZones_;
-
 
     // Private member functions
 
-        //- Set a single zone
-        void oneZone();
-
         //- Disallow construct as copy
         surfMesh(const surfMesh&);
 
@@ -165,23 +109,33 @@ protected:
     // Protected Member Functions
 
         //- Non-const access to global points
-        pointIOField& storedPoints()
+        pointField& storedPoints()
         {
-            return surfMeshAllocator::storedPoints_;
+            return Allocator::storedIOPoints();
         }
 
         //- Non-const access to the faces
-        faceIOList& storedFaces()
+        faceList& storedFaces()
         {
-            return surfMeshAllocator::storedFaces_;
+            return Allocator::storedIOFaces();
         }
 
         //- Non-const access to the zones
-        surfZoneIOList& storedZones()
+        surfZoneList& storedZones()
         {
-            return surfZones_;
+            return Allocator::storedIOZones();
         }
 
+
+        //- Update references to storedFaces
+        virtual void updateFacesRef();
+
+        //- Update references to storedPoints
+        virtual void updatePointsRef();
+
+        //- Update references to storedPoints/storedFaces
+        virtual void updateRefs();
+
 public:
 
     // Public typedefs
@@ -247,10 +201,10 @@ public:
 
         // Access
 
-            //- Return raw points
+            //- Return the number of raw points
             virtual label nPoints() const;
 
-            //- Return raw faces
+            //- Return the number of raw faces
             virtual label nFaces() const;
 
             //- Return number of faces
@@ -260,28 +214,22 @@ public:
             }
 
 
-            //- Return raw points
+            //- Return points
             virtual const pointField& points() const;
 
-            //- Return raw faces
+            //- Return faces
             virtual const faceList& faces() const;
 
             //- Return surface zones
-            const surfZoneList& surfZones() const
+            virtual const surfZoneList& surfZones() const
             {
-                return surfZones_;
-            }
-
-            //- Return non-const access to the zones
-            surfZoneList& surfZones()
-            {
-                return surfZones_;
+                return Allocator::storedIOZones();
             }
 
             //- Check the surface zone definitions
             void checkZones();
 
-            //- Add surface zones patches
+            //- Add surface zones
             void addZones
             (
                 const List<surfZone>&,
@@ -297,15 +245,12 @@ public:
             //- Remove surface zones
             void removeZones();
 
-            //- Rename surface
-            virtual void rename(const word&);
-
             //- Reset mesh primitive data.
             void resetPrimitives
             (
-                const Xfer<pointField>& points,
-                const Xfer<faceList>& faces,
-                const Xfer<surfZoneList>& zones,
+                const Xfer< pointField >& points,
+                const Xfer< faceList >& faces,
+                const Xfer< surfZoneList >& zones,
                 const bool validate = true
             );
 
@@ -313,6 +258,18 @@ public:
             //- Transfer the contents of the argument and annull the argument
             void transfer(MeshedSurface<face>&);
 
+
+
+        using surfaceRegistry::write;
+
+
+        //- Write to file
+        static void write(const fileName&, const surfMesh&);
+
+        //- Write to file
+        void write(const fileName&);
+
+
         //  Storage management
 
             //- Transfer contents to the Xfer container as a MeshedSurface
diff --git a/src/surfMesh/surfMesh/surfMeshClear.C b/src/surfMesh/surfMesh/surfMeshClear.C
index 92611ef150..27df24ddd4 100644
--- a/src/surfMesh/surfMesh/surfMeshClear.C
+++ b/src/surfMesh/surfMesh/surfMeshClear.C
@@ -40,7 +40,7 @@ void Foam::surfMesh::removeZones()
     }
 
     // Remove the surface zones
-    surfZones_.clear();
+    storedZones().clear();
 
     clearOut();
 }
diff --git a/src/surfMesh/surfMesh/surfMeshIO.C b/src/surfMesh/surfMesh/surfMeshIO.C
index 9665b4e20c..f9c44dc8ba 100644
--- a/src/surfMesh/surfMesh/surfMeshIO.C
+++ b/src/surfMesh/surfMesh/surfMeshIO.C
@@ -31,20 +31,22 @@ License
 
 void Foam::surfMesh::setInstance(const fileName& inst)
 {
-    if (debug)
+    if (debug or true)
     {
         Info<< "void surfMesh::setInstance(const fileName& inst) : "
             << "Resetting file instance to " << inst << endl;
     }
 
-    storedPoints_.writeOpt() = IOobject::AUTO_WRITE;
-    storedPoints_.instance() = inst;
+    instance() = inst;
 
-    storedFaces_.writeOpt() = IOobject::AUTO_WRITE;
-    storedFaces_.instance() = inst;
+    storedIOPoints().writeOpt() = IOobject::AUTO_WRITE;
+    storedIOPoints().instance() = inst;
 
-    surfZones_.writeOpt() = IOobject::AUTO_WRITE;
-    surfZones_.instance() = inst;
+    storedIOFaces().writeOpt() = IOobject::AUTO_WRITE;
+    storedIOFaces().instance() = inst;
+
+    storedIOZones().writeOpt() = IOobject::AUTO_WRITE;
+    storedIOZones().instance() = inst;
 }
 
 
@@ -81,9 +83,9 @@ Foam::surfMesh::readUpdateState Foam::surfMesh::readUpdate()
         // Set instance to new instance.
         // Note points instance can differ from faces instance.
         setInstance(facesInst);
-        storedPoints_.instance() = pointsInst;
+        storedIOPoints().instance() = pointsInst;
 
-        storedPoints_ = pointIOField
+        storedIOPoints() = pointIOField
         (
             IOobject
             (
@@ -97,7 +99,7 @@ Foam::surfMesh::readUpdateState Foam::surfMesh::readUpdate()
             )
         );
 
-        storedFaces_ = faceIOList
+        storedFaces() = faceIOList
         (
             IOobject
             (
@@ -111,9 +113,6 @@ Foam::surfMesh::readUpdateState Foam::surfMesh::readUpdate()
             )
         );
 
-        // synchronize sizes and references?
-//        MeshReference::operator=(MeshReference(storedFaces_, storedPoints_));
-
         // Reset the surface zones
         surfZoneIOList newZones
         (
@@ -132,15 +131,16 @@ Foam::surfMesh::readUpdateState Foam::surfMesh::readUpdate()
         // Check that zone types and names are unchanged
         bool zonesChanged = false;
 
-        if (surfZones_.size() != newZones.size())
+        surfZoneList& zones = this->storedIOZones();
+        if (zones.size() != newZones.size())
         {
             zonesChanged = true;
         }
         else
         {
-            forAll (surfZones_, zoneI)
+            forAll(zones, zoneI)
             {
-                if (surfZones_[zoneI].name() != newZones[zoneI].name())
+                if (zones[zoneI].name() != newZones[zoneI].name())
                 {
                     zonesChanged = true;
                     break;
@@ -148,7 +148,7 @@ Foam::surfMesh::readUpdateState Foam::surfMesh::readUpdate()
             }
         }
 
-        surfZones_.transfer(newZones);
+        zones.transfer(newZones);
 
         if (zonesChanged)
         {
@@ -173,10 +173,9 @@ Foam::surfMesh::readUpdateState Foam::surfMesh::readUpdate()
         }
 
         clearGeom();
+        storedIOPoints().instance() = pointsInst;
 
-        storedPoints_.instance() = pointsInst;
-
-        storedPoints_ = pointIOField
+        storedIOPoints() = pointIOField
         (
             IOobject
             (
@@ -204,4 +203,6 @@ Foam::surfMesh::readUpdateState Foam::surfMesh::readUpdate()
 }
 
 
+
+
 // ************************************************************************* //
diff --git a/src/surfMesh/surfaceFormats/ac3d/AC3DsurfaceFormat.C b/src/surfMesh/surfaceFormats/ac3d/AC3DsurfaceFormat.C
index 8347bdeee8..13066c9f67 100644
--- a/src/surfMesh/surfaceFormats/ac3d/AC3DsurfaceFormat.C
+++ b/src/surfMesh/surfaceFormats/ac3d/AC3DsurfaceFormat.C
@@ -26,7 +26,6 @@ License
 
 #include "AC3DsurfaceFormat.H"
 #include "clock.H"
-#include "IFstream.H"
 #include "IStringStream.H"
 #include "tensor.H"
 #include "primitivePatch.H"
@@ -281,26 +280,65 @@ bool Foam::fileFormats::AC3DsurfaceFormat<Face>::read
 template<class Face>
 void Foam::fileFormats::AC3DsurfaceFormat<Face>::write
 (
-    Ostream& os,
-    const pointField& pointLst,
-    const List<Face>& faceLst,
-    const List<surfZone>& zoneLst
+    const fileName& filename,
+    const MeshedSurfaceProxy<Face>& surf
 )
 {
-    writeHeader(os, zoneLst);
+    const pointField& pointLst = surf.points();
+    const List<Face>&  faceLst = surf.faces();
 
-    forAll(zoneLst, zoneI)
+    const List<surfZone>& zones =
+    (
+        surf.surfZones().size()
+      ? surf.surfZones()
+      : oneZone(faceLst)
+    );
+
+    const bool useFaceMap = (surf.useFaceMap() && zones.size() > 1);
+
+    if (useFaceMap)
     {
-        const surfZone& zone = zoneLst[zoneI];
+        FatalErrorIn
+        (
+            "fileFormats::AC3DsurfaceFormat::write"
+            "(const fileName&, const MeshedSurfaceProxy<Face>&)"
+        )
+            << "output with faceMap is not supported " << filename
+            << exit(FatalError);
+    }
+
+
+    OFstream os(filename);
+    if (!os.good())
+    {
+        FatalErrorIn
+        (
+            "fileFormats::AC3DsurfaceFormat::write"
+            "(const fileName&, const MeshedSurfaceProxy<Face>&)"
+        )
+            << "Cannot open file for writing " << filename
+            << exit(FatalError);
+    }
+
+    writeHeader(os, zones);
+
+    forAll(zones, zoneI)
+    {
+        const surfZone& zone = zones[zoneI];
 
         os  << "OBJECT poly" << nl
-            << "name \"" << zone.name() << '"' << endl;
+            << "name \"" << zone.name() << "\"\n";
 
         // Temporary PrimitivePatch to calculate compact points & faces
         // use 'UList' to avoid allocations!
         PrimitivePatch<Face, UList, const pointField&> patch
         (
-            faceLst,
+            SubList<Face>
+            (
+                faceLst,
+                zone.size(),
+                zone.start()
+            ),
             pointLst
         );
 
@@ -310,7 +348,7 @@ void Foam::fileFormats::AC3DsurfaceFormat<Face>::write
         {
             const point& pt = patch.localPoints()[ptI];
 
-            os << pt.x() << ' ' << pt.y() << ' ' << pt.z() << endl;
+            os << pt.x() << ' ' << pt.y() << ' ' << pt.z() << nl;
         }
 
         os << "numsurf " << patch.localFaces().size() << endl;
@@ -337,72 +375,89 @@ void Foam::fileFormats::AC3DsurfaceFormat<Face>::write
 template<class Face>
 void Foam::fileFormats::AC3DsurfaceFormat<Face>::write
 (
-    Ostream& os,
-    const MeshedSurface<Face>& surf
-)
-{
-    write(os, surf.points(), surf.faces(), surf.zones());
-}
-
-
-template<class Face>
-void Foam::fileFormats::AC3DsurfaceFormat<Face>::write
-(
-    Ostream& os,
+    const fileName& filename,
     const UnsortedMeshedSurface<Face>& surf
 )
 {
     labelList faceMap;
     List<surfZone> zoneLst = surf.sortedZones(faceMap);
 
-    writeHeader(os, zoneLst);
-
-    label faceIndex = 0;
-    forAll(zoneLst, zoneI)
+    if (zoneLst.size() <= 1)
     {
-        const surfZone& zone = zoneLst[zoneI];
-
-        os  << "OBJECT poly" << nl
-            << "name \"" << zone.name() << '"' << endl;
-
-        // Create zone with only zone faces included for ease of addressing
-        labelHashSet include(surf.size());
-
-        forAll(zone, localFaceI)
+        write
+        (
+            filename,
+            MeshedSurfaceProxy<Face>
+            (
+                surf.points(),
+                surf.faces(),
+                zoneLst
+            )
+        );
+    }
+    else
+    {
+        OFstream os(filename);
+        if (!os.good())
         {
-            const label faceI = faceMap[faceIndex++];
-            include.insert(faceI);
+            FatalErrorIn
+            (
+                "fileFormats::AC3DsurfaceFormat::write"
+                "(const fileName&, const MeshedSurfaceProxy<Face>&)"
+            )
+                << "Cannot open file for writing " << filename
+                << exit(FatalError);
         }
 
-        UnsortedMeshedSurface<Face> subm = surf.subsetMesh(include);
+        writeHeader(os, zoneLst);
 
-        // Now we have isolated surface for this patch alone. Write it.
-        os << "numvert " << subm.nPoints() << endl;
-
-        forAll(subm.localPoints(), ptI)
+        label faceIndex = 0;
+        forAll(zoneLst, zoneI)
         {
-            const point& pt = subm.localPoints()[ptI];
+            const surfZone& zone = zoneLst[zoneI];
 
-            os << pt.x() << ' ' << pt.y() << ' ' << pt.z() << endl;
-        }
+            os  << "OBJECT poly" << nl
+                << "name \"" << zone.name() << "\"\n";
 
-        os << "numsurf " << subm.localFaces().size() << endl;
+            // Create zone with only zone faces included for ease of addressing
+            labelHashSet include(surf.size());
 
-        forAll(subm.localFaces(), localFaceI)
-        {
-            const Face& f = subm.localFaces()[localFaceI];
-
-            os  << "SURF 0x20" << nl          // polygon
-                << "mat " << zoneI << nl
-                << "refs " << f.size() << nl;
-
-            forAll(f, fp)
+            forAll(zone, localFaceI)
             {
-                os << f[fp] << " 0 0" << nl;
+                const label faceI = faceMap[faceIndex++];
+                include.insert(faceI);
             }
-        }
 
-        os << "kids 0" << endl;
+            UnsortedMeshedSurface<Face> subm = surf.subsetMesh(include);
+
+            // Now we have isolated surface for this patch alone. Write it.
+            os << "numvert " << subm.nPoints() << endl;
+
+            forAll(subm.localPoints(), ptI)
+            {
+                const point& pt = subm.localPoints()[ptI];
+
+                os << pt.x() << ' ' << pt.y() << ' ' << pt.z() << endl;
+            }
+
+            os << "numsurf " << subm.localFaces().size() << endl;
+
+            forAll(subm.localFaces(), localFaceI)
+            {
+                const Face& f = subm.localFaces()[localFaceI];
+
+                os  << "SURF 0x20" << nl          // polygon
+                    << "mat " << zoneI << nl
+                    << "refs " << f.size() << nl;
+
+                forAll(f, fp)
+                {
+                    os << f[fp] << " 0 0" << nl;
+                }
+            }
+
+            os << "kids 0" << endl;
+        }
     }
 }
 
diff --git a/src/surfMesh/surfaceFormats/ac3d/AC3DsurfaceFormat.H b/src/surfMesh/surfaceFormats/ac3d/AC3DsurfaceFormat.H
index 24aa25df18..0334538220 100644
--- a/src/surfMesh/surfaceFormats/ac3d/AC3DsurfaceFormat.H
+++ b/src/surfMesh/surfaceFormats/ac3d/AC3DsurfaceFormat.H
@@ -31,8 +31,9 @@ Description
     http://www.inivis.com/ac3d/man/ac3dfileformat.html
 
 Note
-   The faces are already organized as zones.
-   The output is always sorted by zones.
+    On input, the faces are already organized as zones.
+    The output is always sorted by zones.
+    In the absence of zones, a single zone will be assigned.
 
 SourceFiles
     AC3DsurfaceFormat.C
@@ -42,9 +43,8 @@ SourceFiles
 #ifndef AC3DsurfaceFormat_H
 #define AC3DsurfaceFormat_H
 
-#include "Ostream.H"
-#include "OFstream.H"
 #include "MeshedSurface.H"
+#include "MeshedSurfaceProxy.H"
 #include "UnsortedMeshedSurface.H"
 #include "AC3DsurfaceFormatCore.H"
 
@@ -99,58 +99,20 @@ public:
 
     // Member Functions
 
+        //- Write surface mesh components by proxy
+        static void write(const fileName&, const MeshedSurfaceProxy<Face>&);
+
+        //- Write UnsortedMeshedSurface, the output is always sorted by zones.
+        static void write(const fileName&, const UnsortedMeshedSurface<Face>&);
+
+
         //- Read from file
         virtual bool read(const fileName&);
 
-        //- Write surface mesh components
-        static void write
-        (
-            Ostream&,
-            const pointField&,
-            const List<Face>&,
-            const List<surfZone>&
-        );
-
-        //- Write MeshedSurface
-        static void write
-        (
-            Ostream&,
-            const MeshedSurface<Face>&
-        );
-
-        //- Write MeshedSurface
-        static void write
-        (
-            const fileName& name,
-            const MeshedSurface<Face>& surf
-        )
-        {
-            write(OFstream(name)(), surf);
-        }
-
-        //- Write UnsortedMeshedSurface
-        //  The output is always sorted by zones.
-        static void write
-        (
-            Ostream&,
-            const UnsortedMeshedSurface<Face>&
-        );
-
-        //- Write UnsortedMeshedSurface
-        //  The output is always sorted by zones.
-        static void write
-        (
-            const fileName& name,
-            const UnsortedMeshedSurface<Face>& surf
-        )
-        {
-            write(OFstream(name)(), surf);
-        }
-
         //- Write object
-        virtual void write(Ostream& os) const
+        virtual void write(const fileName& name) const
         {
-            write(os, *this);
+            write(name, MeshedSurfaceProxy<Face>(*this));
         }
 
 };
diff --git a/src/surfMesh/surfaceFormats/ac3d/AC3DsurfaceFormatCore.H b/src/surfMesh/surfaceFormats/ac3d/AC3DsurfaceFormatCore.H
index 93619e5a9b..1c3e5dc828 100644
--- a/src/surfMesh/surfaceFormats/ac3d/AC3DsurfaceFormatCore.H
+++ b/src/surfMesh/surfaceFormats/ac3d/AC3DsurfaceFormatCore.H
@@ -36,10 +36,10 @@ SourceFiles
 #ifndef AC3DsurfaceFormatCore_H
 #define AC3DsurfaceFormatCore_H
 
+#include "IFstream.H"
 #include "Ostream.H"
 #include "OFstream.H"
 #include "MeshedSurface.H"
-#include "UnsortedMeshedSurface.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
diff --git a/src/surfMesh/surfaceFormats/ac3d/AC3DsurfaceFormatRunTime.C b/src/surfMesh/surfaceFormats/ac3d/AC3DsurfaceFormatRunTime.C
index ba802d1656..05bf9d0ffa 100644
--- a/src/surfMesh/surfaceFormats/ac3d/AC3DsurfaceFormatRunTime.C
+++ b/src/surfMesh/surfaceFormats/ac3d/AC3DsurfaceFormatRunTime.C
@@ -25,8 +25,7 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "AC3DsurfaceFormat.H"
-#include "MeshedSurface.H"
-#include "UnsortedMeshedSurface.H"
+
 #include "addToRunTimeSelectionTable.H"
 #include "addToMemberFunctionSelectionTable.H"
 
@@ -36,6 +35,7 @@ namespace Foam
 namespace fileFormats
 {
 
+// read MeshedSurface
 addNamedTemplatedToRunTimeSelectionTable
 (
     MeshedSurface,
@@ -53,10 +53,10 @@ addNamedTemplatedToRunTimeSelectionTable
     ac
 );
 
-
+// write MeshedSurfaceProxy
 addNamedTemplatedToMemberFunctionSelectionTable
 (
-    MeshedSurface,
+    MeshedSurfaceProxy,
     AC3DsurfaceFormat,
     face,
     write,
@@ -65,7 +65,7 @@ addNamedTemplatedToMemberFunctionSelectionTable
 );
 addNamedTemplatedToMemberFunctionSelectionTable
 (
-    MeshedSurface,
+    MeshedSurfaceProxy,
     AC3DsurfaceFormat,
     triFace,
     write,
@@ -74,6 +74,7 @@ addNamedTemplatedToMemberFunctionSelectionTable
 );
 
 
+// write UnsortedMeshedSurface
 addNamedTemplatedToMemberFunctionSelectionTable
 (
     UnsortedMeshedSurface,
diff --git a/src/surfMesh/surfaceFormats/ftr/FTRsurfaceFormat.H b/src/surfMesh/surfaceFormats/ftr/FTRsurfaceFormat.H
index fa7401890f..25883d4eb3 100644
--- a/src/surfMesh/surfaceFormats/ftr/FTRsurfaceFormat.H
+++ b/src/surfMesh/surfaceFormats/ftr/FTRsurfaceFormat.H
@@ -26,7 +26,8 @@ Class
     Foam::fileFormats::FTRsurfaceFormat
 
 Description
-    Reading of the (now deprecated and barely used) Foam Trisurface Format.
+    Reading of the (now deprecated and infrequently used)
+    Foam Trisurface Format.
 
 SourceFiles
     FTRsurfaceFormat.C
diff --git a/src/surfMesh/surfaceFormats/ftr/FTRsurfaceFormatRunTime.C b/src/surfMesh/surfaceFormats/ftr/FTRsurfaceFormatRunTime.C
index a632ab0e48..e52c952b9d 100644
--- a/src/surfMesh/surfaceFormats/ftr/FTRsurfaceFormatRunTime.C
+++ b/src/surfMesh/surfaceFormats/ftr/FTRsurfaceFormatRunTime.C
@@ -25,8 +25,7 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "FTRsurfaceFormat.H"
-#include "MeshedSurface.H"
-#include "UnsortedMeshedSurface.H"
+
 #include "addToRunTimeSelectionTable.H"
 #include "addToMemberFunctionSelectionTable.H"
 
@@ -36,6 +35,7 @@ namespace Foam
 namespace fileFormats
 {
 
+// read UnsortedMeshedSurface
 addNamedTemplatedToRunTimeSelectionTable
 (
     UnsortedMeshedSurface,
diff --git a/src/surfMesh/surfaceFormats/gts/GTSsurfaceFormat.C b/src/surfMesh/surfaceFormats/gts/GTSsurfaceFormat.C
index 0ac2f27a35..a8b70d864e 100644
--- a/src/surfMesh/surfaceFormats/gts/GTSsurfaceFormat.C
+++ b/src/surfMesh/surfaceFormats/gts/GTSsurfaceFormat.C
@@ -25,9 +25,12 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "GTSsurfaceFormat.H"
+#include "surfaceFormatsCore.H"
 #include "clock.H"
 #include "IFstream.H"
 #include "IStringStream.H"
+#include "Ostream.H"
+#include "OFstream.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
@@ -80,9 +83,9 @@ bool Foam::fileFormats::GTSsurfaceFormat<Face>::read
 
 
     // write directly into the lists:
-    pointField&  pointLst  = this->storedPoints();
-    List<Face>&  faceLst   = this->storedFaces();
-    List<label>& zoneIds = this->storedZoneIds();
+    pointField&  pointLst = this->storedPoints();
+    List<Face>&  faceLst  = this->storedFaces();
+    List<label>& zoneIds  = this->storedZoneIds();
 
     pointLst.setSize(nPoints);
     faceLst.setSize(nElems);
@@ -217,6 +220,7 @@ bool Foam::fileFormats::GTSsurfaceFormat<Face>::read
     }
 
     this->storedZoneToc().transfer(newZones);
+
     return true;
 }
 
@@ -224,19 +228,24 @@ bool Foam::fileFormats::GTSsurfaceFormat<Face>::read
 template<class Face>
 void Foam::fileFormats::GTSsurfaceFormat<Face>::write
 (
-    Ostream& os,
+    const fileName& filename,
     const MeshedSurface<Face>& surf
 )
 {
     const pointField& pointLst = surf.points();
     const List<Face>& faceLst  = surf.faces();
-    const List<surfZone>& zoneLst = surf.zones();
 
+    const List<surfZone>& zones =
+    (
+        surf.surfZones().size()
+      ? surf.surfZones()
+      : surfaceFormatsCore::oneZone(faceLst)
+    );
 
     // 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())
+    if (!MeshedSurface<Face>::isTri())
     {
         label nNonTris = 0;
         forAll(faceLst, faceI)
@@ -252,7 +261,7 @@ void Foam::fileFormats::GTSsurfaceFormat<Face>::write
             FatalErrorIn
             (
                 "fileFormats::GTSsurfaceFormat::write"
-                "(Ostream&, const MeshedSurface<Face>&)"
+                "(const fileName&, const MeshedSurface<Face>&)"
             )
                 << "Surface has " << nNonTris << "/" << faceLst.size()
                 << " non-triangulated faces - not writing!" << endl;
@@ -260,16 +269,30 @@ void Foam::fileFormats::GTSsurfaceFormat<Face>::write
         }
     }
 
+
+    OFstream os(filename);
+    if (!os.good())
+    {
+        FatalErrorIn
+        (
+            "fileFormats::GTSsurfaceFormat::write"
+            "(const fileName&, const MeshedSurface<Face>&)"
+        )
+            << "Cannot open file for writing " << filename
+            << exit(FatalError);
+    }
+
+
     // Write header, print zone names as comment
     os  << "# GTS file" << nl
         << "# Zones:" << nl;
 
-    forAll(zoneLst, zoneI)
+    forAll(zones, zoneI)
     {
         os  << "#     " << zoneI << "    "
-            << zoneLst[zoneI].name() << nl;
+            << zones[zoneI].name() << nl;
     }
-    os  << "#" << endl;
+    os  << "#" << nl;
 
     os  << "# nPoints  nEdges  nTriangles" << nl
         << pointLst.size() << ' ' << surf.nEdges() << ' '
@@ -279,9 +302,9 @@ void Foam::fileFormats::GTSsurfaceFormat<Face>::write
     // Write vertex coords
     forAll(pointLst, pointI)
     {
-        os  << pointLst[pointI].x() << ' '
-            << pointLst[pointI].y() << ' '
-            << pointLst[pointI].z() << endl;
+        const point& pt = pointLst[pointI];
+
+        os  << pt.x() << ' ' << pt.y() << ' ' << pt.z() << nl;
     }
 
 
@@ -300,9 +323,9 @@ void Foam::fileFormats::GTSsurfaceFormat<Face>::write
     const labelListList& faceEs = surf.faceEdges();
 
     label faceIndex = 0;
-    forAll(zoneLst, zoneI)
+    forAll(zones, zoneI)
     {
-        const surfZone& zone = zoneLst[zoneI];
+        const surfZone& zone = zones[zoneI];
 
         forAll(zone, localFaceI)
         {
@@ -320,19 +343,19 @@ void Foam::fileFormats::GTSsurfaceFormat<Face>::write
 template<class Face>
 void Foam::fileFormats::GTSsurfaceFormat<Face>::write
 (
-    Ostream& os,
+    const fileName& filename,
     const UnsortedMeshedSurface<Face>& surf
 )
 {
     const pointField& pointLst   = surf.points();
     const List<Face>& faceLst    = surf.faces();
-    const List<label>& zoneIds = surf.zoneIds();
+    const List<label>& zoneIds   = surf.zoneIds();
     const List<surfZoneIdentifier>& zoneToc = surf.zoneToc();
 
     // 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())
+    if (!MeshedSurface<Face>::isTri())
     {
         label nNonTris = 0;
         forAll(faceLst, faceI)
@@ -348,7 +371,7 @@ void Foam::fileFormats::GTSsurfaceFormat<Face>::write
             FatalErrorIn
             (
                 "fileFormats::GTSsurfaceFormat::write"
-                "(Ostream&, const UnsortedMeshedSurfaces<Face>&)"
+                "(const fileName&, const UnsortedMeshedSurfaces<Face>&)"
             )
                 << "Surface has " << nNonTris << "/" << faceLst.size()
                 << " non-triangulated faces - not writing!" << endl;
@@ -356,6 +379,20 @@ void Foam::fileFormats::GTSsurfaceFormat<Face>::write
         }
     }
 
+
+    OFstream os(filename);
+    if (!os.good())
+    {
+        FatalErrorIn
+        (
+            "fileFormats::GTSsurfaceFormat::write"
+            "(const fileName&, const UnsortedMeshedSurface<Face>&)"
+        )
+            << "Cannot open file for writing " << filename
+            << exit(FatalError);
+    }
+
+
     // Write header, print zone names as comment
     os  << "# GTS file" << nl
         << "# Zones:" << nl;
diff --git a/src/surfMesh/surfaceFormats/gts/GTSsurfaceFormat.H b/src/surfMesh/surfaceFormats/gts/GTSsurfaceFormat.H
index be4a7411e4..91ef7227c7 100644
--- a/src/surfMesh/surfaceFormats/gts/GTSsurfaceFormat.H
+++ b/src/surfMesh/surfaceFormats/gts/GTSsurfaceFormat.H
@@ -27,7 +27,8 @@ Class
 
 Description
     Provide a means of reading/writing GTS format.
-    The output is never sorted by zone.
+    The output is never sorted by zone and is only written if it consists
+    entirely of triangles.
 
 SourceFiles
     GTSsurfaceFormat.C
@@ -37,9 +38,8 @@ SourceFiles
 #ifndef GTSsurfaceFormat_H
 #define GTSsurfaceFormat_H
 
-#include "Ostream.H"
-#include "OFstream.H"
 #include "MeshedSurface.H"
+#include "MeshedSurfaceProxy.H"
 #include "UnsortedMeshedSurface.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@@ -90,49 +90,20 @@ public:
 
     // Member Functions
 
+        //- Write MeshedSurface
+        static void write(const fileName&, const MeshedSurface<Face>&);
+
+        //- Write UnsortedMeshedSurface, the output remains unsorted
+        static void write(const fileName&, const UnsortedMeshedSurface<Face>&);
+
+
         //- Read from file
         virtual bool read(const fileName&);
 
-        //- Write MeshedSurface
-        static void write
-        (
-            Ostream&,
-            const MeshedSurface<Face>&
-        );
-
-        //- Write MeshedSurface
-        static void write
-        (
-            const fileName& name,
-            const MeshedSurface<Face>& surf
-        )
-        {
-            write(OFstream(name)(), surf);
-        }
-
-        //- Write UnsortedMeshedSurface
-        //  The output remains unsorted
-        static void write
-        (
-            Ostream&,
-            const UnsortedMeshedSurface<Face>&
-        );
-
-        //- Write UnsortedMeshedSurface
-        //  The output remains unsorted
-        static void write
-        (
-            const fileName& name,
-            const UnsortedMeshedSurface<Face>& surf
-        )
-        {
-            write(OFstream(name)(), surf);
-        }
-
         //- Write object
-        virtual void write(Ostream& os) const
+        virtual void write(const fileName& name) const
         {
-            write(os, *this);
+            write(name, *this);
         }
 
 };
diff --git a/src/surfMesh/surfaceFormats/gts/GTSsurfaceFormatRunTime.C b/src/surfMesh/surfaceFormats/gts/GTSsurfaceFormatRunTime.C
index 8d34c0cc17..d3268962d2 100644
--- a/src/surfMesh/surfaceFormats/gts/GTSsurfaceFormatRunTime.C
+++ b/src/surfMesh/surfaceFormats/gts/GTSsurfaceFormatRunTime.C
@@ -25,8 +25,7 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "GTSsurfaceFormat.H"
-#include "MeshedSurface.H"
-#include "UnsortedMeshedSurface.H"
+
 #include "addToRunTimeSelectionTable.H"
 #include "addToMemberFunctionSelectionTable.H"
 
@@ -36,6 +35,7 @@ namespace Foam
 namespace fileFormats
 {
 
+// read UnsortedMeshedSurface
 addNamedTemplatedToRunTimeSelectionTable
 (
     UnsortedMeshedSurface,
@@ -53,6 +53,7 @@ addNamedTemplatedToRunTimeSelectionTable
     gts
 );
 
+// write MeshedSurface
 addNamedTemplatedToMemberFunctionSelectionTable
 (
     MeshedSurface,
@@ -72,6 +73,7 @@ addNamedTemplatedToMemberFunctionSelectionTable
     gts
 );
 
+// write UnsortedMeshedSurface
 addNamedTemplatedToMemberFunctionSelectionTable
 (
     UnsortedMeshedSurface,
diff --git a/src/surfMesh/surfaceFormats/nas/NASsurfaceFormat.C b/src/surfMesh/surfaceFormats/nas/NASsurfaceFormat.C
index adfa807a62..4933afa9d4 100644
--- a/src/surfMesh/surfaceFormats/nas/NASsurfaceFormat.C
+++ b/src/surfMesh/surfaceFormats/nas/NASsurfaceFormat.C
@@ -76,6 +76,7 @@ bool Foam::fileFormats::NASsurfaceFormat<Face>::read
     Map<label>          lookup;
 
     // assume the types are not intermixed
+    // leave faces that didn't have a group in 0
     bool sorted = true;
     label zoneI = 0;
 
@@ -89,10 +90,6 @@ bool Foam::fileFormats::NASsurfaceFormat<Face>::read
     label ansaId = -1;
     word  ansaType, ansaName;
 
-    // leave faces that didn't have a group in 0
-    //    label groupID = 0;
-    //    label maxGroupID = -1;
-
     // A single warning per unrecognized command
     HashSet<word> unhandledCmd;
 
@@ -374,8 +371,8 @@ bool Foam::fileFormats::NASsurfaceFormat<Face>::read
     List<word> names(dynSizes.size());
     forAllConstIter(Map<label>, lookup, iter)
     {
-        const label zoneI = iter();
-        const label groupI  = iter.key();
+        const label zoneI  = iter();
+        const label groupI = iter.key();
 
         Map<word>::const_iterator fnd = nameLookup.find(groupI);
         if (fnd != nameLookup.end())
@@ -388,7 +385,6 @@ bool Foam::fileFormats::NASsurfaceFormat<Face>::read
         }
     }
 
-
     sortFacesAndStore(dynFaces.xfer(), dynZones.xfer(), sorted);
 
     // add zones, culling empty ones
diff --git a/src/surfMesh/surfaceFormats/nas/NASsurfaceFormat.H b/src/surfMesh/surfaceFormats/nas/NASsurfaceFormat.H
index 83d735acb3..46ea1e59c3 100644
--- a/src/surfMesh/surfaceFormats/nas/NASsurfaceFormat.H
+++ b/src/surfMesh/surfaceFormats/nas/NASsurfaceFormat.H
@@ -44,9 +44,8 @@ SourceFiles
 #ifndef NASsurfaceFormat_H
 #define NASsurfaceFormat_H
 
-#include "Ostream.H"
-#include "OFstream.H"
 #include "MeshedSurface.H"
+#include "MeshedSurfaceProxy.H"
 #include "UnsortedMeshedSurface.H"
 #include "NASsurfaceFormatCore.H"
 
diff --git a/src/surfMesh/surfaceFormats/nas/NASsurfaceFormatCore.C b/src/surfMesh/surfaceFormats/nas/NASsurfaceFormatCore.C
index 568f902e31..af182980ba 100644
--- a/src/surfMesh/surfaceFormats/nas/NASsurfaceFormatCore.C
+++ b/src/surfMesh/surfaceFormats/nas/NASsurfaceFormatCore.C
@@ -25,14 +25,13 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "NASsurfaceFormatCore.H"
-#include "IFstream.H"
 #include "IStringStream.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 
-// Do weird things to extract number
+// Do weird things to extract a floating point number
 Foam::scalar Foam::fileFormats::NASsurfaceFormatCore::parseNASCoord
 (
     const string& s
diff --git a/src/surfMesh/surfaceFormats/nas/NASsurfaceFormatRunTime.C b/src/surfMesh/surfaceFormats/nas/NASsurfaceFormatRunTime.C
index 46d9f4aeb1..7bebc54830 100644
--- a/src/surfMesh/surfaceFormats/nas/NASsurfaceFormatRunTime.C
+++ b/src/surfMesh/surfaceFormats/nas/NASsurfaceFormatRunTime.C
@@ -25,8 +25,7 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "NASsurfaceFormat.H"
-#include "MeshedSurface.H"
-#include "UnsortedMeshedSurface.H"
+
 #include "addToRunTimeSelectionTable.H"
 #include "addToMemberFunctionSelectionTable.H"
 
@@ -36,8 +35,7 @@ namespace Foam
 namespace fileFormats
 {
 
-// .bdf (Bulk Data Format)
-// .nas (Nastran)
+// read MeshedSurface - .bdf (Bulk Data Format)
 addNamedTemplatedToRunTimeSelectionTable
 (
     MeshedSurface,
@@ -55,6 +53,7 @@ addNamedTemplatedToRunTimeSelectionTable
     nas
 );
 
+// read MeshedSurface - .nas (Nastran)
 addNamedTemplatedToRunTimeSelectionTable
 (
     MeshedSurface,
diff --git a/src/surfMesh/surfaceFormats/obj/OBJsurfaceFormat.C b/src/surfMesh/surfaceFormats/obj/OBJsurfaceFormat.C
index db4295ce64..47ae2122eb 100644
--- a/src/surfMesh/surfaceFormats/obj/OBJsurfaceFormat.C
+++ b/src/surfMesh/surfaceFormats/obj/OBJsurfaceFormat.C
@@ -25,8 +25,11 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "OBJsurfaceFormat.H"
+#include "clock.H"
 #include "IFstream.H"
 #include "IStringStream.H"
+#include "Ostream.H"
+#include "OFstream.H"
 #include "ListOps.H"
 
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
@@ -213,84 +216,108 @@ bool Foam::fileFormats::OBJsurfaceFormat<Face>::read
 template<class Face>
 void Foam::fileFormats::OBJsurfaceFormat<Face>::write
 (
-    Ostream& os,
-    const pointField& pointLst,
-    const List<Face>& faceLst,
-    const List<surfZone>& zoneLst
+    const fileName& filename,
+    const MeshedSurfaceProxy<Face>& surf
 )
 {
-    writeHeader(os, pointLst, faceLst.size(), zoneLst);
+    const pointField& pointLst = surf.points();
+    const List<Face>&  faceLst = surf.faces();
+    const List<label>& faceMap = surf.faceMap();
+
+    // for no zones, suppress the group name
+    const List<surfZone>& zones =
+    (
+        surf.surfZones().size() > 1
+      ? surf.surfZones()
+      : oneZone(faceLst, "")
+    );
+
+    const bool useFaceMap = (surf.useFaceMap() && zones.size() > 1);
+
+    OFstream os(filename);
+    if (!os.good())
+    {
+        FatalErrorIn
+        (
+            "fileFormats::OBJsurfaceFormat::write"
+            "(const fileName&, const MeshedSurfaceProxy<Face>&)"
+        )
+            << "Cannot open file for writing " << filename
+            << exit(FatalError);
+    }
+
+
+    os  << "# Wavefront OBJ file written " << clock::dateTime().c_str() << nl
+        << "o " << os.name().lessExt().name() << nl
+        << nl
+        << "# points : " << pointLst.size() << nl
+        << "# faces  : " << faceLst.size() << nl
+        << "# zones  : " << zones.size() << nl;
+
+    // Print zone names as comment
+    forAll(zones, zoneI)
+    {
+        os  << "#   " << zoneI << "  " << zones[zoneI].name()
+            << "  (nFaces: " << zones[zoneI].size() << ")" << nl;
+    }
+
+    os  << nl
+        << "# <points count=\"" << pointLst.size() << "\">" << nl;
+
+    // Write vertex coords
+    forAll(pointLst, ptI)
+    {
+        const point& pt = pointLst[ptI];
+
+        os  << "v " << pt.x() << ' '  << pt.y() << ' '  << pt.z() << nl;
+    }
+
+    os  << "# </points>" << nl
+        << nl
+        << "# <faces count=\"" << faceLst.size() << "\">" << endl;
+
 
     label faceIndex = 0;
-    forAll(zoneLst, zoneI)
+    forAll(zones, zoneI)
     {
-        const surfZone& zone = zoneLst[zoneI];
+        const surfZone& zone = zones[zoneI];
 
-        os << "g " << zone.name() << endl;
-
-        forAll(zone, localFaceI)
+        if (zone.name().size())
         {
-            const Face& f = faceLst[faceIndex++];
+            os << "g " << zone.name() << endl;
+        }
 
-            os << 'f';
-            forAll(f, fp)
+        if (useFaceMap)
+        {
+            forAll(zone, localFaceI)
             {
-                os << ' ' << f[fp] + 1;
+                const Face& f = faceLst[faceMap[faceIndex++]];
+
+                os << 'f';
+                forAll(f, fp)
+                {
+                    os << ' ' << f[fp] + 1;
+                }
+                os << endl;
+            }
+        }
+        else
+        {
+            forAll(zone, localFaceI)
+            {
+                const Face& f = faceLst[faceIndex++];
+
+                os << 'f';
+                forAll(f, fp)
+                {
+                    os << ' ' << f[fp] + 1;
+                }
+                os << endl;
             }
-            os << endl;
         }
     }
     os << "# </faces>" << endl;
 }
 
 
-template<class Face>
-void Foam::fileFormats::OBJsurfaceFormat<Face>::write
-(
-    Ostream& os,
-    const MeshedSurface<Face>& surf
-)
-{
-    write(os, surf.points(), surf.faces(), surf.zones());
-}
-
-
-template<class Face>
-void Foam::fileFormats::OBJsurfaceFormat<Face>::write
-(
-    Ostream& os,
-    const UnsortedMeshedSurface<Face>& surf
-)
-{
-    const List<Face>& faceLst = surf.faces();
-
-    labelList faceMap;
-    List<surfZone> zoneLst = surf.sortedZones(faceMap);
-
-    writeHeader(os, surf.points(), faceLst.size(), zoneLst);
-
-    label faceIndex = 0;
-    forAll(zoneLst, zoneI)
-    {
-        // Print all faces belonging to this zone
-        const surfZone& zone = zoneLst[zoneI];
-
-        os << "g " << zone.name() << endl;
-
-        forAll(zone, localFaceI)
-        {
-            const Face& f = faceLst[faceMap[faceIndex++]];
-
-            os << 'f';
-            forAll(f, fp)
-            {
-                os << ' ' << f[fp] + 1;
-            }
-            os << endl;
-        }
-    }
-
-    os << "# </faces>" << endl;
-}
-
 // ************************************************************************* //
diff --git a/src/surfMesh/surfaceFormats/obj/OBJsurfaceFormat.H b/src/surfMesh/surfaceFormats/obj/OBJsurfaceFormat.H
index d9acc483ab..424074b0f0 100644
--- a/src/surfMesh/surfaceFormats/obj/OBJsurfaceFormat.H
+++ b/src/surfMesh/surfaceFormats/obj/OBJsurfaceFormat.H
@@ -38,11 +38,9 @@ SourceFiles
 #ifndef OBJsurfaceFormat_H
 #define OBJsurfaceFormat_H
 
-#include "Ostream.H"
-#include "OFstream.H"
 #include "MeshedSurface.H"
+#include "MeshedSurfaceProxy.H"
 #include "UnsortedMeshedSurface.H"
-#include "OBJsurfaceFormatCore.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -58,8 +56,7 @@ namespace fileFormats
 template<class Face>
 class OBJsurfaceFormat
 :
-    public MeshedSurface<Face>,
-    public OBJsurfaceFormatCore
+    public MeshedSurface<Face>
 {
     // Private Member Functions
 
@@ -95,58 +92,16 @@ public:
 
     // Member Functions
 
+        //- Write surface mesh components by proxy
+        static void write(const fileName&, const MeshedSurfaceProxy<Face>&);
+
         //- Read from file
         virtual bool read(const fileName&);
 
-        //- Write surface mesh components
-        static void write
-        (
-            Ostream&,
-            const pointField&,
-            const List<Face>&,
-            const List<surfZone>&
-        );
-
-        //- Write MeshedSurface
-        static void write
-        (
-            Ostream&,
-            const MeshedSurface<Face>&
-        );
-
-        //- Write MeshedSurface
-        static void write
-        (
-            const fileName& name,
-            const MeshedSurface<Face>& surf
-        )
+        //- Write object file
+        virtual void write(const fileName& name) const
         {
-            write(OFstream(name)(), surf);
-        }
-
-        //- Write UnsortedMeshedSurface
-        //  The output is sorted by zones
-        static void write
-        (
-            Ostream&,
-            const UnsortedMeshedSurface<Face>&
-        );
-
-        //- Write UnsortedMeshedSurface
-        //  The output is sorted by zones
-        static void write
-        (
-            const fileName& name,
-            const UnsortedMeshedSurface<Face>& surf
-        )
-        {
-            write(OFstream(name)(), surf);
-        }
-
-        //- Write object
-        virtual void write(Ostream& os) const
-        {
-            write(os, *this);
+            write(name, MeshedSurfaceProxy<Face>(*this));
         }
 
 };
diff --git a/src/surfMesh/surfaceFormats/obj/OBJsurfaceFormatRunTime.C b/src/surfMesh/surfaceFormats/obj/OBJsurfaceFormatRunTime.C
index 4752aaf53b..6c6789a3ad 100644
--- a/src/surfMesh/surfaceFormats/obj/OBJsurfaceFormatRunTime.C
+++ b/src/surfMesh/surfaceFormats/obj/OBJsurfaceFormatRunTime.C
@@ -25,8 +25,7 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "OBJsurfaceFormat.H"
-#include "MeshedSurface.H"
-#include "UnsortedMeshedSurface.H"
+
 #include "addToRunTimeSelectionTable.H"
 #include "addToMemberFunctionSelectionTable.H"
 
@@ -36,6 +35,7 @@ namespace Foam
 namespace fileFormats
 {
 
+// read MeshedSurface
 addNamedTemplatedToRunTimeSelectionTable
 (
     MeshedSurface,
@@ -53,10 +53,10 @@ addNamedTemplatedToRunTimeSelectionTable
     obj
 );
 
-
+// write MeshedSurfaceProxy
 addNamedTemplatedToMemberFunctionSelectionTable
 (
-    MeshedSurface,
+    MeshedSurfaceProxy,
     OBJsurfaceFormat,
     face,
     write,
@@ -65,7 +65,7 @@ addNamedTemplatedToMemberFunctionSelectionTable
 );
 addNamedTemplatedToMemberFunctionSelectionTable
 (
-    MeshedSurface,
+    MeshedSurfaceProxy,
     OBJsurfaceFormat,
     triFace,
     write,
@@ -73,26 +73,6 @@ addNamedTemplatedToMemberFunctionSelectionTable
     obj
 );
 
-addNamedTemplatedToMemberFunctionSelectionTable
-(
-    UnsortedMeshedSurface,
-    OBJsurfaceFormat,
-    face,
-    write,
-    fileExtension,
-    obj
-);
-addNamedTemplatedToMemberFunctionSelectionTable
-(
-    UnsortedMeshedSurface,
-    OBJsurfaceFormat,
-    triFace,
-    write,
-    fileExtension,
-    obj
-);
-
-
 }
 }
 
diff --git a/src/surfMesh/surfaceFormats/off/OFFsurfaceFormat.C b/src/surfMesh/surfaceFormats/off/OFFsurfaceFormat.C
index 7e73affa17..531e599f25 100644
--- a/src/surfMesh/surfaceFormats/off/OFFsurfaceFormat.C
+++ b/src/surfMesh/surfaceFormats/off/OFFsurfaceFormat.C
@@ -25,8 +25,11 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "OFFsurfaceFormat.H"
+#include "clock.H"
 #include "IFstream.H"
 #include "IStringStream.H"
+#include "Ostream.H"
+#include "OFstream.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
@@ -60,7 +63,7 @@ bool Foam::fileFormats::OFFsurfaceFormat<Face>::read
     {
         FatalErrorIn
         (
-            "fileFormats::OFFsurfaceFormat<Face>::read(const fileName&)"
+            "fileFormats::OFFsurfaceFormat::read(const fileName&)"
         )
             << "Cannot read file " << filename
             << exit(FatalError);
@@ -72,7 +75,7 @@ bool Foam::fileFormats::OFFsurfaceFormat<Face>::read
     {
         FatalErrorIn
         (
-            "fileFormats::OFFsurfaceFormat<Face>::read(const fileName&)"
+            "fileFormats::OFFsurfaceFormat::read(const fileName&)"
         )
             << "OFF file " << filename << " does not start with 'OFF'"
             << exit(FatalError);
@@ -142,11 +145,9 @@ bool Foam::fileFormats::OFFsurfaceFormat<Face>::read
         }
     }
 
-    // transfer to normal lists
-    reset(pointLst.xfer(), dynFaces.xfer());
+    // transfer to normal lists, no zone information
+    reset(pointLst.xfer(), dynFaces.xfer(), Xfer<surfZoneList>());
 
-    // no zone information
-    this->oneZone();
     return true;
 }
 
@@ -154,81 +155,97 @@ bool Foam::fileFormats::OFFsurfaceFormat<Face>::read
 template<class Face>
 void Foam::fileFormats::OFFsurfaceFormat<Face>::write
 (
-    Ostream& os,
-    const pointField& pointLst,
-    const List<Face>& faceLst,
-    const List<surfZone>& zoneLst
+    const fileName& filename,
+    const MeshedSurfaceProxy<Face>& surf
 )
 {
-    writeHeader(os, pointLst, faceLst.size(), zoneLst);
+    const pointField& pointLst = surf.points();
+    const List<Face>&  faceLst = surf.faces();
+    const List<label>& faceMap = surf.faceMap();
+    const List<surfZone>& zoneLst = surf.surfZones();
 
-    label faceIndex = 0;
-    forAll(zoneLst, zoneI)
+    OFstream os(filename);
+    if (!os.good())
     {
-        os << "# <zone name=\"" << zoneLst[zoneI].name() << "\">" << endl;
-
-        forAll(zoneLst[zoneI], localFaceI)
-        {
-            const Face& f = faceLst[faceIndex++];
-
-            os << f.size();
-            forAll(f, fp)
-            {
-                os << ' ' << f[fp];
-            }
-
-            // add optional zone information
-            os << ' ' << zoneI << endl;
-        }
-        os << "# </zone>" << endl;
+        FatalErrorIn
+        (
+            "fileFormats::OFFsurfaceFormat::write"
+            "(const fileName&, const MeshedSurfaceProxy<Face>&)"
+        )
+            << "Cannot open file for writing " << filename
+            << exit(FatalError);
     }
-    os << "# </faces>" << endl;
-}
 
+    // Write header
+    os  << "OFF" << endl
+        << "# Geomview OFF file written " << clock::dateTime().c_str() << nl
+        << nl
+        << "# points : " << pointLst.size() << nl
+        << "# faces  : " << faceLst.size() << nl
+        << "# zones  : " << zoneLst.size() << nl;
 
-template<class Face>
-void Foam::fileFormats::OFFsurfaceFormat<Face>::write
-(
-    Ostream& os,
-    const MeshedSurface<Face>& surf
-)
-{
-    write(os, surf.points(), surf.faces(), surf.zones());
-}
+    // Print zone names as comment
+    forAll(zoneLst, zoneI)
+    {
+        os  << "#   " << zoneI << "  " << zoneLst[zoneI].name()
+            << "  (nFaces: " << zoneLst[zoneI].size() << ")" << nl;
+    }
 
+    os  << nl
+        << "# nPoints  nFaces  nEdges" << nl
+        << pointLst.size() << ' ' << faceLst.size() << ' ' << 0 << nl
+        << nl
+        << "# <points count=\"" << pointLst.size() << "\">" << endl;
 
-template<class Face>
-void Foam::fileFormats::OFFsurfaceFormat<Face>::write
-(
-    Ostream& os,
-    const UnsortedMeshedSurface<Face>& surf
-)
-{
-    const List<Face>& faceLst = surf.faces();
+    // Write vertex coords
+    forAll(pointLst, ptI)
+    {
+        os  << pointLst[ptI].x() << ' '
+            << pointLst[ptI].y() << ' '
+            << pointLst[ptI].z() << " #" << ptI << endl;
+    }
 
-    labelList faceMap;
-    List<surfZone> zoneLst = surf.sortedZones(faceMap);
-
-    writeHeader(os, surf.points(), faceLst.size(), zoneLst);
+    os  << "# </points>" << nl
+        << nl
+        << "# <faces count=\"" << faceLst.size() << "\">" << endl;
 
     label faceIndex = 0;
     forAll(zoneLst, zoneI)
     {
         os << "# <zone name=\"" << zoneLst[zoneI].name() << "\">" << endl;
 
-        forAll(zoneLst[zoneI], localFaceI)
+        if (surf.useFaceMap()) 
         {
-            const Face& f = faceLst[faceMap[faceIndex++]];
-
-            os << f.size();
-            forAll(f, fp)
+            forAll(zoneLst[zoneI], localFaceI)
             {
-                os << ' ' << f[fp];
-            }
+                const Face& f = faceLst[faceMap[faceIndex++]];
 
-            // add optional zone information
-            os << ' ' << zoneI << endl;
+                os << f.size();
+                forAll(f, fp)
+                {
+                    os << ' ' << f[fp];
+                }
+
+                // add optional zone information
+                os << ' ' << zoneI << endl;
+            }
         }
+        else
+        {
+            forAll(zoneLst[zoneI], localFaceI)
+            {
+                const Face& f = faceLst[faceIndex++];
+
+                os << f.size();
+                forAll(f, fp)
+                {
+                    os << ' ' << f[fp];
+                }
+
+                // add optional zone information
+                os << ' ' << zoneI << endl;
+            }
+        }        
         os << "# </zone>" << endl;
     }
     os << "# </faces>" << endl;
diff --git a/src/surfMesh/surfaceFormats/off/OFFsurfaceFormat.H b/src/surfMesh/surfaceFormats/off/OFFsurfaceFormat.H
index 669be5a9a5..bc3f608add 100644
--- a/src/surfMesh/surfaceFormats/off/OFFsurfaceFormat.H
+++ b/src/surfMesh/surfaceFormats/off/OFFsurfaceFormat.H
@@ -46,11 +46,9 @@ SourceFiles
 #ifndef OFFsurfaceFormat_H
 #define OFFsurfaceFormat_H
 
-#include "Ostream.H"
-#include "OFstream.H"
 #include "MeshedSurface.H"
+#include "MeshedSurfaceProxy.H"
 #include "UnsortedMeshedSurface.H"
-#include "OFFsurfaceFormatCore.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -66,8 +64,7 @@ namespace fileFormats
 template<class Face>
 class OFFsurfaceFormat
 :
-    public MeshedSurface<Face>,
-    public OFFsurfaceFormatCore
+    public MeshedSurface<Face>
 {
     // Private Member Functions
 
@@ -101,58 +98,17 @@ public:
 
     // Member Functions
 
+        //- Write surface mesh components by proxy
+        static void write(const fileName&, const MeshedSurfaceProxy<Face>&);
+
+
         //- Read from file
         virtual bool read(const fileName&);
 
-        //- Write surface mesh components
-        static void write
-        (
-            Ostream&,
-            const pointField&,
-            const List<Face>&,
-            const List<surfZone>&
-        );
-
-        //- Write MeshedSurface
-        static void write
-        (
-            Ostream&,
-            const MeshedSurface<Face>&
-        );
-
-        //- Write MeshedSurface
-        static void write
-        (
-            const fileName& name,
-            const MeshedSurface<Face>& surf
-        )
-        {
-            write(OFstream(name)(), surf);
-        }
-
-        //- Write UnsortedMeshedSurface
-        //  The output is sorted by zone.
-        static void write
-        (
-            Ostream&,
-            const UnsortedMeshedSurface<Face>&
-        );
-
-        //- Write UnsortedMeshedSurface
-        //  The output is sorted by zone.
-        static void write
-        (
-            const fileName& name,
-            const UnsortedMeshedSurface<Face>& surf
-        )
-        {
-            write(OFstream(name)(), surf);
-        }
-
         //- Write object
-        virtual void write(Ostream& os) const
+        virtual void write(const fileName& name) const
         {
-            write(os, *this);
+            write(name, MeshedSurfaceProxy<Face>(*this));
         }
 
 };
diff --git a/src/surfMesh/surfaceFormats/off/OFFsurfaceFormatCore.C b/src/surfMesh/surfaceFormats/off/OFFsurfaceFormatCore.C
deleted file mode 100644
index e65476da67..0000000000
--- a/src/surfMesh/surfaceFormats/off/OFFsurfaceFormatCore.C
+++ /dev/null
@@ -1,78 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 1991-2009 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 "OFFsurfaceFormatCore.H"
-#include "clock.H"
-
-// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
-
-void Foam::fileFormats::OFFsurfaceFormatCore::writeHeader
-(
-    Ostream& os,
-    const pointField& pointLst,
-    const label nFaces,
-    const UList<surfZone>& zoneLst
-)
-{
-    // Write header
-    os  << "OFF" << endl
-        << "# Geomview OFF file written " << clock::dateTime().c_str() << nl
-        << nl
-        << "# points : " << pointLst.size() << nl
-        << "# faces  : " << nFaces << nl
-        << "# zones  : " << zoneLst.size() << nl;
-
-    // Print zone names as comment
-    forAll(zoneLst, zoneI)
-    {
-        os  << "#   " << zoneI << "  " << zoneLst[zoneI].name()
-            << "  (nFaces: " << zoneLst[zoneI].size() << ")" << nl;
-    }
-
-    os  << nl
-        << "# nPoints  nFaces  nEdges" << nl
-        << pointLst.size() << ' ' << nFaces << ' ' << 0 << nl;
-
-    os  << nl
-        << "# <points count=\"" << pointLst.size() << "\">" << endl;
-
-    // Write vertex coords
-    forAll(pointLst, ptI)
-    {
-        os  << pointLst[ptI].x() << ' '
-            << pointLst[ptI].y() << ' '
-            << pointLst[ptI].z() << " #" << ptI << endl;
-    }
-
-    os  << "# </points>" << nl
-        << nl
-        << "# <faces count=\"" << nFaces << "\">" << endl;
-}
-
-// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
-
-
-// ************************************************************************* //
diff --git a/src/surfMesh/surfaceFormats/off/OFFsurfaceFormatRunTime.C b/src/surfMesh/surfaceFormats/off/OFFsurfaceFormatRunTime.C
index 8a848788be..5989f60bf0 100644
--- a/src/surfMesh/surfaceFormats/off/OFFsurfaceFormatRunTime.C
+++ b/src/surfMesh/surfaceFormats/off/OFFsurfaceFormatRunTime.C
@@ -25,8 +25,7 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "OFFsurfaceFormat.H"
-#include "MeshedSurface.H"
-#include "UnsortedMeshedSurface.H"
+
 #include "addToRunTimeSelectionTable.H"
 #include "addToMemberFunctionSelectionTable.H"
 
@@ -36,6 +35,7 @@ namespace Foam
 namespace fileFormats
 {
 
+// read MeshedSurface
 addNamedTemplatedToRunTimeSelectionTable
 (
     MeshedSurface,
@@ -53,10 +53,10 @@ addNamedTemplatedToRunTimeSelectionTable
     off
 );
 
-
+// write MeshedSurfaceProxy
 addNamedTemplatedToMemberFunctionSelectionTable
 (
-    MeshedSurface,
+    MeshedSurfaceProxy,
     OFFsurfaceFormat,
     face,
     write,
@@ -65,7 +65,7 @@ addNamedTemplatedToMemberFunctionSelectionTable
 );
 addNamedTemplatedToMemberFunctionSelectionTable
 (
-    MeshedSurface,
+    MeshedSurfaceProxy,
     OFFsurfaceFormat,
     triFace,
     write,
@@ -74,25 +74,6 @@ addNamedTemplatedToMemberFunctionSelectionTable
 );
 
 
-addNamedTemplatedToMemberFunctionSelectionTable
-(
-    UnsortedMeshedSurface,
-    OFFsurfaceFormat,
-    face,
-    write,
-    fileExtension,
-    off
-);
-addNamedTemplatedToMemberFunctionSelectionTable
-(
-    UnsortedMeshedSurface,
-    OFFsurfaceFormat,
-    triFace,
-    write,
-    fileExtension,
-    off
-);
-
 }
 }
 
diff --git a/src/surfMesh/surfaceFormats/ofs/OFSsurfaceFormat.C b/src/surfMesh/surfaceFormats/ofs/OFSsurfaceFormat.C
new file mode 100644
index 0000000000..3368ff3138
--- /dev/null
+++ b/src/surfMesh/surfaceFormats/ofs/OFSsurfaceFormat.C
@@ -0,0 +1,260 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2009 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 "OFSsurfaceFormat.H"
+#include "IFstream.H"
+#include "IStringStream.H"
+#include "ListOps.H"
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+template<class Face>
+Foam::fileFormats::OFSsurfaceFormat<Face>::OFSsurfaceFormat
+(
+    const fileName& filename
+)
+{
+    read(filename);
+}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+template<class Face>
+bool Foam::fileFormats::OFSsurfaceFormat<Face>::read
+(
+    const fileName& filename
+)
+{
+    this->clear();
+
+    IFstream is(filename);
+    if (!is.good())
+    {
+        FatalErrorIn
+        (
+            "fileFormats::OFSsurfaceFormat::read(const fileName&)"
+        )
+            << "Cannot read file " << filename
+            << exit(FatalError);
+    }
+
+    // read surfZones:
+    is >> this->storedZones();
+
+    // read points:
+    is >> this->storedPoints();
+
+    // must triangulate?
+    if (MeshedSurface<Face>::isTri())
+    {
+        // read faces as 'face' and transcribe to 'triFace'
+        List<face> faceLst(is);
+
+        MeshedSurface<face> surf
+        (
+            xferMove(this->storedPoints()),
+            xferMove(faceLst),
+            xferMove(this->storedZones())
+        );
+
+        this->transcribe(surf);
+    }
+    else
+    {
+        // read faces directly
+        is >> this->storedFaces();
+    }
+
+    return true;
+}
+
+
+template<class Face>
+bool Foam::fileFormats::OFSsurfaceFormat<Face>::read
+(
+    Istream& is,
+    pointField& pointLst,
+    List<Face>& faceLst,
+    List<surfZone>& zoneLst
+)
+{
+    if (!is.good())
+    {
+        FatalErrorIn
+        (
+            "fileFormats::OFSsurfaceFormat::read"
+            "(Istream&, pointField&, List<Face>&, List<surfZone>&)"
+        )
+            << "read error "
+            << exit(FatalError);
+    }
+
+    // read surfZones:
+    is >> zoneLst;
+
+    // read points:
+    is >> pointLst;
+
+    // must triangulate?
+    if (MeshedSurface<Face>::isTri())
+    {
+        // read faces as 'face' and transcribe to 'triFace'
+        List<face> origFaces(is);
+
+        MeshedSurface<face> origSurf
+        (
+            xferMove(pointLst),
+            xferMove(origFaces),
+            xferMove(zoneLst)
+        );
+
+        MeshedSurface<Face> surf;
+        surf.transcribe(origSurf);
+    }
+    else
+    {
+        // read faces directly
+        is >> faceLst;
+    }
+
+    return true;
+}
+
+
+template<class Face>
+bool Foam::fileFormats::OFSsurfaceFormat<Face>::read
+(
+    Istream& is,
+    MeshedSurface<Face>& surf
+)
+{
+    surf.clear();
+
+    if (!is.good())
+    {
+        FatalErrorIn
+        (
+            "fileFormats::OFSsurfaceFormat::read"
+            "(Istream&, MeshedSurface<Face>&)"
+        )
+            << "read error "
+            << exit(FatalError);
+    }
+
+    pointField pointLst;
+    List<Face> faceLst;
+    List<surfZone> zoneLst;
+
+    read(is, pointLst, faceLst, zoneLst);
+
+    surf.reset
+    (
+        xferMove(pointLst),
+        xferMove(faceLst),
+        xferMove(zoneLst)
+    );
+
+    return true;
+}
+
+
+template<class Face>
+bool Foam::fileFormats::OFSsurfaceFormat<Face>::read
+(
+    Istream& is,
+    UnsortedMeshedSurface<Face>& surf
+)
+{
+    surf.clear();
+    MeshedSurface<Face> origSurf(is);
+    surf.transfer(origSurf);
+
+    return true;
+}
+
+
+
+template<class Face>
+void Foam::fileFormats::OFSsurfaceFormat<Face>::write
+(
+    const fileName& filename,
+    const MeshedSurfaceProxy<Face>& surf
+)
+{
+    const List<Face>&  faceLst = surf.faces();
+    const List<label>& faceMap = surf.faceMap();
+
+    OFstream os(filename);
+    if (!os.good())
+    {
+        FatalErrorIn
+        (
+            "fileFormats::OFSsurfaceFormat::write"
+            "(const fileName&, const MeshedSurfaceProxy<Face>&)"
+        )
+            << "Cannot open file for writing " << filename
+            << exit(FatalError);
+    }
+
+
+    OFSsurfaceFormatCore::writeHeader(os, surf.points(), surf.surfZones());
+
+    const List<surfZone>& zones = surf.surfZones();
+    const bool useFaceMap = (surf.useFaceMap() && zones.size() > 1);
+
+    if (useFaceMap)
+    {
+        os  << "\n// faces:"  << nl
+            << faceLst.size() << token::BEGIN_LIST << nl;
+
+        label faceI = 0;
+        forAll(zones, zoneI)
+        {
+            // Print all faces belonging to this zone
+            const surfZone& zone = zones[zoneI];
+
+            forAll(zone, localFaceI)
+            {
+                os << faceLst[faceMap[faceI++]] << nl;
+            }
+        }
+        os << token::END_LIST << nl;
+    }
+    else
+    {
+        os  << "\n// faces:"  << nl << faceLst << nl;
+    }
+
+    IOobject::writeDivider(os);
+
+    // Check state of Ostream
+    os.check("OFSsurfaceFormat<Face>::write(Ostream&)");
+}
+
+// ************************************************************************* //
diff --git a/src/surfMesh/surfaceFormats/ofs/OFSsurfaceFormat.H b/src/surfMesh/surfaceFormats/ofs/OFSsurfaceFormat.H
new file mode 100644
index 0000000000..e550d04e7d
--- /dev/null
+++ b/src/surfMesh/surfaceFormats/ofs/OFSsurfaceFormat.H
@@ -0,0 +1,155 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2009 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
+
+Class
+    Foam::fileFormats::OFSsurfaceFormat
+
+Description
+    Provide a means of reading/writing the single-file OpenFOAM surface format.
+
+Note
+   This class provides more methods than the regular surface format interface.x
+
+SourceFiles
+    OFSsurfaceFormat.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef OFSsurfaceFormat_H
+#define OFSsurfaceFormat_H
+
+#include "Ostream.H"
+#include "OFstream.H"
+#include "MeshedSurface.H"
+#include "MeshedSurfaceProxy.H"
+#include "UnsortedMeshedSurface.H"
+#include "OFSsurfaceFormatCore.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace fileFormats
+{
+
+/*---------------------------------------------------------------------------*\
+                      Class OFSsurfaceFormat Declaration
+\*---------------------------------------------------------------------------*/
+
+template<class Face>
+class OFSsurfaceFormat
+:
+    public MeshedSurface<Face>,
+    public OFSsurfaceFormatCore
+{
+    // Private Member Functions
+
+        //- Disallow default bitwise copy construct
+        OFSsurfaceFormat(const OFSsurfaceFormat<Face>&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const OFSsurfaceFormat<Face>&);
+
+public:
+
+    // Constructors
+
+        //- Construct from file name
+        OFSsurfaceFormat(const fileName&);
+
+    // Selectors
+
+        //- Read file and return surface
+        static autoPtr<MeshedSurface<Face> > New(const fileName& name)
+        {
+            return autoPtr<MeshedSurface<Face> >
+            (
+                new OFSsurfaceFormat<Face>(name)
+            );
+        }
+
+    // Destructor
+
+        virtual ~OFSsurfaceFormat()
+        {}
+
+
+    // Member Functions
+
+        //- Read surface mesh components
+        static bool read
+        (
+            Istream&,
+            pointField&,
+            List<Face>&,
+            List<surfZone>&
+        );
+
+        //- Read MeshedSurface
+        static bool read
+        (
+            Istream&,
+            MeshedSurface<Face>&
+        );
+
+        //- Read UnsortedMeshedSurface
+        //  The output is sorted by zones
+        static bool read
+        (
+            Istream&,
+            UnsortedMeshedSurface<Face>&
+        );
+
+        //- Write surface mesh components by proxy
+        static void write(const fileName&, const MeshedSurfaceProxy<Face>&);
+
+
+        //- Read from file
+        virtual bool read(const fileName&);
+
+        //- Write object
+        virtual void write(const fileName& name) const
+        {
+            write(name, MeshedSurfaceProxy<Face>(*this));
+        }
+
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace fileFormats
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+#   include "OFSsurfaceFormat.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/surfMesh/surfaceFormats/obj/OBJsurfaceFormatCore.C b/src/surfMesh/surfaceFormats/ofs/OFSsurfaceFormatCore.C
similarity index 63%
rename from src/surfMesh/surfaceFormats/obj/OBJsurfaceFormatCore.C
rename to src/surfMesh/surfaceFormats/ofs/OFSsurfaceFormatCore.C
index c6062d54fe..09b4324f38 100644
--- a/src/surfMesh/surfaceFormats/obj/OBJsurfaceFormatCore.C
+++ b/src/surfMesh/surfaceFormats/ofs/OFSsurfaceFormatCore.C
@@ -24,51 +24,53 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-#include "OBJsurfaceFormatCore.H"
+#include "OFSsurfaceFormatCore.H"
 #include "clock.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 
-void Foam::fileFormats::OBJsurfaceFormatCore::writeHeader
+void Foam::fileFormats::OFSsurfaceFormatCore::writeHeader
 (
     Ostream& os,
     const pointField& pointLst,
-    const label nFaces,
     const UList<surfZone>& zoneLst
 )
 {
-    os  << "# Wavefront OBJ file written " << clock::dateTime().c_str() << nl
-        << "o " << os.name().lessExt().name() << nl
-        << nl
-        << "# points : " << pointLst.size() << nl
-        << "# faces  : " << nFaces << nl
-        << "# zones  : " << zoneLst.size() << nl;
+    // just emit some information until we get a nice IOobject
+    IOobject::writeBanner(os)
+        << "// OpenFOAM Surface Format - written "
+        << clock::dateTime().c_str() << nl
+        << "// ~~~~~~~~~~~~~~~~~~~~~~~" << nl << nl
+        << "// surfZones:" << nl;
 
-    // Print zone names as comment
-    forAll(zoneLst, zoneI)
+
+    // treat a single zone as being unzoned
+    if (zoneLst.size() <= 1)
     {
-        os  << "#   " << zoneI << "  " << zoneLst[zoneI].name()
-            << "  (nFaces: " << zoneLst[zoneI].size() << ")" << nl;
+        os  << "0" << token::BEGIN_LIST << token::END_LIST << nl << nl;
+    }
+    else
+    {
+        os  << zoneLst.size() << nl << token::BEGIN_LIST << incrIndent << nl;
+
+        forAll(zoneLst, zoneI)
+        {
+            zoneLst[zoneI].writeDict(os);
+        }
+        os  << decrIndent << token::END_LIST << nl << nl;
     }
 
-    os  << nl
-        << "# <points count=\"" << pointLst.size() << "\">" << endl;
+    // Note: write with global point numbering
 
-    // Write vertex coords
-    forAll(pointLst, ptI)
-    {
-        os  << "v " << pointLst[ptI].x()
-            << ' '  << pointLst[ptI].y()
-            << ' '  << pointLst[ptI].z() << nl;
-    }
+    IOobject::writeDivider(os)
+        << "\n// points:" << nl << pointLst << nl;
 
-    os  << "# </points>" << nl
-        << nl
-        << "# <faces count=\"" << nFaces << "\">" << endl;
+    IOobject::writeDivider(os);
 }
 
+
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
 // ************************************************************************* //
diff --git a/src/surfMesh/surfaceFormats/obj/OBJsurfaceFormatCore.H b/src/surfMesh/surfaceFormats/ofs/OFSsurfaceFormatCore.H
similarity index 86%
rename from src/surfMesh/surfaceFormats/obj/OBJsurfaceFormatCore.H
rename to src/surfMesh/surfaceFormats/ofs/OFSsurfaceFormatCore.H
index 42e48f75f6..d9d7ef5cd3 100644
--- a/src/surfMesh/surfaceFormats/obj/OBJsurfaceFormatCore.H
+++ b/src/surfMesh/surfaceFormats/ofs/OFSsurfaceFormatCore.H
@@ -23,18 +23,18 @@ License
     Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 
 Class
-    Foam::fileFormats::OBJsurfaceFormatCore
+    Foam::fileFormats::OFSsurfaceFormatCore
 
 Description
-    Internal class used by the OBJsurfaceFormat
+    Internal class used by the OFSsurfaceFormat
 
 SourceFiles
-    OBJsurfaceFormatCore.C
+    OFSsurfaceFormatCore.C
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef OBJsurfaceFormatCore_H
-#define OBJsurfaceFormatCore_H
+#ifndef OFSsurfaceFormatCore_H
+#define OFSsurfaceFormatCore_H
 
 #include "Ostream.H"
 #include "OFstream.H"
@@ -49,20 +49,19 @@ namespace fileFormats
 {
 
 /*---------------------------------------------------------------------------*\
-                    Class OBJsurfaceFormatCore Declaration
+                    Class OFSsurfaceFormatCore Declaration
 \*---------------------------------------------------------------------------*/
 
-class OBJsurfaceFormatCore
+class OFSsurfaceFormatCore
 {
 protected:
     // Protected Member Functions
 
-    //- Write header information with points
+    //- Write header information and surfZoneList
     static void writeHeader
     (
         Ostream&,
         const pointField&,
-        const label nFaces,
         const UList<surfZone>&
     );
 
diff --git a/src/surfMesh/surfaceFormats/smesh/SMESHsurfaceFormatCore.H b/src/surfMesh/surfaceFormats/ofs/OFSsurfaceFormatRunTime.C
similarity index 54%
rename from src/surfMesh/surfaceFormats/smesh/SMESHsurfaceFormatCore.H
rename to src/surfMesh/surfaceFormats/ofs/OFSsurfaceFormatRunTime.C
index a50f2a50d7..fc1e609d67 100644
--- a/src/surfMesh/surfaceFormats/smesh/SMESHsurfaceFormatCore.H
+++ b/src/surfMesh/surfaceFormats/ofs/OFSsurfaceFormatRunTime.C
@@ -22,61 +22,60 @@ License
     along with OpenFOAM; if not, write to the Free Software Foundation,
     Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 
-Class
-    Foam::fileFormats::SMESHsurfaceFormatCore
-
-Description
-    Internal class used by the SMESHsurfaceFormat
-
-SourceFiles
-    SMESHsurfaceFormatCore.C
-
 \*---------------------------------------------------------------------------*/
 
-#ifndef SMESHsurfaceFormatCore_H
-#define SMESHsurfaceFormatCore_H
+#include "OFSsurfaceFormat.H"
 
-#include "Ostream.H"
-#include "MeshedSurface.H"
-#include "UnsortedMeshedSurface.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+#include "addToRunTimeSelectionTable.H"
+#include "addToMemberFunctionSelectionTable.H"
 
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 namespace Foam
 {
 namespace fileFormats
 {
 
-/*---------------------------------------------------------------------------*\
-                   Class SMESHsurfaceFormatCore Declaration
-\*---------------------------------------------------------------------------*/
-
-class SMESHsurfaceFormatCore
-{
-protected:
-    // Protected Member Functions
-
-    //- Write header information with points
-    static void writeHeader
-    (
-        Ostream&,
-        const pointField&,
-        const label nFaces
-    );
-
-    //- Write tail information
-    static void writeTail(Ostream&);
-
-};
+// read MeshedSurface
+addNamedTemplatedToRunTimeSelectionTable
+(
+    MeshedSurface,
+    OFSsurfaceFormat,
+    face,
+    fileExtension,
+    ofs
+);
+addNamedTemplatedToRunTimeSelectionTable
+(
+    MeshedSurface,
+    OFSsurfaceFormat,
+    triFace,
+    fileExtension,
+    ofs
+);
 
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+// write MeshedSurfaceProxy
+addNamedTemplatedToMemberFunctionSelectionTable
+(
+    MeshedSurfaceProxy,
+    OFSsurfaceFormat,
+    face,
+    write,
+    fileExtension,
+    ofs
+);
+addNamedTemplatedToMemberFunctionSelectionTable
+(
+    MeshedSurfaceProxy,
+    OFSsurfaceFormat,
+    triFace,
+    write,
+    fileExtension,
+    ofs
+);
 
-} // End namespace fileFormats
-} // End namespace Foam
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#endif
+}
+}
 
 // ************************************************************************* //
diff --git a/src/surfMesh/surfaceFormats/smesh/SMESHsurfaceFormat.C b/src/surfMesh/surfaceFormats/smesh/SMESHsurfaceFormat.C
index 3aba1aa744..c354f4ce5a 100644
--- a/src/surfMesh/surfaceFormats/smesh/SMESHsurfaceFormat.C
+++ b/src/surfMesh/surfaceFormats/smesh/SMESHsurfaceFormat.C
@@ -25,6 +25,10 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "SMESHsurfaceFormat.H"
+#include "clock.H"
+#include "IFstream.H"
+#include "OFstream.H"
+#include "Ostream.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
@@ -41,76 +45,98 @@ Foam::fileFormats::SMESHsurfaceFormat<Face>::SMESHsurfaceFormat()
 template<class Face>
 void Foam::fileFormats::SMESHsurfaceFormat<Face>::write
 (
-    Ostream& os,
-    const pointField& pointLst,
-    const List<Face>& faceLst,
-    const List<surfZone>& zoneLst
+    const fileName& filename,
+    const MeshedSurfaceProxy<Face>& surf
 )
 {
-    writeHeader(os, pointLst, faceLst.size());
+    const pointField& pointLst = surf.points();
+    const List<Face>&  faceLst = surf.faces();
+    const List<label>& faceMap = surf.faceMap();
+
+    const List<surfZone>& zones =
+    (
+        surf.surfZones().size() > 1
+      ? surf.surfZones()
+      : oneZone(faceLst)
+    );
+
+    const bool useFaceMap = (surf.useFaceMap() && zones.size() > 1);
+
+
+    OFstream os(filename);
+    if (!os.good())
+    {
+        FatalErrorIn
+        (
+            "fileFormats::SMESHsurfaceFormat::write"
+            "(const fileName&, const MeshedSurfaceProxy<Face>&)"
+        )
+            << "Cannot open file for writing " << filename
+            << exit(FatalError);
+    }
+
+
+    // Write header
+    os  << "# tetgen .smesh file written " << clock::dateTime().c_str() << nl
+        << "# <points count=\"" << pointLst.size() << "\">" << nl
+        << pointLst.size() << " 3" << nl;    // 3: dimensions
+
+    // Write vertex coords
+    forAll(pointLst, ptI)
+    {
+        const point& pt = pointLst[ptI];
+
+        os  << ptI << ' ' << pt.x() << ' ' << pt.y() << ' ' << pt.z() << nl;
+    }
+    os  << "# </points>" << nl
+        << nl
+        << "# <faces count=\"" << faceLst.size() << "\">" << endl;
+
+    os  << faceLst.size() << " 1" << endl;   // one attribute: zone number
+
 
     label faceIndex = 0;
-    forAll(zoneLst, zoneI)
+    forAll(zones, zoneI)
     {
-        forAll(zoneLst[zoneI], localFaceI)
-        {
-            const Face& f = faceLst[faceIndex++];
+        const surfZone& zone = zones[zoneI];
 
-            os << f.size();
-            forAll(f, fp)
+        if (useFaceMap)
+        {
+            forAll(zone, localFaceI)
             {
-                os << ' ' << f[fp];
+                const Face& f = faceLst[faceMap[faceIndex++]];
+
+                os << f.size();
+                forAll(f, fp)
+                {
+                    os << ' ' << f[fp];
+                }
+                os << ' ' << zoneI << endl;
+            }
+        }
+        else
+        {
+            forAll(zones[zoneI], localFaceI)
+            {
+                const Face& f = faceLst[faceIndex++];
+
+                os << f.size();
+                forAll(f, fp)
+                {
+                    os << ' ' << f[fp];
+                }
+                os << ' ' << zoneI << endl;
             }
-            os << ' ' << zoneI << endl;
         }
     }
 
-    writeTail(os);
-}
+    // write tail
 
-
-template<class Face>
-void Foam::fileFormats::SMESHsurfaceFormat<Face>::write
-(
-    Ostream& os,
-    const MeshedSurface<Face>& surf
-)
-{
-    write(os, surf.points(), surf.faces(), surf.zones());
-}
-
-
-template<class Face>
-void Foam::fileFormats::SMESHsurfaceFormat<Face>::write
-(
-    Ostream& os,
-    const UnsortedMeshedSurface<Face>& surf
-)
-{
-    const List<Face>& faceLst = surf.faces();
-
-    writeHeader(os, surf.points(), faceLst.size());
-
-    labelList faceMap;
-    List<surfZone> zoneLst = surf.sortedZones(faceMap);
-
-    label faceIndex = 0;
-    forAll(zoneLst, zoneI)
-    {
-        forAll(zoneLst[zoneI], localFaceI)
-        {
-            const Face& f = faceLst[faceMap[faceIndex++]];
-
-            os << f.size();
-            forAll(f, fp)
-            {
-                os << ' ' << f[fp];
-            }
-            os << ' ' << zoneI << endl;
-        }
-    }
-
-    writeTail(os);
+    os  << "# </faces>" << nl
+        << nl
+        << "# no holes or regions:" << nl
+        << '0' << nl        // holes
+        << '0' << endl;     // regions
 }
 
 
diff --git a/src/surfMesh/surfaceFormats/smesh/SMESHsurfaceFormat.H b/src/surfMesh/surfaceFormats/smesh/SMESHsurfaceFormat.H
index 4ddc438cbb..c3a472da3f 100644
--- a/src/surfMesh/surfaceFormats/smesh/SMESHsurfaceFormat.H
+++ b/src/surfMesh/surfaceFormats/smesh/SMESHsurfaceFormat.H
@@ -42,12 +42,9 @@ SourceFiles
 #ifndef SMESHsurfaceFormat_H
 #define SMESHsurfaceFormat_H
 
-#include "IFstream.H"
-#include "OFstream.H"
-#include "Ostream.H"
 #include "MeshedSurface.H"
+#include "MeshedSurfaceProxy.H"
 #include "UnsortedMeshedSurface.H"
-#include "SMESHsurfaceFormatCore.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -63,8 +60,7 @@ namespace fileFormats
 template<class Face>
 class SMESHsurfaceFormat
 :
-    public MeshedSurface<Face>,
-    public SMESHsurfaceFormatCore
+    public MeshedSurface<Face>
 {
     // Private Member Functions
 
@@ -91,55 +87,14 @@ public:
 
     // Member Functions
 
-        //- Write surface mesh components
-        static void write
-        (
-            Ostream&,
-            const pointField&,
-            const List<Face>&,
-            const List<surfZone>&
-        );
+        //- Write surface mesh components by proxy
+        static void write(const fileName&, const MeshedSurfaceProxy<Face>&);
 
-        //- Write MeshedSurface
-        static void write
-        (
-            Ostream&,
-            const MeshedSurface<Face>&
-        );
-
-        //- Write MeshedSurface
-        static void write
-        (
-            const fileName& name,
-            const MeshedSurface<Face>& surf
-        )
-        {
-            write(OFstream(name)(), surf);
-        }
-
-        //- Write UnsortedMeshedSurface
-        //  The output is sorted by zone.
-        static void write
-        (
-            Ostream&,
-            const UnsortedMeshedSurface<Face>&
-        );
-
-        //- Write UnsortedMeshedSurface
-        //  The output is sorted by zone.
-        static void write
-        (
-            const fileName& name,
-            const UnsortedMeshedSurface<Face>& surf
-        )
-        {
-            write(OFstream(name)(), surf);
-        }
 
         //- Write object
-        virtual void write(Ostream& os) const
+        virtual void write(const fileName& name) const
         {
-            write(os, *this);
+            write(name, MeshedSurfaceProxy<Face>(*this));
         }
 
 };
diff --git a/src/surfMesh/surfaceFormats/smesh/SMESHsurfaceFormatCore.C b/src/surfMesh/surfaceFormats/smesh/SMESHsurfaceFormatCore.C
deleted file mode 100644
index 0095dc9279..0000000000
--- a/src/surfMesh/surfaceFormats/smesh/SMESHsurfaceFormatCore.C
+++ /dev/null
@@ -1,71 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 1991-2009 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 "SMESHsurfaceFormatCore.H"
-#include "clock.H"
-
-// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
-
-void Foam::fileFormats::SMESHsurfaceFormatCore::writeHeader
-(
-    Ostream& os,
-    const pointField& pointLst,
-    const label nFaces
-)
-{
-    // Write header
-    os << "# tetgen .smesh file written " << clock::dateTime().c_str() << nl;
-    os << "# <points count=\"" << pointLst.size() << "\">" << endl;
-    os << pointLst.size() << " 3" << nl;    // 3: dimensions
-
-    // Write vertex coords
-    forAll(pointLst, ptI)
-    {
-        os  << ptI
-            << ' ' << pointLst[ptI].x()
-            << ' ' << pointLst[ptI].y()
-            << ' ' << pointLst[ptI].z() << nl;
-    }
-    os  << "# </points>" << nl
-        << nl
-        << "# <faces count=\"" << nFaces << "\">" << endl;
-
-    os  << nFaces << " 1" << endl;   // one attribute: zone number
-}
-
-
-void Foam::fileFormats::SMESHsurfaceFormatCore::writeTail(Ostream& os)
-{
-    os  << "# </faces>" << nl
-        << nl
-        << "# no holes or regions:" << nl
-        << '0' << nl        // holes
-        << '0' << endl;     // regions
-}
-
-// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
-
-// ************************************************************************* //
diff --git a/src/surfMesh/surfaceFormats/smesh/SMESHsurfaceFormatRunTime.C b/src/surfMesh/surfaceFormats/smesh/SMESHsurfaceFormatRunTime.C
index 8f041d1bae..e985af30ad 100644
--- a/src/surfMesh/surfaceFormats/smesh/SMESHsurfaceFormatRunTime.C
+++ b/src/surfMesh/surfaceFormats/smesh/SMESHsurfaceFormatRunTime.C
@@ -25,8 +25,7 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "SMESHsurfaceFormat.H"
-#include "MeshedSurface.H"
-#include "UnsortedMeshedSurface.H"
+
 #include "addToRunTimeSelectionTable.H"
 #include "addToMemberFunctionSelectionTable.H"
 
@@ -36,9 +35,10 @@ namespace Foam
 namespace fileFormats
 {
 
+// write MeshedSurfaceProxy
 addNamedTemplatedToMemberFunctionSelectionTable
 (
-    MeshedSurface,
+    MeshedSurfaceProxy,
     SMESHsurfaceFormat,
     face,
     write,
@@ -47,26 +47,7 @@ addNamedTemplatedToMemberFunctionSelectionTable
 );
 addNamedTemplatedToMemberFunctionSelectionTable
 (
-    MeshedSurface,
-    SMESHsurfaceFormat,
-    triFace,
-    write,
-    fileExtension,
-    smesh
-);
-
-addNamedTemplatedToMemberFunctionSelectionTable
-(
-    UnsortedMeshedSurface,
-    SMESHsurfaceFormat,
-    face,
-    write,
-    fileExtension,
-    smesh
-);
-addNamedTemplatedToMemberFunctionSelectionTable
-(
-    UnsortedMeshedSurface,
+    MeshedSurfaceProxy,
     SMESHsurfaceFormat,
     triFace,
     write,
diff --git a/src/surfMesh/surfaceFormats/starcd/STARCDsurfaceFormat.C b/src/surfMesh/surfaceFormats/starcd/STARCDsurfaceFormat.C
index 4fcac468c2..0daa6de71b 100644
--- a/src/surfMesh/surfaceFormats/starcd/STARCDsurfaceFormat.C
+++ b/src/surfMesh/surfaceFormats/starcd/STARCDsurfaceFormat.C
@@ -41,10 +41,10 @@ inline void Foam::fileFormats::STARCDsurfaceFormat<Face>::writeShell
 )
 {
     os  << cellId                    // includes 1 offset
-        << " " << starcdShellShape_  // 3(shell) shape
-        << " " << f.size()
-        << " " << cellTableId
-        << " " << starcdShellType_;  // 4(shell)
+        << ' ' << starcdShellShape_  // 3(shell) shape
+        << ' ' << f.size()
+        << ' ' << cellTableId
+        << ' ' << starcdShellType_;  // 4(shell)
 
     // primitives have <= 8 vertices, but prevent overrun anyhow
     // indent following lines for ease of reading
@@ -55,7 +55,7 @@ inline void Foam::fileFormats::STARCDsurfaceFormat<Face>::writeShell
         {
             os  << nl << "  " << cellId;
         }
-        os  << " " << f[fp] + 1;
+        os  << ' ' << f[fp] + 1;
         count++;
     }
     os  << endl;
@@ -221,11 +221,23 @@ template<class Face>
 void Foam::fileFormats::STARCDsurfaceFormat<Face>::write
 (
     const fileName& filename,
-    const pointField& pointLst,
-    const List<Face>& faceLst,
-    const List<surfZone>& zoneLst
+    const MeshedSurfaceProxy<Face>& surf
 )
 {
+    const pointField& pointLst = surf.points();
+    const List<Face>&  faceLst = surf.faces();
+    const List<label>& faceMap = surf.faceMap();
+
+    const List<surfZone>& zones =
+    (
+        surf.surfZones().size() > 1
+      ? surf.surfZones()
+      : oneZone(faceLst)
+    );
+
+    const bool useFaceMap = (surf.useFaceMap() && zones.size() > 1);
+
+
     fileName baseName = filename.lessExt();
 
     writePoints(OFstream(baseName + ".vrt")(), pointLst);
@@ -233,14 +245,25 @@ void Foam::fileFormats::STARCDsurfaceFormat<Face>::write
     writeHeader(os, "CELL");
 
     label faceIndex = 0;
-    forAll(zoneLst, zoneI)
+    forAll(zones, zoneI)
     {
-        const surfZone& zone = zoneLst[zoneI];
+        const surfZone& zone = zones[zoneI];
 
-        forAll(zone, localFaceI)
+        if (useFaceMap)
         {
-            const Face& f = faceLst[faceIndex++];
-            writeShell(os, f, faceIndex, zoneI + 1);
+            forAll(zone, localFaceI)
+            {
+                const Face& f = faceLst[faceMap[faceIndex++]];
+                writeShell(os, f, faceIndex, zoneI + 1);
+            }
+        }
+        else
+        {
+            forAll(zone, localFaceI)
+            {
+                const Face& f = faceLst[faceIndex++];
+                writeShell(os, f, faceIndex, zoneI + 1);
+            }
         }
     }
 
@@ -250,60 +273,9 @@ void Foam::fileFormats::STARCDsurfaceFormat<Face>::write
         OFstream(baseName + ".inp")(),
         pointLst,
         faceLst.size(),
-        zoneLst
-    );
-
-}
-
-
-template<class Face>
-void Foam::fileFormats::STARCDsurfaceFormat<Face>::write
-(
-    const fileName& filename,
-    const MeshedSurface<Face>& surf
-)
-{
-    write(filename, surf.points(), surf.faces(), surf.zones());
-}
-
-
-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<surfZone> zoneLst = surf.sortedZones(faceMap);
-
-    label faceIndex = 0;
-    forAll(zoneLst, zoneI)
-    {
-        const surfZone& zone = zoneLst[zoneI];
-
-        forAll(zone, localFaceI)
-        {
-            const Face& f = faceLst[faceMap[faceIndex++]];
-            writeShell(os, f, faceIndex, zoneI + 1);
-        }
-    }
-
-    // write simple .inp file
-    writeCase
-    (
-        OFstream(baseName + ".inp")(),
-        surf.points(),
-        surf.size(),
-        zoneLst
+        zones
     );
 }
 
+
 // ************************************************************************* //
diff --git a/src/surfMesh/surfaceFormats/starcd/STARCDsurfaceFormat.H b/src/surfMesh/surfaceFormats/starcd/STARCDsurfaceFormat.H
index a0e8314c26..9bdb435bd7 100644
--- a/src/surfMesh/surfaceFormats/starcd/STARCDsurfaceFormat.H
+++ b/src/surfMesh/surfaceFormats/starcd/STARCDsurfaceFormat.H
@@ -42,9 +42,8 @@ SourceFiles
 #ifndef STARCDsurfaceFormat_H
 #define STARCDsurfaceFormat_H
 
-#include "Ostream.H"
-#include "OFstream.H"
 #include "MeshedSurface.H"
+#include "MeshedSurfaceProxy.H"
 #include "UnsortedMeshedSurface.H"
 #include "STARCDsurfaceFormatCore.H"
 
@@ -114,37 +113,17 @@ public:
 
     // Member Functions
 
+        //- Write surface mesh components by proxy
+        static void write(const fileName&, const MeshedSurfaceProxy<Face>&);
+
+
         //- Read from file
         virtual bool read(const fileName&);
 
-        //- Write surface mesh components
-        static void write
-        (
-            const fileName&,
-            const pointField&,
-            const List<Face>&,
-            const List<surfZone>&
-        );
-
-        //- Write MeshedSurface
-        static void write
-        (
-            const fileName&,
-            const MeshedSurface<Face>&
-        );
-
-        //- Write UnsortedMeshedSurface
-        //  The output is sorted by zones
-        static void write
-        (
-            const fileName&,
-            const UnsortedMeshedSurface<Face>&
-        );
-
-        //- Write to Ostream as one large file - not really useful
-        virtual void write(Ostream&) const
+        //- Write object
+        virtual void write(const fileName& name) const
         {
-            notImplemented("fileFormats::STARCDsurfaceFormat::write(Ostream&)");
+            write(name, MeshedSurfaceProxy<Face>(*this));
         }
 
 };
diff --git a/src/surfMesh/surfaceFormats/starcd/STARCDsurfaceFormatCore.C b/src/surfMesh/surfaceFormats/starcd/STARCDsurfaceFormatCore.C
index 0539f41e58..ab052f5229 100644
--- a/src/surfMesh/surfaceFormats/starcd/STARCDsurfaceFormatCore.C
+++ b/src/surfMesh/surfaceFormats/starcd/STARCDsurfaceFormatCore.C
@@ -104,7 +104,7 @@ bool Foam::fileFormats::STARCDsurfaceFormatCore::readPoints
     {
         FatalErrorIn
         (
-            "fileFormats::STARCDsurfaceFormatCore::readPoints(const fileName&)"
+            "fileFormats::STARCDsurfaceFormatCore::readPoints(...)"
         )
             << "Cannot read file " << is.name()
             << exit(FatalError);
diff --git a/src/surfMesh/surfaceFormats/starcd/STARCDsurfaceFormatCore.H b/src/surfMesh/surfaceFormats/starcd/STARCDsurfaceFormatCore.H
index 0cadd394d2..944d363e3e 100644
--- a/src/surfMesh/surfaceFormats/starcd/STARCDsurfaceFormatCore.H
+++ b/src/surfMesh/surfaceFormats/starcd/STARCDsurfaceFormatCore.H
@@ -38,8 +38,8 @@ SourceFiles
 
 #include "IFstream.H"
 #include "Ostream.H"
+#include "OFstream.H"
 #include "MeshedSurface.H"
-#include "UnsortedMeshedSurface.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
diff --git a/src/surfMesh/surfaceFormats/starcd/STARCDsurfaceFormatRunTime.C b/src/surfMesh/surfaceFormats/starcd/STARCDsurfaceFormatRunTime.C
index 612b2c4f92..5affcb9960 100644
--- a/src/surfMesh/surfaceFormats/starcd/STARCDsurfaceFormatRunTime.C
+++ b/src/surfMesh/surfaceFormats/starcd/STARCDsurfaceFormatRunTime.C
@@ -25,8 +25,7 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "STARCDsurfaceFormat.H"
-#include "MeshedSurface.H"
-#include "UnsortedMeshedSurface.H"
+
 #include "addToRunTimeSelectionTable.H"
 #include "addToMemberFunctionSelectionTable.H"
 
@@ -36,6 +35,7 @@ namespace Foam
 namespace fileFormats
 {
 
+// read MeshedSurface
 addNamedTemplatedToRunTimeSelectionTable
 (
     MeshedSurface,
@@ -53,10 +53,10 @@ addNamedTemplatedToRunTimeSelectionTable
     inp
 );
 
-
+// write MeshedSurfaceProxy
 addNamedTemplatedToMemberFunctionSelectionTable
 (
-    MeshedSurface,
+    MeshedSurfaceProxy,
     STARCDsurfaceFormat,
     face,
     write,
@@ -65,7 +65,7 @@ addNamedTemplatedToMemberFunctionSelectionTable
 );
 addNamedTemplatedToMemberFunctionSelectionTable
 (
-    MeshedSurface,
+    MeshedSurfaceProxy,
     STARCDsurfaceFormat,
     triFace,
     write,
@@ -74,25 +74,6 @@ addNamedTemplatedToMemberFunctionSelectionTable
 );
 
 
-addNamedTemplatedToMemberFunctionSelectionTable
-(
-    UnsortedMeshedSurface,
-    STARCDsurfaceFormat,
-    face,
-    write,
-    fileExtension,
-    inp
-);
-addNamedTemplatedToMemberFunctionSelectionTable
-(
-    UnsortedMeshedSurface,
-    STARCDsurfaceFormat,
-    triFace,
-    write,
-    fileExtension,
-    inp
-);
-
 }
 }
 
diff --git a/src/surfMesh/surfaceFormats/stl/STLsurfaceFormat.C b/src/surfMesh/surfaceFormats/stl/STLsurfaceFormat.C
index bbc1c09730..fcab0389fd 100644
--- a/src/surfMesh/surfaceFormats/stl/STLsurfaceFormat.C
+++ b/src/surfMesh/surfaceFormats/stl/STLsurfaceFormat.C
@@ -111,91 +111,6 @@ inline void Foam::fileFormats::STLsurfaceFormat<Face>::writeShell
 }
 
 
-template<class Face>
-void Foam::fileFormats::STLsurfaceFormat<Face>::writeBINARY
-(
-    ostream& os,
-    const pointField& pointLst,
-    const List<Face>& faceLst,
-    const List<surfZone>& zoneLst
-)
-{
-    unsigned int nTris = 0;
-    if (BasicMeshedSurface<Face>::isTri())
-    {
-        nTris = faceLst.size();
-    }
-    else
-    {
-        // count triangles for on-the-fly triangulation
-        forAll(faceLst, faceI)
-        {
-            nTris += faceLst[faceI].size() - 2;
-        }
-    }
-
-    // Write the STL header
-    STLsurfaceFormatCore::writeHeaderBINARY(os, nTris);
-
-    label faceIndex = 0;
-    forAll(zoneLst, zoneI)
-    {
-        forAll(zoneLst[zoneI], localFaceI)
-        {
-            writeShell
-            (
-                os,
-                pointLst,
-                faceLst[faceIndex++],
-                zoneI
-            );
-        }
-    }
-}
-
-
-template<class Face>
-void Foam::fileFormats::STLsurfaceFormat<Face>::writeBINARY
-(
-    ostream& os,
-    const UnsortedMeshedSurface<Face>& surf
-)
-{
-    const pointField&  pointLst = surf.points();
-    const List<Face>&  faceLst = surf.faces();
-    const List<label>& zoneIds = surf.zoneIds();
-
-    unsigned int nTris = 0;
-    if (surf.isTri())
-    {
-        nTris = faceLst.size();
-    }
-    else
-    {
-        // count triangles for on-the-fly triangulation
-        forAll(faceLst, faceI)
-        {
-            nTris += faceLst[faceI].size() - 2;
-        }
-    }
-
-    // Write the STL header
-    STLsurfaceFormatCore::writeHeaderBINARY(os, nTris);
-
-    // always write unsorted
-    forAll(faceLst, faceI)
-    {
-        writeShell
-        (
-            os,
-            pointLst,
-            faceLst[faceI],
-            zoneIds[faceI]
-        );
-    }
-}
-
-
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
 template<class Face>
@@ -274,25 +189,61 @@ bool Foam::fileFormats::STLsurfaceFormat<Face>::read
 }
 
 
+
 template<class Face>
-void Foam::fileFormats::STLsurfaceFormat<Face>::write
+void Foam::fileFormats::STLsurfaceFormat<Face>::writeAscii
 (
-    Ostream& os,
-    const pointField& pointLst,
-    const List<Face>& faceLst,
-    const List<surfZone>& zoneLst
+    const fileName& filename,
+    const MeshedSurfaceProxy<Face>& surf
 )
 {
+    OFstream os(filename);
+    if (!os.good())
+    {
+        FatalErrorIn
+        (
+            "fileFormats::STLsurfaceFormat::writeAscii"
+            "(const fileName&, const MeshedSurfaceProxy<Face>&)"
+        )
+            << "Cannot open file for writing " << filename
+            << exit(FatalError);
+    }
+
+    const pointField& pointLst = surf.points();
+    const List<Face>&  faceLst = surf.faces();
+    const List<label>& faceMap = surf.faceMap();
+
+    const List<surfZone>& zones =
+    (
+        surf.surfZones().size() > 1
+      ? surf.surfZones()
+      : oneZone(faceLst)
+    );
+
+    const bool useFaceMap = (surf.useFaceMap() && zones.size() > 1);
+
     label faceIndex = 0;
-    forAll(zoneLst, zoneI)
+    forAll(zones, zoneI)
     {
         // Print all faces belonging to this zone
-        const surfZone& zone = zoneLst[zoneI];
+        const surfZone& zone = zones[zoneI];
 
-        os << "solid " << zone.name() << endl;
-        forAll(zone, localFaceI)
+        os << "solid " << zone.name() << nl;
+
+        if (useFaceMap)
         {
-            writeShell(os, pointLst, faceLst[faceIndex++]);
+            forAll(zone, localFaceI)
+            {
+                const label faceI = faceMap[faceIndex++];
+                writeShell(os, pointLst, faceLst[faceI]);
+            }
+        }
+        else
+        {
+            forAll(zone, localFaceI)
+            {
+                writeShell(os, pointLst, faceLst[faceIndex++]);
+            }
         }
         os << "endsolid " << zone.name() << endl;
     }
@@ -300,29 +251,116 @@ void Foam::fileFormats::STLsurfaceFormat<Face>::write
 
 
 template<class Face>
-void Foam::fileFormats::STLsurfaceFormat<Face>::write
+void Foam::fileFormats::STLsurfaceFormat<Face>::writeBinary
 (
-    Ostream& os,
-    const MeshedSurface<Face>& surf
+    const fileName& filename,
+    const MeshedSurfaceProxy<Face>& surf
 )
 {
-    write(os, surf.points(), surf.faces(), surf.zones());
+    std::ofstream os(filename.c_str(), std::ios::binary);
+    if (!os.good())
+    {
+        FatalErrorIn
+        (
+            "fileFormats::STLsurfaceFormat::writeBinary"
+            "(const fileName&, const MeshedSurfaceProxy<Face>&)"
+        )
+            << "Cannot open file for writing " << filename
+            << exit(FatalError);
+    }
+
+
+    const pointField& pointLst = surf.points();
+    const List<Face>&  faceLst = surf.faces();
+    const List<label>& faceMap = surf.faceMap();
+
+    const List<surfZone>& zones =
+    (
+        surf.surfZones().size() > 1
+      ? surf.surfZones()
+      : oneZone(faceLst)
+    );
+
+    const bool useFaceMap = (surf.useFaceMap() && zones.size() > 1);
+
+
+    unsigned int nTris = 0;
+    if (MeshedSurface<Face>::isTri())
+    {
+        nTris = faceLst.size();
+    }
+    else
+    {
+        // count triangles for on-the-fly triangulation
+        forAll(faceLst, faceI)
+        {
+            nTris += faceLst[faceI].size() - 2;
+        }
+    }
+
+    // Write the STL header
+    STLsurfaceFormatCore::writeHeaderBINARY(os, nTris);
+
+    label faceIndex = 0;
+    forAll(zones, zoneI)
+    {
+        const surfZone& zone = zones[zoneI];
+
+        if (useFaceMap)
+        {
+            forAll(zone, localFaceI)
+            {
+                writeShell
+                (
+                    os,
+                    pointLst,
+                    faceLst[faceMap[faceIndex++]],
+                    zoneI
+                );
+            }
+        }
+        else
+        {
+            forAll(zone, localFaceI)
+            {
+                writeShell
+                (
+                    os,
+                    pointLst,
+                    faceLst[faceIndex++],
+                    zoneI
+                );
+            }
+        }
+    }
 }
 
 
 template<class Face>
-void Foam::fileFormats::STLsurfaceFormat<Face>::write
+void Foam::fileFormats::STLsurfaceFormat<Face>::writeAscii
 (
-    Ostream& os,
+    const fileName& filename,
     const UnsortedMeshedSurface<Face>& surf
 )
 {
-    const pointField& pointLst = surf.points();
-    const List<Face>& faceLst  = surf.faces();
+    OFstream os(filename);
+    if (!os.good())
+    {
+        FatalErrorIn
+        (
+            "fileFormats::STLsurfaceFormat::writeAscii"
+            "(const fileName&, const UnsortedMeshedSurface<Face>&)"
+        )
+            << "Cannot open file for writing " << filename
+            << exit(FatalError);
+    }
 
+    // a single zone - we can skip sorting
     if (surf.zoneToc().size() == 1)
     {
-        // a single zone - we can skip sorting
+        const pointField& pointLst = surf.points();
+        const List<Face>& faceLst  = surf.faces();
+
         os << "solid " << surf.zoneToc()[0].name() << endl;
         forAll(faceLst, faceI)
         {
@@ -332,32 +370,82 @@ void Foam::fileFormats::STLsurfaceFormat<Face>::write
     }
    else
    {
-        labelList faceMap;
-        List<surfZone> zoneLst = surf.sortedZones(faceMap);
+       labelList faceMap;
+       List<surfZone> zoneLst = surf.sortedZones(faceMap);
 
-        label faceIndex = 0;
-        forAll(zoneLst, zoneI)
-        {
-            // Print all faces belonging to this zone
-            const surfZone& zone = zoneLst[zoneI];
-
-            os << "solid " << zone.name() << endl;
-            forAll(zone, localFaceI)
-            {
-                const label faceI = faceMap[faceIndex++];
-                writeShell(os, pointLst, faceLst[faceI]);
-            }
-            os << "endsolid " << zone.name() << endl;
-        }
+       writeAscii
+       (
+           filename,
+           MeshedSurfaceProxy<Face>
+           (
+               surf.points(),
+               surf.faces(),
+               zoneLst,
+               faceMap
+           )
+       );
    }
 }
 
 
+template<class Face>
+void Foam::fileFormats::STLsurfaceFormat<Face>::writeBinary
+(
+    const fileName& filename,
+    const UnsortedMeshedSurface<Face>& surf
+)
+{
+    std::ofstream os(filename.c_str(), std::ios::binary);
+    if (!os.good())
+    {
+        FatalErrorIn
+        (
+            "fileFormats::STLsurfaceFormat::writeBinary"
+            "(const fileName&, const UnsortedMeshedSurface<Face>&)"
+        )
+            << "Cannot open file for writing " << filename
+            << exit(FatalError);
+    }
+
+    const pointField&  pointLst = surf.points();
+    const List<Face>&  faceLst  = surf.faces();
+    const List<label>& zoneIds  = surf.zoneIds();
+
+    unsigned int nTris = 0;
+    if (surf.isTri())
+    {
+        nTris = faceLst.size();
+    }
+    else
+    {
+        // count triangles for on-the-fly triangulation
+        forAll(faceLst, faceI)
+        {
+            nTris += faceLst[faceI].size() - 2;
+        }
+    }
+
+    // Write the STL header
+    STLsurfaceFormatCore::writeHeaderBINARY(os, nTris);
+
+    // always write unsorted
+    forAll(faceLst, faceI)
+    {
+        writeShell
+        (
+            os,
+            pointLst,
+            faceLst[faceI],
+            zoneIds[faceI]
+        );
+    }
+}
+
 template<class Face>
 void Foam::fileFormats::STLsurfaceFormat<Face>::write
 (
     const fileName& filename,
-    const MeshedSurface<Face>& surf
+    const MeshedSurfaceProxy<Face>& surf
 )
 {
     const word ext = filename.ext();
@@ -365,18 +453,11 @@ void Foam::fileFormats::STLsurfaceFormat<Face>::write
     // handle 'stlb' as binary directly
     if (ext == "stlb")
     {
-        std::ofstream ofs(filename.c_str(), std::ios::binary);
-        writeBINARY(ofs, surf);
+        writeBinary(filename, surf);
     }
     else
     {
-        write
-        (
-            OFstream(filename)(),
-            surf.points(),
-            surf.faces(),
-            surf.zones()
-        );
+        writeAscii(filename, surf);
     }
 }
 
@@ -393,12 +474,11 @@ void Foam::fileFormats::STLsurfaceFormat<Face>::write
     // handle 'stlb' as binary directly
     if (ext == "stlb")
     {
-        std::ofstream ofs(filename.c_str(), std::ios::binary);
-        writeBINARY(ofs, surf);
+        writeBinary(filename, surf);
     }
     else
     {
-        write(OFstream(filename)(), surf);
+        writeAscii(filename, surf);
     }
 }
 
diff --git a/src/surfMesh/surfaceFormats/stl/STLsurfaceFormat.H b/src/surfMesh/surfaceFormats/stl/STLsurfaceFormat.H
index 8fa474455c..ada49101ae 100644
--- a/src/surfMesh/surfaceFormats/stl/STLsurfaceFormat.H
+++ b/src/surfMesh/surfaceFormats/stl/STLsurfaceFormat.H
@@ -43,6 +43,7 @@ SourceFiles
 
 #include "STLsurfaceFormatCore.H"
 #include "MeshedSurface.H"
+#include "MeshedSurfaceProxy.H"
 #include "UnsortedMeshedSurface.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@@ -63,7 +64,7 @@ class STLsurfaceFormat
 {
     // Private Member Functions
 
-        //- Write Face in ASCII
+        //- Write Face (ASCII)
         static inline void writeShell
         (
             Ostream&,
@@ -71,7 +72,7 @@ class STLsurfaceFormat
             const Face&
         );
 
-        //- Write Face in BINARY
+        //- Write Face (BINARY)
         static inline void writeShell
         (
             ostream&,
@@ -80,19 +81,6 @@ class STLsurfaceFormat
             const label zoneI
         );
 
-
-        //- Write surface mesh components (as BINARY)
-        static void writeBINARY
-        (
-            ostream&,
-            const pointField&,
-            const List<Face>&,
-            const List<surfZone>&
-        );
-
-        //- Write UnsortedMeshedSurface
-        static void writeBINARY(ostream&, const UnsortedMeshedSurface<Face>&);
-
         //- Disallow default bitwise copy construct
         STLsurfaceFormat(const STLsurfaceFormat<Face>&);
 
@@ -122,51 +110,50 @@ public:
 
     // Member Functions
 
-        //- Read from file
-        virtual bool read(const fileName&);
-
-        //- Write surface mesh components (as ASCII)
-        static void write
-        (
-            Ostream&,
-            const pointField&,
-            const List<Face>&,
-            const List<surfZone>&
-        );
-
-        //- Write MeshedSurface (as ASCII)
-        static void write
-        (
-            Ostream&,
-            const MeshedSurface<Face>&
-        );
-
-        //- Write MeshedSurface (ASCII or BINARY, depending on the extension)
-        static void write
+        //- Write surface mesh components by proxy (as ASCII)
+        static void writeAscii
         (
             const fileName&,
-            const MeshedSurface<Face>&
+            const MeshedSurfaceProxy<Face>&
         );
 
-        //- Write UnsortedMeshedSurface (as ASCII) sorted by zone
-        static void write
+        //- Write surface mesh components by proxy (as BINARY)
+        static void writeBinary
         (
-            Ostream&,
+            const fileName&,
+            const MeshedSurfaceProxy<Face>&
+        );
+
+        //- Write surface mesh components by proxy
+        //  as ASCII or BINARY, depending on the extension
+        static void write(const fileName&, const MeshedSurfaceProxy<Face>&);
+
+        //- Write UnsortedMeshedSurface (as ASCII) sorted by zone
+        static void writeAscii
+        (
+            const fileName&,
+            const UnsortedMeshedSurface<Face>&
+        );
+
+        //- Write UnsortedMeshedSurface (as BINARY) unsorted by zone
+        static void writeBinary
+        (
+            const fileName&,
             const UnsortedMeshedSurface<Face>&
         );
 
         //- Write UnsortedMeshedSurface
-        //  ASCII output is sorted by zone; binary output is unsorted
-        static void write
-        (
-            const fileName&,
-            const UnsortedMeshedSurface<Face>&
-        );
+        //  as ASCII or BINARY, depending on the extension
+        static void write(const fileName&, const UnsortedMeshedSurface<Face>&);
 
-        //- Write object (only ASCII output)
-        virtual void write(Ostream& os) const
+
+        //- Read from file
+        virtual bool read(const fileName&);
+
+        //- Write object
+        virtual void write(const fileName& name) const
         {
-            write(os, *this);
+            write(name, MeshedSurfaceProxy<Face>(*this));
         }
 
 };
diff --git a/src/surfMesh/surfaceFormats/stl/STLsurfaceFormatASCII.L b/src/surfMesh/surfaceFormats/stl/STLsurfaceFormatASCII.L
index 74e9ab2245..4bf7880c25 100644
--- a/src/surfMesh/surfaceFormats/stl/STLsurfaceFormatASCII.L
+++ b/src/surfMesh/surfaceFormats/stl/STLsurfaceFormatASCII.L
@@ -403,13 +403,13 @@ endsolid              {space}("endsolid"|"ENDSOLID")({some_space}{word})*
 //
 bool Foam::fileFormats::STLsurfaceFormatCore::readASCII
 (
-    IFstream& ifs,
+    istream& is,
     const off_t dataFileSize
 )
 {
     // Create the lexer with the approximate number of vertices in the STL
     // from the file size
-    STLASCIILexer lexer(&ifs.stdStream(), dataFileSize/400);
+    STLASCIILexer lexer(&is, dataFileSize/400);
     while (lexer.lex() != 0) {}
 
     sorted_ = lexer.sorted();
diff --git a/src/surfMesh/surfaceFormats/stl/STLsurfaceFormatCore.C b/src/surfMesh/surfaceFormats/stl/STLsurfaceFormatCore.C
index 6ba5f661e3..f9d052d6ac 100644
--- a/src/surfMesh/surfaceFormats/stl/STLsurfaceFormatCore.C
+++ b/src/surfMesh/surfaceFormats/stl/STLsurfaceFormatCore.C
@@ -28,6 +28,8 @@ License
 #include "gzstream.h"
 #include "OSspecific.H"
 #include "Map.H"
+#include "IFstream.H"
+#include "Ostream.H"
 
 #undef DEBUG_STLBINARY
 
@@ -48,8 +50,7 @@ int Foam::fileFormats::STLsurfaceFormatCore::detectBINARY
 {
     off_t dataFileSize = Foam::fileSize(filename);
 
-    IFstream ifs(filename, IOstream::BINARY);
-    istream& is = ifs.stdStream();
+    istream& is = IFstream(filename, IOstream::BINARY)().stdStream();
 
     // Read the STL header
     char header[headerSize];
@@ -89,12 +90,11 @@ int Foam::fileFormats::STLsurfaceFormatCore::detectBINARY
 
 bool Foam::fileFormats::STLsurfaceFormatCore::readBINARY
 (
-    IFstream& ifs,
+    istream& is,
     const off_t dataFileSize
 )
 {
     sorted_ = true;
-    istream& is = ifs.stdStream();
 
     // Read the STL header
     char header[headerSize];
@@ -131,7 +131,7 @@ bool Foam::fileFormats::STLsurfaceFormatCore::readBINARY
     {
         FatalErrorIn
         (
-            "fileFormats::STLsurfaceFormatCore::readBINARY(IFstream&)"
+            "fileFormats::STLsurfaceFormatCore::readBINARY(istream&)"
         )
             << "problem reading number of triangles, perhaps file is not binary"
             << exit(FatalError);
@@ -230,11 +230,19 @@ Foam::fileFormats::STLsurfaceFormatCore::STLsurfaceFormatCore
     // auto-detect ascii/binary
     if (detectBINARY(filename))
     {
-        readBINARY(IFstream(filename, IOstream::BINARY)(), dataFileSize);
+        readBINARY
+        (
+            IFstream(filename, IOstream::BINARY)().stdStream(),
+            dataFileSize
+        );
     }
     else
     {
-        readASCII(IFstream(filename)(), dataFileSize);
+        readASCII
+        (
+            IFstream(filename)().stdStream(),
+            dataFileSize
+        );
     }
 }
 
diff --git a/src/surfMesh/surfaceFormats/stl/STLsurfaceFormatCore.H b/src/surfMesh/surfaceFormats/stl/STLsurfaceFormatCore.H
index f7c28a98f1..7e4fe94e8a 100644
--- a/src/surfMesh/surfaceFormats/stl/STLsurfaceFormatCore.H
+++ b/src/surfMesh/surfaceFormats/stl/STLsurfaceFormatCore.H
@@ -41,7 +41,6 @@ SourceFiles
 #include "triFace.H"
 #include "IFstream.H"
 #include "Ostream.H"
-#include "OFstream.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -51,7 +50,7 @@ namespace fileFormats
 {
 
 /*---------------------------------------------------------------------------*\
-                   Class STLsurfaceFormatCore Declaration
+                    Class STLsurfaceFormatCore Declaration
 \*---------------------------------------------------------------------------*/
 
 class STLsurfaceFormatCore
@@ -84,10 +83,10 @@ class STLsurfaceFormatCore
         static int detectBINARY(const fileName&);
 
         //- Read ASCII
-        bool readASCII(IFstream&, const off_t);
+        bool readASCII(istream&, const off_t);
 
         //- Read BINARY
-        bool readBINARY(IFstream&, const off_t);
+        bool readBINARY(istream&, const off_t);
 
 public:
 
diff --git a/src/surfMesh/surfaceFormats/stl/STLsurfaceFormatRunTime.C b/src/surfMesh/surfaceFormats/stl/STLsurfaceFormatRunTime.C
index cb3d091d45..8e78ce7675 100644
--- a/src/surfMesh/surfaceFormats/stl/STLsurfaceFormatRunTime.C
+++ b/src/surfMesh/surfaceFormats/stl/STLsurfaceFormatRunTime.C
@@ -25,8 +25,7 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "STLsurfaceFormat.H"
-#include "MeshedSurface.H"
-#include "UnsortedMeshedSurface.H"
+
 #include "addToRunTimeSelectionTable.H"
 #include "addToMemberFunctionSelectionTable.H"
 
@@ -36,6 +35,7 @@ namespace Foam
 namespace fileFormats
 {
 
+// read MeshedSurface (ascii)
 addNamedTemplatedToRunTimeSelectionTable
 (
     MeshedSurface,
@@ -53,6 +53,7 @@ addNamedTemplatedToRunTimeSelectionTable
     stl
 );
 
+// read MeshedSurface (binary)
 addNamedTemplatedToRunTimeSelectionTable
 (
     MeshedSurface,
@@ -71,9 +72,10 @@ addNamedTemplatedToRunTimeSelectionTable
 );
 
 
+// write MeshedSurfaceProxy (ascii)
 addNamedTemplatedToMemberFunctionSelectionTable
 (
-    MeshedSurface,
+    MeshedSurfaceProxy,
     STLsurfaceFormat,
     face,
     write,
@@ -82,7 +84,7 @@ addNamedTemplatedToMemberFunctionSelectionTable
 );
 addNamedTemplatedToMemberFunctionSelectionTable
 (
-    MeshedSurface,
+    MeshedSurfaceProxy,
     STLsurfaceFormat,
     triFace,
     write,
@@ -90,9 +92,10 @@ addNamedTemplatedToMemberFunctionSelectionTable
     stl
 );
 
+// write MeshedSurfaceProxy (binary)
 addNamedTemplatedToMemberFunctionSelectionTable
 (
-    MeshedSurface,
+    MeshedSurfaceProxy,
     STLsurfaceFormat,
     face,
     write,
@@ -101,7 +104,7 @@ addNamedTemplatedToMemberFunctionSelectionTable
 );
 addNamedTemplatedToMemberFunctionSelectionTable
 (
-    MeshedSurface,
+    MeshedSurfaceProxy,
     STLsurfaceFormat,
     triFace,
     write,
@@ -109,6 +112,7 @@ addNamedTemplatedToMemberFunctionSelectionTable
     stlb
 );
 
+// write UnsortedMeshedSurface (ascii)
 addNamedTemplatedToMemberFunctionSelectionTable
 (
     UnsortedMeshedSurface,
@@ -128,6 +132,7 @@ addNamedTemplatedToMemberFunctionSelectionTable
     stl
 );
 
+// write UnsortedMeshedSurface (binary)
 addNamedTemplatedToMemberFunctionSelectionTable
 (
     UnsortedMeshedSurface,
diff --git a/src/surfMesh/surfaceFormats/surfaceFormatsCore.C b/src/surfMesh/surfaceFormats/surfaceFormatsCore.C
index 81c99e9b0d..1e957ed672 100644
--- a/src/surfMesh/surfaceFormats/surfaceFormatsCore.C
+++ b/src/surfMesh/surfaceFormats/surfaceFormatsCore.C
@@ -267,7 +267,7 @@ Foam::fileFormats::surfaceFormatsCore::checkSupport
 
         Info<<"Unknown file extension for " << functionName
             << " : " << ext << nl
-            <<"Valid types: ( " << nativeExt;
+            <<"Valid types: (";
         // compact output:
         forAll(known, i)
         {
diff --git a/src/surfMesh/surfaceFormats/surfaceFormatsCore.H b/src/surfMesh/surfaceFormats/surfaceFormatsCore.H
index b8b227902c..3e69ddb150 100644
--- a/src/surfMesh/surfaceFormats/surfaceFormatsCore.H
+++ b/src/surfMesh/surfaceFormats/surfaceFormatsCore.H
@@ -61,30 +61,19 @@ namespace fileFormats
 
 class surfaceFormatsCore
 {
-public:
+protected:
 
-    // Static Data
-
-    //- The file extension corresponding to 'native' surface format
-    //  Normally "ofs" (mnemonic: OF = OpenFOAM, S = Surface)
-    static word nativeExt;
-
-    // Static Member Functions
-
-        //- Check if file extension corresponds to 'native' surface format
-        static bool isNative(const word&);
-
-        //- Read non-comment line
-        static string getLineNoComment(IFstream&);
-
-        //- Return the local file name (within time directory)
-        static fileName localMeshFileName(const word& surfName="");
-
-        //- Find instance with surfName
-        static fileName findMeshInstance(const Time&, const word& surfName="");
-
-        //- Find mesh file with surfName
-        static fileName findMeshFile(const Time&, const word& surfName="");
+        //- Return a list with a single entry,
+        //  the size corresponds to that of the container
+        template<class Container>
+        static List<surfZone> oneZone
+        (
+            const Container& container,
+            const word& name = "zone0"
+        )
+        {
+            return List<surfZone>(1, surfZone(name, container.size(), 0, 0));
+        }
 
         //- Determine the sort order from the zone ids.
         //  Returns zone list and sets faceMap to indices within faceLst
@@ -95,6 +84,31 @@ public:
             labelList& faceMap
         );
 
+        //- Read non-comment line
+        static string getLineNoComment(IFstream&);
+
+public:
+
+    // Static Data
+
+        //- The file extension corresponding to 'native' surface format
+        //  Normally "ofs" (mnemonic: OF = OpenFOAM, S = Surface)
+        static word nativeExt;
+
+    // Static Member Functions
+
+        //- Check if file extension corresponds to 'native' surface format
+        static bool isNative(const word&);
+
+        //- Return the local file name (within time directory)
+        static fileName localMeshFileName(const word& surfName="");
+
+        //- Find instance with surfName
+        static fileName findMeshInstance(const Time&, const word& surfName="");
+
+        //- Find mesh file with surfName
+        static fileName findMeshFile(const Time&, const word& surfName="");
+
         static bool checkSupport
         (
             const wordHashSet& available,
@@ -103,6 +117,7 @@ public:
             const word& functionName
         );
 
+
     // Constructors
 
         //- Construct null
diff --git a/src/surfMesh/surfaceFormats/tri/TRIsurfaceFormat.C b/src/surfMesh/surfaceFormats/tri/TRIsurfaceFormat.C
index 2058b3e8f3..da5d868514 100644
--- a/src/surfMesh/surfaceFormats/tri/TRIsurfaceFormat.C
+++ b/src/surfMesh/surfaceFormats/tri/TRIsurfaceFormat.C
@@ -131,19 +131,55 @@ bool Foam::fileFormats::TRIsurfaceFormat<Face>::read
 template<class Face>
 void Foam::fileFormats::TRIsurfaceFormat<Face>::write
 (
-    Ostream& os,
-    const pointField& pointLst,
-    const List<Face>& faceLst,
-    const List<surfZone>& zoneLst
+    const fileName& filename,
+    const MeshedSurfaceProxy<Face>& surf
 )
 {
-    label faceIndex = 0;
-    forAll(zoneLst, zoneI)
+    const pointField& pointLst = surf.points();
+    const List<Face>&  faceLst = surf.faces();
+    const List<label>& faceMap = surf.faceMap();
+
+    const List<surfZone>& zones =
+    (
+        surf.surfZones().size() > 1
+      ? surf.surfZones()
+      : oneZone(faceLst)
+    );
+
+    const bool useFaceMap = (surf.useFaceMap() && zones.size() > 1);
+
+    OFstream os(filename);
+    if (!os.good())
     {
-        forAll(zoneLst[zoneI], localFaceI)
+        FatalErrorIn
+        (
+            "fileFormats::TRIsurfaceFormat::write"
+            "(const fileName&, const MeshedSurfaceProxy<Face>&)"
+        )
+            << "Cannot open file for writing " << filename
+            << exit(FatalError);
+    }
+
+    label faceIndex = 0;
+    forAll(zones, zoneI)
+    {
+        const surfZone& zone = zones[zoneI];
+
+        if (useFaceMap)
         {
-            const Face& f = faceLst[faceIndex++];
-            writeShell(os, pointLst, f, zoneI);
+            forAll(zone, localFaceI)
+            {
+                const Face& f = faceLst[faceMap[faceIndex++]];
+                writeShell(os, pointLst, f, zoneI);
+            }
+        }
+        else
+        {
+            forAll(zone, localFaceI)
+            {
+                const Face& f = faceLst[faceIndex++];
+                writeShell(os, pointLst, f, zoneI);
+            }
         }
     }
 }
@@ -152,32 +188,37 @@ void Foam::fileFormats::TRIsurfaceFormat<Face>::write
 template<class Face>
 void Foam::fileFormats::TRIsurfaceFormat<Face>::write
 (
-    Ostream& os,
-    const MeshedSurface<Face>& surf
-)
-{
-    write(os, surf.points(), surf.faces(), surf.zones());
-}
-
-
-template<class Face>
-void Foam::fileFormats::TRIsurfaceFormat<Face>::write
-(
-    Ostream& os,
+    const fileName& filename,
     const UnsortedMeshedSurface<Face>& surf
 )
 {
     const pointField& pointLst = surf.points();
     const List<Face>& faceLst  = surf.faces();
 
-    bool doSort = false;
+    OFstream os(filename);
+    if (!os.good())
+    {
+        FatalErrorIn
+        (
+            "fileFormats::TRIsurfaceFormat::write"
+            "(const fileName&, const UnsortedMeshedSurface<Face>&)"
+        )
+            << "Cannot open file for writing " << filename
+            << exit(FatalError);
+    }
+
+
     // a single zone needs no sorting
     if (surf.zoneToc().size() == 1)
     {
-        doSort = false;
-    }
+        const List<label>& zoneIds  = surf.zoneIds();
 
-    if (doSort)
+        forAll(faceLst, faceI)
+        {
+            writeShell(os, pointLst, faceLst[faceI], zoneIds[faceI]);
+        }
+    }
+    else
     {
         labelList faceMap;
         List<surfZone> zoneLst = surf.sortedZones(faceMap);
@@ -192,15 +233,6 @@ void Foam::fileFormats::TRIsurfaceFormat<Face>::write
             }
         }
     }
-    else
-    {
-        const List<label>& zoneIds  = surf.zoneIds();
-
-        forAll(faceLst, faceI)
-        {
-            writeShell(os, pointLst, faceLst[faceI], zoneIds[faceI]);
-        }
-    }
 }
 
 // ************************************************************************* //
diff --git a/src/surfMesh/surfaceFormats/tri/TRIsurfaceFormat.H b/src/surfMesh/surfaceFormats/tri/TRIsurfaceFormat.H
index 6506954b04..557cb60170 100644
--- a/src/surfMesh/surfaceFormats/tri/TRIsurfaceFormat.H
+++ b/src/surfMesh/surfaceFormats/tri/TRIsurfaceFormat.H
@@ -41,9 +41,8 @@ SourceFiles
 #define TRIsurfaceFormat_H
 
 #include "TRIsurfaceFormatCore.H"
-#include "Ostream.H"
-#include "OFstream.H"
 #include "MeshedSurface.H"
+#include "MeshedSurfaceProxy.H"
 #include "UnsortedMeshedSurface.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@@ -102,58 +101,21 @@ public:
 
     // Member Functions
 
+        //- Write surface mesh components by proxy
+        static void write(const fileName&, const MeshedSurfaceProxy<Face>&);
+
+        //- Write UnsortedMeshedSurface,
+        //  by default the output is not sorted by zones
+        static void write(const fileName&, const UnsortedMeshedSurface<Face>&);
+
+
         //- Read from file
         virtual bool read(const fileName&);
 
-        //- Write surface mesh components
-        static void write
-        (
-            Ostream&,
-            const pointField&,
-            const List<Face>&,
-            const List<surfZone>&
-        );
-
-        //- Write MeshedSurface
-        static void write
-        (
-            Ostream&,
-            const MeshedSurface<Face>&
-        );
-
-        //- Write MeshedSurface
-        static void write
-        (
-            const fileName& name,
-            const MeshedSurface<Face>& surf
-        )
-        {
-            write(OFstream(name)(), surf);
-        }
-
-        //- Write UnsortedMeshedSurface
-        //  By default, the output is not sorted by zones
-        static void write
-        (
-            Ostream&,
-            const UnsortedMeshedSurface<Face>&
-        );
-
-        //- Write UnsortedMeshedSurface
-        //  By default, the output is not sorted by zones
-        static void write
-        (
-            const fileName& name,
-            const UnsortedMeshedSurface<Face>& surf
-        )
-        {
-            write(OFstream(name)(), surf);
-        }
-
         //- Write object
-        virtual void write(Ostream& os) const
+        virtual void write(const fileName& name) const
         {
-            write(os, *this);
+            write(name, MeshedSurfaceProxy<Face>(*this));
         }
 
 };
diff --git a/src/surfMesh/surfaceFormats/tri/TRIsurfaceFormatCore.H b/src/surfMesh/surfaceFormats/tri/TRIsurfaceFormatCore.H
index 18855d8696..67b4595280 100644
--- a/src/surfMesh/surfaceFormats/tri/TRIsurfaceFormatCore.H
+++ b/src/surfMesh/surfaceFormats/tri/TRIsurfaceFormatCore.H
@@ -38,6 +38,7 @@ SourceFiles
 
 #include "surfaceFormatsCore.H"
 #include "triFace.H"
+
 #include "IFstream.H"
 #include "Ostream.H"
 #include "OFstream.H"
diff --git a/src/surfMesh/surfaceFormats/tri/TRIsurfaceFormatRunTime.C b/src/surfMesh/surfaceFormats/tri/TRIsurfaceFormatRunTime.C
index 8dbe5818de..9f333cc4fe 100644
--- a/src/surfMesh/surfaceFormats/tri/TRIsurfaceFormatRunTime.C
+++ b/src/surfMesh/surfaceFormats/tri/TRIsurfaceFormatRunTime.C
@@ -25,8 +25,7 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "TRIsurfaceFormat.H"
-#include "MeshedSurface.H"
-#include "UnsortedMeshedSurface.H"
+
 #include "addToRunTimeSelectionTable.H"
 #include "addToMemberFunctionSelectionTable.H"
 
@@ -36,6 +35,7 @@ namespace Foam
 namespace fileFormats
 {
 
+// read MeshedSurface
 addNamedTemplatedToRunTimeSelectionTable
 (
     MeshedSurface,
@@ -53,10 +53,10 @@ addNamedTemplatedToRunTimeSelectionTable
     tri
 );
 
-
+// write MeshedSurfaceProxy
 addNamedTemplatedToMemberFunctionSelectionTable
 (
-    MeshedSurface,
+    MeshedSurfaceProxy,
     TRIsurfaceFormat,
     face,
     write,
@@ -65,7 +65,7 @@ addNamedTemplatedToMemberFunctionSelectionTable
 );
 addNamedTemplatedToMemberFunctionSelectionTable
 (
-    MeshedSurface,
+    MeshedSurfaceProxy,
     TRIsurfaceFormat,
     triFace,
     write,
@@ -73,6 +73,7 @@ addNamedTemplatedToMemberFunctionSelectionTable
     tri
 );
 
+// write UnsortedMeshedSurface
 addNamedTemplatedToMemberFunctionSelectionTable
 (
     UnsortedMeshedSurface,
diff --git a/src/surfMesh/surfaceFormats/vtk/VTKsurfaceFormat.C b/src/surfMesh/surfaceFormats/vtk/VTKsurfaceFormat.C
index 9a8723dd3b..c8a1fbf1db 100644
--- a/src/surfMesh/surfaceFormats/vtk/VTKsurfaceFormat.C
+++ b/src/surfMesh/surfaceFormats/vtk/VTKsurfaceFormat.C
@@ -61,53 +61,98 @@ Foam::fileFormats::VTKsurfaceFormat<Face>::VTKsurfaceFormat()
 template<class Face>
 void Foam::fileFormats::VTKsurfaceFormat<Face>::write
 (
-    Ostream& os,
-    const pointField& pointLst,
-    const List<Face>& faceLst,
-    const List<surfZone>& zoneLst
+    const fileName& filename,
+    const MeshedSurfaceProxy<Face>& surf
 )
 {
+    const pointField& pointLst = surf.points();
+    const List<Face>&  faceLst = surf.faces();
+    const List<label>& faceMap = surf.faceMap();
+
+    const List<surfZone>& zones =
+    (
+        surf.surfZones().size() > 1
+      ? surf.surfZones()
+      : oneZone(faceLst)
+    );
+
+    const bool useFaceMap = (surf.useFaceMap() && zones.size() > 1);
+
+    OFstream os(filename);
+    if (!os.good())
+    {
+        FatalErrorIn
+        (
+            "fileFormats::VTKsurfaceFormat::write"
+            "(const fileName&, const MeshedSurfaceProxy<Face>&)"
+        )
+            << "Cannot open file for writing " << filename
+            << exit(FatalError);
+    }
+
+
     writeHeader(os, pointLst);
     writeHeaderPolygons(os, faceLst);
 
     label faceIndex = 0;
-    forAll(zoneLst, zoneI)
+    forAll(zones, zoneI)
     {
-        forAll(zoneLst[zoneI], localFaceI)
-        {
-            const Face& f = faceLst[faceIndex++];
+        const surfZone& zone = zones[zoneI];
 
-            os << f.size();
-            forAll(f, fp)
+        if (useFaceMap)
+        {
+            forAll(zone, localFaceI)
             {
-                os << ' ' << f[fp];
+                const Face& f = faceLst[faceMap[faceIndex++]];
+
+                os << f.size();
+                forAll(f, fp)
+                {
+                    os << ' ' << f[fp];
+                }
+                os << ' ' << nl;
+            }
+        }
+        else
+        {
+            forAll(zone, localFaceI)
+            {
+                const Face& f = faceLst[faceIndex++];
+
+                os << f.size();
+                forAll(f, fp)
+                {
+                    os << ' ' << f[fp];
+                }
+                os << ' ' << nl;
             }
-            os << ' ' << nl;
         }
     }
 
-    writeTail(os, zoneLst);
+    writeTail(os, zones);
 }
 
 
 template<class Face>
 void Foam::fileFormats::VTKsurfaceFormat<Face>::write
 (
-    Ostream& os,
-    const MeshedSurface<Face>& surf
-)
-{
-    write(os, surf.points(), surf.faces(), surf.zones());
-}
-
-
-template<class Face>
-void Foam::fileFormats::VTKsurfaceFormat<Face>::write
-(
-    Ostream& os,
+    const fileName& filename,
     const UnsortedMeshedSurface<Face>& surf
 )
 {
+    OFstream os(filename);
+    if (!os.good())
+    {
+        FatalErrorIn
+        (
+            "fileFormats::VTKsurfaceFormat::write"
+            "(const fileName&, const UnsortedMeshedSurface<Face>&)"
+        )
+            << "Cannot open file for writing " << filename
+            << exit(FatalError);
+    }
+
+
     const List<Face>& faceLst = surf.faces();
 
     writeHeader(os, surf.points());
diff --git a/src/surfMesh/surfaceFormats/vtk/VTKsurfaceFormat.H b/src/surfMesh/surfaceFormats/vtk/VTKsurfaceFormat.H
index 22dc33ebc1..93e3510ca1 100644
--- a/src/surfMesh/surfaceFormats/vtk/VTKsurfaceFormat.H
+++ b/src/surfMesh/surfaceFormats/vtk/VTKsurfaceFormat.H
@@ -37,9 +37,8 @@ SourceFiles
 #ifndef VTKsurfaceFormat_H
 #define VTKsurfaceFormat_H
 
-#include "Ostream.H"
-#include "OFstream.H"
 #include "MeshedSurface.H"
+#include "MeshedSurfaceProxy.H"
 #include "UnsortedMeshedSurface.H"
 #include "VTKsurfaceFormatCore.H"
 
@@ -89,55 +88,17 @@ public:
 
         // Write
 
-        //- Write surface mesh components
-        static void write
-        (
-            Ostream&,
-            const pointField&,
-            const List<Face>&,
-            const List<surfZone>&
-        );
+        //- Write surface mesh components by proxy
+        static void write(const fileName&, const MeshedSurfaceProxy<Face>&);
 
-        //- Write MeshedSurface
-        static void write
-        (
-            Ostream&,
-            const MeshedSurface<Face>&
-        );
+        //- Write UnsortedMeshedSurface, the output remains unsorted
+        static void write(const fileName&, const UnsortedMeshedSurface<Face>&);
 
-        //- Write MeshedSurface
-        static void write
-        (
-            const fileName& name,
-            const MeshedSurface<Face>& surf
-        )
-        {
-            write(OFstream(name)(), surf);
-        }
-
-        //- Write UnsortedMeshedSurface
-        //  The output remains unsorted
-        static void write
-        (
-            Ostream&,
-            const UnsortedMeshedSurface<Face>&
-        );
-
-        //- Write UnsortedMeshedSurface
-        //  The output remains unsorted
-        static void write
-        (
-            const fileName& name,
-            const UnsortedMeshedSurface<Face>& surf
-        )
-        {
-            write(OFstream(name)(), surf);
-        }
 
         //- Write object
         virtual void write(Ostream& os) const
         {
-            write(os, *this);
+            write(os, MeshedSurfaceProxy<Face>(*this));
         }
 
 };
diff --git a/src/surfMesh/surfaceFormats/vtk/VTKsurfaceFormatCore.C b/src/surfMesh/surfaceFormats/vtk/VTKsurfaceFormatCore.C
index fefb0de03c..c4059632f1 100644
--- a/src/surfMesh/surfaceFormats/vtk/VTKsurfaceFormatCore.C
+++ b/src/surfMesh/surfaceFormats/vtk/VTKsurfaceFormatCore.C
@@ -48,9 +48,9 @@ void Foam::fileFormats::VTKsurfaceFormatCore::writeHeader
     os  << "POINTS " << pointLst.size() << " float" << nl;
     forAll(pointLst, ptI)
     {
-        os  << pointLst[ptI].x() << ' '
-            << pointLst[ptI].y() << ' '
-            << pointLst[ptI].z() << nl;
+        const point& pt = pointLst[ptI];
+
+        os  << pt.x() << ' ' << pt.y() << ' ' << pt.z() << nl;
     }
 }
 
diff --git a/src/surfMesh/surfaceFormats/vtk/VTKsurfaceFormatCore.H b/src/surfMesh/surfaceFormats/vtk/VTKsurfaceFormatCore.H
index 5165dfea12..d0f6ed1de5 100644
--- a/src/surfMesh/surfaceFormats/vtk/VTKsurfaceFormatCore.H
+++ b/src/surfMesh/surfaceFormats/vtk/VTKsurfaceFormatCore.H
@@ -39,7 +39,6 @@ SourceFiles
 #include "Ostream.H"
 #include "OFstream.H"
 #include "MeshedSurface.H"
-#include "UnsortedMeshedSurface.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
diff --git a/src/surfMesh/surfaceFormats/vtk/VTKsurfaceFormatRunTime.C b/src/surfMesh/surfaceFormats/vtk/VTKsurfaceFormatRunTime.C
index 5d6877c7fd..bd300b84f7 100644
--- a/src/surfMesh/surfaceFormats/vtk/VTKsurfaceFormatRunTime.C
+++ b/src/surfMesh/surfaceFormats/vtk/VTKsurfaceFormatRunTime.C
@@ -25,8 +25,7 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "VTKsurfaceFormat.H"
-#include "MeshedSurface.H"
-#include "UnsortedMeshedSurface.H"
+
 #include "addToRunTimeSelectionTable.H"
 #include "addToMemberFunctionSelectionTable.H"
 
@@ -36,9 +35,10 @@ namespace Foam
 namespace fileFormats
 {
 
+// write MeshedSurfaceProxy
 addNamedTemplatedToMemberFunctionSelectionTable
 (
-    MeshedSurface,
+    MeshedSurfaceProxy,
     VTKsurfaceFormat,
     face,
     write,
@@ -47,7 +47,7 @@ addNamedTemplatedToMemberFunctionSelectionTable
 );
 addNamedTemplatedToMemberFunctionSelectionTable
 (
-    MeshedSurface,
+    MeshedSurfaceProxy,
     VTKsurfaceFormat,
     triFace,
     write,
@@ -55,6 +55,7 @@ addNamedTemplatedToMemberFunctionSelectionTable
     vtk
 );
 
+// write UnsortedMeshedSurface
 addNamedTemplatedToMemberFunctionSelectionTable
 (
     UnsortedMeshedSurface,