sampledSurface hacking proof-of-concept

- using 'nil' type to write geometry only, in the future we could fallback to 'null'
  writer and hook in arbitrary formats from surfMesh

- IOobject gets writeEndDivider() static method

src/OpenFOAM/db/IOobject/IOobject.H

@@ -359,6 +359,10 @@ public:
             template<class Stream>
             static inline Stream& writeDivider(Stream& os);
 
+            //- Write the standard end file divider
+            template<class Stream>
+            static inline Stream& writeEndDivider(Stream& os);
+
             //- Write header
             bool writeHeader(Ostream&) const;
 

src/OpenFOAM/db/IOobject/IOobjectI.H

@@ -82,5 +82,14 @@ inline Stream& Foam::IOobject::writeDivider(Stream& os)
     return os;
 }
 
+template<class Stream>
+inline Stream& Foam::IOobject::writeEndDivider(Stream& os)
+{
+    os  << "\n\n"
+        "// ************************************************************************* //\n";
+
+    return os;
+}
+
 
 // ************************************************************************* //

src/OpenFOAM/db/regIOobject/regIOobjectWrite.C

@@ -103,9 +103,7 @@ bool Foam::regIOobject::writeObject
             return false;
         }
 
-        os  << "\n\n"
+        writeEndDivider(os);
-            "// ************************************************************************* //"
-            << endl;
 
         osGood = os.good();
     }

src/conversion/meshReader/meshReaderAux.C

@@ -97,10 +97,8 @@ void Foam::meshReader::writeInterfaces(const objectRegistry& registry) const
     OFstream os(ioObj.objectPath());
     ioObj.writeHeader(os);
 
-    os  << interfaces_
+    os << interfaces_;
-        << "// *************************************"
+    io.writeEndDivider(os);
-        << "************************************ //"
-        << endl;
 }
 
 

src/sampling/sampledSurface/writers/dx/dxSurfaceWriter.C

@@ -25,6 +25,7 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "dxSurfaceWriter.H"
+
 #include "fileName.H"
 #include "OFstream.H"
 #include "faceList.H"
@@ -33,12 +34,12 @@ License
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 
 template<class Type>
-void Foam::dxSurfaceWriter<Type>::writeDXGeometry
+void Foam::dxSurfaceWriter<Type>::writeGeometry
 (
+    Ostream& os,
     const pointField& points,
-    const faceList& faces,
+    const faceList& faces
-    Ostream& os
+)
-) const
 {
     // Write vertex coordinates
 
@@ -69,7 +70,7 @@ void Foam::dxSurfaceWriter<Type>::writeDXGeometry
         {
             FatalErrorIn
             (
-                "writeDXGeometry(Ostream&, const pointField&, const faceList&)"
+                "writeGeometry(Ostream&, const pointField&, const faceList&)"
             )   << "Face " << faceI << " vertices " << f
                 << " is not a triangle."
                 << exit(FatalError);
@@ -82,51 +83,38 @@ void Foam::dxSurfaceWriter<Type>::writeDXGeometry
 }
 
 
+namespace Foam
+{
     // Write scalarField in DX format
-template<class Type>
+    template<>
-void Foam::dxSurfaceWriter<Type>::writeDXData
+    void Foam::dxSurfaceWriter<Foam::scalar>::writeData
     (
-    const pointField& points,
+        Ostream& os,
-    const scalarField& values,
+        const Field<scalar>& values
-    Ostream& os
+    )
-) const
     {
         // Write data
         os  << "object 3 class array type float rank 0 items "
-        << values.size()
+            << values.size() << " data follows" << nl;
-        << " data follows" << nl;
 
         forAll(values, elemI)
         {
             os << float(values[elemI]) << nl;
         }
-
-    if (values.size() == points.size())
-    {
-        os  << nl << "attribute \"dep\" string \"positions\""
-            << nl << nl;
-    }
-    else
-    {
-        os  << nl << "attribute \"dep\" string \"connections\""
-            << nl << nl;
-    }
     }
 
 
     // Write vectorField in DX format
-template<class Type>
+    template<>
-void Foam::dxSurfaceWriter<Type>::writeDXData
+    void Foam::dxSurfaceWriter<Foam::vector>::writeData
     (
-    const pointField& points,
+        Ostream& os,
-    const vectorField& values,
+        const Field<vector>& values
-    Ostream& os
+    )
-) const
     {
         // Write data
         os  << "object 3 class array type float rank 1 shape 3 items "
-        << values.size()
+            << values.size() << " data follows" << nl;
-        << " data follows" << nl;
 
         forAll(values, elemI)
         {
@@ -134,65 +122,39 @@ void Foam::dxSurfaceWriter<Type>::writeDXData
                 << float(values[elemI].y()) << ' '
                 << float(values[elemI].z()) << nl;
         }
-
-    if (values.size() == points.size())
-    {
-        os  << nl << "attribute \"dep\" string \"positions\""
-            << nl << nl;
-    }
-    else
-    {
-        os  << nl << "attribute \"dep\" string \"connections\""
-            << nl << nl;
-    }
     }
 
 
     // Write sphericalTensorField in DX format
-template<class Type>
+    template<>
-void Foam::dxSurfaceWriter<Type>::writeDXData
+    void Foam::dxSurfaceWriter<Foam::sphericalTensor>::writeData
     (
-    const pointField& points,
+        Ostream& os,
-    const sphericalTensorField& values,
+        const Field<sphericalTensor>& values
-    Ostream& os
+    )
-) const
     {
         // Write data
         os  << "object 3 class array type float rank 0 items "
-        << values.size()
+            << values.size() << " data follows" << nl;
-        << " data follows" << nl;
 
         forAll(values, elemI)
         {
             os << float(values[elemI][0]) << nl;
         }
-
-    if (values.size() == points.size())
-    {
-        os  << nl << "attribute \"dep\" string \"positions\""
-            << nl << nl;
-    }
-    else
-    {
-        os  << nl << "attribute \"dep\" string \"connections\""
-            << nl << nl;
-    }
     }
 
 
     // Write symmTensorField in DX format
-template<class Type>
+    template<>
-void Foam::dxSurfaceWriter<Type>::writeDXData
+    void Foam::dxSurfaceWriter<Foam::symmTensor>::writeData
     (
-    const pointField& points,
+        Ostream& os,
-    const symmTensorField& values,
+        const Field<symmTensor>& values
-    Ostream& os
+    )
-) const
     {
         // Write data
         os  << "object 3 class array type float rank 2 shape 3 items "
-        << values.size()
+            << values.size() << " data follows" << nl;
-        << " data follows" << nl;
 
         forAll(values, elemI)
         {
@@ -203,33 +165,20 @@ void Foam::dxSurfaceWriter<Type>::writeDXData
                 << float(t.xz()) << ' ' << float(t.yz()) << ' ' << float(t.zz())
                 << nl;
         }
-
-    if (values.size() == points.size())
-    {
-        os  << nl << "attribute \"dep\" string \"positions\""
-            << nl << nl;
-    }
-    else
-    {
-        os  << nl << "attribute \"dep\" string \"connections\""
-            << nl << nl;
-    }
     }
 
 
     // Write tensorField in DX format
-template<class Type>
+    template<>
-void Foam::dxSurfaceWriter<Type>::writeDXData
+    void Foam::dxSurfaceWriter<Foam::tensor>::writeData
     (
-    const pointField& points,
+        Ostream& os,
-    const tensorField& values,
+        const Field<tensor>& values
-    Ostream& os
+    )
-) const
     {
         // Write data
         os  << "object 3 class array type float rank 2 shape 3 items "
-        << values.size()
+            << values.size() << " data follows" << nl;
-        << " data follows" << nl;
 
         forAll(values, elemI)
         {
@@ -240,23 +189,31 @@ void Foam::dxSurfaceWriter<Type>::writeDXData
                 << float(t.zx()) << ' ' << float(t.zy()) << ' ' << float(t.zz())
                 << nl;
         }
-
-    if (values.size() == points.size())
-    {
-        os  << nl << "attribute \"dep\" string \"positions\""
-            << nl << nl;
     }
-    else
+}
+
+// Write tensorField in DX format
+template<class Type>
+void Foam::dxSurfaceWriter<Type>::writeData
+(
+    Ostream& os,
+    const Field<Type>& values
+)
 {
-        os  << nl << "attribute \"dep\" string \"connections\""
+    // Write data
-            << nl << nl;
+    os  << "object 3 class array type float rank 0 items "
+        << values.size() << " data follows" << nl;
+
+    forAll(values, elemI)
+    {
+        os << float(0.0) << nl;
     }
 }
 
 
 // Write trailer in DX format
 template<class Type>
-void Foam::dxSurfaceWriter<Type>::writeDXTrailer(Ostream& os) const
+void Foam::dxSurfaceWriter<Type>::writeTrailer(Ostream& os)
 {
     os  << "# the field, with three components: \"positions\","
         << " \"connections\", and \"data\"" << nl
@@ -316,11 +273,22 @@ void Foam::dxSurfaceWriter<Type>::write
 
     OFstream os(fName);
 
-    writeDXGeometry(points, faces, os);
+    writeGeometry(os, points, faces);
 
-    writeDXData(points, values, os);
+    writeData(os, values);
 
-    writeDXTrailer(os);
+    if (values.size() == points.size())
+    {
+        os  << nl << "attribute \"dep\" string \"positions\""
+            << nl << nl;
+    }
+    else
+    {
+        os  << nl << "attribute \"dep\" string \"connections\""
+            << nl << nl;
+    }
+
+    writeTrailer(os);
 
     os << "end" << nl;
 }

src/sampling/sampledSurface/writers/dx/dxSurfaceWriter.H

@@ -54,49 +54,11 @@ class dxSurfaceWriter
 
     // Private Member Functions
 
-        void writeDXGeometry
+        static void writeGeometry(Ostream&, const pointField&, const faceList&);
-        (
-            const pointField& points,
-            const faceList& faces,
-            Ostream& os
-        ) const;
 
-        void writeDXData
+        static void writeData(Ostream&, const Field<Type>& values);
-        (
-            const pointField& points,
-            const scalarField& values,
-            Ostream& os
-        ) const;
 
-        void writeDXData
+        static void writeTrailer(Ostream&);
-        (
-            const pointField& points,
-            const vectorField& values,
-            Ostream& os
-        ) const;
-
-        void writeDXData
-        (
-            const pointField& points,
-            const sphericalTensorField& values,
-            Ostream& os
-        ) const;
-
-        void writeDXData
-        (
-            const pointField& points,
-            const symmTensorField& values,
-            Ostream& os
-        ) const;
-
-        void writeDXData
-        (
-            const pointField& points,
-            const tensorField& values,
-            Ostream& os
-        ) const;
-
-        void writeDXTrailer(Ostream& os) const;
 
 public:
 

src/sampling/sampledSurface/writers/foamFile/foamFileSurfaceWriter.C

@@ -25,6 +25,7 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "foamFileSurfaceWriter.H"
+
 #include "fileName.H"
 #include "OFstream.H"
 #include "faceList.H"
@@ -48,6 +49,43 @@ Foam::foamFileSurfaceWriter<Type>::~foamFileSurfaceWriter()
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
+namespace Foam
+{
+template<>
+void Foam::foamFileSurfaceWriter<Foam::nil>::write
+(
+    const fileName& samplePath,
+    const fileName& timeDir,
+    const fileName& surfaceName,
+    const pointField& points,
+    const faceList& faces,
+    const fileName& fieldName,
+    const Field<Foam::nil>& values,
+    const bool verbose
+) const
+{
+    fileName surfaceDir(samplePath/timeDir/surfaceName);
+
+    if (!isDir(surfaceDir))
+    {
+        mkDir(surfaceDir);
+    }
+
+    if (verbose)
+    {
+        Info<< "Writing nil to " << surfaceDir << endl;
+    }
+
+    // Points
+    OFstream(surfaceDir/"points")() << points;
+
+    // Faces
+    OFstream(surfaceDir/"faces")() << faces;
+}
+
+}
+
+
 template<class Type>
 void Foam::foamFileSurfaceWriter<Type>::write
 (

src/sampling/sampledSurface/writers/foamFile/foamFileSurfaceWriterRunTime.C

@@ -35,6 +35,7 @@ namespace Foam
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
+makeSurfaceWriterType(foamFileSurfaceWriter, nil);
 makeSurfaceWriters(foamFileSurfaceWriter);
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

src/sampling/sampledSurface/writers/null/nullSurfaceWriterRunTime.C

@@ -35,6 +35,7 @@ namespace Foam
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
+makeSurfaceWriterType(nullSurfaceWriter, nil);
 makeSurfaceWriters(nullSurfaceWriter);
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

src/sampling/sampledSurface/writers/obj/objSurfaceWriter.C

@@ -25,6 +25,7 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "objSurfaceWriter.H"
+
 #include "fileName.H"
 #include "OFstream.H"
 #include "faceList.H"
@@ -48,6 +49,80 @@ Foam::objSurfaceWriter<Type>::~objSurfaceWriter()
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
+namespace Foam
+{
+
+template<>
+void Foam::objSurfaceWriter<Foam::nil>::write
+(
+    const fileName& samplePath,
+    const fileName& timeDir,
+    const fileName& surfaceName,
+    const pointField& points,
+    const faceList& faces,
+    const fileName& fieldName,
+    const Field<Foam::nil>& values,
+    const bool verbose
+) const
+{
+    fileName surfaceDir(samplePath/timeDir);
+
+    if (!isDir(surfaceDir))
+    {
+        mkDir(surfaceDir);
+    }
+
+    fileName fName(surfaceDir/surfaceName + ".obj");
+
+    if (verbose)
+    {
+        Info<< "Writing nil to " << fName << endl;
+    }
+
+    // this is a quick hack
+    OFstream os(fName);
+
+    os  << "# Wavefront OBJ file" << nl
+        << "o " << os.name().lessExt().name() << nl
+        << nl
+        << "# points : " << points.size() << nl
+        << "# faces  : " << faces.size() << nl
+        << "# no zones " << nl;
+
+    os  << nl
+        << "# <points count=\"" << points.size() << "\">" << endl;
+
+    // Write vertex coords
+    forAll(points, ptI)
+    {
+        os  << "v " << points[ptI].x()
+            << ' '  << points[ptI].y()
+            << ' '  << points[ptI].z() << nl;
+    }
+
+    os  << "# </points>" << nl
+        << nl
+        << "# <faces count=\"" << faces.size() << "\">" << endl;
+
+    forAll(faces, i)
+    {
+        const face& f = faces[i];
+
+        os << 'f';
+        forAll(f, fp)
+        {
+            os << ' ' << f[fp] + 1;
+        }
+        os << nl;
+
+    }
+
+    os << "# </faces>" << endl;
+}
+
+}
+
+
 template<class Type>
 void Foam::objSurfaceWriter<Type>::write
 (

src/sampling/sampledSurface/writers/obj/objSurfaceWriterRunTime.C

@@ -35,6 +35,7 @@ namespace Foam
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
+makeSurfaceWriterType(objSurfaceWriter, nil);
 makeSurfaceWriters(objSurfaceWriter);
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

src/sampling/sampledSurface/writers/raw/rawSurfaceWriter.C

@@ -25,6 +25,7 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "rawSurfaceWriter.H"
+
 #include "fileName.H"
 #include "OFstream.H"
 #include "faceList.H"
@@ -37,9 +38,9 @@ template<class Type>
 void Foam::rawSurfaceWriter<Type>::writeGeometry
 (
     const pointField& points,
-    const label& pointI,
+    const label pointI,
     Ostream& os
-) const
+)
 {
     const point& pt = points[pointI];
 
@@ -52,15 +53,16 @@ void Foam::rawSurfaceWriter<Type>::writeGeometry
 (
     const pointField& points,
     const faceList& faces,
-    const label& faceI,
+    const label faceI,
     Ostream& os
-) const
+)
 {
     const point& ct = faces[faceI].centre(points);
 
     os << ct.x() << ' ' << ct.y() << ' ' << ct.z() << ' ';
 }
 
+
 // Write scalarField in raw format
 template<class Type>
 void Foam::rawSurfaceWriter<Type>::writeData
@@ -70,38 +72,29 @@ void Foam::rawSurfaceWriter<Type>::writeData
     const faceList& faces,
     const scalarField& values,
     Ostream& os
-) const
+)
 {
     // header
-    os << "# " << fieldName;
+    os  << "#  x  y  z  " << fieldName << endl;
-
-    if (values.size() == points.size())
-    {
-        os  << "  POINT_DATA " << values.size()
-            << nl;
-    }
-    else
-    {
-        os  << "  FACE_DATA " << values.size()
-            << nl;
-    }
-
-    os  << "#  x  y  z  " << fieldName
-        << endl;
 
     // Write data
-    forAll(values, elemI)
-    {
     if (values.size() == points.size())
+    {
+        forAll(values, elemI)
         {
             writeGeometry(points, elemI, os);
+            os << values[elemI] << nl;
+        }
     }
     else
+    {
+        forAll(values, elemI)
         {
             writeGeometry(points, faces, elemI, os);
+            os << values[elemI] << nl;
         }
-        os << values[elemI] << endl;
     }
+
     os << nl;
 }
 
@@ -115,22 +108,9 @@ void Foam::rawSurfaceWriter<Type>::writeData
     const faceList& faces,
     const vectorField& values,
     Ostream& os
-) const
+)
 {
     // header
-    os << "# " << fieldName;
-
-    if (values.size() == points.size())
-    {
-        os  << "  POINT_DATA " << values.size()
-            << nl;
-    }
-    else
-    {
-        os  << "  FACE_DATA " << values.size()
-            << nl;
-    }
-
     os  << "#  x  y  z  "
         << fieldName << "_x  "
         << fieldName << "_y  "
@@ -138,23 +118,29 @@ void Foam::rawSurfaceWriter<Type>::writeData
         << endl;
 
     // Write data
-    forAll(values, elemI)
-    {
-        const vector& v = values[elemI];
-
     if (values.size() == points.size())
+    {
+        forAll(values, elemI)
         {
             writeGeometry(points, elemI, os);
+
+            const vector& v = values[elemI];
+            os << v[0] << ' ' << v[1] << ' ' << v[2] << nl;
+        }
     }
     else
+    {
+        forAll(values, elemI)
         {
             writeGeometry(points, faces, elemI, os);
-        }
 
+            const vector& v = values[elemI];
             os << v[0] << ' ' << v[1] << ' ' << v[2] << nl;
         }
     }
 
+}
+
 
 // Write sphericalTensorField in raw format
 template<class Type>
@@ -165,42 +151,34 @@ void Foam::rawSurfaceWriter<Type>::writeData
     const faceList& faces,
     const sphericalTensorField& values,
     Ostream& os
-) const
+)
 {
     // header
-    os << "# " << fieldName;
-
-    if (values.size() == points.size())
-    {
-        os  << "  POINT_DATA " << values.size()
-            << nl;
-    }
-    else
-    {
-        os  << "  FACE_DATA " << values.size()
-            << nl;
-    }
-
     os  << "#  ii  ";
     os << fieldName << "_ii" << endl;
 
     // Write data
-    forAll(values, elemI)
-    {
-        const sphericalTensor& v = values[elemI];
-
     if (values.size() == points.size())
+    {
+        forAll(values, elemI)
         {
             writeGeometry(points, elemI, os);
+
+            const sphericalTensor& v = values[elemI];
+            os  << v[0] << nl;
+        }
     }
     else
+    {
+        forAll(values, elemI)
         {
             writeGeometry(points, faces, elemI, os);
-        }
 
+            const sphericalTensor& v = values[elemI];
             os  << v[0] << nl;
         }
     }
+}
 
 
 // Write symmTensorField in raw format
@@ -212,22 +190,9 @@ void Foam::rawSurfaceWriter<Type>::writeData
     const faceList& faces,
     const symmTensorField& values,
     Ostream& os
-) const
+)
 {
     // header
-    os << "# " << fieldName;
-
-    if (values.size() == points.size())
-    {
-        os  << "  POINT_DATA " << values.size()
-            << nl;
-    }
-    else
-    {
-        os  << "  FACE_DATA " << values.size()
-            << nl;
-    }
-
     os  << "#  xx  xy  xz  yy  yz ";
     for(int i=0; i<6; i++)
     {
@@ -236,24 +201,33 @@ void Foam::rawSurfaceWriter<Type>::writeData
     os << endl;
 
     // Write data
-    forAll(values, elemI)
-    {
-        const symmTensor& v = values[elemI];
-
     if (values.size() == points.size())
     {
-            writeGeometry(points, elemI, os);
+        forAll(values, elemI)
-        }
-        else
         {
-            writeGeometry(points, faces, elemI, os);
+            writeGeometry(points, elemI, os);
-        }
+
+            const symmTensor& v = values[elemI];
 
             os  << v[0] << ' ' << v[1] << ' ' << v[2]
                 << v[3] << ' ' << v[4] << ' ' << v[5]
                 << nl;
         }
     }
+    else
+    {
+        forAll(values, elemI)
+        {
+            writeGeometry(points, faces, elemI, os);
+
+            const symmTensor& v = values[elemI];
+
+            os  << v[0] << ' ' << v[1] << ' ' << v[2]
+                << v[3] << ' ' << v[4] << ' ' << v[5]
+                << nl;
+        }
+    }
+}
 
 
 // Write tensorField in raw format
@@ -265,48 +239,42 @@ void Foam::rawSurfaceWriter<Type>::writeData
     const faceList& faces,
     const tensorField& values,
     Ostream& os
-) const
+)
 {
     // header
-    os << "# " << fieldName;
-
-    if (values.size() == points.size())
-    {
-        os  << "  POINT_DATA " << values.size()
-            << nl;
-    }
-    else
-    {
-        os  << "  FACE_DATA " << values.size()
-            << nl;
-    }
-
     os  << "#  xx  xy  xz  yx  yy  yz  zx  zy  zz";
-    for(int i=0; i<9; i++)
+    for (int i=0; i<9; ++i)
     {
         os << fieldName << "_" << i << "  ";
     }
     os << endl;
 
     // Write data
-    forAll(values, elemI)
-    {
-        const tensor& v = values[elemI];
-
     if (values.size() == points.size())
     {
-            writeGeometry(points, elemI, os);
+        forAll(values, elemI)
-        }
-        else
         {
-            writeGeometry(points, faces, elemI, os);
+            writeGeometry(points, elemI, os);
-        }
 
+            const tensor& v = values[elemI];
             os  << v[0] << ' ' << v[1] << ' ' << v[2]
                 << v[3] << ' ' << v[4] << ' ' << v[5]
                 << v[6] << ' ' << v[7] << ' ' << v[8] << nl;
         }
     }
+    else
+    {
+        forAll(values, elemI)
+        {
+            writeGeometry(points, faces, elemI, os);
+
+            const tensor& v = values[elemI];
+            os  << v[0] << ' ' << v[1] << ' ' << v[2]
+                << v[3] << ' ' << v[4] << ' ' << v[5]
+                << v[6] << ' ' << v[7] << ' ' << v[8] << nl;
+        }
+    }
+}
 
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
@@ -327,6 +295,55 @@ Foam::rawSurfaceWriter<Type>::~rawSurfaceWriter()
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
+namespace Foam
+{
+
+template<>
+void Foam::rawSurfaceWriter<Foam::nil>::write
+(
+    const fileName& samplePath,
+    const fileName& timeDir,
+    const fileName& surfaceName,
+    const pointField& points,
+    const faceList& faces,
+    const fileName& fieldName,
+    const Field<Foam::nil>& values,
+    const bool verbose
+) const
+{
+    fileName surfaceDir(samplePath/timeDir);
+
+    if (!isDir(surfaceDir))
+    {
+        mkDir(surfaceDir);
+    }
+
+    fileName fName(surfaceDir/surfaceName + ".raw");
+
+    if (verbose)
+    {
+        Info<< "Writing nil to " << fName << endl;
+    }
+
+    OFstream os(fName);
+
+    // header
+    os  << "# geometry NO_DATA " << faces.size() << nl
+        << "#  x  y  z" << endl;
+
+    // Write faces
+    forAll(faces, elemI)
+    {
+        writeGeometry(points, faces, elemI, os);
+        os << nl;
+    }
+
+    os << nl;
+}
+
+}
+
+
 template<class Type>
 void Foam::rawSurfaceWriter<Type>::write
 (
@@ -355,6 +372,20 @@ void Foam::rawSurfaceWriter<Type>::write
     }
 
     OFstream os(fName);
+
+    // header
+    os  << "# " << fieldName;
+    if (values.size() == points.size())
+    {
+        os  << "  POINT_DATA ";
+    }
+    else
+    {
+        os  << "  FACE_DATA ";
+    }
+
+    os  << values.size() << nl;
+
     writeData(fieldName, points, faces, values, os);
 }
 

src/sampling/sampledSurface/writers/raw/rawSurfaceWriter.H

@@ -53,65 +53,65 @@ class rawSurfaceWriter
 {
     // Private Member Functions
 
-        void writeGeometry
+        static void writeGeometry
         (
             const pointField& points,
-            const label& pointI,
+            const label pointI,
             Ostream& os
-        ) const;
+        );
 
-        void writeGeometry
+        static void writeGeometry
         (
             const pointField& points,
             const faceList& faces,
-            const label& faceI,
+            const label faceI,
             Ostream& os
-        ) const;
+        );
 
-        void writeData
+        static void writeData
         (
             const fileName& fieldName,
             const pointField& points,
             const faceList& faces,
             const scalarField& values,
             Ostream& os
-        ) const;
+        );
 
-        void writeData
+        static void writeData
         (
             const fileName& fieldName,
             const pointField& points,
             const faceList& faces,
             const vectorField& values,
             Ostream& os
-        ) const;
+        );
 
-        void writeData
+        static void writeData
         (
             const fileName& fieldName,
             const pointField& points,
             const faceList& faces,
             const sphericalTensorField& values,
             Ostream& os
-        ) const;
+        );
 
-        void writeData
+        static void writeData
         (
             const fileName& fieldName,
             const pointField& points,
             const faceList& faces,
             const symmTensorField& values,
             Ostream& os
-        ) const;
+        );
 
-        void writeData
+        static void writeData
         (
             const fileName& fieldName,
             const pointField& points,
             const faceList& faces,
             const tensorField& values,
             Ostream& os
-        ) const;
+        );
 
 
 public:

src/sampling/sampledSurface/writers/raw/rawSurfaceWriterRunTime.C

@@ -35,6 +35,7 @@ namespace Foam
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
+makeSurfaceWriterType(rawSurfaceWriter, nil);
 makeSurfaceWriters(rawSurfaceWriter);
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

src/sampling/sampledSurface/writers/stl/stlSurfaceWriter.C

@@ -49,6 +49,74 @@ Foam::stlSurfaceWriter<Type>::~stlSurfaceWriter()
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
+namespace Foam
+{
+
+template<>
+void Foam::stlSurfaceWriter<Foam::nil>::write
+(
+    const fileName& samplePath,
+    const fileName& timeDir,
+    const fileName& surfaceName,
+    const pointField& points,
+    const faceList& faces,
+    const fileName& fieldName,
+    const Field<Foam::nil>& values,
+    const bool verbose
+) const
+{
+    fileName surfaceDir(samplePath/timeDir);
+
+    if (!isDir(surfaceDir))
+    {
+        mkDir(surfaceDir);
+    }
+
+    fileName fName(surfaceDir/surfaceName + ".stl");
+
+    if (verbose)
+    {
+        Info<< "Writing nil to " << fName << endl;
+    }
+
+    // Convert faces to triangles.
+    DynamicList<labelledTri> tris(faces.size());
+
+    forAll(faces, i)
+    {
+        const face& f = faces[i];
+
+        faceList triFaces(f.nTriangles(points));
+        label nTris = 0;
+        f.triangles(points, nTris, triFaces);
+
+        forAll(triFaces, triI)
+        {
+            const face& tri = triFaces[triI];
+            tris.append(labelledTri(tri[0], tri[1], tri[2], 0));
+        }
+    }
+
+    triSurface
+    (
+        tris.shrink(),
+        geometricSurfacePatchList
+        (
+            1,
+            geometricSurfacePatch
+            (
+                "patch",   // geometricType
+                "patch0",  // fieldName
+                0          // index
+            )
+        ),
+        points
+    ).write(fName);
+}
+
+}
+
+
 template<class Type>
 void Foam::stlSurfaceWriter<Type>::write
 (

src/sampling/sampledSurface/writers/stl/stlSurfaceWriterRunTime.C

@@ -35,6 +35,7 @@ namespace Foam
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
+makeSurfaceWriterType(stlSurfaceWriter, nil);
 makeSurfaceWriters(stlSurfaceWriter);
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

src/sampling/sampledSurface/writers/surfaceWriter.C

@@ -31,15 +31,31 @@ License
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-namespace Foam
-{
-
 template<class Type>
-autoPtr<surfaceWriter<Type> > surfaceWriter<Type>::New(const word& writeType)
+Foam::autoPtr< Foam::surfaceWriter<Type> >
+Foam::surfaceWriter<Type>::New(const word& writeType)
 {
     typename wordConstructorTable::iterator cstrIter =
-        wordConstructorTablePtr_
+        wordConstructorTablePtr_->find(writeType);
-            ->find(writeType);
+
+    if (cstrIter == wordConstructorTablePtr_->end())
+    {
+        // unknown, check if it can handle Foam::nil specialization
+        // (ie, geometry write)
+
+        // generally supported, but not for this data type
+        if
+        (
+            Foam::surfaceWriter<Foam::nil>::wordConstructorTablePtr_->found
+            (
+                writeType
+            )
+        )
+        {
+            // use 'null' file instead
+            cstrIter = wordConstructorTablePtr_->find("null");
+        }
+
 
         if (cstrIter == wordConstructorTablePtr_->end())
         {
@@ -52,6 +68,7 @@ autoPtr<surfaceWriter<Type> > surfaceWriter<Type>::New(const word& writeType)
                 << wordConstructorTablePtr_->toc()
                 << exit(FatalError);
         }
+    }
 
     return autoPtr< surfaceWriter<Type> >(cstrIter()());
 }
@@ -60,19 +77,15 @@ autoPtr<surfaceWriter<Type> > surfaceWriter<Type>::New(const word& writeType)
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
 template<class Type>
-surfaceWriter<Type>::surfaceWriter()
+Foam::surfaceWriter<Type>::surfaceWriter()
 {}
 
 
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
 template<class Type>
-surfaceWriter<Type>::~surfaceWriter()
+Foam::surfaceWriter<Type>::~surfaceWriter()
 {}
 
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
-
 // ************************************************************************* //

src/sampling/sampledSurface/writers/surfaceWriter.H

@@ -41,12 +41,17 @@ SourceFiles
 #include "autoPtr.H"
 #include "pointField.H"
 #include "faceList.H"
+#include "nil.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 namespace Foam
 {
 
+// Forward declaration of friend functions and operators
+
+template<class Type> class surfaceWriter;
+
 /*---------------------------------------------------------------------------*\
                         Class surfaceWriter Declaration
 \*---------------------------------------------------------------------------*/
@@ -54,6 +59,8 @@ namespace Foam
 template<class Type>
 class surfaceWriter
 {
+    //- friendship between writer data types
+    template<class Type2> friend class surfaceWriter;
 
 public:
 

src/sampling/sampledSurface/writers/surfaceWriters.C

@@ -34,7 +34,9 @@ namespace Foam
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 #define defineSurfaceWriterType(dataType)                                     \
     defineNamedTemplateTypeNameAndDebug(surfaceWriter< dataType >, 0);        \
-    defineTemplatedRunTimeSelectionTable(surfaceWriter, word, dataType);
+    defineTemplatedRunTimeSelectionTable(surfaceWriter, word, dataType)
+
+defineSurfaceWriterType(nil);
 
 defineSurfaceWriterType(scalar);
 defineSurfaceWriterType(vector);

src/sampling/sampledSurface/writers/surfaceWriters.H

@@ -39,7 +39,7 @@ Description
 // Only used internally
 #define makeTypeSurfaceWritersTypeName(typeWriter, dataType)                 \
                                                                              \
-    defineNamedTemplateTypeNameAndDebug(typeWriter<dataType >, 0);
+    defineNamedTemplateTypeNameAndDebug(typeWriter< dataType >, 0)
 
 // Sometimes used externally
 #define makeSurfaceWritersTypeName(typeWriter)                               \
@@ -48,7 +48,7 @@ Description
     makeTypeSurfaceWritersTypeName(typeWriter, vector);                      \
     makeTypeSurfaceWritersTypeName(typeWriter, sphericalTensor);             \
     makeTypeSurfaceWritersTypeName(typeWriter, symmTensor);                  \
-    makeTypeSurfaceWritersTypeName(typeWriter, tensor);
+    makeTypeSurfaceWritersTypeName(typeWriter, tensor)
 
 // Define type info for single dataType template instantiation (eg, vector)
 #define makeSurfaceWriterType(typeWriter, dataType)                          \
@@ -57,7 +57,7 @@ Description
     addTemplatedToRunTimeSelectionTable                                      \
     (                                                                        \
         surfaceWriter, typeWriter, dataType, word                            \
-    );
+    )
 
 
 // Define type info for scalar, vector etc. instantiations
@@ -67,7 +67,7 @@ Description
     makeSurfaceWriterType(typeWriter, vector);                               \
     makeSurfaceWriterType(typeWriter, sphericalTensor);                      \
     makeSurfaceWriterType(typeWriter, symmTensor);                           \
-    makeSurfaceWriterType(typeWriter, tensor);
+    makeSurfaceWriterType(typeWriter, tensor)
 
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

src/sampling/sampledSurface/writers/vtk/vtkSurfaceWriter.C

@@ -25,6 +25,7 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "vtkSurfaceWriter.H"
+
 #include "fileName.H"
 #include "OFstream.H"
 #include "faceList.H"
@@ -35,13 +36,12 @@ License
 template<class Type>
 void Foam::vtkSurfaceWriter<Type>::writeGeometry
 (
+    Ostream& os,
     const pointField& points,
-    const faceList& faces,
+    const faceList& faces
-    Ostream& os
+)
-) const
 {
-    // Write vertex coordinates
+    // header
-
     os
         << "# vtk DataFile Version 2.0" << nl
         << "sampleSurface" << nl
@@ -57,7 +57,7 @@ void Foam::vtkSurfaceWriter<Type>::writeGeometry
             << float(pt.y()) << ' '
             << float(pt.z()) << nl;
     }
-    os  << endl;
+    os  << nl;
 
 
     // Write faces
@@ -84,31 +84,18 @@ void Foam::vtkSurfaceWriter<Type>::writeGeometry
 }
 
 
-// Write scalarField in vtk format
+namespace Foam
-template<class Type>
-void Foam::vtkSurfaceWriter<Type>::writeData
-(
-    const fileName& fieldName,
-    const pointField& points,
-    const scalarField& values,
-    Ostream& os
-) const
 {
-    // Write data
-    if (values.size() == points.size())
-    {
-        os  << "POINT_DATA " << values.size()
-            << nl
-            << "FIELD attributes 1" << nl;
-    }
-    else
-    {
-        os  << "CELL_DATA " << values.size()
-            << nl
-            << "FIELD attributes 1" << nl;
-    }
 
-    os  << fieldName << " 1 " << values.size() << " float" << nl;
+    // Write scalarField in vtk format
+    template<>
+    void Foam::vtkSurfaceWriter<Foam::scalar>::writeData
+    (
+        Ostream& os,
+        const Field<Foam::scalar>& values
+    )
+    {
+        os << "1 " << values.size() << " float" << nl;
 
         forAll(values, elemI)
         {
@@ -123,154 +110,107 @@ void Foam::vtkSurfaceWriter<Type>::writeData
                     os << nl;
                 }
             }
-        os << float(values[elemI]);
+
+            const scalar& v = values[elemI];
+            os << float(v);
         }
         os << nl;
     }
 
-
     // Write vectorField in vtk format
-template<class Type>
+    template<>
-void Foam::vtkSurfaceWriter<Type>::writeData
+    void Foam::vtkSurfaceWriter<Foam::vector>::writeData
     (
-    const fileName& fieldName,
+        Ostream& os,
-    const pointField& points,
+        const Field<Foam::vector>& values
-    const vectorField& values,
+    )
-    Ostream& os
-) const
     {
-    // Write data
+        os << "3 " << values.size() << " float" << nl;
-    if (values.size() == points.size())
-    {
-        os  << "POINT_DATA " << values.size()
-            << nl
-            << "FIELD attributes 1" << nl;
-    }
-    else
-    {
-        os  << "CELL_DATA " << values.size()
-            << nl
-            << "FIELD attributes 1" << nl;
-    }
-
-    os  << fieldName << " 3 " << values.size() << " float" << nl;
 
         forAll(values, elemI)
         {
             const vector& v = values[elemI];
-
+            os  << float(v[0]) << ' ' << float(v[1]) << ' ' << float(v[2])
-        os << float(v[0]) << ' ' << float(v[1]) << ' ' << float(v[2]) << nl;
+                << nl;
         }
     }
 
 
     // Write sphericalTensorField in vtk format
-template<class Type>
+    template<>
-void Foam::vtkSurfaceWriter<Type>::writeData
+    void Foam::vtkSurfaceWriter<Foam::sphericalTensor>::writeData
     (
-    const fileName& fieldName,
+        Ostream& os,
-    const pointField& points,
+        const Field<sphericalTensor>& values
-    const sphericalTensorField& values,
+    )
-    Ostream& os
-) const
     {
-    // Write data
+        os << "1 " << values.size() << " float" << nl;
-    if (values.size() == points.size())
-    {
-        os  << "POINT_DATA " << values.size()
-            << nl
-            << "FIELD attributes 1" << nl;
-    }
-    else
-    {
-        os  << "CELL_DATA " << values.size()
-            << nl
-            << "FIELD attributes 1" << nl;
-    }
-
-    os  << fieldName << " 1 " << values.size() << " float" << nl;
 
         forAll(values, elemI)
         {
             const sphericalTensor& v = values[elemI];
-
+            os << float(v[0]) << nl;
-        os  << float(v[0])
-            << nl;
         }
     }
 
 
     // Write symmTensorField in vtk format
-template<class Type>
+    template<>
-void Foam::vtkSurfaceWriter<Type>::writeData
+    void Foam::vtkSurfaceWriter<Foam::symmTensor>::writeData
     (
-    const fileName& fieldName,
+        Ostream& os,
-    const pointField& points,
+        const Field<symmTensor>& values
-    const symmTensorField& values,
+    )
-    Ostream& os
-) const
     {
-    // Write data
+        os << "6 " << values.size() << " float" << nl;
-    if (values.size() == points.size())
-    {
-        os  << "POINT_DATA " << values.size()
-            << nl
-            << "FIELD attributes 1" << nl;
-    }
-    else
-    {
-        os  << "CELL_DATA " << values.size()
-            << nl
-            << "FIELD attributes 1" << nl;
-    }
-
-    os  << fieldName << " 6 " << values.size() << " float" << nl;
 
         forAll(values, elemI)
         {
             const symmTensor& v = values[elemI];
-
             os  << float(v[0]) << ' ' << float(v[1]) << ' ' << float(v[2])
                 << float(v[3]) << ' ' << float(v[4]) << ' ' << float(v[5])
                 << nl;
+
         }
     }
 
 
+    // Write tensorField in vtk format
+    template<>
+    void Foam::vtkSurfaceWriter<Foam::tensor>::writeData
+    (
+        Ostream& os,
+        const Field<tensor>& values
+    )
+    {
+        os << "9 " << values.size() << " float" << nl;
+
+        forAll(values, elemI)
+        {
+            const tensor& v = values[elemI];
+            os  << float(v[0]) << ' ' << float(v[1]) << ' ' << float(v[2])
+                << float(v[3]) << ' ' << float(v[4]) << ' ' << float(v[5])
+                << float(v[6]) << ' ' << float(v[7]) << ' ' << float(v[8])
+                << nl;
+        }
+    }
+
+}
+
+
 // Write tensorField in vtk format
 template<class Type>
 void Foam::vtkSurfaceWriter<Type>::writeData
 (
-    const fileName& fieldName,
+    Ostream& os,
-    const pointField& points,
+    const Field<Type>& values
-    const tensorField& values,
+)
-    Ostream& os
-) const
 {
-    // Write data
+    os << "1 " << values.size() << " float" << nl;
-    if (values.size() == points.size())
-    {
-        os  << "POINT_DATA " << values.size()
-            << nl
-            << "FIELD attributes 1" << nl;
-    }
-    else
-    {
-        os  << "CELL_DATA " << values.size()
-            << nl
-            << "FIELD attributes 1" << nl;
-    }
-
-    os  << fieldName << " 9 " << values.size() << " float" << nl;
 
     forAll(values, elemI)
     {
-        const tensor& v = values[elemI];
+        os << float(0) << nl;
-
-        os  << float(v[0]) << ' ' << float(v[1]) << ' ' << float(v[2])
-            << float(v[3]) << ' ' << float(v[4]) << ' ' << float(v[5])
-            << float(v[6]) << ' ' << float(v[7]) << ' ' << float(v[8])
-            << nl;
     }
 }
 
@@ -294,6 +234,42 @@ Foam::vtkSurfaceWriter<Type>::~vtkSurfaceWriter()
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
+namespace Foam
+{
+template<>
+void Foam::vtkSurfaceWriter<Foam::nil>::write
+(
+    const fileName& samplePath,
+    const fileName& timeDir,
+    const fileName& surfaceName,
+    const pointField& points,
+    const faceList& faces,
+    const fileName& fieldName,
+    const Field<Foam::nil>& values,
+    const bool verbose
+) const
+{
+    fileName surfaceDir(samplePath/timeDir);
+
+    if (!isDir(surfaceDir))
+    {
+        mkDir(surfaceDir);
+    }
+
+    fileName fName(surfaceDir/surfaceName + ".vtk");
+
+    if (verbose)
+    {
+        Info<< "Writing nil to " << fName << endl;
+    }
+
+    OFstream os(fName);
+    writeGeometry(os, points, faces);
+}
+
+}
+
+
 template<class Type>
 void Foam::vtkSurfaceWriter<Type>::write
 (
@@ -322,9 +298,25 @@ void Foam::vtkSurfaceWriter<Type>::write
     }
 
     OFstream os(fName);
+    writeGeometry(os, points, faces);
+
+    // start writing data
+    if (values.size() == points.size())
+    {
+        os  << "POINT_DATA ";
+    }
+    else
+    {
+        os  << "CELL_DATA ";
+    }
+
+    os  << values.size() << nl
+        << "FIELD attributes 1" << nl
+        << fieldName << " ";
+
+    // Write data
+    writeData(os, values);
 
-    writeGeometry(points, faces, os);
-    writeData(fieldName, points, values, os);
 }
 
 

src/sampling/sampledSurface/writers/vtk/vtkSurfaceWriter.H

@@ -53,52 +53,9 @@ class vtkSurfaceWriter
 {
     // Private Member Functions
 
-        void writeGeometry
+        static void writeGeometry(Ostream&, const pointField&, const faceList&);
-        (
-            const pointField& points,
-            const faceList& faces,
-            Ostream& os
-        ) const;
 
-        void writeData
+        static void writeData(Ostream&, const Field<Type>& values);
-        (
-            const fileName& fieldName,
-            const pointField& points,
-            const scalarField& values,
-            Ostream& os
-        ) const;
-
-        void writeData
-        (
-            const fileName& fieldName,
-            const pointField& points,
-            const vectorField& values,
-            Ostream& os
-        ) const;
-
-        void writeData
-        (
-            const fileName& fieldName,
-            const pointField& points,
-            const sphericalTensorField& values,
-            Ostream& os
-        ) const;
-
-        void writeData
-        (
-            const fileName& fieldName,
-            const pointField& points,
-            const symmTensorField& values,
-            Ostream& os
-        ) const;
-
-        void writeData
-        (
-            const fileName& fieldName,
-            const pointField& points,
-            const tensorField& values,
-            Ostream& os
-        ) const;
 
 
 public:

src/sampling/sampledSurface/writers/vtk/vtkSurfaceWriterRunTime.C

@@ -35,6 +35,7 @@ namespace Foam
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
+makeSurfaceWriterType(vtkSurfaceWriter, nil);
 makeSurfaceWriters(vtkSurfaceWriter);
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

src/surfMesh/MeshedSurfaceProxy/MeshedSurfaceProxy.C

@@ -25,13 +25,13 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "MeshedSurfaceProxy.H"
-#include "MeshedSurface.H"
+
 #include "Time.H"
 #include "surfMesh.H"
 #include "OFstream.H"
 #include "ListOps.H"
 
-// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+// * * * * * * * * * * * * * Static Member Functions * * * * * * * * * * * * //
 
 template<class Face>
 Foam::wordHashSet Foam::MeshedSurfaceProxy<Face>::writeTypes()
@@ -40,8 +40,6 @@ Foam::wordHashSet Foam::MeshedSurfaceProxy<Face>::writeTypes()
 }
 
 
-// * * * * * * * * * * * * * Static Member Functions * * * * * * * * * * * * //
-
 template<class Face>
 bool Foam::MeshedSurfaceProxy<Face>::canWriteType
 (
@@ -135,13 +133,19 @@ void Foam::MeshedSurfaceProxy<Face>::write
             )
         );
 
-        OFstream os(objectDir/io.name());
+        OFstream os
+        (
+            objectDir/io.name(),
+            t.writeFormat(),
+            IOstream::currentVersion,
+            t.writeCompression()
+        );
+
         io.writeHeader(os);
 
         os  << this->points();
 
-        os  << "\n\n"
+        io.writeEndDivider(os);
-            "// ************************************************************************* //\n";
     }
 
 
@@ -161,7 +165,13 @@ void Foam::MeshedSurfaceProxy<Face>::write
             )
         );
 
-        OFstream os(objectDir/io.name());
+        OFstream os
+        (
+            objectDir/io.name(),
+            t.writeFormat(),
+            IOstream::currentVersion,
+            t.writeCompression()
+        );
         io.writeHeader(os);
 
         if (this->useFaceMap())
@@ -174,8 +184,7 @@ void Foam::MeshedSurfaceProxy<Face>::write
             os  << this->faces();
         }
 
-        os  << "\n\n"
+        io.writeEndDivider(os);
-            "// ************************************************************************* //\n";
     }
 
 
@@ -195,14 +204,13 @@ void Foam::MeshedSurfaceProxy<Face>::write
             )
         );
 
+        // write as ascii
         OFstream os(objectDir/io.name());
         io.writeHeader(os);
 
         os  << this->surfZones();
 
-        os  << "\n\n"
+        io.writeEndDivider(os);
-            "// ************************************************************************* //"
-            << endl;
     }
 
 }

src/surfMesh/MeshedSurfaceProxy/MeshedSurfaceProxy.H

@@ -83,10 +83,12 @@ public:
 
     // Static
 
-        //- Can we write this file format?
+        //- The file format types that can be written via MeshedSurfaceProxy
+        static wordHashSet writeTypes();
+
+        //- Can this file format type be written via MeshedSurfaceProxy?
         static bool canWriteType(const word& ext, const bool verbose=false);
 
-        static wordHashSet writeTypes();
 
     // Constructors
 
@@ -95,7 +97,7 @@ public:
         (
             const pointField&,
             const List<Face>&,
-            const List<surfZone>&,
+            const List<surfZone>& = List<surfZone>(),
             const List<label>& faceMap = List<label>()
         );