diff --git a/applications/utilities/surface/surfaceMeshConvert/surfaceMeshConvert.C b/applications/utilities/surface/surfaceMeshConvert/surfaceMeshConvert.C
index aa8b89c033..93d385104f 100644
--- a/applications/utilities/surface/surfaceMeshConvert/surfaceMeshConvert.C
+++ b/applications/utilities/surface/surfaceMeshConvert/surfaceMeshConvert.C
@@ -52,10 +52,11 @@ Note
 #include "timeSelector.H"
 #include "Time.H"
 #include "polyMesh.H"
-#include "keyedSurface.H"
-#include "meshedSurface.H"
 #include "triSurface.H"
 
+#include "MeshedSurfaces.H"
+#include "UnsortedMeshedSurfaces.H"
+
 using namespace Foam;
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@@ -69,7 +70,7 @@ int main(int argc, char *argv[])
     argList::validOptions.insert("clean", "");
     argList::validOptions.insert("scale", "scale");
     argList::validOptions.insert("triSurface", "");
-    argList::validOptions.insert("keyed", "");
+    argList::validOptions.insert("unsorted", "");
 #   include "setRootCase.H"
     const stringList& params = args.additionalArgs();
 
@@ -122,9 +123,9 @@ int main(int argc, char *argv[])
         // write sorted by region
         surf.write(exportName, true);
     }
-    else if (args.options().found("keyed"))
+    else if (args.options().found("unsorted"))
     {
-        keyedSurface surf(importName);
+        unsortedMeshedSurface surf(importName);
 
         if (args.options().found("clean"))
         {
diff --git a/src/surfMesh/Make/files b/src/surfMesh/Make/files
index def352062d..c7be4a4f32 100644
--- a/src/surfMesh/Make/files
+++ b/src/surfMesh/Make/files
@@ -2,27 +2,23 @@ surfGroup/surfGroup.C
 surfGroup/surfGroupIOList.C
 surfPatchIdentifier/surfPatchIdentifier.C
 
-keyedSurface/keyedSurface.C
-keyedSurface/keyedSurfaceCleanup.C
-keyedSurface/newKeyedSurface.C
+MeshedSurface/MeshedSurfaces.C
+UnsortedMeshedSurface/UnsortedMeshedSurfaces.C
 
-meshedSurface/meshedSurface.C
-meshedSurface/meshedSurfaceCleanup.C
-meshedSurface/newMeshedSurface.C
-
-fileFormats = keyedSurface/fileFormats
-$(fileFormats)/ac3d/AC3DfileFormat.C
-$(fileFormats)/ftr/FTRfileFormat.C
-$(fileFormats)/gts/GTSfileFormat.C
-$(fileFormats)/nas/NASfileFormat.C
-$(fileFormats)/obj/OBJfileFormat.C
-$(fileFormats)/off/OFFfileFormat.C
-$(fileFormats)/smesh/SMESHfileFormat.C
-$(fileFormats)/starcd/STARCDfileFormat.C
-$(fileFormats)/stl/STLfileFormat.C
-$(fileFormats)/stl/STLfileFormatASCII.L
-$(fileFormats)/tri/TRIfileFormat.C
-$(fileFormats)/vtk/VTKfileFormat.C
+surfaceFormats = surfaceFormats
+$(surfaceFormats)/ac3d/AC3DsurfaceFormatRunTime.C
+$(surfaceFormats)/ftr/FTRsurfaceFormatRunTime.C
+$(surfaceFormats)/gts/GTSsurfaceFormatRunTime.C
+$(surfaceFormats)/nas/NASsurfaceFormatRunTime.C
+$(surfaceFormats)/obj/OBJsurfaceFormatRunTime.C
+$(surfaceFormats)/off/OFFsurfaceFormatRunTime.C
+$(surfaceFormats)/smesh/SMESHsurfaceFormatRunTime.C
+$(surfaceFormats)/starcd/STARCDsurfaceFormatRunTime.C
+$(surfaceFormats)/stl/STLsurfaceFormatRunTime.C
+$(surfaceFormats)/stl/STLsurfaceFormatASCII.L
+$(surfaceFormats)/stl/STLsurfaceFormatCore.C
+$(surfaceFormats)/tri/TRIsurfaceFormatRunTime.C
+$(surfaceFormats)/vtk/VTKsurfaceFormatRunTime.C
 
 LIB = $(FOAM_LIBBIN)/libsurfMesh
 
diff --git a/src/surfMesh/meshedSurface/meshedSurface.C b/src/surfMesh/MeshedSurface/MeshedSurface.C
similarity index 67%
rename from src/surfMesh/meshedSurface/meshedSurface.C
rename to src/surfMesh/MeshedSurface/MeshedSurface.C
index 92aa30295f..b7a3a2f5f9 100644
--- a/src/surfMesh/meshedSurface/meshedSurface.C
+++ b/src/surfMesh/MeshedSurface/MeshedSurface.C
@@ -24,8 +24,8 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-#include "meshedSurface.H"
-#include "keyedSurface.H"
+#include "MeshedSurface.H"
+#include "UnsortedMeshedSurface.H"
 #include "demandDrivenData.H"
 #include "IFstream.H"
 #include "OFstream.H"
@@ -41,27 +41,16 @@ License
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-namespace Foam
-{
-defineTypeNameAndDebug(meshedSurface, 0);
-defineMemberFunctionSelectionTable
-(
-    meshedSurface,
-    write,
-    fileExtension
-);
-}
-
-//  File extension for 'native' raw format
-//! @cond localscope
-const char * const nativeExt = "ofs";
-//! @endcond localscope
+// File extension for 'native' raw format
+#undef  nativeSurfaceExt
+#define nativeSurfaceExt "ofs"
 
 // * * * * * * * * * * * * * Static Member Functions * * * * * * * * * * * * //
 
-Foam::fileName Foam::meshedSurface::triSurfInstance(const Time& d)
+template<class Face>
+Foam::fileName Foam::MeshedSurface<Face>::triSurfInstance(const Time& d)
 {
-    fileName foamName(d.caseName() + "." + nativeExt);
+    fileName foamName(d.caseName() + "." + nativeSurfaceExt);
 
     // Search back through the time directories list to find the time
     // closest to and lower than current time
@@ -88,7 +77,7 @@ Foam::fileName Foam::meshedSurface::triSurfInstance(const Time& d)
             {
                 if (debug)
                 {
-                    Pout<< " meshedSurface::triSurfInstance(const Time& d)"
+                    Pout<< " MeshedSurface::triSurfInstance(const Time& d)"
                         << "reading " << foamName
                         << " from " << ts[j].name()/typeName
                         << endl;
@@ -101,7 +90,7 @@ Foam::fileName Foam::meshedSurface::triSurfInstance(const Time& d)
 
     if (debug)
     {
-        Pout<< " meshedSurface::triSurfInstance(const Time& d)"
+        Pout<< " MeshedSurface::triSurfInstance(const Time& d)"
             << "reading " << foamName
             << " from constant/" << endl;
     }
@@ -110,9 +99,10 @@ Foam::fileName Foam::meshedSurface::triSurfInstance(const Time& d)
 }
 
 
-Foam::fileName Foam::meshedSurface::triSurfName(const Time& d)
+template<class Face>
+Foam::fileName Foam::MeshedSurface<Face>::triSurfName(const Time& d)
 {
-    fileName foamName(d.caseName() + "." + nativeExt);
+    fileName foamName(d.caseName() + "." + nativeSurfaceExt);
 
     // Search back through the time directories list to find the time
     // closest to and lower than current time
@@ -141,7 +131,7 @@ Foam::fileName Foam::meshedSurface::triSurfName(const Time& d)
             {
                 if (debug)
                 {
-                    Pout<< " meshedSurface::triSurfName(const Time& d)"
+                    Pout<< " MeshedSurface::triSurfName(const Time& d)"
                         << "reading " << foamName
                         << " from " << ts[j].name()/typeName
                         << endl;
@@ -154,7 +144,7 @@ Foam::fileName Foam::meshedSurface::triSurfName(const Time& d)
 
     if (debug)
     {
-        Pout<< " meshedSurface::triSurfName(const Time& d)"
+        Pout<< " MeshedSurface::triSurfName(const Time& d)"
             << "reading " << foamName
             << " from constant/" << endl;
     }
@@ -162,13 +152,21 @@ Foam::fileName Foam::meshedSurface::triSurfName(const Time& d)
     return d.path()/"constant"/typeName/foamName;
 }
 
-bool Foam::meshedSurface::canRead(const word& ext, const bool verbose)
+template<class Face>
+bool Foam::MeshedSurface<Face>::canRead(const word& ext, const bool verbose)
 {
-    return keyedSurface::canRead(ext, verbose);
+    // handle 'native' format directly
+    if (ext == nativeSurfaceExt)
+    {
+        return true;
+    }
+
+    return UnsortedMeshedSurface<Face>::canRead(ext, verbose);
 }
 
 
-bool Foam::meshedSurface::canWrite(const word& ext, const bool verbose)
+template<class Face>
+bool Foam::MeshedSurface<Face>::canWrite(const word& ext, const bool verbose)
 {
     // perhaps sent an entire name
     word fExt(ext);
@@ -180,12 +178,12 @@ bool Foam::meshedSurface::canWrite(const word& ext, const bool verbose)
     }
 
     // handle 'native' format directly
-    if (fExt == nativeExt)
+    if (fExt == nativeSurfaceExt)
     {
         return true;
     }
 
-    writefileExtensionMemberFunctionTable::iterator mfIter =
+    typename writefileExtensionMemberFunctionTable::iterator mfIter =
         writefileExtensionMemberFunctionTablePtr_->find(fExt);
 
     if (mfIter == writefileExtensionMemberFunctionTablePtr_->end())
@@ -199,7 +197,7 @@ bool Foam::meshedSurface::canWrite(const word& ext, const bool verbose)
 
             Info<<"Unknown file extension for writing: " << fExt << nl;
             // compact output:
-            Info<<"Valid types: ( " << nativeExt;
+            Info<<"Valid types: ( " << nativeSurfaceExt;
             forAll(known, i)
             {
                 Info<<" " << known[i];
@@ -214,63 +212,65 @@ bool Foam::meshedSurface::canWrite(const word& ext, const bool verbose)
 }
 
 
-void Foam::meshedSurface::write
+template<class Face>
+void Foam::MeshedSurface<Face>::write
 (
     const fileName& fName,
-    const meshedSurface& surf
+    const MeshedSurface& surf
 )
 {
     if (debug)
     {
-        Info<< "meshedSurface::write(const fileName&, const meshedSurface&) : "
-               "writing meshedSurface to " << fName
+        Info<< "MeshedSurface::write(const fileName&, const MeshedSurface&) : "
+               "writing MeshedSurface to " << fName
             << endl;
     }
 
     const word ext = fName.ext();
 
     // handle 'native' format directly
-    if (ext == nativeExt)
+    if (ext == nativeSurfaceExt)
     {
         surf.write(OFstream(fName)());
+        return;
     }
-    else
+
+    typename writefileExtensionMemberFunctionTable::iterator mfIter =
+        writefileExtensionMemberFunctionTablePtr_->find(ext);
+
+    if (mfIter == writefileExtensionMemberFunctionTablePtr_->end())
     {
-        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
-                << writefileExtensionMemberFunctionTablePtr_->toc()
-                << exit(FatalError);
-        }
-
-        mfIter()(fName, surf);
+        FatalErrorIn
+        (
+            "MeshedSurface::write(const fileName&)"
+        )   << "Unknown file extension " << ext << nl << nl
+            << "Valid types are :" << endl
+            << writefileExtensionMemberFunctionTablePtr_->toc()
+            << exit(FatalError);
     }
+
+    mfIter()(fName, surf);
 }
 
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
-Foam::meshedSurface::meshedSurface()
+template<class Face>
+Foam::MeshedSurface<Face>::MeshedSurface()
 :
-    MeshStorage(List<FaceType>(), pointField())
+    ParentType(List<Face>(), pointField())
 {}
 
 
-Foam::meshedSurface::meshedSurface
+template<class Face>
+Foam::MeshedSurface<Face>::MeshedSurface
 (
     const xfer<pointField>& pointLst,
-    const xfer<List<FaceType> >& faceLst,
+    const xfer<List<Face> >& faceLst,
     const xfer<surfGroupList>& patchLst
 )
 :
-    MeshStorage(List<FaceType>(), pointField()),
+    ParentType(List<Face>(), pointField()),
     patches_(patchLst)
 {
     points().transfer(pointLst());
@@ -278,16 +278,17 @@ Foam::meshedSurface::meshedSurface
 }
 
 
-Foam::meshedSurface::meshedSurface
+template<class Face>
+Foam::MeshedSurface<Face>::MeshedSurface
 (
     const xfer<pointField>& pointLst,
-    const xfer<List<FaceType> >& faceLst,
+    const xfer<List<Face> >& faceLst,
     const UList<label>& patchSizes,
     const UList<word>& patchNames,
     const UList<word>& patchTypes
 )
 :
-    MeshStorage(List<FaceType>(), pointField())
+    ParentType(List<Face>(), pointField())
 {
     points().transfer(pointLst());
     faces().transfer(faceLst());
@@ -312,15 +313,16 @@ Foam::meshedSurface::meshedSurface
 }
 
 
-Foam::meshedSurface::meshedSurface
+template<class Face>
+Foam::MeshedSurface<Face>::MeshedSurface
 (
     const xfer<pointField>& pointLst,
-    const xfer<List<FaceType> >& faceLst,
+    const xfer<List<Face> >& faceLst,
     const UList<label>& regionIds,
     const Map<word>& regionNames
 )
 :
-    MeshStorage(List<FaceType>(), pointField())
+    ParentType(List<Face>(), pointField())
 {
     points().transfer(pointLst());
     faces().transfer(faceLst());
@@ -334,10 +336,10 @@ Foam::meshedSurface::meshedSurface
     {
         FatalErrorIn
         (
-            "meshedSurface::meshedSurface(\n"
+            "MeshedSurface::MeshedSurface(\n"
             "(\n"
             "    const xfer<pointField>&,\n"
-            "    const xfer<List<FaceType> >&,\n"
+            "    const xfer<List<Face> >&,\n"
             "    const UList<label>& regionIds,\n"
             "    const Map<word>& regionNames\n"
             " )\n"
@@ -352,15 +354,16 @@ Foam::meshedSurface::meshedSurface
 }
 
 
-Foam::meshedSurface::meshedSurface
+template<class Face>
+Foam::MeshedSurface<Face>::MeshedSurface
 (
     const xfer<pointField>& pointLst,
-    const xfer<List<FaceType> >& faceLst,
+    const xfer<List<Face> >& faceLst,
     const UList<label>& regionIds,
     const HashTable<label>& nameToRegionMapping
 )
 :
-    MeshStorage(List<FaceType>(), pointField())
+    ParentType(List<Face>(), pointField())
 {
     points().transfer(pointLst());
     faces().transfer(faceLst());
@@ -369,10 +372,10 @@ Foam::meshedSurface::meshedSurface
     {
         FatalErrorIn
         (
-            "meshedSurface::meshedSurface(\n"
+            "MeshedSurface::MeshedSurface(\n"
             "(\n"
             "    const xfer<pointField>&,\n"
-            "    const xfer<List<FaceType> >&,\n"
+            "    const xfer<List<Face> >&,\n"
             "    const UList<label>& regionIds,\n"
             "    const HashTable<label>& nameToRegionMapping\n"
             " )\n"
@@ -393,13 +396,14 @@ Foam::meshedSurface::meshedSurface
 }
 
 
-Foam::meshedSurface::meshedSurface
+template<class Face>
+Foam::MeshedSurface<Face>::MeshedSurface
 (
     const polyBoundaryMesh& bMesh,
     const bool useGlobalPoints
 )
 :
-    MeshStorage(List<FaceType>(), pointField())
+    ParentType(List<Face>(), pointField())
 {
     const polyMesh& mesh = bMesh.mesh();
     const polyPatchList& bPatches = bMesh;
@@ -408,7 +412,7 @@ Foam::meshedSurface::meshedSurface
     // Get patch for all of outside
     primitivePatch allBoundary
     (
-        SubList<FaceType>
+        SubList<Face>
         (
             mesh.faces(),
             mesh.nFaces() - nIntFaces,
@@ -455,12 +459,12 @@ Foam::meshedSurface::meshedSurface
 
 #if 0
 // in preparation
-Foam::meshedSurface::meshedSurface
+Foam::MeshedSurface<Face>::MeshedSurface
 (
     const surfMesh& sMesh
 )
 :
-    MeshStorage(List<FaceType>(sMesh.faces()), sMesh.points())
+    ParentType(List<Face>(sMesh.faces()), sMesh.points())
 {
     const surfPatchList& sPatches = sMesh.boundaryMesh();
 
@@ -488,19 +492,20 @@ Foam::meshedSurface::meshedSurface
 #endif
 
 
-Foam::meshedSurface::meshedSurface
+template<class Face>
+Foam::MeshedSurface<Face>::MeshedSurface
 (
-    const keyedSurface& surf
+    const UnsortedMeshedSurface<Face>& surf
 )
 :
-    MeshStorage(List<FaceType>(), surf.points())
+    ParentType(List<Face>(), surf.points())
 {
     labelList faceMap;
     surfGroupList patchLst = surf.sortedRegions(faceMap);
     patches_.transfer(patchLst);
 
-    const List<FaceType>& origFaces = surf.faces();
-    List<FaceType> newFaces(origFaces.size());
+    const List<Face>& origFaces = surf.faces();
+    List<Face> newFaces(origFaces.size());
 
     // this is somewhat like ListOps reorder and/or IndirectList
     forAll(newFaces, faceI)
@@ -512,66 +517,74 @@ Foam::meshedSurface::meshedSurface
 }
 
 
-Foam::meshedSurface::meshedSurface
+template<class Face>
+Foam::MeshedSurface<Face>::MeshedSurface
 (
     const fileName& fName,
-    const word& ext,
-    const bool triangulate
+    const word& ext
 )
 :
-    MeshStorage(List<FaceType>(), pointField())
+    ParentType(List<Face>(), pointField())
 {
-    read(fName, ext, triangulate);
+    read(fName, ext);
 }
 
 
-Foam::meshedSurface::meshedSurface
+template<class Face>
+Foam::MeshedSurface<Face>::MeshedSurface
 (
-    const fileName& fName,
-    const bool triangulate
+    const fileName& fName
 )
 :
-    MeshStorage(List<FaceType>(), pointField())
+    ParentType(List<Face>(), pointField())
 {
-    read(fName, fName.ext(), triangulate);
+    read(fName, fName.ext());
 }
 
 
-Foam::meshedSurface::meshedSurface(Istream& is, const bool triangulate)
+template<class Face>
+Foam::MeshedSurface<Face>::MeshedSurface(Istream& is)
 :
-    MeshStorage(List<FaceType>(), pointField())
+    ParentType(List<Face>(), pointField())
 {
-    read(is, triangulate);
+    read(is);
 }
 
 
-Foam::meshedSurface::meshedSurface(const Time& d)
+template<class Face>
+Foam::MeshedSurface<Face>::MeshedSurface(const Time& d)
 :
-    MeshStorage(List<FaceType>(), pointField())
+    ParentType(List<Face>(), pointField())
 {
     read(IFstream(triSurfName(d))());
     // setDefaultPatches();
 }
 
 
-Foam::meshedSurface::meshedSurface(const meshedSurface& surf)
+template<class Face>
+Foam::MeshedSurface<Face>::MeshedSurface(const MeshedSurface& surf)
 :
-    MeshStorage(surf.faces(), surf.points()),
+    ParentType(surf.faces(), surf.points()),
     patches_(surf.patches_)
 {}
 
 
-Foam::meshedSurface::meshedSurface(const xfer<keyedSurface>& surf)
+template<class Face>
+Foam::MeshedSurface<Face>::MeshedSurface
+(
+    const xfer<UnsortedMeshedSurface<Face> >& surf
+)
 :
-    MeshStorage(List<FaceType>(), pointField())
+    ParentType(List<Face>(), pointField())
 {
     transfer(surf());
 }
 
 
-Foam::meshedSurface::meshedSurface(const xfer<meshedSurface>& surf)
+template<class Face>
+Foam::MeshedSurface<Face>::MeshedSurface(const xfer<MeshedSurface>& surf)
 :
-    MeshStorage(List<FaceType>(), pointField())
+    ParentType(List<Face>(), pointField())
 {
     transfer(surf());
 }
@@ -580,13 +593,15 @@ Foam::meshedSurface::meshedSurface(const xfer<meshedSurface>& surf)
 
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
-Foam::meshedSurface::~meshedSurface()
+template<class Face>
+Foam::MeshedSurface<Face>::~MeshedSurface()
 {}
 
 
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 
-void Foam::meshedSurface::onePatch()
+template<class Face>
+void Foam::MeshedSurface<Face>::onePatch()
 {
     // set single default patch
     patches_.setSize(1);
@@ -600,7 +615,8 @@ void Foam::meshedSurface::onePatch()
 }
 
 
-void Foam::meshedSurface::checkPatches()
+template<class Face>
+void Foam::MeshedSurface<Face>::checkPatches()
 {
     // extra safety, ensure we have at some patches,
     // and they cover all the faces
@@ -618,7 +634,7 @@ void Foam::meshedSurface::checkPatches()
         {
             WarningIn
             (
-                "meshedSurface::checkPatches()\n"
+                "MeshedSurface::checkPatches()\n"
             )
                 << "more nFaces " << size()
                 << " than patches " << count
@@ -631,7 +647,7 @@ void Foam::meshedSurface::checkPatches()
         {
             FatalErrorIn
             (
-                "meshedSurface::checkPatches()\n"
+                "MeshedSurface::checkPatches()\n"
             )
                 << "more patches " << count
                 << " than nFaces " << size()
@@ -655,13 +671,14 @@ void Foam::meshedSurface::checkPatches()
 }
 
 
-void Foam::meshedSurface::sortFacesByRegion
+template<class Face>
+void Foam::MeshedSurface<Face>::sortFacesByRegion
 (
     const UList<label>& regionIds,
     const Map<word>& regionNames
 )
 {
-    const List<FaceType>& unsortedFaces = faces();
+    const List<Face>& unsortedFaces = faces();
 
     if (!&regionNames || !&regionIds || regionIds.size() == 0)
     {
@@ -670,7 +687,7 @@ void Foam::meshedSurface::sortFacesByRegion
     else if (regionIds.size() == unsortedFaces.size())
     {
         labelList faceMap;
-        surfGroupList newPatches = keyedSurface::sortedRegions
+        surfGroupList newPatches = UnsortedMeshedSurface<Face>::sortedRegions
         (
             regionIds,
             regionNames,
@@ -679,7 +696,7 @@ void Foam::meshedSurface::sortFacesByRegion
         patches_.transfer(newPatches);
 
         // this is somewhat like ListOps reorder and/or IndirectList
-        List<FaceType> newFaces(unsortedFaces.size());
+        List<Face> newFaces(unsortedFaces.size());
         forAll(newFaces, faceI)
         {
             newFaces[faceI] = unsortedFaces[faceMap[faceI]];
@@ -691,40 +708,15 @@ void Foam::meshedSurface::sortFacesByRegion
 }
 
 
-// Read surf grouping, points, faces directly from Istream
-bool Foam::meshedSurface::read(Istream& is, const bool doTriangulate)
-{
-    List<surfGroup> patchLst(is);
-    is >> points() >> faces();
-
-    // copy patch info:
-    patches_.setSize(patchLst.size());
-    forAll(patchLst, patchI)
-    {
-        patches_[patchI] = surfGroup
-        (
-            patchLst[patchI],
-            patchI
-        );
-    }
-
-    if (doTriangulate)
-    {
-        triangulate();
-    }
-
-    return is.good();
-}
-
-
 // * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
 
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
-void Foam::meshedSurface::clear()
+template<class Face>
+void Foam::MeshedSurface<Face>::clear()
 {
-    MeshStorage::clearOut();
+    ParentType::clearOut();
 
     points().clear();
     faces().clear();
@@ -732,47 +724,50 @@ void Foam::meshedSurface::clear()
 }
 
 
-void Foam::meshedSurface::movePoints(const pointField& newPoints)
+template<class Face>
+void Foam::MeshedSurface<Face>::movePoints(const pointField& newPoints)
 {
     // Remove all geometry dependent data
-    MeshStorage::clearTopology();
+    ParentType::clearTopology();
 
     // Adapt for new point position
-    MeshStorage::movePoints(newPoints);
+    ParentType::movePoints(newPoints);
 
     // Copy new points
     points() = newPoints;
 }
 
 
-void Foam::meshedSurface::scalePoints(const scalar& scaleFactor)
+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
-        MeshStorage::clearTopology();
+        ParentType::clearTopology();
 
         // Adapt for new point position
-        MeshStorage::movePoints(pointField());
+        ParentType::movePoints(pointField());
 
         points() *= scaleFactor;
     }
 }
 
 
-Foam::meshedSurface Foam::meshedSurface::subsetMesh
+template<class Face>
+Foam::MeshedSurface<Face> Foam::MeshedSurface<Face>::subsetMesh
 (
     const UList<bool>& include,
     labelList& pointMap,
     labelList& faceMap
 ) const
 {
-    const pointField& locPoints = localPoints();
-    const List<FaceType>& locFaces = localFaces();
+    const pointField& locPoints = ParentType::localPoints();
+    const List<Face>& locFaces  = ParentType::localFaces();
 
     // Fill pointMap, faceMap
-    subsetMap(include, pointMap, faceMap);
+    ParentType::subsetMap(include, pointMap, faceMap);
 
     // Create compact coordinate list and forward mapping array
     pointField newPoints(pointMap.size());
@@ -792,18 +787,18 @@ Foam::meshedSurface Foam::meshedSurface::subsetMesh
     }
 
     // Renumber face node labels and compact
-    List<FaceType> newFaces(faceMap.size());
+    List<Face> newFaces(faceMap.size());
 
     forAll(faceMap, faceI)
     {
         // Get old vertex labels
         label origFaceI = faceMap[faceI];
-        const FaceType& oldFace = locFaces[origFaceI];
+        const Face& oldFace = locFaces[origFaceI];
 
-        newFaces[faceI] = FaceType(oldFace);
+        newFaces[faceI] = Face(oldFace);
 
         // Renumber labels for face
-        FaceType& f = newFaces[faceI];
+        Face& f = newFaces[faceI];
         forAll(f, fp)
         {
             f[fp] = oldToNew[oldFace[fp]];
@@ -835,7 +830,7 @@ Foam::meshedSurface Foam::meshedSurface::subsetMesh
     }
 
     // construct a sub-surface
-    meshedSurface subSurf
+    MeshedSurface subSurf
     (
         xferMove(newPoints),
         xferMove(newFaces),
@@ -846,7 +841,11 @@ Foam::meshedSurface Foam::meshedSurface::subsetMesh
 }
 
 
-void Foam::meshedSurface::transfer(meshedSurface& surf)
+template<class Face>
+void Foam::MeshedSurface<Face>::transfer
+(
+    MeshedSurface<Face>& surf
+)
 {
     clear();
 
@@ -858,7 +857,11 @@ void Foam::meshedSurface::transfer(meshedSurface& surf)
 }
 
 
-void Foam::meshedSurface::transfer(keyedSurface& surf)
+template<class Face>
+void Foam::MeshedSurface<Face>::transfer
+(
+    UnsortedMeshedSurface<Face>& surf
+)
 {
     clear();
     points().transfer(surf.points());
@@ -870,8 +873,8 @@ void Foam::meshedSurface::transfer(keyedSurface& surf)
     surf.regions_.clear();
     surf.patches_.clear();
 
-    List<FaceType>& oldFaces = surf.faces();
-    List<FaceType>  newFaces(oldFaces.size());
+    List<Face>& oldFaces = surf.faces();
+    List<Face>  newFaces(oldFaces.size());
 
     // this is somewhat like ListOps reorder and/or IndirectList
     forAll(newFaces, faceI)
@@ -886,101 +889,74 @@ void Foam::meshedSurface::transfer(keyedSurface& surf)
 
 
 // Read from file in given format
-bool Foam::meshedSurface::read
+template<class Face>
+bool Foam::MeshedSurface<Face>::read
 (
-    const fileName& fName,
-    const bool triangulate
+    const fileName& fName
 )
 {
     clear();
     const word ext = fName.ext();
 
     // handle 'native' format directly
-    if (ext == nativeExt)
+    if (ext == nativeSurfaceExt)
     {
-        return read(IFstream(fName)(), triangulate);
+        return read(IFstream(fName)());
     }
     else
     {
         // use selector mechanism
-        transfer(New(fName, ext, triangulate)());
+        transfer(New(fName, ext)());
         return true;
     }
 }
 
 
 // Read from file in given format
-bool Foam::meshedSurface::read
+template<class Face>
+bool Foam::MeshedSurface<Face>::read
 (
     const fileName& fName,
-    const word& ext,
-    const bool triangulate
+    const word& ext
 )
 {
     clear();
 
     // handle 'native' format directly
-    if (ext == nativeExt)
+    if (ext == nativeSurfaceExt)
     {
-        return read(IFstream(fName)(), triangulate);
+        return read(IFstream(fName)());
     }
     else
     {
         // use selector mechanism
-        transfer(New(fName, ext, triangulate)());
+        transfer(New(fName, ext)());
         return true;
     }
 }
 
 
-void Foam::meshedSurface::write(Ostream& os) const
-{
-    // just emit some information until we get a nice IOobject
-    IOobject::writeBanner(os);
-    os  << "// OpenFOAM Surface format" << nl
-        << "// ~~~~~~~~~~~~~~~~~~~~~~~" << nl
-        << "// regions:" << nl
-        << patches_.size() << nl << token::BEGIN_LIST << incrIndent << nl;
-
-    forAll(patches_, patchI)
-    {
-        patches_[patchI].writeDict(os);
-    }
-    os  << decrIndent << token::END_LIST << nl;
-
-    IOobject::writeDivider(os);
-
-    // Note: Write with global point numbering
-    os  << "\n// points:" << nl << points() << nl;
-
-    IOobject::writeDivider(os);
-    os  << "\n// faces:"  << nl << faces() << nl;
-
-    IOobject::writeDivider(os);
-
-    // Check state of Ostream
-    os.check("meshedSurface::write(Ostream&)");
-}
-
-
-void Foam::meshedSurface::write(const Time& d) const
+template<class Face>
+void Foam::MeshedSurface<Face>::write(const Time& d) const
 {
     write(OFstream(triSurfName(d))());
 }
 
 
-void Foam::meshedSurface::writeStats(Ostream& os) const
+template<class Face>
+void Foam::MeshedSurface<Face>::writeStats(Ostream& os) const
 {
-    os  << "Faces        : " << size() << endl
-        << "Edges        : " << nEdges() << endl
-        << "Vertices     : " << nPoints() << endl
-        << "Bounding Box : " << boundBox(localPoints(), false) << endl;
+//    os  << "Faces        : " << size() << endl
+//        << "Edges        : " << nEdges() << endl
+//        << "Vertices     : " << nPoints() << endl
+//        << "Bounding Box : " << boundBox(localPoints(), false) << endl;
 }
 
 
 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
 
-void Foam::meshedSurface::operator=(const meshedSurface& surf)
+template<class Face>
+void Foam::MeshedSurface<Face>::operator=(const MeshedSurface& surf)
 {
     clear();
 
@@ -993,13 +969,12 @@ void Foam::meshedSurface::operator=(const meshedSurface& surf)
 
 // * * * * * * * * * * * * * * * IOstream Operators  * * * * * * * * * * * * //
 
-Foam::Ostream& Foam::operator<<(Ostream& os, const meshedSurface& surf)
-{
-    surf.write(os);
-    return os;
-}
-
-
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
+#include "MeshedSurfaceCleanup.C"
+#include "MeshedSurfaceIO.C"
+#include "MeshedSurfaceNew.C"
+
+#undef  nativeSurfaceExt
+
 // ************************************************************************* //
diff --git a/src/surfMesh/meshedSurface/meshedSurface.H b/src/surfMesh/MeshedSurface/MeshedSurface.H
similarity index 72%
rename from src/surfMesh/meshedSurface/meshedSurface.H
rename to src/surfMesh/MeshedSurface/MeshedSurface.H
index a8d8383017..bc7e59a1b1 100644
--- a/src/surfMesh/meshedSurface/meshedSurface.H
+++ b/src/surfMesh/MeshedSurface/MeshedSurface.H
@@ -23,33 +23,34 @@ License
     Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 
 Class
-    Foam::meshedSurface
+    Foam::MeshedSurface
 
 Description
     A surface geometry mesh with patch information, not to be confused
     with a similarily named surfaceMesh, which actually refers to
     the cell faces of a volume mesh!
 
-   The meshedSurface is intended to surfaces from a variety of sources.
+   The MeshedSurface is intended to surfaces from a variety of sources.
    - A set of points and faces without any patch information.
    - A set of points and faces with randomly sorted patch information.
      This could arise, for example, from reading external file formats
      such as STL, etc.
 
 SourceFiles
-    meshedSurface.C
+    MeshedSurface.C
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef meshedSurface_H
-#define meshedSurface_H
+#ifndef MeshedSurface_H
+#define MeshedSurface_H
 
 #include "pointField.H"
 #include "PrimitivePatchExtra.H"
 #include "boolList.H"
 #include "surfGroupList.H"
-#include "face.H"
 #include "xfer.H"
+#include "face.H"
+#include "triFace.H"
 #include "runTimeSelectionTables.H"
 #include "memberFunctionSelectionTables.H"
 
@@ -61,44 +62,38 @@ namespace Foam
 // Forward declaration of friend functions and operators
 
 class Time;
-class keyedSurface;
-class meshedSurface;
+template<class Face> class MeshedSurface;
+template<class Face> class UnsortedMeshedSurface;
+
 class polyBoundaryMesh;
 class surfMesh;
 
-Ostream& operator<<(Ostream&, const meshedSurface&);
+template<class Face>
+    Ostream& operator<<(Ostream&, const MeshedSurface<Face>&);
 
 /*---------------------------------------------------------------------------*\
-                      Class meshedSurface Declaration
+                      Class MeshedSurface Declaration
 \*---------------------------------------------------------------------------*/
 
-class meshedSurface
+template<class Face>
+class MeshedSurface
 :
-    public PrimitivePatchExtra<face, ::Foam::List, pointField, point>
+    public PrimitivePatchExtra<Face, ::Foam::List, pointField, point>
 {
-    friend class keyedSurface;
-
-protected:
-
-    // Protected Member Data
-
-        //- Typedef for similar code in keyedSurface and meshedSurface
-        typedef face FaceType;
+    friend class UnsortedMeshedSurface<Face>;
 
 private:
 
-    // Private Member Data
-
-    // Private typedefs
-
+    //- Private typedefs for convenience
+        typedef MeshedSurface<Face> ThisType;
         typedef PrimitivePatchExtra
         <
-            FaceType,
+            Face,
             ::Foam::List,
             pointField,
             point
         >
-        MeshStorage;
+        ParentType;
 
     // Private Member Data
 
@@ -118,7 +113,7 @@ private:
         void sortFacesByRegion(const UList<label>&, const Map<word>&);
 
         //- Read OpenFOAM Surface format
-        bool read(Istream&, const bool triangulate=false);
+        bool read(Istream&);
 
 
 protected:
@@ -128,26 +123,26 @@ protected:
         //- Return non-const access to global points
         pointField& points()
         {
-            return const_cast<pointField&>(MeshStorage::points());
+            return const_cast<pointField&>(ParentType::points());
         }
 
         //- Return non-const access to the faces
-        List<FaceType>& faces()
+        List<Face>& faces()
         {
-            return static_cast<List<FaceType> &>(*this);
+            return static_cast<List<Face> &>(*this);
         }
 
 public:
 
         //- Runtime type information
-        ClassName("meshedSurface");
+        ClassName("MeshedSurface");
 
     // Static
 
-        //- Name of meshedSurface directory to use.
+        //- Name of MeshedSurface directory to use.
         static fileName triSurfInstance(const Time&);
 
-        //- Name of meshedSurface directory to use.
+        //- Name of MeshedSurface directory to use.
         static fileName triSurfName(const Time&);
 
         //- Can we read this file format?
@@ -160,22 +155,22 @@ public:
     // Constructors
 
         //- Construct null
-        meshedSurface();
+        MeshedSurface();
 
         //- Construct by transferring components
         //  (points, faces and patches).
-        meshedSurface
+        MeshedSurface
         (
             const xfer<pointField>&,
-            const xfer<List<face> >&,
+            const xfer<List<Face> >&,
             const xfer<surfGroupList>&
         );
 
         //- Construct from points, faces, and patch information
-        meshedSurface
+        MeshedSurface
         (
             const xfer<pointField>&,
-            const xfer<List<face> >&,
+            const xfer<List<Face> >&,
             const UList<label>& patchSizes,
             const UList<word>& patchNames,
             const UList<word>& patchTypes
@@ -184,88 +179,90 @@ public:
         //- Construct by transferring points, faces.
         //  Sort faces according to regionIds with the names of the regions,
         //  or jsut set a single default patch.
-        meshedSurface
+        MeshedSurface
         (
             const xfer<pointField>&,
-            const xfer<List<face> >&,
+            const xfer<List<Face> >&,
             const UList<label>& regionIds = UList<label>::null(),
             const Map<word>& regionNames = Map<word>::null()
         );
 
         //- Construct by transferring points, faces.
         //  Sort faces according to regionIds with patch-names from hash
-        meshedSurface
+        MeshedSurface
         (
             const xfer<pointField>&,
-            const xfer<List<face> >&,
+            const xfer<List<Face> >&,
             const UList<label>& regionIds,
             const HashTable<label>& nameToRegionMapping
         );
 
         //- Construct from a boundary mesh with local points/faces
-        meshedSurface
+        MeshedSurface
         (
             const polyBoundaryMesh&,
             const bool globalPoints=false
         );
 
-        //- Construct from a keyedSurface
-        meshedSurface(const keyedSurface&);
+        //- Construct from a UnsortedMeshedSurface
+        MeshedSurface(const UnsortedMeshedSurface<Face>&);
 
         //- Construct from a surfMesh
-        meshedSurface(const surfMesh&);
+        MeshedSurface(const surfMesh&);
 
-        //- Construct by transferring the contents from a keyedSurface
-        meshedSurface(const xfer<keyedSurface>&);
+        //- Construct by transferring the contents from a UnsortedMeshedSurface
+        MeshedSurface(const xfer<UnsortedMeshedSurface<Face> >&);
 
-        //- Construct by transferring the contents from a meshedSurface
-        meshedSurface(const xfer<meshedSurface>&);
+        //- Construct by transferring the contents from a MeshedSurface
+        MeshedSurface(const xfer<MeshedSurface<Face> >&);
 
         //- Construct from file name (uses extension to determine type)
-        meshedSurface
-        (
-            const fileName&,
-            const bool triangulate=false
-        );
+        MeshedSurface(const fileName&);
 
         //- Construct from file name (uses extension to determine type)
-        meshedSurface
-        (
-            const fileName&,
-            const word& ext,
-            const bool triangulate=false
-        );
+        MeshedSurface(const fileName&, const word& ext);
 
         //- Construct from Istream
-        meshedSurface(Istream&, const bool triangulate=false);
+        MeshedSurface(Istream&);
 
         //- Construct from objectRegistry
-        meshedSurface(const Time&);
+        MeshedSurface(const Time&);
 
         //- Construct as copy
-        meshedSurface(const meshedSurface&);
+        MeshedSurface(const MeshedSurface&);
+
+    // Declare run-time constructor selection table
+
+        declareRunTimeSelectionTable
+        (
+            autoPtr,
+            MeshedSurface,
+            fileExtension,
+            (
+                const fileName& fName
+            ),
+            (fName)
+        );
 
     // Selectors
 
         //- Select constructed from filename (implicit extension)
-        static autoPtr<meshedSurface> New
+        static autoPtr<MeshedSurface> New
         (
-            const fileName&,
-            const bool triangulate=false
+            const fileName&
         );
 
         //- Select constructed from filename (explicit extension)
-        static autoPtr<meshedSurface> New
+        static autoPtr<MeshedSurface> New
         (
             const fileName&,
-            const word&,
-            const bool triangulate=false
+            const word& ext
         );
 
 
     // Destructor
 
-        virtual ~meshedSurface();
+        virtual ~MeshedSurface();
 
 
     // Member Function Selectors
@@ -273,18 +270,18 @@ public:
         declareMemberFunctionSelectionTable
         (
             void,
-            meshedSurface,
+            MeshedSurface,
             write,
             fileExtension,
             (
                 const fileName& fName,
-                const meshedSurface& surf
+                const MeshedSurface<Face>& surf
             ),
             (fName, surf)
         );
 
         //- Write to file
-        static void write(const fileName&, const meshedSurface&);
+        static void write(const fileName&, const MeshedSurface<Face>&);
 
 
     // Member Functions
@@ -300,25 +297,25 @@ public:
         //- Return the number of faces
         label nFaces() const
         {
-            return MeshStorage::size();
+            return ParentType::size();
         }
 
         //- The surface size is the number of faces
         label size() const
         {
-            return MeshStorage::size();
+            return ParentType::size();
         }
 
         //- Return const access to global points
         const pointField& points() const
         {
-            return MeshStorage::points();
+            return ParentType::points();
         }
 
         //- Return const access to the faces
-        const List<FaceType>& faces() const
+        const List<Face>& faces() const
         {
-            return static_cast<const List<FaceType> &>(*this);
+            return static_cast<const List<Face> &>(*this);
         }
 
         const surfGroupList& patches() const
@@ -358,7 +355,7 @@ public:
 
         //- Return new surface.
         // Returns pointMap, faceMap from subsetMeshMap
-        meshedSurface subsetMesh
+        MeshedSurface subsetMesh
         (
             const UList<bool>& include,
             labelList& pointMap,
@@ -366,29 +363,20 @@ public:
         ) const;
 
         //- Transfer the contents of the argument and annull the argument
-        void transfer(meshedSurface&);
+        void transfer(MeshedSurface<Face>&);
 
         //- Transfer the contents of the argument and annull the argument
-        void transfer(keyedSurface&);
+        void transfer(UnsortedMeshedSurface<Face>&);
 
 
     // Read
 
         //- Read from file. Chooses reader based on explicit extension
-        bool read
-        (
-            const fileName&,
-            const word& ext,
-            const bool triangulate=false
-        );
+        bool read(const fileName&, const word& ext);
 
 
         //- Read from file. Chooses reader based on detected extension
-        virtual bool read
-        (
-            const fileName&,
-            const bool triangulate=false
-        );
+        virtual bool read(const fileName&);
 
 
     // Write
@@ -411,11 +399,16 @@ public:
 
     // Member operators
 
-        void operator=(const meshedSurface&);
+        void operator=(const MeshedSurface<Face>&);
 
     // Ostream Operator
 
-        friend Ostream& operator<<(Ostream&, const meshedSurface&);
+        friend Ostream& operator<<
+        <Face>
+        (
+            Ostream&,
+            const MeshedSurface<Face>&
+        );
 };
 
 
@@ -425,6 +418,12 @@ public:
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
+#ifdef NoRepository
+#   include "MeshedSurface.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
 #endif
 
 // ************************************************************************* //
diff --git a/src/surfMesh/meshedSurface/meshedSurfaceCleanup.C b/src/surfMesh/MeshedSurface/MeshedSurfaceCleanup.C
similarity index 86%
rename from src/surfMesh/meshedSurface/meshedSurfaceCleanup.C
rename to src/surfMesh/MeshedSurface/MeshedSurfaceCleanup.C
index e39784834c..c6642f17e9 100644
--- a/src/surfMesh/meshedSurface/meshedSurfaceCleanup.C
+++ b/src/surfMesh/MeshedSurface/MeshedSurfaceCleanup.C
@@ -24,24 +24,29 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-#include "meshedSurface.H"
+#include "MeshedSurface.H"
 #include "mergePoints.H"
-#include "triFace.H"
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
 // Remove badly degenerate faces, double faces.
-void Foam::meshedSurface::cleanup(const bool verbose)
+template<class Face>
+void Foam::MeshedSurface<Face>::cleanup(const bool verbose)
 {
     // merge points (already done for STL, TRI)
     stitchFaces(SMALL, verbose);
 
     checkFaces(verbose);
-    checkEdges(verbose);
+    ParentType::checkEdges(verbose);
 }
 
 
-bool Foam::meshedSurface::stitchFaces(const scalar tol, const bool verbose)
+template<class Face>
+bool Foam::MeshedSurface<Face>::stitchFaces
+(
+    const scalar tol,
+    const bool verbose
+)
 {
     pointField& pointLst = points();
 
@@ -58,14 +63,14 @@ bool Foam::meshedSurface::stitchFaces(const scalar tol, const bool verbose)
 
     if (verbose)
     {
-        Info<< "meshedSurface::stitchFaces : Renumbering all faces"
+        Info<< "MeshedSurface::stitchFaces : Renumbering all faces"
             << endl;
     }
 
     // Set the coordinates to the merged ones
     pointLst.transfer(newPoints);
 
-    List<FaceType>& faceLst = faces();
+    List<Face>& faceLst = faces();
 
     // ensure we have at some patches, and they cover all the faces
     checkPatches();
@@ -83,7 +88,7 @@ bool Foam::meshedSurface::stitchFaces(const scalar tol, const bool verbose)
         label patchEnd = oldFaceI + p.size();
         for (; oldFaceI < patchEnd; ++oldFaceI)
         {
-            FaceType& f = faceLst[oldFaceI];
+            Face& f = faceLst[oldFaceI];
             forAll (f, fp)
             {
                 f[fp] = pointMap[f[fp]];
@@ -99,7 +104,7 @@ bool Foam::meshedSurface::stitchFaces(const scalar tol, const bool verbose)
             }
             else if (verbose)
             {
-                Pout<< "meshedSurface::stitchFaces : "
+                Pout<< "MeshedSurface::stitchFaces : "
                     << "Removing collapsed face " << oldFaceI << endl
                     << "    vertices   :" << f << endl;
             }
@@ -113,7 +118,7 @@ bool Foam::meshedSurface::stitchFaces(const scalar tol, const bool verbose)
     {
         if (verbose)
         {
-            Pout<< "meshedSurface::stitchFaces : "
+            Pout<< "MeshedSurface::stitchFaces : "
                 << "Removed " << faceLst.size() - newFaceI
                 << " faces" << endl;
         }
@@ -122,7 +127,7 @@ bool Foam::meshedSurface::stitchFaces(const scalar tol, const bool verbose)
 
 
     // Merging points might have changed geometric factors
-    MeshStorage::clearOut();
+    ParentType::clearOut();
 
     return true;
 }
@@ -130,23 +135,24 @@ bool Foam::meshedSurface::stitchFaces(const scalar tol, const bool verbose)
 
 
 // Remove badly degenerate faces and double faces.
-void Foam::meshedSurface::checkFaces(const bool verbose)
+template<class Face>
+void Foam::MeshedSurface<Face>::checkFaces(const bool verbose)
 {
     // Simple check on indices ok.
     const label maxPointI = points().size() - 1;
 
-    List<FaceType>& faceLst = faces();
+    List<Face>& faceLst = faces();
 
     // Phase 0: detect badly labelled faces
     forAll (faceLst, faceI)
     {
-        const FaceType& f = faceLst[faceI];
+        const Face& f = faceLst[faceI];
 
         forAll (f, fp)
         {
             if (f[fp] < 0 || f[fp] > maxPointI)
             {
-                FatalErrorIn("meshedSurface::checkFaces(bool)")
+                FatalErrorIn("MeshedSurface::checkFaces(bool)")
                     << "face " << f
                     << " uses point indices outside point range 0.."
                     << maxPointI
@@ -160,7 +166,7 @@ void Foam::meshedSurface::checkFaces(const bool verbose)
 
     // Phase 1: find and skip over invalid faces
     // Phase 2: pack
-    const labelListList& fFaces = faceFaces();
+    const labelListList& fFaces = ParentType::faceFaces();
 
     label oldFaceI = 0;
     label newFaceI = 0;
@@ -174,7 +180,7 @@ void Foam::meshedSurface::checkFaces(const bool verbose)
         label patchEnd = oldFaceI + p.size();
         for (; oldFaceI < patchEnd; ++oldFaceI)
         {
-            FaceType& f = faceLst[oldFaceI];
+            Face& f = faceLst[oldFaceI];
 
             // 'degenerate' face check
             if (f.collapse() >= 3)
@@ -203,7 +209,7 @@ void Foam::meshedSurface::checkFaces(const bool verbose)
                         {
                             WarningIn
                             (
-                                "meshedSurface::checkFaces(bool verbose)"
+                                "MeshedSurface::checkFaces(bool verbose)"
                             )   << "faces share the same vertices:\n"
                                 << "    face 1 :" << oldFaceI << endl;
                             // printFace(Warning, "    ", f, points());
@@ -232,7 +238,7 @@ void Foam::meshedSurface::checkFaces(const bool verbose)
             {
                 WarningIn
                 (
-                    "meshedSurface::checkFaces(bool verbose)"
+                    "MeshedSurface::checkFaces(bool verbose)"
                 )   << "face " << oldFaceI
                     << " has fewer than three unique vertices:\n";
                 // printTriangle(Warning, "    ", f, points());
@@ -249,22 +255,23 @@ void Foam::meshedSurface::checkFaces(const bool verbose)
         {
             WarningIn
             (
-                "meshedSurface::checkFaces(bool verbose)"
+                "MeshedSurface::checkFaces(bool verbose)"
             )   << "Removed " << faceLst.size() - newFaceI
                 << " illegal faces." << endl;
         }
         faceLst.setSize(newFaceI);
 
         // Topology can change because of renumbering
-        MeshStorage::clearOut();
+        ParentType::clearOut();
     }
 }
 
 
-Foam::label Foam::meshedSurface::triangulate()
+template<class Face>
+Foam::label Foam::MeshedSurface<Face>::triangulate()
 {
     label nTri = 0;
-    List<FaceType>& faceLst = faces();
+    List<Face>& faceLst = faces();
 
     // determine how many triangles are needed
     forAll (faceLst, faceI)
@@ -278,7 +285,7 @@ Foam::label Foam::meshedSurface::triangulate()
         return 0;
     }
 
-    List<FaceType> newFaces(nTri);
+    List<Face> newFaces(nTri);
 
     // note the number of *additional* faces
     nTri -= faceLst.size();
@@ -296,7 +303,7 @@ Foam::label Foam::meshedSurface::triangulate()
         label patchEnd = oldFaceI + p.size();
         for (; oldFaceI < patchEnd; ++oldFaceI)
         {
-            const FaceType& f = faceLst[oldFaceI];
+            const Face& f = faceLst[oldFaceI];
             triFace fTri;
 
             // Do simple face triangulation around f[0].
diff --git a/src/surfMesh/MeshedSurface/MeshedSurfaceIO.C b/src/surfMesh/MeshedSurface/MeshedSurfaceIO.C
new file mode 100644
index 0000000000..cc0d8efd41
--- /dev/null
+++ b/src/surfMesh/MeshedSurface/MeshedSurfaceIO.C
@@ -0,0 +1,125 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+\*---------------------------------------------------------------------------*/
+
+#include "MeshedSurface.H"
+#include "UnsortedMeshedSurface.H"
+#include "IFstream.H"
+#include "OFstream.H"
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+// Read surf grouping, points, faces directly from Istream
+template<class Face>
+bool Foam::MeshedSurface<Face>::read(Istream& is)
+{
+    clear();
+
+    // triangulation required?
+    bool mustTriangulate = false;
+    {
+        Face f;
+        if (f.max_size() == 3)
+        {
+            mustTriangulate = true;
+        }
+    }
+
+    List<surfGroup> patchLst(is);
+
+    // copy and set the indices
+    patches_.setSize(patchLst.size());
+    forAll(patchLst, patchI)
+    {
+        patches_[patchI] = surfGroup
+        (
+            patchLst[patchI],
+            patchI
+        );
+    }
+
+    // read points:
+    is >> points();
+
+    // read faces:
+    // TODO - specialization to triangulate on-the-fly
+    if (mustTriangulate)
+    {
+        is >> faces();
+    }
+    else
+    {
+        is >> faces();
+    }
+
+    return is.good();
+}
+
+
+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
+        << "// regions:" << nl
+        << patches_.size() << nl << token::BEGIN_LIST << incrIndent << nl;
+
+    forAll(patches_, patchI)
+    {
+        patches_[patchI].writeDict(os);
+    }
+    os  << decrIndent << token::END_LIST << nl;
+
+    IOobject::writeDivider(os);
+
+    // Note: Write with global point numbering
+    os  << "\n// points:" << nl << points() << nl;
+
+    IOobject::writeDivider(os);
+    os  << "\n// faces:"  << nl << 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/newMeshedSurface.C b/src/surfMesh/MeshedSurface/MeshedSurfaceNew.C
similarity index 66%
rename from src/surfMesh/meshedSurface/newMeshedSurface.C
rename to src/surfMesh/MeshedSurface/MeshedSurfaceNew.C
index a1142e8f04..4eb86d92e4 100644
--- a/src/surfMesh/meshedSurface/newMeshedSurface.C
+++ b/src/surfMesh/MeshedSurface/MeshedSurfaceNew.C
@@ -24,50 +24,49 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-#include "keyedSurface.H"
-#include "meshedSurface.H"
+#include "MeshedSurface.H"
+#include "UnsortedMeshedSurface.H"
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
-// all input is indirect via keyedSurface
-Foam::autoPtr<Foam::meshedSurface>
-Foam::meshedSurface::New
+// all input is indirect via UnsortedMeshedSurface
+template<class Face>
+Foam::autoPtr<Foam::MeshedSurface<Face> >
+Foam::MeshedSurface<Face>::New
 (
     const fileName& fName,
-    const word& ext,
-    const bool triangulate
+    const word& ext
 )
 {
     if (debug)
     {
-        Info<< "meshedSurface::New(const fileName&, const word&, const bool) : "
-               "constructing meshedSurface"
+        Info<< "MeshedSurface::New(const fileName&, const word&) : "
+            "constructing MeshedSurface"
             << endl;
     }
 
-    // created indirectly via keyedSurface
-    autoPtr<meshedSurface> surf(new meshedSurface);
-    surf().transfer( keyedSurface::New(fName,ext,triangulate)() );
+    // created indirectly via UnsortedMeshedSurface
+    autoPtr<MeshedSurface<Face> > surf(new MeshedSurface<Face>);
+    surf().transfer( UnsortedMeshedSurface<Face>::New(fName,ext)() );
 
     return surf;
 }
 
-
-Foam::autoPtr<Foam::meshedSurface>
-Foam::meshedSurface::New
+template<class Face>
+Foam::autoPtr<Foam::MeshedSurface<Face> >
+Foam::MeshedSurface<Face>::New
 (
-    const fileName& fName,
-    const bool triangulate
+    const fileName& fName
 )
 {
     if (debug)
     {
-        Info<< "meshedSurface::New(const fileName&, const bool) : "
-               "constructing meshedSurface"
+        Info<< "MeshedSurface::New(const fileName&) : "
+            "constructing MeshedSurface"
             << endl;
     }
 
-    return New(fName, fName.ext(), triangulate);
+    return New(fName, fName.ext());
 }
 
 // ************************************************************************* //
diff --git a/src/surfMesh/MeshedSurface/MeshedSurfaces.C b/src/surfMesh/MeshedSurface/MeshedSurfaces.C
new file mode 100644
index 0000000000..e6d7c3856f
--- /dev/null
+++ b/src/surfMesh/MeshedSurface/MeshedSurfaces.C
@@ -0,0 +1,48 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+\*---------------------------------------------------------------------------*/
+
+#include "MeshedSurfaces.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+#define makeMeshedSurface(surfaceType)                                        \
+defineNamedTemplateTypeNameAndDebug(surfaceType, 0);                          \
+defineTemplateMemberFunctionSelectionTable(surfaceType,write,fileExtension);  \
+defineTemplateRunTimeSelectionTable(surfaceType, fileExtension);
+
+makeMeshedSurface(meshedSurface)
+makeMeshedSurface(triMeshedSurface)
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// ************************************************************************* //
diff --git a/src/surfMesh/MeshedSurface/MeshedSurfaces.H b/src/surfMesh/MeshedSurface/MeshedSurfaces.H
new file mode 100644
index 0000000000..1f205bbb32
--- /dev/null
+++ b/src/surfMesh/MeshedSurface/MeshedSurfaces.H
@@ -0,0 +1,35 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef MeshedSurfaces_H
+#define MeshedSurfaces_H
+
+#include "MeshedSurface.H"
+#include "MeshedSurfacesFwd.H"
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/surfMesh/MeshedSurface/MeshedSurfacesFwd.H b/src/surfMesh/MeshedSurface/MeshedSurfacesFwd.H
new file mode 100644
index 0000000000..dbf9923223
--- /dev/null
+++ b/src/surfMesh/MeshedSurface/MeshedSurfacesFwd.H
@@ -0,0 +1,53 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef MeshedSurfacesFwd_H
+#define MeshedSurfacesFwd_H
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+class face;
+class triFace;
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+template<class Face> class MeshedSurface;
+
+typedef MeshedSurface<face>    meshedSurface;
+typedef MeshedSurface<triFace> triMeshedSurface;
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/surfMesh/keyedSurface/keyedSurface.C b/src/surfMesh/UnsortedMeshedSurface/UnsortedMeshedSurface.C
similarity index 66%
rename from src/surfMesh/keyedSurface/keyedSurface.C
rename to src/surfMesh/UnsortedMeshedSurface/UnsortedMeshedSurface.C
index b6a0497cf5..1e20018eae 100644
--- a/src/surfMesh/keyedSurface/keyedSurface.C
+++ b/src/surfMesh/UnsortedMeshedSurface/UnsortedMeshedSurface.C
@@ -24,14 +24,12 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-#include "keyedSurface.H"
-#include "meshedSurface.H"
-#include "demandDrivenData.H"
+#include "MeshedSurface.H"
+#include "UnsortedMeshedSurface.H"
 #include "IFstream.H"
 #include "OFstream.H"
 #include "Time.H"
 #include "boundBox.H"
-#include "SortableList.H"
 #include "polyBoundaryMesh.H"
 #include "polyMesh.H"
 #include "primitivePatch.H"
@@ -39,27 +37,14 @@ License
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-namespace Foam
-{
-defineTypeNameAndDebug(keyedSurface, 0);
-defineRunTimeSelectionTable(keyedSurface, fileExtension);
-defineMemberFunctionSelectionTable
-(
-    keyedSurface,
-    write,
-    fileExtension
-);
-
-}
-
-//  File extension for 'native' raw format
-//! @cond localscope
-const char * const nativeExt = "ofs";
-//! @endcond localscope
+// File extension for 'native' raw format
+#undef  nativeSurfaceExt
+#define nativeSurfaceExt "ofs"
 
 // * * * * * * * * * * * * * Static Member Functions * * * * * * * * * * * * //
 
-Foam::string Foam::keyedSurface::getLineNoComment(IFstream& is)
+template<class Face>
+Foam::string Foam::UnsortedMeshedSurface<Face>::getLineNoComment(IFstream& is)
 {
     string line;
     do
@@ -71,10 +56,10 @@ Foam::string Foam::keyedSurface::getLineNoComment(IFstream& is)
     return line;
 }
 
-
-Foam::fileName Foam::keyedSurface::triSurfInstance(const Time& d)
+template<class Face>
+Foam::fileName Foam::UnsortedMeshedSurface<Face>::triSurfInstance(const Time& d)
 {
-    fileName foamName(d.caseName() + "." + nativeExt);
+    fileName foamName(d.caseName() + "." + nativeSurfaceExt);
 
     // Search back through the time directories list to find the time
     // closest to and lower than current time
@@ -101,7 +86,7 @@ Foam::fileName Foam::keyedSurface::triSurfInstance(const Time& d)
             {
                 if (debug)
                 {
-                    Pout<< " keyedSurface::triSurfInstance(const Time& d)"
+                    Pout<< " UnsortedMeshedSurface::triSurfInstance(const Time& d)"
                         << "reading " << foamName
                         << " from " << ts[j].name()/typeName
                         << endl;
@@ -114,7 +99,7 @@ Foam::fileName Foam::keyedSurface::triSurfInstance(const Time& d)
 
     if (debug)
     {
-        Pout<< " keyedSurface::triSurfInstance(const Time& d)"
+        Pout<< " UnsortedMeshedSurface::triSurfInstance(const Time& d)"
             << "reading " << foamName
             << " from constant/" << endl;
     }
@@ -123,9 +108,10 @@ Foam::fileName Foam::keyedSurface::triSurfInstance(const Time& d)
 }
 
 
-Foam::fileName Foam::keyedSurface::triSurfName(const Time& d)
+template<class Face>
+Foam::fileName Foam::UnsortedMeshedSurface<Face>::triSurfName(const Time& d)
 {
-    fileName foamName(d.caseName() + "." + nativeExt);
+    fileName foamName(d.caseName() + "." + nativeSurfaceExt);
 
     // Search back through the time directories list to find the time
     // closest to and lower than current time
@@ -154,7 +140,7 @@ Foam::fileName Foam::keyedSurface::triSurfName(const Time& d)
             {
                 if (debug)
                 {
-                    Pout<< " keyedSurface::triSurfName(const Time& d)"
+                    Pout<< " UnsortedMeshedSurface::triSurfName(const Time& d)"
                         << "reading " << foamName
                         << " from " << ts[j].name()/typeName
                         << endl;
@@ -167,7 +153,7 @@ Foam::fileName Foam::keyedSurface::triSurfName(const Time& d)
 
     if (debug)
     {
-        Pout<< " keyedSurface::triSurfName(const Time& d)"
+        Pout<< " UnsortedMeshedSurface::triSurfName(const Time& d)"
             << "reading " << foamName
             << " from constant/" << endl;
     }
@@ -176,7 +162,12 @@ Foam::fileName Foam::keyedSurface::triSurfName(const Time& d)
 }
 
 
-bool Foam::keyedSurface::canRead(const word& ext, const bool verbose)
+template<class Face>
+bool Foam::UnsortedMeshedSurface<Face>::canRead
+(
+    const word& ext,
+    const bool verbose
+)
 {
     // perhaps sent an entire name
     word fExt(ext);
@@ -188,12 +179,12 @@ bool Foam::keyedSurface::canRead(const word& ext, const bool verbose)
     }
 
     // handle 'native' format directly
-    if (fExt == nativeExt)
+    if (fExt == nativeSurfaceExt)
     {
         return true;
     }
 
-    fileExtensionConstructorTable::iterator cstrIter =
+    typename fileExtensionConstructorTable::iterator cstrIter =
         fileExtensionConstructorTablePtr_->find(fExt);
 
     // would be nice to have information about which format this actually is
@@ -208,7 +199,7 @@ bool Foam::keyedSurface::canRead(const word& ext, const bool verbose)
 
             Info<<"Unknown file extension for reading: " << fExt << nl;
             // compact output:
-            Info<<"Valid types: ( " << nativeExt;
+            Info<<"Valid types: ( " << nativeSurfaceExt;
             forAll(known, i)
             {
                 Info<<" " << known[i];
@@ -222,7 +213,12 @@ bool Foam::keyedSurface::canRead(const word& ext, const bool verbose)
 }
 
 
-bool Foam::keyedSurface::canWrite(const word& ext, const bool verbose)
+template<class Face>
+bool Foam::UnsortedMeshedSurface<Face>::canWrite
+(
+    const word& ext,
+    const bool verbose
+)
 {
     // perhaps sent an entire name
     word fExt(ext);
@@ -234,12 +230,12 @@ bool Foam::keyedSurface::canWrite(const word& ext, const bool verbose)
     }
 
     // handle 'native' format directly
-    if (fExt == nativeExt)
+    if (fExt == nativeSurfaceExt)
     {
         return true;
     }
 
-    writefileExtensionMemberFunctionTable::iterator mfIter =
+    typename writefileExtensionMemberFunctionTable::iterator mfIter =
         writefileExtensionMemberFunctionTablePtr_->find(fExt);
 
     if (mfIter == writefileExtensionMemberFunctionTablePtr_->end())
@@ -253,7 +249,7 @@ bool Foam::keyedSurface::canWrite(const word& ext, const bool verbose)
 
             Info<<"Unknown file extension for writing: " << fExt << nl;
             // compact output:
-            Info<<"Valid types: ( " << nativeExt;
+            Info<<"Valid types: ( " << nativeSurfaceExt;
             forAll(known, i)
             {
                 Info<<" " << known[i];
@@ -268,51 +264,53 @@ bool Foam::keyedSurface::canWrite(const word& ext, const bool verbose)
 }
 
 
-void Foam::keyedSurface::write
+template<class Face>
+void Foam::UnsortedMeshedSurface<Face>::write
 (
     const fileName& fName,
-    const keyedSurface& surf
+    const UnsortedMeshedSurface<Face>& surf
 )
 {
     if (debug)
     {
-        Info<< "keyedSurface::write(const fileName&, const keyedSurface&) : "
-               "writing keyedSurface to " << fName
+        Info<< "UnsortedMeshedSurface::write(const fileName&, const UnsortedMeshedSurface&) : "
+               "writing UnsortedMeshedSurface to " << fName
             << endl;
     }
 
     const word ext = fName.ext();
 
     // handle 'native' format directly
-    if (ext == nativeExt)
+    if (ext == nativeSurfaceExt)
     {
         surf.write(OFstream(fName)());
+        return;
     }
-    else
+
+    typename writefileExtensionMemberFunctionTable::iterator mfIter =
+        writefileExtensionMemberFunctionTablePtr_->find(ext);
+
+    if (mfIter == writefileExtensionMemberFunctionTablePtr_->end())
     {
-        writefileExtensionMemberFunctionTable::iterator mfIter =
-            writefileExtensionMemberFunctionTablePtr_->find(ext);
-
-        if (mfIter == writefileExtensionMemberFunctionTablePtr_->end())
-        {
-            FatalErrorIn
-            (
-                "keyedSurface::write(const fileName&, const keyedSurface&)"
-            )   << "Unknown file extension " << ext << nl << nl
-                << "Valid types are :" << endl
-                << writefileExtensionMemberFunctionTablePtr_->toc()
-                << exit(FatalError);
-        }
-
-        mfIter()(fName, surf);
+        FatalErrorIn
+        (
+            "UnsortedMeshedSurface::write"
+            "(const fileName&, const UnsortedMeshedSurface&)"
+        )   << "Unknown file extension " << ext << nl << nl
+            << "Valid types are :" << endl
+            << writefileExtensionMemberFunctionTablePtr_->toc()
+            << exit(FatalError);
     }
+
+    mfIter()(fName, surf);
 }
 
 
 // Returns patch info.
 // Sets faceMap to the indexing according to patch numbers.
 // Patch numbers start at 0.
-Foam::surfGroupList Foam::keyedSurface::sortedRegions
+template<class Face>
+Foam::surfGroupList Foam::UnsortedMeshedSurface<Face>::sortedRegions
 (
     const UList<label>& regionLst,
     const Map<word>& patchNames,
@@ -396,21 +394,23 @@ Foam::surfGroupList Foam::keyedSurface::sortedRegions
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
-Foam::keyedSurface::keyedSurface()
+template<class Face>
+Foam::UnsortedMeshedSurface<Face>::UnsortedMeshedSurface()
 :
-    MeshStorage(List<FaceType>(), pointField())
+    ParentType(List<Face>(), pointField())
 {}
 
 
-Foam::keyedSurface::keyedSurface
+template<class Face>
+Foam::UnsortedMeshedSurface<Face>::UnsortedMeshedSurface
 (
     const xfer<pointField>& pointLst,
-    const xfer<List<face> >& faceLst,
+    const xfer<List<Face> >& faceLst,
     const xfer<List<label> >& regionIds,
     const xfer<surfPatchIdentifierList>& patchLst
 )
 :
-    MeshStorage(List<FaceType>(), pointField()),
+    ParentType(List<Face>(), pointField()),
     regions_(regionIds),
     patches_(patchLst)
 {
@@ -419,15 +419,16 @@ Foam::keyedSurface::keyedSurface
 }
 
 
-Foam::keyedSurface::keyedSurface
+template<class Face>
+Foam::UnsortedMeshedSurface<Face>::UnsortedMeshedSurface
 (
     const xfer<pointField>& pointLst,
-    const xfer<List<face> >& faceLst,
+    const xfer<List<Face> >& faceLst,
     const xfer<List<label> >& regionIds,
     const Map<word>& regionNames
 )
 :
-    MeshStorage(List<FaceType>(), pointField()),
+    ParentType(List<Face>(), pointField()),
     regions_(regionIds)
 {
     faces().transfer(faceLst());
@@ -446,15 +447,16 @@ Foam::keyedSurface::keyedSurface
 }
 
 
-Foam::keyedSurface::keyedSurface
+template<class Face>
+Foam::UnsortedMeshedSurface<Face>::UnsortedMeshedSurface
 (
     const xfer<pointField>& pointLst,
-    const xfer<List<face> >& faceLst,
+    const xfer<List<Face> >& faceLst,
     const xfer<List<label> >& regionIds,
     const HashTable<label>& labelToRegion
 )
 :
-    MeshStorage(List<FaceType>(), pointField()),
+    ParentType(List<Face>(), pointField()),
     regions_(regionIds)
 {
     points().transfer(pointLst());
@@ -465,13 +467,14 @@ Foam::keyedSurface::keyedSurface
 }
 
 
-Foam::keyedSurface::keyedSurface
+template<class Face>
+Foam::UnsortedMeshedSurface<Face>::UnsortedMeshedSurface
 (
     const xfer<pointField>& pointLst,
-    const xfer<List<face> >& faceLst
+    const xfer<List<Face> >& faceLst
 )
 :
-    MeshStorage(List<FaceType>(), pointField()),
+    ParentType(List<Face>(), pointField()),
     regions_(faceLst().size(), 0),     // single default patch
     patches_()
 {
@@ -482,14 +485,15 @@ Foam::keyedSurface::keyedSurface
 }
 
 
-
-Foam::keyedSurface::keyedSurface
+#if 0
+template<class Face>
+Foam::UnsortedMeshedSurface<Face>::UnsortedMeshedSurface
 (
     const polyBoundaryMesh& bMesh,
     const bool useGlobalPoints
 )
 :
-    MeshStorage(List<FaceType>(), pointField())
+    ParentType(List<Face>(), pointField())
 {
     const polyMesh& mesh = bMesh.mesh();
     const polyPatchList& bPatches = bMesh;
@@ -500,7 +504,7 @@ Foam::keyedSurface::keyedSurface
     // Get patch for all of outside
     primitivePatch allBoundary
     (
-        SubList<face>
+        SubList<Face>
         (
             mesh.faces(),
             mesh.nFaces() - nIntFaces,
@@ -509,8 +513,8 @@ Foam::keyedSurface::keyedSurface
         mesh.points()
     );
 
-    List<FaceType> newFaces(allBoundary.size());
-    List<label>    newRegions(allBoundary.size());
+    List<Face>  newFaces(allBoundary.size());
+    List<label> newRegions(allBoundary.size());
 
     if (useGlobalPoints)
     {
@@ -524,7 +528,7 @@ Foam::keyedSurface::keyedSurface
     }
 
     // global or local face addressing
-    const List<face>& bfaces =
+    const List<Face>& bfaces =
     (
         useGlobalPoints
       ? allBoundary
@@ -554,20 +558,23 @@ Foam::keyedSurface::keyedSurface
     regions_.transfer(newRegions);
     patches_.transfer(newPatches);
 }
+#endif
 
 
-Foam::keyedSurface::keyedSurface
+#if 0
+template<class Face>
+Foam::UnsortedMeshedSurface<Face>::UnsortedMeshedSurface
 (
-    const meshedSurface& surf
+    const MeshedSurface<Face>& surf
 )
 :
-    MeshStorage(List<FaceType>(), surf.points())
+    ParentType(List<Face>(), surf.points())
 {
-    const List<face>& origFaces = surf.faces();
+    const List<Face>&   origFaces = surf.faces();
     const surfGroupList& patchLst = surf.patches();
 
-    List<FaceType> newFaces(origFaces.size());
-    List<label>    newRegions(origFaces.size());
+    List<Face>   newFaces(origFaces.size());
+    List<label>  newRegions(origFaces.size());
     List<PatchRegionType> newPatches(patchLst.size());
 
     label faceIndex = 0;
@@ -586,123 +593,106 @@ Foam::keyedSurface::keyedSurface
     regions_.transfer(newRegions);
     patches_.transfer(newPatches);
 }
+#endif
 
-
-Foam::keyedSurface::keyedSurface
+template<class Face>
+Foam::UnsortedMeshedSurface<Face>::UnsortedMeshedSurface
 (
     const fileName& fName,
-    const word& ext,
-    const bool triangulate
+    const word& ext
 )
 :
-    MeshStorage(List<FaceType>(), pointField())
+    ParentType(List<Face>(), pointField())
 {
-    read(fName, ext, triangulate);
+    read(fName, ext);
 }
 
 
-Foam::keyedSurface::keyedSurface
+template<class Face>
+Foam::UnsortedMeshedSurface<Face>::UnsortedMeshedSurface
 (
-    const fileName& fName,
-    const bool triangulate
+    const fileName& fName
 )
 :
-    MeshStorage(List<FaceType>(), pointField())
+    ParentType(List<Face>(), pointField())
 {
-    read(fName, fName.ext(), triangulate);
+    read(fName, fName.ext());
 }
 
 
-Foam::keyedSurface::keyedSurface(Istream& is, const bool triangulate)
+template<class Face>
+Foam::UnsortedMeshedSurface<Face>::UnsortedMeshedSurface
+(
+    Istream& is
+)
 :
-    MeshStorage(List<FaceType>(), pointField())
+    ParentType(List<Face>(), pointField())
 {
-    read(is, triangulate);
+    read(is);
 }
 
 
-Foam::keyedSurface::keyedSurface(const Time& d)
+template<class Face>
+Foam::UnsortedMeshedSurface<Face>::UnsortedMeshedSurface(const Time& d)
 :
-    MeshStorage(List<FaceType>(), pointField())
+    ParentType(List<Face>(), pointField())
 {
     read(IFstream(triSurfName(d))());
 }
 
 
-Foam::keyedSurface::keyedSurface(const keyedSurface& surf)
+template<class Face>
+Foam::UnsortedMeshedSurface<Face>::UnsortedMeshedSurface
+(
+    const UnsortedMeshedSurface<Face>& surf
+)
 :
-    MeshStorage(surf.faces(), surf.points()),
+    ParentType(surf.faces(), surf.points()),
     regions_(surf.regions_),
     patches_(surf.patches_)
 {}
 
 
-Foam::keyedSurface::keyedSurface(const xfer<keyedSurface>& surf)
+template<class Face>
+Foam::UnsortedMeshedSurface<Face>::UnsortedMeshedSurface
+(
+    const xfer<UnsortedMeshedSurface<Face> >& surf
+)
 :
-    MeshStorage(List<FaceType>(), pointField()),
+    ParentType(List<Face>(), pointField()),
     regions_(),
     patches_()
 {
     transfer(surf());
 }
 
-
-Foam::keyedSurface::keyedSurface(const xfer<meshedSurface>& surf)
+#if 0
+template<class Face>
+Foam::UnsortedMeshedSurface<Face>::UnsortedMeshedSurface
+(
+    const xfer<MeshedSurface<Face> >& surf
+)
 :
-    MeshStorage(List<FaceType>(), pointField()),
+    ParentType(List<Face>(), pointField()),
     regions_(),
     patches_()
 {
     transfer(surf());
 }
-
+#endif
 
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
-Foam::keyedSurface::~keyedSurface()
+template<class Face>
+Foam::UnsortedMeshedSurface<Face>::~UnsortedMeshedSurface()
 {}
 
 // * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * * //
 
-// Read surf grouping, points, faces directly from Istream
-bool Foam::keyedSurface::read(Istream& is, const bool doTriangulate)
-{
-    clear();
-
-    List<surfGroup> patchLst(is);
-    is >> points() >> faces();
-
-    patches_.setSize(patchLst.size());
-    regions_.setSize(size());
-
-    // copy patch info and set regions:
-    label faceIndex = 0;
-    forAll(patchLst, patchI)
-    {
-        patches_[patchI] = PatchRegionType
-        (
-            patchLst[patchI],
-            patchI
-        );
-
-        forAll(patchLst[patchI], patchFaceI)
-        {
-            regions_[faceIndex++] = patchI;
-        }
-    }
-
-    if (doTriangulate)
-    {
-        triangulate();
-    }
-
-    return is.good();
-}
-
-
 // * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
 
-void Foam::keyedSurface::setPatches(const label maxPatch)
+template<class Face>
+void Foam::UnsortedMeshedSurface<Face>::setPatches(const label maxPatch)
 {
     patches_.setSize(maxPatch+1);
 
@@ -717,7 +707,8 @@ void Foam::keyedSurface::setPatches(const label maxPatch)
 }
 
 
-void Foam::keyedSurface::setPatches()
+template<class Face>
+void Foam::UnsortedMeshedSurface<Face>::setPatches()
 {
     label maxPatch = 0;
 
@@ -736,8 +727,8 @@ void Foam::keyedSurface::setPatches()
 }
 
 
-
-void Foam::keyedSurface::setPatches
+template<class Face>
+void Foam::UnsortedMeshedSurface<Face>::setPatches
 (
     const Map<word>& regionNames,
     const label maxPatchHint
@@ -786,7 +777,8 @@ void Foam::keyedSurface::setPatches
 }
 
 
-void Foam::keyedSurface::setPatches
+template<class Face>
+void Foam::UnsortedMeshedSurface<Face>::setPatches
 (
     const HashTable<label>& groupToPatch
 )
@@ -810,16 +802,18 @@ void Foam::keyedSurface::setPatches
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
-void Foam::keyedSurface::setSize(const label s)
+template<class Face>
+void Foam::UnsortedMeshedSurface<Face>::setSize(const label s)
 {
-    MeshStorage::setSize(s);
+    ParentType::setSize(s);
     regions_.setSize(s);
 }
 
 
-void Foam::keyedSurface::clear()
+template<class Face>
+void Foam::UnsortedMeshedSurface<Face>::clear()
 {
-    MeshStorage::clearOut();
+    ParentType::clearOut();
 
     points().clear();
     faces().clear();
@@ -828,7 +822,8 @@ void Foam::keyedSurface::clear()
 }
 
 
-Foam::surfGroupList Foam::keyedSurface::sortedRegions
+template<class Face>
+Foam::surfGroupList Foam::UnsortedMeshedSurface<Face>::sortedRegions
 (
     labelList& faceMap
 ) const
@@ -844,48 +839,50 @@ Foam::surfGroupList Foam::keyedSurface::sortedRegions
 }
 
 
-void Foam::keyedSurface::movePoints(const pointField& newPoints)
+template<class Face>
+void Foam::UnsortedMeshedSurface<Face>::movePoints(const pointField& newPoints)
 {
     // Remove all geometry dependent data
-    MeshStorage::clearTopology();
+    ParentType::clearTopology();
 
     // Adapt for new point position
-    MeshStorage::movePoints(newPoints);
+    ParentType::movePoints(newPoints);
 
     // Copy new points
     points() = newPoints;
 }
 
 
-void Foam::keyedSurface::scalePoints(const scalar& scaleFactor)
+template<class Face>
+void Foam::UnsortedMeshedSurface<Face>::scalePoints(const scalar& scaleFactor)
 {
     // avoid bad scaling
     if (scaleFactor > 0 && scaleFactor != 1.0)
     {
         // Remove all geometry dependent data
-        MeshStorage::clearTopology();
+        ParentType::clearTopology();
 
         // Adapt for new point position
-        MeshStorage::movePoints(pointField());
+        ParentType::movePoints(pointField());
 
         points() *= scaleFactor;
     }
 }
 
 
-
-Foam::keyedSurface Foam::keyedSurface::subsetMesh
+template<class Face>
+Foam::UnsortedMeshedSurface<Face> Foam::UnsortedMeshedSurface<Face>::subsetMesh
 (
     const UList<bool>& include,
     labelList& pointMap,
     labelList& faceMap
 ) const
 {
-    const pointField& locPoints = localPoints();
-    const List<FaceType>& locFaces = localFaces();
+    const pointField& locPoints = ParentType::localPoints();
+    const List<Face>& locFaces  = ParentType::localFaces();
 
     // Fill pointMap, faceMap
-    subsetMap(include, pointMap, faceMap);
+    ParentType::subsetMap(include, pointMap, faceMap);
 
     // Create compact coordinate list and forward mapping array
     pointField newPoints(pointMap.size());
@@ -897,17 +894,17 @@ Foam::keyedSurface Foam::keyedSurface::subsetMesh
     }
 
     // Renumber face node labels and compact
-    List<FaceType> newFaces(faceMap.size());
+    List<Face> newFaces(faceMap.size());
 
     forAll(faceMap, faceI)
     {
         // Get old vertex labels
-        const FaceType& oldFace = locFaces[faceMap[faceI]];
+        const Face& oldFace = locFaces[faceMap[faceI]];
 
-        newFaces[faceI] = FaceType(oldFace);
+        newFaces[faceI] = Face(oldFace);
 
         // Renumber labels for face
-        FaceType& f = newFaces[faceI];
+        Face& f = newFaces[faceI];
         forAll(f, fp)
         {
             f[fp] = oldToNew[oldFace[fp]];
@@ -915,7 +912,7 @@ Foam::keyedSurface Foam::keyedSurface::subsetMesh
     }
 
     // construct a sub-surface
-    keyedSurface subSurf;
+    UnsortedMeshedSurface<Face> subSurf;
     (
         xferMove(newPoints),
         xferMove(newFaces),
@@ -926,7 +923,11 @@ Foam::keyedSurface Foam::keyedSurface::subsetMesh
 }
 
 
-void Foam::keyedSurface::transfer(keyedSurface& surf)
+template<class Face>
+void Foam::UnsortedMeshedSurface<Face>::transfer
+(
+    UnsortedMeshedSurface<Face>& surf
+)
 {
     clear();
 
@@ -939,7 +940,12 @@ void Foam::keyedSurface::transfer(keyedSurface& surf)
 }
 
 
-void Foam::keyedSurface::transfer(meshedSurface& surf)
+#if 0
+template<class Face>
+void Foam::UnsortedMeshedSurface<Face>::transfer
+(
+    MeshedSurface<Face>& surf
+)
 {
     surfGroupList& patchLst = surf.patches();
 
@@ -965,125 +971,81 @@ void Foam::keyedSurface::transfer(meshedSurface& surf)
     patchLst.clear();
     surf.clear();
 }
+#endif
 
 
 // Read from file in given format
-bool Foam::keyedSurface::read
+template<class Face>
+bool Foam::UnsortedMeshedSurface<Face>::read
 (
-    const fileName& fName,
-    const bool triangulate
+    const fileName& fName
 )
 {
     clear();
     const word ext = fName.ext();
 
     // handle 'native' format directly
-    if (ext == nativeExt)
+    if (ext == nativeSurfaceExt)
     {
-        return read(IFstream(fName)(), triangulate);
+        return read(IFstream(fName)());
     }
     else
     {
         // use selector mechanism
-        transfer(New(fName, ext, triangulate)());
+        transfer(New(fName, ext)());
         return true;
     }
 }
 
 
 // Read from file in given format
-bool Foam::keyedSurface::read
+template<class Face>
+bool Foam::UnsortedMeshedSurface<Face>::read
 (
     const fileName& fName,
-    const word& ext,
-    const bool triangulate
+    const word& ext
 )
 {
     clear();
 
     // handle 'native' format directly
-    if (ext == nativeExt)
+    if (ext == nativeSurfaceExt)
     {
-        return read(IFstream(fName)(), triangulate);
+        return read(IFstream(fName)());
     }
     else
     {
         // use selector mechanism
-        transfer(New(fName, ext, triangulate)());
+        transfer(New(fName, ext)());
         return true;
     }
 }
 
 
-// write (sorted)
-void Foam::keyedSurface::write(Ostream& os) const
-{
-    const List<face>& faceLst = faces();
-    labelList faceMap;
-    List<surfGroup> patchLst = sortedRegions(faceMap);
-
-    // just emit some information until we get a nice IOobject
-    IOobject::writeBanner(os);
-    os  << "// OpenFOAM Surface format" << nl
-        << "// ~~~~~~~~~~~~~~~~~~~~~~~" << nl
-        << "// regions:" << nl
-        << patchLst.size() << nl << token::BEGIN_LIST << incrIndent << nl;
-
-    forAll(patchLst, patchI)
-    {
-        patchLst[patchI].writeDict(os);
-    }
-    os  << decrIndent << token::END_LIST << nl;
-
-    IOobject::writeDivider(os);
-
-    // Note: Write with global point numbering
-    os  << "\n// points:" << nl << points() << nl;
-
-    IOobject::writeDivider(os);
-    os  << "\n// faces:"  << nl;
-    os  << faceLst.size() << nl << token::BEGIN_LIST << nl;
-
-    label faceIndex = 0;
-    forAll(patchLst, patchI)
-    {
-        // Print all faces belonging to this region
-        const surfGroup& patch = patchLst[patchI];
-
-        forAll(patch, patchFaceI)
-        {
-            const face& f = faceLst[faceMap[faceIndex++]];
-
-            os  << f << nl;
-        }
-    }
-    os << token::END_LIST << nl;
-
-    IOobject::writeDivider(os);
-
-    // Check state of Ostream
-    os.check("meshedSurface::write(Ostream&)");
-}
-
-
-void Foam::keyedSurface::write(const Time& d) const
+template<class Face>
+void Foam::UnsortedMeshedSurface<Face>::write(const Time& d) const
 {
     write(OFstream(triSurfName(d))());
 }
 
 
-void Foam::keyedSurface::writeStats(Ostream& os) const
+template<class Face>
+void Foam::UnsortedMeshedSurface<Face>::writeStats(Ostream& os) const
 {
-    os  << "Faces        : " << size() << endl
-        << "Edges        : " << nEdges() << endl
-        << "Vertices     : " << nPoints() << endl
-        << "Bounding Box : " << boundBox(localPoints(), false) << endl;
+//    os  << "Faces        : " << size() << endl
+//        << "Edges        : " << nEdges() << endl
+//        << "Vertices     : " << nPoints() << endl
+//        << "Bounding Box : " << boundBox(localPoints(), false) << endl;
 }
 
 
 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
 
-void Foam::keyedSurface::operator=(const keyedSurface& surf)
+template<class Face>
+void Foam::UnsortedMeshedSurface<Face>::operator=
+(
+    const UnsortedMeshedSurface<Face>& surf
+)
 {
     clear();
     faces()  = surf.faces();
@@ -1097,13 +1059,12 @@ void Foam::keyedSurface::operator=(const keyedSurface& surf)
 
 // * * * * * * * * * * * * * * * IOstream Operators  * * * * * * * * * * * * //
 
-Foam::Ostream& Foam::operator<<(Ostream& os, const keyedSurface& surf)
-{
-    surf.write(os);
-    return os;
-}
-
-
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
+#include "UnsortedMeshedSurfaceCleanup.C"
+#include "UnsortedMeshedSurfaceIO.C"
+#include "UnsortedMeshedSurfaceNew.C"
+
+#undef nativeSurfaceExt
+
 // ************************************************************************* //
diff --git a/src/surfMesh/keyedSurface/keyedSurface.H b/src/surfMesh/UnsortedMeshedSurface/UnsortedMeshedSurface.H
similarity index 76%
rename from src/surfMesh/keyedSurface/keyedSurface.H
rename to src/surfMesh/UnsortedMeshedSurface/UnsortedMeshedSurface.H
index 12778e54c2..ac727d7ce7 100644
--- a/src/surfMesh/keyedSurface/keyedSurface.H
+++ b/src/surfMesh/UnsortedMeshedSurface/UnsortedMeshedSurface.H
@@ -23,7 +23,7 @@ License
     Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 
 Class
-    Foam::keyedSurface
+    Foam::UnsortedMeshedSurface
 
 Description
     A surface geometry mesh, in which the patch information is conveyed by
@@ -40,20 +40,21 @@ See Also
     with independent patch information.
 
 SourceFiles
-    keyedSurface.C
+    UnsortedMeshedSurface.C
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef keyedSurface_H
-#define keyedSurface_H
+#ifndef UnsortedMeshedSurface_H
+#define UnsortedMeshedSurface_H
 
 #include "pointField.H"
 #include "PrimitivePatchExtra.H"
 #include "boolList.H"
 #include "surfPatchIdentifierList.H"
 #include "surfGroupList.H"
-#include "face.H"
 #include "xfer.H"
+#include "face.H"
+#include "triFace.H"
 #include "runTimeSelectionTables.H"
 #include "memberFunctionSelectionTables.H"
 
@@ -66,45 +67,45 @@ namespace Foam
 
 class Time;
 class IFstream;
-class keyedSurface;
-class meshedSurface;
+template<class Face> class UnsortedMeshedSurface;
+template<class Face> class MeshedSurface;
+
 class polyBoundaryMesh;
 
-Ostream& operator<<(Ostream&, const keyedSurface&);
+template<class Face>
+    Ostream& operator<<(Ostream&, const UnsortedMeshedSurface<Face>&);
 
 
 /*---------------------------------------------------------------------------*\
-                      Class keyedSurface Declaration
+                      Class UnsortedMeshedSurface Declaration
 \*---------------------------------------------------------------------------*/
 
-class keyedSurface
+template<class Face>
+class UnsortedMeshedSurface
 :
-    public PrimitivePatchExtra<face, ::Foam::List, pointField, point>
+    public PrimitivePatchExtra<Face, ::Foam::List, pointField, point>
 {
-    friend class meshedSurface;
+    friend class MeshedSurface<Face>;
 
 protected:
 
     // Protected Member Data
 
-        //- Typedef for similar code in keyedSurface and meshedSurface
-        typedef face FaceType;
-
         //- Typedef for type holding the region (patch) informationm
         typedef surfPatchIdentifier PatchRegionType;
 
 private:
 
-    // Private typedefs
-
+    //- Private typedefs for convenience
+        typedef UnsortedMeshedSurface<Face> ThisType;
         typedef PrimitivePatchExtra
         <
-            FaceType,
+            Face,
             ::Foam::List,
             pointField,
             point
         >
-        MeshStorage;
+        ParentType;
 
     // Private Member Data
 
@@ -118,10 +119,10 @@ private:
     // Private member functions
 
         //- Disable setSize with value
-        void setSize(const label, const FaceType&);
+        void setSize(const label, const Face&);
 
         //- Read OpenFOAM Surface format
-        bool read(Istream&, const bool triangulate=false);
+        bool read(Istream&);
 
 protected:
 
@@ -130,6 +131,7 @@ protected:
         //- Read non-comment line
         static string getLineNoComment(IFstream&);
 
+
     // Protected Member functions
 
         //- Sets default patch names based on the maximum patch number
@@ -151,13 +153,13 @@ protected:
         //- Return non-const access to global points
         pointField& points()
         {
-            return const_cast<pointField&>(MeshStorage::points());
+            return const_cast<pointField&>(ParentType::points());
         }
 
         //- Return non-const access to the faces
-        List<FaceType>& faces()
+        List<Face>& faces()
         {
-            return static_cast<List<FaceType> &>(*this);
+            return static_cast<List<Face> &>(*this);
         }
 
         //- Return non-const access to the region Ids
@@ -169,14 +171,14 @@ protected:
 public:
 
         //- Runtime type information
-        ClassName("keyedSurface");
+        TypeName("UnsortedMeshedSurface");
 
     // Static
 
-        //- Name of keyedSurface directory to use.
+        //- Name of UnsortedMeshedSurface directory to use.
         static fileName triSurfInstance(const Time&);
 
-        //- Name of keyedSurface directory to use.
+        //- Name of UnsortedMeshedSurface directory to use.
         static fileName triSurfName(const Time&);
 
         //- Can we read this file format?
@@ -197,120 +199,110 @@ public:
     // Constructors
 
         //- Construct null
-        keyedSurface();
+        UnsortedMeshedSurface();
 
         //- Construct by transferring components
         //  (points, faces, region ids, patches).
-        keyedSurface
+        UnsortedMeshedSurface
         (
             const xfer<pointField>&,
-            const xfer<List<face> >&,
+            const xfer<List<Face> >&,
             const xfer<List<label> >& regionIds,
             const xfer<surfPatchIdentifierList>&
         );
 
         //- Construct by transferring points, faces and regionIds
         //  with region names per map or set to default.
-        keyedSurface
+        UnsortedMeshedSurface
         (
             const xfer<pointField>&,
-            const xfer<List<face> >&,
+            const xfer<List<Face> >&,
             const xfer<List<label> >& regionIds,
             const Map<word>& regionNames = Map<word>::null()
         );
 
         //- Construct by transferring points, faces and regionIds
         //  with patch-names from hash
-        keyedSurface
+        UnsortedMeshedSurface
         (
             const xfer<pointField>&,
-            const xfer<List<face> >&,
+            const xfer<List<Face> >&,
             const xfer<List<label> >& regionIds,
             const HashTable<label>& labelToRegion
         );
 
         //- Construct by transferring points, faces.
         //  Set single default patch.
-        keyedSurface
+        UnsortedMeshedSurface
         (
             const xfer<pointField>&,
-            const xfer<List<face> >&
+            const xfer<List<Face> >&
         );
 
+#if 0
         //- Construct from a boundary mesh with local points/faces
-        keyedSurface
+        UnsortedMeshedSurface
         (
             const polyBoundaryMesh&,
             const bool globalPoints=false
         );
+#endif
 
         //- Construct from a meshedSurface
-        keyedSurface(const meshedSurface&);
+        UnsortedMeshedSurface(const MeshedSurface<Face>&);
 
-        //- Construct by transferring the contents from a keyedSurface
-        keyedSurface(const xfer<keyedSurface>&);
+        //- Construct by transferring the contents from a UnsortedMeshedSurface
+        UnsortedMeshedSurface(const xfer<UnsortedMeshedSurface<Face> >&);
 
         //- Construct by transferring the contents from a meshedSurface
-        keyedSurface(const xfer<meshedSurface>&);
+        UnsortedMeshedSurface(const xfer<MeshedSurface<Face> >&);
 
         //- Construct from file name (uses extension to determine type)
-        keyedSurface
-        (
-            const fileName&,
-            const bool triangulate=false
-        );
+        UnsortedMeshedSurface(const fileName&);
 
         //- Construct from file name (uses extension to determine type)
-        keyedSurface
-        (
-            const fileName&,
-            const word&,
-            const bool triangulate=false
-        );
+        UnsortedMeshedSurface(const fileName&, const word&);
 
         //- Construct from Istream
-        keyedSurface(Istream&, const bool triangulate=false);
+        UnsortedMeshedSurface(Istream&);
 
         //- Construct from objectRegistry
-        keyedSurface(const Time&);
+        UnsortedMeshedSurface(const Time&);
 
         //- Construct as copy
-        keyedSurface(const keyedSurface&);
+        UnsortedMeshedSurface(const UnsortedMeshedSurface<Face>&);
 
     // Declare run-time constructor selection table
 
         declareRunTimeSelectionTable
         (
             autoPtr,
-            keyedSurface,
+            UnsortedMeshedSurface,
             fileExtension,
             (
-                const fileName& fName,
-                const bool triangulate
+                const fileName& fName
             ),
-            (fName, triangulate)
+            (fName)
         );
 
     // Selectors
 
         //- Select constructed from filename (implicit extension)
-        static autoPtr<keyedSurface> New
+        static autoPtr<UnsortedMeshedSurface> New
         (
-            const fileName& fName,
-            const bool triangulate=false
+            const fileName&
         );
 
         //- Select constructed from filename (explicit extension)
-        static autoPtr<keyedSurface> New
+        static autoPtr<UnsortedMeshedSurface> New
         (
-            const fileName& fName,
-            const word& ext,
-            const bool triangulate=false
+            const fileName&,
+            const word& ext
         );
 
     // Destructor
 
-        virtual ~keyedSurface();
+        virtual ~UnsortedMeshedSurface();
 
 
     // Member Function Selectors
@@ -318,18 +310,18 @@ public:
         declareMemberFunctionSelectionTable
         (
             void,
-            keyedSurface,
+            UnsortedMeshedSurface,
             write,
             fileExtension,
             (
                 const fileName& fName,
-                const keyedSurface& surf
+                const UnsortedMeshedSurface<Face>& surf
             ),
             (fName, surf)
         );
 
         //- Write to file
-        static void write(const fileName&, const keyedSurface&);
+        static void write(const fileName&, const UnsortedMeshedSurface<Face>&);
 
 
     // Member Functions
@@ -345,13 +337,13 @@ public:
         //- Return the number of faces
         label nFaces() const
         {
-            return MeshStorage::size();
+            return ParentType::size();
         }
 
         //- The surface size is the number of faces
         label size() const
         {
-            return MeshStorage::size();
+            return ParentType::size();
         }
 
         //- Reset size of face and region list
@@ -360,13 +352,13 @@ public:
         //- Return const access to global points
         const pointField& points() const
         {
-            return MeshStorage::points();
+            return ParentType::points();
         }
 
         //- Return const access to the faces
-        const List<FaceType>& faces() const
+        const List<Face>& faces() const
         {
-            return static_cast<const List<FaceType> &>(*this);
+            return static_cast<const List<Face> &>(*this);
         }
 
         //- Return const access to the regions
@@ -415,7 +407,7 @@ public:
 
         //- Return new surface. Returns pointMap, faceMap from
         //  subsetMeshMap
-        keyedSurface subsetMesh
+        UnsortedMeshedSurface subsetMesh
         (
             const UList<bool>& include,
             labelList& pointMap,
@@ -423,27 +415,18 @@ public:
         ) const;
 
         //- Transfer the contents of the argument and annull the argument
-        void transfer(keyedSurface&);
+        void transfer(UnsortedMeshedSurface<Face>&);
 
         //- Transfer the contents of the argument and annull the argument
-        void transfer(meshedSurface&);
+        void transfer(MeshedSurface<Face>&);
 
     // Read
 
         //- Read from file. Chooses reader based on explicit extension
-        bool read
-        (
-            const fileName&,
-            const word& ext,
-            const bool triangulate
-        );
+        bool read(const fileName&, const word& ext);
 
         //- Read from file. Chooses reader based on detected extension
-        virtual bool read
-        (
-            const fileName&,
-            const bool triangulate=false
-        );
+        virtual bool read(const fileName&);
 
     // Write
 
@@ -465,13 +448,17 @@ public:
 
     // Member operators
 
-        void operator=(const keyedSurface&);
+        void operator=(const UnsortedMeshedSurface<Face>&);
 
 
     // Ostream Operator
 
-        // friend Istream& operator>>(Istream&, keyedSurface&);
-        friend Ostream& operator<<(Ostream&, const keyedSurface&);
+        friend Ostream& operator<<
+        <Face>
+        (
+            Ostream&,
+            const UnsortedMeshedSurface<Face>&
+        );
 
 };
 
@@ -482,6 +469,12 @@ public:
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
+#ifdef NoRepository
+#   include "UnsortedMeshedSurface.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
 #endif
 
 // ************************************************************************* //
diff --git a/src/surfMesh/keyedSurface/keyedSurfaceCleanup.C b/src/surfMesh/UnsortedMeshedSurface/UnsortedMeshedSurfaceCleanup.C
similarity index 83%
rename from src/surfMesh/keyedSurface/keyedSurfaceCleanup.C
rename to src/surfMesh/UnsortedMeshedSurface/UnsortedMeshedSurfaceCleanup.C
index 02e6ab6bb1..a617a0550e 100644
--- a/src/surfMesh/keyedSurface/keyedSurfaceCleanup.C
+++ b/src/surfMesh/UnsortedMeshedSurface/UnsortedMeshedSurfaceCleanup.C
@@ -24,24 +24,29 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-#include "keyedSurface.H"
+#include "UnsortedMeshedSurface.H"
 #include "mergePoints.H"
-#include "triFace.H"
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
 // Remove badly degenerate faces, double faces.
-void Foam::keyedSurface::cleanup(const bool verbose)
+template<class Face>
+void Foam::UnsortedMeshedSurface<Face>::cleanup(const bool verbose)
 {
     // merge points (already done for STL, TRI)
     stitchFaces(SMALL, verbose);
 
     checkFaces(verbose);
-    checkEdges(verbose);
+    ParentType::checkEdges(verbose);
 }
 
 
-bool Foam::keyedSurface::stitchFaces(const scalar tol, const bool verbose)
+template<class Face>
+bool Foam::UnsortedMeshedSurface<Face>::stitchFaces
+(
+    const scalar tol,
+    const bool verbose
+)
 {
     pointField& pointLst = points();
 
@@ -58,20 +63,20 @@ bool Foam::keyedSurface::stitchFaces(const scalar tol, const bool verbose)
 
     if (verbose)
     {
-        Info<< "keyedSurface::stitchFaces : Renumbering all faces"
+        Info<< "UnsortedMeshedSurface::stitchFaces : Renumbering all faces"
             << endl;
     }
 
     // Set the coordinates to the merged ones
     pointLst.transfer(newPoints);
 
-    List<FaceType>& faceLst = faces();
+    List<Face>& faceLst = faces();
 
     // Reset the point labels to the unique points array
     label newFaceI = 0;
     forAll (faceLst, faceI)
     {
-        FaceType& f = faceLst[faceI];
+        Face& f = faceLst[faceI];
         forAll (f, fp)
         {
             f[fp] = pointMap[f[fp]];
@@ -88,7 +93,7 @@ bool Foam::keyedSurface::stitchFaces(const scalar tol, const bool verbose)
         }
         else if (verbose)
         {
-            Pout<< "keyedSurface::stitchFaces : "
+            Pout<< "UnsortedMeshedSurface::stitchFaces : "
                 << "Removing collapsed face " << faceI << endl
                 << "    vertices   :" << f << endl;
         }
@@ -98,7 +103,7 @@ bool Foam::keyedSurface::stitchFaces(const scalar tol, const bool verbose)
     {
         if (verbose)
         {
-            Pout<< "keyedSurface::stitchFaces : "
+            Pout<< "UnsortedMeshedSurface::stitchFaces : "
                 << "Removed " << faceLst.size() - newFaceI
                 << " faces" << endl;
         }
@@ -107,30 +112,31 @@ bool Foam::keyedSurface::stitchFaces(const scalar tol, const bool verbose)
     }
 
     // Merging points might have changed geometric factors
-    MeshStorage::clearOut();
+    ParentType::clearOut();
 
     return true;
 }
 
 
 // Remove badly degenerate faces and double faces.
-void Foam::keyedSurface::checkFaces(const bool verbose)
+template<class Face>
+void Foam::UnsortedMeshedSurface<Face>::checkFaces(const bool verbose)
 {
     // Simple check on indices ok.
     const label maxPointI = points().size() - 1;
 
-    List<FaceType>& faceLst = faces();
+    List<Face>& faceLst = faces();
 
     // Phase 0: detect badly labelled faces
     forAll (faceLst, faceI)
     {
-        const FaceType& f = faceLst[faceI];
+        const Face& f = faceLst[faceI];
 
         forAll (f, fp)
         {
             if (f[fp] < 0 || f[fp] > maxPointI)
             {
-                FatalErrorIn("keyedSurface::checkFaces(bool)")
+                FatalErrorIn("UnsortedMeshedSurface::checkFaces(bool)")
                     << "face " << f
                     << " uses point indices outside point range 0.."
                     << maxPointI
@@ -142,12 +148,12 @@ void Foam::keyedSurface::checkFaces(const bool verbose)
     // Phase 1: mark invalid faces
     // Phase 1: pack
     // Done to keep numbering constant in phase 1
-    const labelListList& fFaces = faceFaces();
+    const labelListList& fFaces = ParentType::faceFaces();
     label newFaceI = 0;
 
     forAll (faceLst, faceI)
     {
-        FaceType& f = faceLst[faceI];
+        Face& f = faceLst[faceI];
 
         // avoid degenerate faces
         if (f.collapse() >= 3)
@@ -176,7 +182,7 @@ void Foam::keyedSurface::checkFaces(const bool verbose)
                     {
                         WarningIn
                         (
-                            "keyedSurface::checkFaces(bool verbose)"
+                            "UnsortedMeshedSurface::checkFaces(bool verbose)"
                         )   << "faces share the same vertices:\n"
                             << "    face 1 :" << faceI << endl;
                         // printFace(Warning, "    ", f, points());
@@ -206,7 +212,7 @@ void Foam::keyedSurface::checkFaces(const bool verbose)
         {
             WarningIn
             (
-                "keyedSurface::checkFaces(bool verbose)"
+                "UnsortedMeshedSurface::checkFaces(bool verbose)"
             )   << "face " << faceI
                 << " does not at least three unique vertices:\n";
             // printFace(Warning, "    ", f, points());
@@ -219,7 +225,7 @@ void Foam::keyedSurface::checkFaces(const bool verbose)
         {
             WarningIn
             (
-                "keyedSurface::checkFaces(bool verbose)"
+                "UnsortedMeshedSurface::checkFaces(bool verbose)"
             )   << "Removed " << faceLst.size() - newFaceI
                 << " illegal faces." << endl;
         }
@@ -227,15 +233,16 @@ void Foam::keyedSurface::checkFaces(const bool verbose)
         regions_.setSize(newFaceI);
 
         // Topology can change because of renumbering
-        MeshStorage::clearOut();
+        ParentType::clearOut();
     }
 }
 
 
-Foam::label Foam::keyedSurface::triangulate()
+template<class Face>
+Foam::label Foam::UnsortedMeshedSurface<Face>::triangulate()
 {
     label nTri = 0;
-    List<FaceType>& faceLst = faces();
+    List<Face>& faceLst = faces();
 
     // determine how many triangles are needed
     forAll (faceLst, faceI)
@@ -249,8 +256,8 @@ Foam::label Foam::keyedSurface::triangulate()
         return 0;
     }
 
-    List<FaceType> newFaces(nTri);
-    List<label>    newRegions(nTri);
+    List<Face>  newFaces(nTri);
+    List<label> newRegions(nTri);
 
     // note the number of *additional* faces
     nTri -= faceLst.size();
@@ -259,7 +266,7 @@ Foam::label Foam::keyedSurface::triangulate()
     label newFaceI = 0;
     forAll (faceLst, faceI)
     {
-        const FaceType& f = faceLst[faceI];
+        const Face& f = faceLst[faceI];
         triFace fTri;
 
         // Do simple face triangulation around f[0].
diff --git a/src/surfMesh/UnsortedMeshedSurface/UnsortedMeshedSurfaceIO.C b/src/surfMesh/UnsortedMeshedSurface/UnsortedMeshedSurfaceIO.C
new file mode 100644
index 0000000000..4fea3e44c3
--- /dev/null
+++ b/src/surfMesh/UnsortedMeshedSurface/UnsortedMeshedSurfaceIO.C
@@ -0,0 +1,153 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+\*---------------------------------------------------------------------------*/
+
+#include "MeshedSurface.H"
+#include "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)
+{
+    clear();
+
+    // triangulation required?
+    bool mustTriangulate = false;
+    {
+        Face f;
+        if (f.max_size() == 3)
+        {
+            mustTriangulate = true;
+        }
+    }
+
+    List<surfGroup> patchLst(is);
+    // read points:
+    is >> points();
+    
+    
+    // read faces:
+    // TODO - specialization to triangulate on-the-fly
+    if (mustTriangulate)
+    {
+        is >> faces();
+    }
+    else
+    {
+        is >> faces();
+    }
+
+    patches_.setSize(patchLst.size());
+    regions_.setSize(size());
+
+    // copy patch info and set regions:
+    label faceIndex = 0;
+    forAll(patchLst, patchI)
+    {
+        patches_[patchI] = PatchRegionType
+        (
+            patchLst[patchI],
+            patchI
+        );
+
+        forAll(patchLst[patchI], patchFaceI)
+        {
+            regions_[faceIndex++] = patchI;
+        }
+    }
+
+    return is.good();
+}
+
+
+// write (sorted)
+template<class Face>
+void Foam::UnsortedMeshedSurface<Face>::write(Ostream& os) const
+{
+    const List<Face>& faceLst = faces();
+    labelList faceMap;
+    List<surfGroup> patchLst = sortedRegions(faceMap);
+
+    // just emit some information until we get a nice IOobject
+    IOobject::writeBanner(os);
+    os  << "// OpenFOAM Surface format" << nl
+        << "// ~~~~~~~~~~~~~~~~~~~~~~~" << nl
+        << "// regions:" << nl
+        << patchLst.size() << nl << token::BEGIN_LIST << incrIndent << nl;
+
+    forAll(patchLst, patchI)
+    {
+        patchLst[patchI].writeDict(os);
+    }
+    os  << decrIndent << token::END_LIST << nl;
+
+    IOobject::writeDivider(os);
+
+    // Note: Write with global point numbering
+    os  << "\n// points:" << nl << points() << nl;
+
+    IOobject::writeDivider(os);
+    os  << "\n// faces:"  << nl;
+    os  << faceLst.size() << nl << token::BEGIN_LIST << nl;
+
+    label faceIndex = 0;
+    forAll(patchLst, patchI)
+    {
+        // Print all faces belonging to this region
+        const surfGroup& patch = patchLst[patchI];
+
+        forAll(patch, patchFaceI)
+        {
+            const face& f = faceLst[faceMap[faceIndex++]];
+
+            os  << f << nl;
+        }
+    }
+    os << token::END_LIST << 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 UnsortedMeshedSurface<Face>& surf
+)
+{
+    surf.write(os);
+    return os;
+}
+
+// ************************************************************************* //
diff --git a/src/surfMesh/keyedSurface/newKeyedSurface.C b/src/surfMesh/UnsortedMeshedSurface/UnsortedMeshedSurfaceNew.C
similarity index 69%
rename from src/surfMesh/keyedSurface/newKeyedSurface.C
rename to src/surfMesh/UnsortedMeshedSurface/UnsortedMeshedSurfaceNew.C
index 286cb83162..d06dc8b334 100644
--- a/src/surfMesh/keyedSurface/newKeyedSurface.C
+++ b/src/surfMesh/UnsortedMeshedSurface/UnsortedMeshedSurfaceNew.C
@@ -24,60 +24,64 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-#include "keyedSurface.H"
-#include "addToRunTimeSelectionTable.H"
+#include "UnsortedMeshedSurface.H"
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
 
-Foam::autoPtr<Foam::keyedSurface>
-Foam::keyedSurface::New
+template<class Face>
+Foam::autoPtr<Foam::UnsortedMeshedSurface<Face> >
+Foam::UnsortedMeshedSurface<Face>::New
 (
     const fileName& fName,
-    const word& ext,
-    const bool triangulate
+    const word& ext
 )
 {
     if (debug)
     {
-        Info<< "keyedSurface::New"
-            "(const fileName&, const word&, const bool) : "
-            "constructing keyedSurface"
+        Info<< "UnsortedMeshedSurface<Face>::New"
+            "(const fileName&, const word&) : "
+            "constructing UnsortedMeshedSurface"
             << endl;
     }
 
-    fileExtensionConstructorTable::iterator cstrIter =
+    typename fileExtensionConstructorTable::iterator cstrIter =
         fileExtensionConstructorTablePtr_->find(ext);
 
     if (cstrIter == fileExtensionConstructorTablePtr_->end())
     {
         FatalErrorIn
         (
-            "keyedSurface::New(const fileName&, const word&, const bool) : "
-            "constructing keyedSurface"
+            "UnsortedMeshedSurface<Face>::New"
+            "(const fileName&, const word&) : "
+            "constructing UnsortedMeshedSurface"
         )   << "Unknown file extension " << ext << nl << nl
             << "Valid types are :" << nl
             << fileExtensionConstructorTablePtr_->toc()
             << exit(FatalError);
     }
 
-    return autoPtr<keyedSurface>(cstrIter()(fName, triangulate));
+    return autoPtr<UnsortedMeshedSurface<Face> >
+    (
+        cstrIter()(fName)
+    );
 }
 
 
-Foam::autoPtr<Foam::keyedSurface>
-Foam::keyedSurface::New
+template<class Face>
+Foam::autoPtr<Foam::UnsortedMeshedSurface<Face> >
+Foam::UnsortedMeshedSurface<Face>::New
 (
-    const fileName& fName,
-    const bool triangulate
+    const fileName& fName
 )
 {
     const word ext = fName.ext();
 
     if (debug)
     {
-        Info<< "keyedSurface::New(const fileName&, const bool) : "
-               "constructing keyedSurface"
+        Info<< "UnsortedMeshedSurface<Face>::New"
+            "(const fileName&) : "
+            "constructing UnsortedMeshedSurface"
             << endl;
     }
 
@@ -89,7 +93,7 @@ Foam::keyedSurface::New
     //    return New(unzipName, unzipName.ext(), ext);
     // }
 
-    return New(fName, ext, triangulate);
+    return New(fName, ext);
 }
 
 // ************************************************************************* //
diff --git a/src/surfMesh/UnsortedMeshedSurface/UnsortedMeshedSurfaces.C b/src/surfMesh/UnsortedMeshedSurface/UnsortedMeshedSurfaces.C
new file mode 100644
index 0000000000..9dd95cd0c4
--- /dev/null
+++ b/src/surfMesh/UnsortedMeshedSurface/UnsortedMeshedSurfaces.C
@@ -0,0 +1,48 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+\*---------------------------------------------------------------------------*/
+
+#include "UnsortedMeshedSurfaces.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+#define makeUnsortedMeshedSurface(surfaceType)                                \
+defineNamedTemplateTypeNameAndDebug(surfaceType, 0);                          \
+defineTemplateRunTimeSelectionTable(surfaceType, fileExtension);              \
+defineTemplateMemberFunctionSelectionTable(surfaceType,write,fileExtension);
+
+makeUnsortedMeshedSurface(unsortedMeshedSurface)
+makeUnsortedMeshedSurface(triUnsortedMeshedSurface)
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// ************************************************************************* //
diff --git a/src/surfMesh/UnsortedMeshedSurface/UnsortedMeshedSurfaces.H b/src/surfMesh/UnsortedMeshedSurface/UnsortedMeshedSurfaces.H
new file mode 100644
index 0000000000..e2cf68ea0f
--- /dev/null
+++ b/src/surfMesh/UnsortedMeshedSurface/UnsortedMeshedSurfaces.H
@@ -0,0 +1,35 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef UnsortedMeshedSurfaces_H
+#define UnsortedMeshedSurfaces_H
+
+#include "UnsortedMeshedSurface.H"
+#include "UnsortedMeshedSurfacesFwd.H"
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/surfMesh/UnsortedMeshedSurface/UnsortedMeshedSurfacesFwd.H b/src/surfMesh/UnsortedMeshedSurface/UnsortedMeshedSurfacesFwd.H
new file mode 100644
index 0000000000..2d5d007e2c
--- /dev/null
+++ b/src/surfMesh/UnsortedMeshedSurface/UnsortedMeshedSurfacesFwd.H
@@ -0,0 +1,52 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef UnsortedMeshedSurfacesFwd_H
+#define UnsortedMeshedSurfacesFwd_H
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+class face;
+class triFace;
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+template<class Face> class UnsortedMeshedSurface;
+
+typedef UnsortedMeshedSurface<face>    unsortedMeshedSurface;
+typedef UnsortedMeshedSurface<triFace> triUnsortedMeshedSurface;
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/surfMesh/keyedSurface/fileFormats/stl/STLfileFormat.C b/src/surfMesh/keyedSurface/fileFormats/stl/STLfileFormat.C
deleted file mode 100644
index 1691666330..0000000000
--- a/src/surfMesh/keyedSurface/fileFormats/stl/STLfileFormat.C
+++ /dev/null
@@ -1,611 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software; you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by the
-    Free Software Foundation; either version 2 of the License, or (at your
-    option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM; if not, write to the Free Software Foundation,
-    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
-
-\*---------------------------------------------------------------------------*/
-
-#include "STLfileFormat.H"
-#include "triFace.H"
-#include "clock.H"
-#include "OSspecific.H"
-#include "addToRunTimeSelectionTable.H"
-#include "addToMemberFunctionSelectionTable.H"
-
-// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
-namespace Foam
-{
-namespace fileFormats
-{
-
-addNamedToRunTimeSelectionTable
-(
-    keyedSurface,
-    STLfileFormat,
-    fileExtension,
-    stl
-);
-
-addNamedToRunTimeSelectionTable
-(
-    keyedSurface,
-    STLfileFormat,
-    fileExtension,
-    stlb
-);
-
-addNamedToMemberFunctionSelectionTable
-(
-    keyedSurface,
-    STLfileFormat,
-    write,
-    fileExtension,
-    stl
-);
-
-addNamedToMemberFunctionSelectionTable
-(
-    keyedSurface,
-    STLfileFormat,
-    write,
-    fileExtension,
-    stlb
-);
-
-addNamedToMemberFunctionSelectionTable
-(
-    meshedSurface,
-    STLfileFormat,
-    write,
-    fileExtension,
-    stl
-);
-
-addNamedToMemberFunctionSelectionTable
-(
-    meshedSurface,
-    STLfileFormat,
-    write,
-    fileExtension,
-    stlb
-);
-
-}
-}
-
-// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
-
-// check binary by getting the header and number of facets
-// this seems to work better than the old token-based method
-// - some programs (eg, pro-STAR) have 'solid' as the first word in
-//   the binary header.
-// - using wordToken can cause an abort if non-word (binary) content
-//   is detected ... this is not exactly what we want.
-bool Foam::fileFormats::STLfileFormat::detectBINARY
-(
-    const fileName& fName
-)
-{
-    off_t fileSize = Foam::size(fName);
-
-    IFstream ifs(fName, IOstream::BINARY);
-    istream& is = ifs.stdStream();
-
-    // Read the STL header
-    char header[headerSize];
-    is.read(header, headerSize);
-
-    // Check that stream is OK, if not this may be an ASCII file
-    if (!is.good())
-    {
-        return false;
-    }
-
-    // Read the number of triangles in the STl file
-    // (note: read as int so we can check whether >2^31)
-    int nTris;
-    is.read(reinterpret_cast<char*>(&nTris), sizeof(unsigned int));
-
-    // Check that stream is OK and number of triangles is positive,
-    // if not this maybe an ASCII file
-    //
-    // Also compare the file size with that expected from the number of tris
-    // If the comparison is not sensible then it may be an ASCII file
-    if
-    (
-        !is
-     || nTris < 0
-     || nTris < (fileSize - headerSize)/50
-     || nTris > (fileSize - headerSize)/25
-    )
-    {
-        return false;
-    }
-
-    // looks like it might be BINARY
-    return true;
-}
-
-
-#undef DEBUG_STLBINARY
-
-bool Foam::fileFormats::STLfileFormat::readBINARY
-(
-    IFstream& ifs,
-    const off_t fileSize
-)
-{
-    clear();
-
-    istream& is = ifs.stdStream();
-
-    // Read the STL header
-    char header[headerSize];
-    is.read(header, headerSize);
-
-    // Check that stream is OK, if not this may be an ASCII file
-    if (!is.good())
-    {
-        FatalErrorIn
-        (
-            "fileFormats::STLfileFormat::readBINARY(Istream&)"
-        )
-            << "problem reading header, perhaps file is not binary "
-            << exit(FatalError);
-    }
-
-    // Read the number of triangles in the STl file
-    // (note: read as int so we can check whether >2^31)
-    int nTris;
-    is.read(reinterpret_cast<char*>(&nTris), sizeof(unsigned int));
-
-    // Check that stream is OK and number of triangles is positive,
-    // if not this maybe an ASCII file
-    //
-    // Also compare the file size with that expected from the number of tris
-    // If the comparison is not sensible then it may be an ASCII file
-    if
-    (
-        !is
-     || nTris < 0
-     || nTris < (fileSize - headerSize)/50
-     || nTris > (fileSize - headerSize)/25
-    )
-    {
-        FatalErrorIn
-        (
-            "fileFormats::STLfileFormat::readBINARY(Istream&)"
-        )
-            << "problem reading number of triangles, perhaps file is not binary"
-            << exit(FatalError);
-    }
-
-#ifdef DEBUG_STLBINARY
-    Info<< "# " << nTris << " facets" << endl;
-    label prevRegion = -1;
-#endif
-
-
-    // write directly into the lists:
-    pointField& pointLst = points();
-    List<face>& faceLst = faces();
-    List<label>& regionLst = regions();
-
-    pointLst.setSize(3*nTris);
-    faceLst.setSize(nTris);
-    regionLst.setSize(nTris);
-
-    label maxRegionId = 0;
-
-    label pointI = 0;
-    forAll(faceLst, faceI)
-    {
-        triFace fTri;
-
-        // Read an STL triangle
-        STLtriangle stlTri(is);
-
-        // Set the rawPoints to the vertices of the STL triangle
-        // and set the point labels of the face
-
-        pointLst[pointI] = stlTri.a();
-        fTri[0] = pointI++;
-
-        pointLst[pointI] = stlTri.b();
-        fTri[1] = pointI++;
-
-        pointLst[pointI] = stlTri.c();
-        fTri[2] = pointI++;
-
-        faceLst[faceI] = fTri;
-
-        // interprete colour as a region
-        regionLst[faceI] = stlTri.region();
-
-        if (maxRegionId < stlTri.region())
-        {
-            maxRegionId = stlTri.region();
-        }
-
-#ifdef DEBUG_STLBINARY
-        if
-        (
-            prevRegion != stlTri.region()
-        )
-        {
-            if (prevRegion != -1)
-            {
-                Info<< "endsolid region" << prevRegion << nl;
-            }
-            prevRegion = stlTri.region();
-
-            Info<< "solid region" << prevRegion << nl;
-        }
-
-        Info<< "  facet normal " << stlTri.normal() << nl;
-        Info<< "    outer loop" << nl;
-        Info<< "      vertex " << stlTri.a() << nl;
-        Info<< "      vertex " << stlTri.b() << nl;
-        Info<< "      vertex " << stlTri.c() << nl;
-        Info<< "    outer loop" << nl;
-        Info<< "  endfacet" << endl;
-#endif
-    }
-#ifdef DEBUG_STLBINARY
-    Info<< "endsolid region" << prevRegion << nl;
-#endif
-
-    setPatches(maxRegionId);
-    stitchFaces(SMALL);
-
-    return true;
-}
-
-
-inline void Foam::fileFormats::STLfileFormat::writeShell
-(
-    Ostream& os,
-    const pointField& pointLst,
-    const face& f,
-    const vector& norm
-)
-{
-    // simple triangulation about f[0].
-    // better triangulation should have been done before
-    const point& p0 = pointLst[f[0]];
-    for (label fp1 = 1; fp1 < f.size() - 1; ++fp1)
-    {
-        label fp2 = (fp1 + 1) % f.size();
-
-        const point& p1 = pointLst[f[fp1]];
-        const point& p2 = pointLst[f[fp2]];
-
-        // write STL triangle
-        os  << "  facet normal "
-            << norm.x() << ' ' << norm.y() << ' ' << norm.z() << nl
-            << "    outer loop\n"
-            << "       vertex "
-            << p0.x() << ' ' << p0.y() << ' ' << p0.z() << nl
-            << "       vertex "
-            << p1.x() << ' ' << p1.y() << ' ' << p1.z() << nl
-            << "       vertex "
-            << p2.x() << ' ' << p2.y() << ' ' << p2.z() << nl
-            << "    endloop\n"
-            << "  endfacet" << endl;
-    }
-}
-
-
-inline void Foam::fileFormats::STLfileFormat::writeShell
-(
-    ostream& os,
-    const pointField& pointLst,
-    const face& f,
-    const vector& norm,
-    const label patchI
-)
-{
-    // simple triangulation about f[0].
-    // better triangulation should have been done before
-    const point& p0 = pointLst[f[0]];
-    for (label fp1 = 1; fp1 < f.size() - 1; ++fp1)
-    {
-        label fp2 = (fp1 + 1) % f.size();
-
-        STLtriangle stlTri
-        (
-            norm,
-            p0,
-            pointLst[f[fp1]],
-            pointLst[f[fp2]],
-            patchI
-        );
-
-        stlTri.write(os);
-    }
-}
-
-
-
-
-// write sorted:
-void Foam::fileFormats::STLfileFormat::writeASCII
-(
-    Ostream& os,
-    const keyedSurface& surf
-)
-{
-    const pointField& pointLst = surf.points();
-    const List<face>& faceLst  = surf.faces();
-    const vectorField& normLst = surf.faceNormals();
-
-    labelList faceMap;
-    List<surfGroup> patchLst = surf.sortedRegions(faceMap);
-
-    label faceIndex = 0;
-    forAll(patchLst, patchI)
-    {
-        // Print all faces belonging to this region
-        const surfGroup& patch = patchLst[patchI];
-
-        os << "solid " << patch.name() << endl;
-
-        forAll(patch, patchFaceI)
-        {
-            const label faceI = faceMap[faceIndex++];
-            writeShell(os, pointLst, faceLst[faceI], normLst[faceI]);
-        }
-
-        os << "endsolid " << patch.name() << endl;
-    }
-}
-
-
-
-// write sorted:
-void Foam::fileFormats::STLfileFormat::writeASCII
-(
-    Ostream& os,
-    const meshedSurface& surf
-)
-{
-    const pointField& pointLst = surf.points();
-    const List<face>& faceLst = surf.faces();
-    const List<surfGroup>& patchLst = surf.patches();
-    const vectorField& normLst = surf.faceNormals();
-
-    // force triangulation, but just do the cheapest form possible
-    label faceIndex = 0;
-    forAll(patchLst, patchI)
-    {
-        // Print all faces belonging to this region
-        const surfGroup& patch = patchLst[patchI];
-
-        os << "solid " << patch.name() << endl;
-
-        forAll(patch, patchFaceI)
-        {
-            const label faceI = faceIndex++;
-            writeShell(os, pointLst, faceLst[faceI], normLst[faceI]);
-        }
-
-        os << "endsolid " << patch.name() << endl;
-    }
-}
-
-
-// write unsorted:
-void Foam::fileFormats::STLfileFormat::writeBINARY
-(
-    ostream& os,
-    const keyedSurface& surf
-)
-{
-    const pointField& pointLst = surf.points();
-    const List<face>&  faceLst = surf.faces();
-    const List<label>& regionLst = surf.regions();
-    const vectorField& normLst = surf.faceNormals();
-
-    // Write the STL header
-    string header("STL binary file", headerSize);
-
-    // clear possible trailing junk
-    for (label i = header.size(); i < headerSize; ++i)
-    {
-        header[i] = 0;
-    }
-    os.write(header.c_str(), headerSize);
-
-    // force triangulation, but just do the cheapest form possible
-    unsigned int nTris = 0;
-    forAll(faceLst, faceI)
-    {
-        nTris += faceLst[faceI].size() - 2;
-    }
-
-    os.write(reinterpret_cast<char*>(&nTris), sizeof(unsigned int));
-
-    // always write unsorted
-    forAll(faceLst, faceI)
-    {
-        writeShell
-        (
-            os,
-            pointLst,
-            faceLst[faceI],
-            normLst[faceI],
-            regionLst[faceI]
-        );
-    }
-}
-
-
-void Foam::fileFormats::STLfileFormat::writeBINARY
-(
-    ostream& os,
-    const meshedSurface& surf
-)
-{
-    const pointField& pointLst = surf.points();
-    const List<face>& faceLst  = surf.faces();
-    const vectorField& normLst = surf.faceNormals();
-    const List<surfGroup>& patchLst = surf.patches();
-
-    // Write the STL header
-    string header("STL binary file", headerSize);
-    os.write(header.c_str(), headerSize);
-
-    // force triangulation, but just do the cheapest form possible
-
-    unsigned int nTris = 0;
-    forAll(faceLst, faceI)
-    {
-        nTris += faceLst[faceI].size() - 2;
-    }
-
-    os.write(reinterpret_cast<char*>(&nTris), sizeof(unsigned int));
-
-    label faceIndex = 0;
-    forAll(patchLst, patchI)
-    {
-        forAll(patchLst[patchI], patchFaceI)
-        {
-            writeShell
-            (
-                os,
-                pointLst,
-                faceLst[faceIndex],
-                normLst[faceIndex],
-                patchI
-            );
-
-            ++faceIndex;
-        }
-    }
-}
-
-
-// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
-
-Foam::fileFormats::STLfileFormat::STLfileFormat()
-:
-    Foam::keyedSurface()
-{}
-
-
-Foam::fileFormats::STLfileFormat::STLfileFormat
-(
-    const fileName& fName,
-    const bool
-)
-:
-    Foam::keyedSurface()
-{
-    read(fName, true);
-}
-
-
-// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
-
-
-bool Foam::fileFormats::STLfileFormat::read
-(
-    const fileName& fName,
-    const bool
-)
-{
-    off_t fileSize = Foam::size(fName);
-
-    // auto-detect ascii/binary
-    if (detectBINARY(fName))
-    {
-        return readBINARY(IFstream(fName, IOstream::BINARY)(), fileSize);
-    }
-    else
-    {
-        return readASCII(IFstream(fName)(), fileSize);
-    }
-}
-
-
-void Foam::fileFormats::STLfileFormat::write
-(
-    Ostream& os,
-    const keyedSurface& surf
-)
-{
-    writeASCII(os, surf);
-}
-
-
-void Foam::fileFormats::STLfileFormat::write
-(
-    Ostream& os,
-    const meshedSurface& surf
-)
-{
-    writeASCII(os, surf);
-}
-
-
-void Foam::fileFormats::STLfileFormat::write
-(
-    const fileName& fName,
-    const keyedSurface& surf
-)
-{
-    const word ext = fName.ext();
-
-    // handle 'stlb' as binary directly
-    if (ext == "stlb")
-    {
-        std::ofstream ofs(fName.c_str(), std::ios::binary);
-        writeBINARY(ofs, surf);
-    }
-    else
-    {
-        writeASCII(OFstream(fName)(), surf);
-    }
-}
-
-
-void Foam::fileFormats::STLfileFormat::write
-(
-    const fileName& fName,
-    const meshedSurface& surf
-)
-{
-    const word ext = fName.ext();
-
-    // handle 'stlb' as binary directly
-    if (ext == "stlb")
-    {
-        std::ofstream ofs(fName.c_str(), std::ios::binary);
-        writeBINARY(ofs, surf);
-    }
-    else
-    {
-        writeASCII(OFstream(fName)(), surf);
-    }
-}
-
-// ************************************************************************* //
diff --git a/src/surfMesh/keyedSurface/fileFormats/ac3d/AC3DfileFormat.C b/src/surfMesh/surfaceFormats/ac3d/AC3DsurfaceFormat.C
similarity index 83%
rename from src/surfMesh/keyedSurface/fileFormats/ac3d/AC3DfileFormat.C
rename to src/surfMesh/surfaceFormats/ac3d/AC3DsurfaceFormat.C
index 9555f2a4d3..938b393e76 100644
--- a/src/surfMesh/keyedSurface/fileFormats/ac3d/AC3DfileFormat.C
+++ b/src/surfMesh/surfaceFormats/ac3d/AC3DsurfaceFormat.C
@@ -24,56 +24,20 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-#include "AC3DfileFormat.H"
-#include "triFace.H"
+#include "AC3DsurfaceFormat.H"
 #include "clock.H"
 #include "IFstream.H"
 #include "IStringStream.H"
 #include "tensor.H"
-#include "triFace.H"
 #include "primitivePatch.H"
-#include "addToRunTimeSelectionTable.H"
-#include "addToMemberFunctionSelectionTable.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
-namespace Foam
-{
-namespace fileFormats
-{
-
-addNamedToRunTimeSelectionTable
-(
-    keyedSurface,
-    AC3DfileFormat,
-    fileExtension,
-    ac
-);
-
-addNamedToMemberFunctionSelectionTable
-(
-    keyedSurface,
-    AC3DfileFormat,
-    write,
-    fileExtension,
-    ac
-);
-
-addNamedToMemberFunctionSelectionTable
-(
-    meshedSurface,
-    AC3DfileFormat,
-    write,
-    fileExtension,
-    ac
-);
-
-}
-}
 
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 
+template<class Face>
 template<class Type>
-Type Foam::fileFormats::AC3DfileFormat::parse(const string& str)
+Type Foam::fileFormats::AC3DsurfaceFormat<Face>::parse(const string& str)
 {
     IStringStream ss(str);
 
@@ -83,7 +47,8 @@ Type Foam::fileFormats::AC3DfileFormat::parse(const string& str)
 }
 
 
-bool Foam::fileFormats::AC3DfileFormat::readCmd
+template<class Face>
+bool Foam::fileFormats::AC3DsurfaceFormat<Face>::readCmd
 (
     IFstream& is,
     string& cmd,
@@ -111,7 +76,8 @@ bool Foam::fileFormats::AC3DfileFormat::readCmd
 
 // Read up to line starting with cmd. Sets args to rest of line.
 // Returns true if found, false if stream is not good anymore.
-bool Foam::fileFormats::AC3DfileFormat::cueTo
+template<class Face>
+bool Foam::fileFormats::AC3DsurfaceFormat<Face>::cueTo
 (
     IFstream& is,
     const string& cmd,
@@ -140,7 +106,8 @@ bool Foam::fileFormats::AC3DfileFormat::cueTo
 
 
 // Similar to cueTo(), but throws error if cmd not found
-Foam::string Foam::fileFormats::AC3DfileFormat::cueToOrDie
+template<class Face>
+Foam::string Foam::fileFormats::AC3DsurfaceFormat<Face>::cueToOrDie
 (
     IFstream& is,
     const string& cmd,
@@ -152,7 +119,7 @@ Foam::string Foam::fileFormats::AC3DfileFormat::cueToOrDie
     {
         FatalErrorIn
         (
-            "fileFormats::AC3DfileFormat::read(const fileName&)"
+            "fileFormats::AC3DsurfaceFormat::read(const fileName&)"
         )
             << "Cannot find command " << cmd
             << " " << errorMsg
@@ -163,7 +130,8 @@ Foam::string Foam::fileFormats::AC3DfileFormat::cueToOrDie
 }
 
 
-void Foam::fileFormats::AC3DfileFormat::writeHeader
+template<class Face>
+void Foam::fileFormats::AC3DsurfaceFormat<Face>::writeHeader
 (
     Ostream& os,
     const List<surfGroup>& patchLst
@@ -211,39 +179,50 @@ void Foam::fileFormats::AC3DfileFormat::writeHeader
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
-Foam::fileFormats::AC3DfileFormat::AC3DfileFormat()
+template<class Face>
+Foam::fileFormats::AC3DsurfaceFormat<Face>::AC3DsurfaceFormat()
 :
-    Foam::keyedSurface()
+    ParentType()
 {}
 
 
-Foam::fileFormats::AC3DfileFormat::AC3DfileFormat
+template<class Face>
+Foam::fileFormats::AC3DsurfaceFormat<Face>::AC3DsurfaceFormat
 (
-    const fileName& fName,
-    const bool triangulate
+    const fileName& fName
 )
 :
-    Foam::keyedSurface()
+    ParentType()
 {
-    read(fName,triangulate);
+    read(fName);
 }
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
-bool Foam::fileFormats::AC3DfileFormat::read
+template<class Face>
+bool Foam::fileFormats::AC3DsurfaceFormat<Face>::read
 (
-    const fileName& fName,
-    const bool triangulate
+    const fileName& fName
 )
 {
-    clear();
-    IFstream is(fName);
+    ParentType::clear();
 
+    // triangulation required?
+    bool mustTriangulate = false;
+    {
+        Face f;
+        if (f.max_size() == 3)
+        {
+            mustTriangulate = true;
+        }
+    }
+
+    IFstream is(fName);
     if (!is.good())
     {
         FatalErrorIn
         (
-            "fileFormats::AC3DfileFormat::read(const fileName&)"
+            "fileFormats::AC3DsurfaceFormat::read(const fileName&)"
         )
             << "Cannot read file " << fName
             << exit(FatalError);
@@ -259,8 +238,7 @@ bool Foam::fileFormats::AC3DfileFormat::read
     {
         WarningIn
         (
-            "fileFormats::AC3DfileFormat::AC3DfileFormat"
-            "(const fileName&)"
+            "fileFormats::AC3DsurfaceFormat::read(const fileName&)"
         )
             << "When reading AC3D file " << fName
             << " read header " << line << " with version "
@@ -274,7 +252,7 @@ bool Foam::fileFormats::AC3DfileFormat::read
     {
         FatalErrorIn
         (
-            "fileFormats::AC3DfileFormat::read(const fileName&)"
+            "fileFormats::AC3DsurfaceFormat::read(const fileName&)"
         )
             << "Cannot find \"OBJECT world\" in file " << fName
             << exit(FatalError);
@@ -287,9 +265,9 @@ bool Foam::fileFormats::AC3DfileFormat::read
     // Start of vertices for object/patch
     label patchVertOffset = 0;
 
-    DynamicList<point>    pointLst;
-    DynamicList<FaceType> faceLst;
-    DynamicList<label>    regionLst;
+    DynamicList<point> pointLst;
+    DynamicList<Face>  faceLst;
+    DynamicList<label> regionLst;
 
     // patchId => patchName
     Map<word> regionNames;
@@ -314,7 +292,7 @@ bool Foam::fileFormats::AC3DfileFormat::read
             {
                 FatalErrorIn
                 (
-                    "fileFormats::AC3DfileFormat::read(const fileName&)"
+                    "fileFormats::AC3DsurfaceFormat::read(const fileName&)"
                 )
                     << "Did not read up to \"kids 0\" while reading patch "
                     << patchI << " from file " << fName
@@ -342,7 +320,7 @@ bool Foam::fileFormats::AC3DfileFormat::read
 
                 WarningIn
                 (
-                    "fileFormats::AC3DfileFormat::read"
+                    "fileFormats::AC3DsurfaceFormat::read"
                     "(const fileName&)"
                 )
                     << "rot (rotation tensor) command not implemented"
@@ -395,14 +373,16 @@ bool Foam::fileFormats::AC3DfileFormat::read
 
                     label nVert = parse<int>(args);
 
-                    face verts(nVert);
+                    List<label> verts(nVert);
                     forAll(verts, vertI)
                     {
                         is.getLine(line);
                         verts[vertI] = parse<int>(line) + patchVertOffset;
                     }
 
-                    if (triangulate && verts.size() > 3)
+                    UList<label>& f = static_cast<UList<label>&>(verts);
+
+                    if (mustTriangulate)
                     {
                         triFace fTri;
 
@@ -423,7 +403,7 @@ bool Foam::fileFormats::AC3DfileFormat::read
                     }
                     else
                     {
-                        faceLst.append(verts);
+                        faceLst.append(Face(f));
                         regionLst.append(patchI);
                     }
                 }
@@ -441,7 +421,7 @@ bool Foam::fileFormats::AC3DfileFormat::read
                 {
                     FatalErrorIn
                     (
-                        "fileFormats::AC3DfileFormat::read(const fileName&)"
+                        "fileFormats::AC3DsurfaceFormat::read(const fileName&)"
                     )
                         << "Can only read objects without kids."
                         << " Encountered " << nKids << " kids when"
@@ -457,21 +437,22 @@ bool Foam::fileFormats::AC3DfileFormat::read
     }
 
     // transfer to normal lists
-    points().transfer(pointLst);
-    faces().transfer(faceLst);
-    regions().transfer(regionLst);
+    ParentType::points().transfer(pointLst);
+    ParentType::faces().transfer(faceLst);
 
-    setPatches(regionNames);
-    stitchFaces(SMALL);
+    ParentType::regions().transfer(regionLst);
 
+    ParentType::setPatches(regionNames);
+    ParentType::stitchFaces(SMALL);
     return true;
 }
 
 
-void Foam::fileFormats::AC3DfileFormat::write
+template<class Face>
+void Foam::fileFormats::AC3DsurfaceFormat<Face>::write
 (
     Ostream& os,
-    const keyedSurface& surf
+    const UnsortedMeshedSurface<Face>& surf
 )
 {
     labelList faceMap;
@@ -500,7 +481,7 @@ void Foam::fileFormats::AC3DfileFormat::write
         labelList pMap;
         labelList fMap;
 
-        keyedSurface patch = surf.subsetMesh
+        ParentType patch = surf.subsetMesh
         (
             include, pMap, fMap
         );
@@ -536,14 +517,15 @@ void Foam::fileFormats::AC3DfileFormat::write
 }
 
 
-void Foam::fileFormats::AC3DfileFormat::write
+template<class Face>
+void Foam::fileFormats::AC3DsurfaceFormat<Face>::write
 (
     Ostream& os,
-    const meshedSurface& surf
+    const MeshedSurface<Face>& surf
 )
 {
     const pointField& pointLst = surf.points();
-    const List<FaceType>& faceLst = surf.faces();
+    const List<Face>& faceLst = surf.faces();
     const List<surfGroup>& patchLst = surf.patches();
 
     writeHeader(os, patchLst);
@@ -555,15 +537,11 @@ void Foam::fileFormats::AC3DfileFormat::write
         os  << "OBJECT poly" << nl
             << "name \"" << p.name() << '"' << endl;
 
-        // Temporary primitivePatch to calculate compact points & faces
-        primitivePatch patch
+        // Temporary PrimitivePatch to calculate compact points & faces
+        // use 'UList' to avoid allocations!
+        PrimitivePatch<Face, UList, const pointField&> patch
         (
-            SubList<face>
-            (
-                faceLst,
-                p.start(),
-                p.size()
-            ),
+            faceLst,
             pointLst
         );
 
diff --git a/src/surfMesh/keyedSurface/fileFormats/ac3d/AC3DfileFormat.H b/src/surfMesh/surfaceFormats/ac3d/AC3DsurfaceFormat.H
similarity index 70%
rename from src/surfMesh/keyedSurface/fileFormats/ac3d/AC3DfileFormat.H
rename to src/surfMesh/surfaceFormats/ac3d/AC3DsurfaceFormat.H
index 9ff18bc325..68f9d58291 100644
--- a/src/surfMesh/keyedSurface/fileFormats/ac3d/AC3DfileFormat.H
+++ b/src/surfMesh/surfaceFormats/ac3d/AC3DsurfaceFormat.H
@@ -23,7 +23,7 @@ License
     Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 
 Class
-    Foam::fileFormats::AC3DfileFormat
+    Foam::fileFormats::AC3DsurfaceFormat
 
 Description
     Provide a means of reading/writing AC3D format.
@@ -39,13 +39,13 @@ SourceFiles
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef AC3DfileFormat_H
-#define AC3DfileFormat_H
+#ifndef AC3DsurfaceFormat_H
+#define AC3DsurfaceFormat_H
 
 #include "Ostream.H"
 #include "OFstream.H"
-#include "keyedSurface.H"
-#include "meshedSurface.H"
+#include "MeshedSurface.H"
+#include "UnsortedMeshedSurface.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -54,16 +54,18 @@ namespace Foam
 namespace fileFormats
 {
 
-class AC3DfileFormat;
-
 /*---------------------------------------------------------------------------*\
                       Class AC3DfileFormat Declaration
 \*---------------------------------------------------------------------------*/
 
-class AC3DfileFormat
+template<class Face>
+class AC3DsurfaceFormat
 :
-    public keyedSurface
+    public UnsortedMeshedSurface<Face>
 {
+    //- Private typedefs for convenience
+    typedef AC3DsurfaceFormat<Face>     ThisType;
+    typedef UnsortedMeshedSurface<Face> ParentType;
 
     // Private Member Functions
 
@@ -90,57 +92,76 @@ class AC3DfileFormat
         static void writeHeader(Ostream&, const List<surfGroup>&);
 
         //- Disallow default bitwise copy construct
-        AC3DfileFormat(const AC3DfileFormat&);
+        AC3DsurfaceFormat(const AC3DsurfaceFormat<Face>&);
 
         //- Disallow default bitwise assignment
-        void operator=(const AC3DfileFormat&);
+        void operator=(const AC3DsurfaceFormat<Face>&);
 
 public:
 
     // Constructors
 
         //- Construct null
-        AC3DfileFormat();
+        AC3DsurfaceFormat();
 
         //- Construct from file name
-        AC3DfileFormat(const fileName&, const bool triangulate=false);
+        AC3DsurfaceFormat(const fileName&);
 
     // Selectors
 
-        //- Read file and return keyedSurface
-        static autoPtr<keyedSurface> New
+        //- Read file and return surface
+        static autoPtr<UnsortedMeshedSurface<Face> > New
         (
-            const fileName& fName,
-            const bool triangulate=false
+            const fileName& fName
         )
         {
-            return autoPtr<keyedSurface>
+            return autoPtr<UnsortedMeshedSurface<Face> >
             (
-                new AC3DfileFormat(fName,triangulate)
+                new AC3DsurfaceFormat<Face>(fName)
             );
         }
 
     // Destructor
 
+        virtual ~AC3DsurfaceFormat()
+        {}
+
+
     // Member Functions
 
         //- Read from file
-        virtual bool read(const fileName&, const bool triangulate);
+        virtual bool read(const fileName&);
 
-        //- Write keyedSurface
-        static void write(Ostream&, const keyedSurface&);
+        //- Write UnsortedMeshedSurface
+        static void write
+        (
+            Ostream&,
+            const UnsortedMeshedSurface<Face>&
+        );
 
-        //- Write keyedSurface
-        static void write(const fileName& fName, const keyedSurface& surf)
+        //- Write UnsortedMeshedSurface
+        static void write
+        (
+            const fileName& fName,
+            const UnsortedMeshedSurface<Face>& surf
+        )
         {
             write(OFstream(fName)(), surf);
         }
 
-        //- Write meshedSurface
-        static void write(Ostream&, const meshedSurface&);
+        //- Write MeshedSurface
+        static void write
+        (
+            Ostream&,
+            const MeshedSurface<Face>&
+        );
 
-        //- Write meshedSurface
-        static void write(const fileName& fName, const meshedSurface& surf)
+        //- Write MeshedSurface
+        static void write
+        (
+            const fileName& fName,
+            const MeshedSurface<Face>& surf
+        )
         {
             write(OFstream(fName)(), surf);
         }
@@ -161,6 +182,10 @@ public:
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
+#ifdef NoRepository
+#   include "AC3DsurfaceFormat.C"
+#endif
+
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 #endif
diff --git a/src/surfMesh/surfaceFormats/ac3d/AC3DsurfaceFormatRunTime.C b/src/surfMesh/surfaceFormats/ac3d/AC3DsurfaceFormatRunTime.C
new file mode 100644
index 0000000000..852622a8dc
--- /dev/null
+++ b/src/surfMesh/surfaceFormats/ac3d/AC3DsurfaceFormatRunTime.C
@@ -0,0 +1,99 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+\*---------------------------------------------------------------------------*/
+
+#include "AC3DsurfaceFormat.H"
+#include "MeshedSurface.H"
+#include "UnsortedMeshedSurface.H"
+#include "addToRunTimeSelectionTable.H"
+#include "addToMemberFunctionSelectionTable.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+namespace Foam
+{
+namespace fileFormats
+{
+
+addNamedTemplatedToRunTimeSelectionTable
+(
+    UnsortedMeshedSurface,
+    AC3DsurfaceFormat,
+    face,
+    fileExtension,
+    ac
+);
+addNamedTemplatedToRunTimeSelectionTable
+(
+    UnsortedMeshedSurface,
+    AC3DsurfaceFormat,
+    triFace,
+    fileExtension,
+    ac
+);
+
+
+addNamedTemplatedToMemberFunctionSelectionTable
+(
+    UnsortedMeshedSurface,
+    AC3DsurfaceFormat,
+    face,
+    write,
+    fileExtension,
+    ac
+);
+addNamedTemplatedToMemberFunctionSelectionTable
+(
+    UnsortedMeshedSurface,
+    AC3DsurfaceFormat,
+    triFace,
+    write,
+    fileExtension,
+    ac
+);
+
+
+addNamedTemplatedToMemberFunctionSelectionTable
+(
+    MeshedSurface,
+    AC3DsurfaceFormat,
+    face,
+    write,
+    fileExtension,
+    ac
+);
+addNamedTemplatedToMemberFunctionSelectionTable
+(
+    MeshedSurface,
+    AC3DsurfaceFormat,
+    triFace,
+    write,
+    fileExtension,
+    ac
+);
+
+}
+}
+
+// ************************************************************************* //
diff --git a/src/surfMesh/keyedSurface/fileFormats/ftr/FTRfileFormat.C b/src/surfMesh/surfaceFormats/ftr/FTRsurfaceFormat.C
similarity index 71%
rename from src/surfMesh/keyedSurface/fileFormats/ftr/FTRfileFormat.C
rename to src/surfMesh/surfaceFormats/ftr/FTRsurfaceFormat.C
index 248e5c2943..208fd24960 100644
--- a/src/surfMesh/keyedSurface/fileFormats/ftr/FTRfileFormat.C
+++ b/src/surfMesh/surfaceFormats/ftr/FTRsurfaceFormat.C
@@ -24,67 +24,48 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-#include "FTRfileFormat.H"
+#include "FTRsurfaceFormat.H"
 #include "Keyed.H"
-#include "triFace.H"
 #include "IFstream.H"
-#include "IStringStream.H"
-#include "addToRunTimeSelectionTable.H"
-#include "addToMemberFunctionSelectionTable.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
-namespace Foam
-{
-namespace fileFormats
-{
-
-addNamedToRunTimeSelectionTable
-(
-    keyedSurface,
-    FTRfileFormat,
-    fileExtension,
-    ftr
-);
-
-}
-}
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
-
-Foam::fileFormats::FTRfileFormat::FTRfileFormat()
+template<class Face>
+Foam::fileFormats::FTRsurfaceFormat<Face>::FTRsurfaceFormat()
 :
-    Foam::keyedSurface()
+    ParentType()
 {}
 
 
-Foam::fileFormats::FTRfileFormat::FTRfileFormat
+template<class Face>
+Foam::fileFormats::FTRsurfaceFormat<Face>::FTRsurfaceFormat
 (
-    const fileName& fName,
-    const bool triangulate
+    const fileName& fName
 )
 :
-    Foam::keyedSurface()
+    ParentType()
 {
-    read(fName,true);
+    ThisType::read(fName);
 }
 
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
-bool Foam::fileFormats::FTRfileFormat::read
+template<class Face>
+bool Foam::fileFormats::FTRsurfaceFormat<Face>::read
 (
-    const fileName& fName,
-    const bool
+    const fileName& fName
 )
 {
-    clear();
-    IFstream is(fName);
+    ParentType::clear();
 
+    IFstream is(fName);
     if (!is.good())
     {
         FatalErrorIn
         (
-            "fileFormats::FTRfileFormat::read(const fileName&)"
+            "fileFormats::FTRsurfaceFormat::read(const fileName&)"
         )
             << "Cannot read file " << fName
             << exit(FatalError);
@@ -94,13 +75,13 @@ bool Foam::fileFormats::FTRfileFormat::read
     List<point> pointLst(is);
 
     // transfer to normal list
-    points().transfer(pointLst);
+    ParentType::points().transfer(pointLst);
 
     // read faces with keys
     List<Keyed<triFace> > readFaces(is);
 
-    List<FaceType>  faceLst(readFaces.size());
-    List<label>     regionLst(readFaces.size());
+    List<Face>    faceLst(readFaces.size());
+    List<label>   regionLst(readFaces.size());
 
     // disentangle faces/keys - already triangulated
     forAll(readFaces, faceI)
@@ -110,8 +91,8 @@ bool Foam::fileFormats::FTRfileFormat::read
         regionLst[faceI] = readFaces[faceI].key();
     }
 
-    faces().transfer(faceLst);
-    regions().transfer(regionLst);
+    ParentType::faces().transfer(faceLst);
+    ParentType::regions().transfer(regionLst);
 
     Map<word> regionNames;
     forAll(readPatches, patchI)
@@ -119,8 +100,7 @@ bool Foam::fileFormats::FTRfileFormat::read
         regionNames.insert(patchI, readPatches[patchI].name());
     }
 
-    setPatches(regionNames, readPatches.size() - 1);
-
+    ParentType::setPatches(regionNames, readPatches.size() - 1);
     return true;
 }
 
diff --git a/src/surfMesh/keyedSurface/fileFormats/ftr/FTRfileFormat.H b/src/surfMesh/surfaceFormats/ftr/FTRsurfaceFormat.H
similarity index 71%
rename from src/surfMesh/keyedSurface/fileFormats/ftr/FTRfileFormat.H
rename to src/surfMesh/surfaceFormats/ftr/FTRsurfaceFormat.H
index 5b1c5a71e5..cfd1104bd7 100644
--- a/src/surfMesh/keyedSurface/fileFormats/ftr/FTRfileFormat.H
+++ b/src/surfMesh/surfaceFormats/ftr/FTRsurfaceFormat.H
@@ -23,22 +23,22 @@ License
     Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 
 Class
-    Foam::fileFormats::FTRfileFormat
+    Foam::fileFormats::FTRsurfaceFormat
 
 Description
     Reading of Foam Trisurface Format
 
 SourceFiles
-    FTRfileFormat.C
+    FTRsurfaceFormat.C
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef FTRfileFormat_H
-#define FTRfileFormat_H
+#ifndef FTRsurfaceFormat_H
+#define FTRsurfaceFormat_H
 
-#include "Ostream.H"
-#include "OFstream.H"
-#include "keyedSurface.H"
+#include "IFstream.H"
+#include "MeshedSurface.H"
+#include "UnsortedMeshedSurface.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -48,21 +48,25 @@ namespace fileFormats
 {
 
 /*---------------------------------------------------------------------------*\
-                       Class FTRfileFormat Declaration
+                     Class FTRsurfaceFormat Declaration
 \*---------------------------------------------------------------------------*/
 
-class FTRfileFormat
+template<class Face>
+class FTRsurfaceFormat
 :
-    public keyedSurface
+    public UnsortedMeshedSurface<Face>
 {
+    //- Private typedefs for convenience
+    typedef FTRsurfaceFormat<Face>      ThisType;
+    typedef UnsortedMeshedSurface<Face> ParentType;
 
     // Private Member Functions
 
         //- Disallow default bitwise copy construct
-        FTRfileFormat(const FTRfileFormat&);
+        FTRsurfaceFormat(const FTRsurfaceFormat<Face>&);
 
         //- Disallow default bitwise assignment
-        void operator=(const FTRfileFormat&);
+        void operator=(const FTRsurfaceFormat<Face>&);
 
 
     //- read compatibility for ftr format
@@ -93,30 +97,36 @@ public:
     // Constructors
 
         //- Construct null
-        FTRfileFormat();
+        FTRsurfaceFormat();
 
         //- Construct from file name
-        FTRfileFormat(const fileName&, const bool triangulate=false);
+        FTRsurfaceFormat(const fileName&);
 
     // Selectors
 
-        //- Read file and return keyedSurface
-        static autoPtr<keyedSurface> New
+        //- Read file and return surface
+        static autoPtr<UnsortedMeshedSurface<Face> > New
         (
-            const fileName& fName,
-            const bool triangulate=false
+            const fileName& fName
         )
         {
-            return autoPtr<keyedSurface>
+            return autoPtr<UnsortedMeshedSurface<Face> >
             (
-                new FTRfileFormat(fName,true)
+                new FTRsurfaceFormat<Face>(fName)
             );
         }
 
+
+    // Destructor
+
+        virtual ~FTRsurfaceFormat()
+        {}
+
+
     // Member Functions
 
         //- Read from file
-        virtual bool read(const fileName&, const bool triangulate);
+        virtual bool read(const fileName&);
 
 };
 
@@ -128,6 +138,10 @@ public:
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
+#ifdef NoRepository
+#   include "FTRsurfaceFormat.C"
+#endif
+
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 #endif
diff --git a/src/surfMesh/surfaceFormats/ftr/FTRsurfaceFormatRunTime.C b/src/surfMesh/surfaceFormats/ftr/FTRsurfaceFormatRunTime.C
new file mode 100644
index 0000000000..2b980bee50
--- /dev/null
+++ b/src/surfMesh/surfaceFormats/ftr/FTRsurfaceFormatRunTime.C
@@ -0,0 +1,59 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+\*---------------------------------------------------------------------------*/
+
+#include "FTRsurfaceFormat.H"
+#include "MeshedSurface.H"
+#include "UnsortedMeshedSurface.H"
+#include "addToRunTimeSelectionTable.H"
+#include "addToMemberFunctionSelectionTable.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+namespace Foam
+{
+namespace fileFormats
+{
+
+addNamedTemplatedToRunTimeSelectionTable
+(
+    UnsortedMeshedSurface,
+    FTRsurfaceFormat,
+    face,
+    fileExtension,
+    ftr
+);
+addNamedTemplatedToRunTimeSelectionTable
+(
+    UnsortedMeshedSurface,
+    FTRsurfaceFormat,
+    triFace,
+    fileExtension,
+    ftr
+);
+
+}
+}
+
+// ************************************************************************* //
diff --git a/src/surfMesh/keyedSurface/fileFormats/gts/GTSfileFormat.C b/src/surfMesh/surfaceFormats/gts/GTSsurfaceFormat.C
similarity index 76%
rename from src/surfMesh/keyedSurface/fileFormats/gts/GTSfileFormat.C
rename to src/surfMesh/surfaceFormats/gts/GTSsurfaceFormat.C
index f0ec9edf74..0e2414a587 100644
--- a/src/surfMesh/keyedSurface/fileFormats/gts/GTSfileFormat.C
+++ b/src/surfMesh/surfaceFormats/gts/GTSsurfaceFormat.C
@@ -24,96 +24,59 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-#include "GTSfileFormat.H"
-#include "triFace.H"
+#include "GTSsurfaceFormat.H"
 #include "clock.H"
 #include "IFstream.H"
 #include "IStringStream.H"
-#include "tensor.H"
-#include "primitivePatch.H"
-#include "addToRunTimeSelectionTable.H"
-#include "addToMemberFunctionSelectionTable.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
-namespace Foam
-{
-namespace fileFormats
-{
-
-addNamedToRunTimeSelectionTable
-(
-    keyedSurface,
-    GTSfileFormat,
-    fileExtension,
-    gts
-);
-
-addNamedToMemberFunctionSelectionTable
-(
-    keyedSurface,
-    GTSfileFormat,
-    write,
-    fileExtension,
-    gts
-);
-
-addNamedToMemberFunctionSelectionTable
-(
-    meshedSurface,
-    GTSfileFormat,
-    write,
-    fileExtension,
-    gts
-);
-
-}
-}
 
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 
-
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
-Foam::fileFormats::GTSfileFormat::GTSfileFormat()
+template<class Face>
+Foam::fileFormats::GTSsurfaceFormat<Face>::GTSsurfaceFormat()
 :
-    Foam::keyedSurface()
+    ParentType()
 {}
 
-Foam::fileFormats::GTSfileFormat::GTSfileFormat
+
+template<class Face>
+Foam::fileFormats::GTSsurfaceFormat<Face>::GTSsurfaceFormat
 (
-    const fileName& fName,
-    const bool
+    const fileName& fName
 )
 :
-    Foam::keyedSurface()
+    ParentType()
 {
-    read(fName,true);
+    read(fName);
 }
 
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
-bool Foam::fileFormats::GTSfileFormat::read
+template<class Face>
+bool Foam::fileFormats::GTSsurfaceFormat<Face>::read
 (
-    const fileName& fName,
-    const bool
+    const fileName& fName
 )
 {
-    clear();
-    IFstream is(fName);
+    ParentType::clear();
 
+    IFstream is(fName);
     if (!is.good())
     {
         FatalErrorIn
         (
-            "fileFormats::GTSfileFormat::read(const fileName&)"
+            "fileFormats::GTSsurfaceFormat::read(const fileName&)"
         )
             << "Cannot read file " << fName
             << exit(FatalError);
     }
 
     // Read header
-    string line = getLineNoComment(is);
+    string line = ParentType::getLineNoComment(is);
 
     label nPoints, nEdges, nElems;
     {
@@ -126,9 +89,9 @@ bool Foam::fileFormats::GTSfileFormat::read
 
 
     // write directly into the lists:
-    pointField& pointLst = points();
-    List<FaceType>& faceLst = faces();
-    List<label>& regionLst = regions();
+    pointField& pointLst = ParentType::points();
+    List<Face>& faceLst  = ParentType::faces();
+    List<label>& regionLst = ParentType::regions();
 
     pointLst.setSize(nPoints);
     faceLst.setSize(nElems);
@@ -139,7 +102,7 @@ bool Foam::fileFormats::GTSfileFormat::read
     forAll(pointLst, pointI)
     {
         scalar x, y, z;
-        line = getLineNoComment(is);
+        line = ParentType::getLineNoComment(is);
         {
             IStringStream lineStream(line);
             lineStream
@@ -154,7 +117,7 @@ bool Foam::fileFormats::GTSfileFormat::read
     forAll(edges, edgei)
     {
         label beg, end;
-        line = getLineNoComment(is);
+        line = ParentType::getLineNoComment(is);
         {
             IStringStream lineStream(line);
             lineStream
@@ -171,7 +134,7 @@ bool Foam::fileFormats::GTSfileFormat::read
         label e0Label, e1Label, e2Label;
         label regionI = 0;
 
-        line = getLineNoComment(is);
+        line = ParentType::getLineNoComment(is);
         {
             IStringStream lineStream(line);
             lineStream
@@ -206,7 +169,7 @@ bool Foam::fileFormats::GTSfileFormat::read
         {
             FatalErrorIn
             (
-                "fileFormats::GTSfileFormat::read(const fileName&)"
+                "fileFormats::GTSsurfaceFormat::read(const fileName&)"
             )
                 << "Edges 0 and 1 of triangle " << faceI
                 << " do not share a point.\n"
@@ -223,7 +186,7 @@ bool Foam::fileFormats::GTSfileFormat::read
         {
             FatalErrorIn
             (
-                "fileFormats::GTSfileFormat::read(const fileName&)"
+                "fileFormats::GTSsurfaceFormat::read(const fileName&)"
             )
                 << "Edges 1 and 2 of triangle " << faceI
                 << " do not share a point.\n"
@@ -238,7 +201,7 @@ bool Foam::fileFormats::GTSfileFormat::read
         {
             FatalErrorIn
             (
-                "fileFormats::GTSfileFormat::read(const fileName&)"
+                "fileFormats::GTSsurfaceFormat::read(const fileName&)"
             )
                 << "Edges of triangle " << faceI
                 << " reference more than three points.\n"
@@ -252,44 +215,50 @@ bool Foam::fileFormats::GTSfileFormat::read
         regionLst[faceI] = regionI;
     }
 
-    setPatches(maxPatch);
-    // stitchFaces(SMALL);
-
+    ParentType::setPatches(maxPatch);
+    // ParentType::stitchFaces(SMALL);
     return true;
 }
 
 
-void Foam::fileFormats::GTSfileFormat::write
+template<class Face>
+void Foam::fileFormats::GTSsurfaceFormat<Face>::write
 (
     Ostream& os,
-    const keyedSurface& surf
+    const UnsortedMeshedSurface<Face>& surf
 )
 {
     const pointField& pointLst = surf.points();
-    const List<FaceType>& faceLst  = surf.faces();
+    const List<Face>& faceLst  = surf.faces();
 
+    // check if output triangulation would be required
     // It is too annoying to triangulate on-the-fly
     // just issue a warning and get out
-    label nNonTris = 0;
-    forAll(faceLst, faceI)
+    //
+    if (faceLst.size() && faceLst[0].max_size() != 3)
     {
-        if (faceLst[faceI].size() > 3)
+        label nNonTris = 0;
+        forAll(faceLst, faceI)
         {
-            ++nNonTris;
+            if (faceLst[faceI].size() != 3)
+            {
+                ++nNonTris;
+            }
+        }
+
+        if (nNonTris)
+        {
+            FatalErrorIn
+            (
+                "fileFormats::GTSsurfaceFormat::write"
+                "(Ostream&, const UnsortedMeshedSurfaces<Face>&)"
+            )
+                << "Surface has " << nNonTris << "/" << faceLst.size()
+                << " non-triangulated faces - not writing!" << endl;
+            return;
         }
     }
 
-    if (nNonTris)
-    {
-        FatalErrorIn
-        (
-            "fileFormats::GTSfileFormat::write"
-            "(Ostream&, const keyedSurface&)"
-        )
-            << "Surface has " << nNonTris << "/" << faceLst.size()
-            << " non-triangulated faces - not writing!" << endl;
-        return;
-    }
 
     labelList faceMap;
     List<surfGroup> patchLst = surf.sortedRegions(faceMap);
@@ -352,38 +321,44 @@ void Foam::fileFormats::GTSfileFormat::write
 }
 
 
-void Foam::fileFormats::GTSfileFormat::write
+template<class Face>
+void Foam::fileFormats::GTSsurfaceFormat<Face>::write
 (
     Ostream& os,
-    const meshedSurface& surf
+    const MeshedSurface<Face>& surf
 )
 {
     const pointField& pointLst = surf.points();
-    const List<FaceType>& faceLst  = surf.faces();
+    const List<Face>& faceLst  = surf.faces();
     const List<surfGroup>& patchLst = surf.patches();
 
+
+    // check if output triangulation would be required
     // It is too annoying to triangulate on-the-fly
     // just issue a warning and get out
-    label nNonTris = 0;
-    forAll(faceLst, faceI)
+    //
+    if (faceLst.size() && faceLst[0].max_size() != 3)
     {
-        if (faceLst[faceI].size() > 3)
+        label nNonTris = 0;
+        forAll(faceLst, faceI)
         {
-            ++nNonTris;
+            if (faceLst[faceI].size() != 3)
+            {
+                ++nNonTris;
+            }
         }
-    }
 
-    if (nNonTris)
-    {
-        WarningIn
-        (
-            "fileFormats::GTSfileFormat::write"
-            "(Ostream&, const meshedSurface&)"
-        )
-            << "Surface has " << nNonTris << "/" << faceLst.size()
-            << " non-triangulated faces - not writing!" << endl;
-
-        return;
+        if (nNonTris)
+        {
+            FatalErrorIn
+            (
+                "fileFormats::GTSsurfaceFormat::write"
+                "(Ostream&, const MeshedSurface<Face>&)"
+            )
+                << "Surface has " << nNonTris << "/" << faceLst.size()
+                << " non-triangulated faces - not writing!" << endl;
+            return;
+        }
     }
 
     // Write header, print patch names as comment
diff --git a/src/surfMesh/keyedSurface/fileFormats/gts/GTSfileFormat.H b/src/surfMesh/surfaceFormats/gts/GTSsurfaceFormat.H
similarity index 62%
rename from src/surfMesh/keyedSurface/fileFormats/gts/GTSfileFormat.H
rename to src/surfMesh/surfaceFormats/gts/GTSsurfaceFormat.H
index 9512fab5e0..1a983fb794 100644
--- a/src/surfMesh/keyedSurface/fileFormats/gts/GTSfileFormat.H
+++ b/src/surfMesh/surfaceFormats/gts/GTSsurfaceFormat.H
@@ -23,23 +23,23 @@ License
     Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 
 Class
-    Foam::fileFormats::GTSfileFormat
+    Foam::fileFormats::GTSsurfaceFormat
 
 Description
     Provide a means of reading/writing GTS format.
 
 SourceFiles
-    GTSfileFormat.C
+    GTSsurfaceFormat.C
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef GTSfileFormat_H
-#define GTSfileFormat_H
+#ifndef GTSsurfaceFormat_H
+#define GTSsurfaceFormat_H
 
 #include "Ostream.H"
 #include "OFstream.H"
-#include "keyedSurface.H"
-#include "meshedSurface.H"
+#include "MeshedSurface.H"
+#include "UnsortedMeshedSurface.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -48,71 +48,90 @@ namespace Foam
 namespace fileFormats
 {
 
-class GTSfileFormat;
-
 /*---------------------------------------------------------------------------*\
-                      Class GTSfileFormat Declaration
+                      Class GTSsurfaceFormat Declaration
 \*---------------------------------------------------------------------------*/
 
-class GTSfileFormat
+template<class Face>
+class GTSsurfaceFormat
 :
-    public keyedSurface
+    public UnsortedMeshedSurface<Face>
 {
+    //- Private typedefs for convenience
+    typedef GTSsurfaceFormat<Face>      ThisType;
+    typedef UnsortedMeshedSurface<Face> ParentType;
 
     // Private Member Functions
 
         //- Disallow default bitwise copy construct
-        GTSfileFormat(const GTSfileFormat&);
+        GTSsurfaceFormat(const GTSsurfaceFormat<Face>&);
 
         //- Disallow default bitwise assignment
-        void operator=(const GTSfileFormat&);
+        void operator=(const GTSsurfaceFormat<Face>&);
 
 public:
 
     // Constructors
 
         //- Construct null
-        GTSfileFormat();
+        GTSsurfaceFormat();
 
         //- Construct from file name
-        GTSfileFormat(const fileName&, const bool triangulate=true);
+        GTSsurfaceFormat(const fileName&);
 
     // Selectors
 
-        //- Read file and return keyedSurface
-        static autoPtr<keyedSurface> New
+        //- Read file and return surface
+        static autoPtr<UnsortedMeshedSurface<Face> > New
         (
-            const fileName& fName,
-            const bool triangulate=true
+            const fileName& fName
         )
         {
-            return autoPtr<keyedSurface>
+            return autoPtr<UnsortedMeshedSurface<Face> >
             (
-                new GTSfileFormat(fName,true)
+                new GTSsurfaceFormat<Face>(fName)
             );
         }
 
     // Destructor
+        virtual ~GTSsurfaceFormat()
+        {}
 
     // Member Functions
 
         //- Read from file
-        virtual bool read(const fileName&, const bool triangulate);
+        virtual bool read(const fileName&);
 
-        //- Write keyedSurface
-        static void write(Ostream&, const keyedSurface&);
+        //- Write UnsortedMeshedSurface
+        static void write
+        (
+            Ostream&,
+            const UnsortedMeshedSurface<Face>&
+        );
 
-        //- Write keyedSurface
-        static void write(const fileName& fName, const keyedSurface& surf)
+        //- Write UnsortedMeshedSurface
+        static void write
+        (
+            const fileName& fName,
+            const UnsortedMeshedSurface<Face>& surf
+        )
         {
             write(OFstream(fName)(), surf);
         }
 
-        //- Write meshedSurface
-        static void write(Ostream&, const meshedSurface&);
+        //- Write MeshedSurface
+        static void write
+        (
+            Ostream&,
+            const MeshedSurface<Face>&
+        );
 
-        //- Write meshedSurface
-        static void write(const fileName& fName, const meshedSurface& surf)
+        //- Write MeshedSurface
+        static void write
+        (
+            const fileName& fName,
+            const MeshedSurface<Face>& surf
+        )
         {
             write(OFstream(fName)(), surf);
         }
@@ -133,6 +152,10 @@ public:
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
+#ifdef NoRepository
+#   include "GTSsurfaceFormat.C"
+#endif
+
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 #endif
diff --git a/src/surfMesh/surfaceFormats/gts/GTSsurfaceFormatRunTime.C b/src/surfMesh/surfaceFormats/gts/GTSsurfaceFormatRunTime.C
new file mode 100644
index 0000000000..a090693ff5
--- /dev/null
+++ b/src/surfMesh/surfaceFormats/gts/GTSsurfaceFormatRunTime.C
@@ -0,0 +1,98 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+\*---------------------------------------------------------------------------*/
+
+#include "GTSsurfaceFormat.H"
+#include "MeshedSurface.H"
+#include "UnsortedMeshedSurface.H"
+#include "addToRunTimeSelectionTable.H"
+#include "addToMemberFunctionSelectionTable.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+namespace Foam
+{
+namespace fileFormats
+{
+
+addNamedTemplatedToRunTimeSelectionTable
+(
+    UnsortedMeshedSurface,
+    GTSsurfaceFormat,
+    face,
+    fileExtension,
+    gts
+);
+addNamedTemplatedToRunTimeSelectionTable
+(
+    UnsortedMeshedSurface,
+    GTSsurfaceFormat,
+    triFace,
+    fileExtension,
+    gts
+);
+
+addNamedTemplatedToMemberFunctionSelectionTable
+(
+    UnsortedMeshedSurface,
+    GTSsurfaceFormat,
+    face,
+    write,
+    fileExtension,
+    gts
+);
+addNamedTemplatedToMemberFunctionSelectionTable
+(
+    UnsortedMeshedSurface,
+    GTSsurfaceFormat,
+    triFace,
+    write,
+    fileExtension,
+    gts
+);
+
+
+addNamedTemplatedToMemberFunctionSelectionTable
+(
+    MeshedSurface,
+    GTSsurfaceFormat,
+    face,
+    write,
+    fileExtension,
+    gts
+);
+addNamedTemplatedToMemberFunctionSelectionTable
+(
+    MeshedSurface,
+    GTSsurfaceFormat,
+    triFace,
+    write,
+    fileExtension,
+    gts
+);
+
+}
+}
+
+// ************************************************************************* //
diff --git a/src/surfMesh/keyedSurface/fileFormats/nas/NASfileFormat.C b/src/surfMesh/surfaceFormats/nas/NASsurfaceFormat.C
similarity index 85%
rename from src/surfMesh/keyedSurface/fileFormats/nas/NASfileFormat.C
rename to src/surfMesh/surfaceFormats/nas/NASsurfaceFormat.C
index 99b8500327..29fc4bd3f4 100644
--- a/src/surfMesh/keyedSurface/fileFormats/nas/NASfileFormat.C
+++ b/src/surfMesh/surfaceFormats/nas/NASsurfaceFormat.C
@@ -24,63 +24,21 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-#include "NASfileFormat.H"
-#include "triFace.H"
-#include "clock.H"
+#include "NASsurfaceFormat.H"
 #include "IFstream.H"
 #include "IStringStream.H"
-#include "addToRunTimeSelectionTable.H"
-#include "addToMemberFunctionSelectionTable.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
-namespace Foam
-{
-namespace fileFormats
-{
 
-// .bdf (Bulk Data Format)
-addNamedToRunTimeSelectionTable
-(
-    keyedSurface,
-    NASfileFormat,
-    fileExtension,
-    bdf
-);
-
-// .nas (Nastran)
-addNamedToRunTimeSelectionTable
-(
-    keyedSurface,
-    NASfileFormat,
-    fileExtension,
-    nas
-);
-
-// addNamedToMemberFunctionSelectionTable
-// (
-//     keyedSurface,
-//     NASfileFormat,
-//     write,
-//     fileExtension,
-//     nas
-// );
-//
-// addNamedToMemberFunctionSelectionTable
-// (
-//     meshedSurface,
-//     NASfileFormat,
-//     write,
-//     fileExtension,
-//     nas
-// );
-
-}
-}
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 
 
 // Do weird things to extract number
-Foam::scalar Foam::fileFormats::NASfileFormat::parseNASCoord(const string& s)
+template<class Face>
+Foam::scalar Foam::fileFormats::NASsurfaceFormat<Face>::parseNASCoord
+(
+    const string& s
+)
 {
     size_t expSign = s.find_last_of("+-");
 
@@ -103,51 +61,62 @@ Foam::scalar Foam::fileFormats::NASfileFormat::parseNASCoord(const string& s)
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
-Foam::fileFormats::NASfileFormat::NASfileFormat()
+template<class Face>
+Foam::fileFormats::NASsurfaceFormat<Face>::NASsurfaceFormat()
 :
-    Foam::keyedSurface()
+    ParentType()
 {}
 
 
-Foam::fileFormats::NASfileFormat::NASfileFormat
+template<class Face>
+Foam::fileFormats::NASsurfaceFormat<Face>::NASsurfaceFormat
 (
-    const fileName& fName,
-    const bool triangulate
+    const fileName& fName
 )
 :
-    Foam::keyedSurface()
+    ParentType()
 {
-    read(fName,triangulate);
+    ThisType::read(fName);
 }
 
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
-bool Foam::fileFormats::NASfileFormat::read
+template<class Face>
+bool Foam::fileFormats::NASsurfaceFormat<Face>::read
 (
-    const fileName& fName,
-    const bool triangulate
+    const fileName& fName
 )
 {
-    clear();
-    IFstream is(fName);
+    ParentType::clear();
 
+    // triangulation required?
+    bool mustTriangulate = false;
+    {
+        Face f;
+        if (f.max_size() == 3)
+        {
+            mustTriangulate = true;
+        }
+    }
+
+    IFstream is(fName);
     if (!is.good())
     {
         FatalErrorIn
         (
-            "fileFormats::NASfileFormat::read(const fileName&)"
+            "fileFormats::NASsurfaceFormat::read(const fileName&)"
         )
             << "Cannot read file " << fName
             << exit(FatalError);
     }
 
-    DynamicList<point>    pointLst;
+    DynamicList<point>  pointLst;
     // Nastran index of points
-    DynamicList<label>    pointId;
-    DynamicList<FaceType> faceLst;
-    DynamicList<label>    regionLst;
-    HashTable<label>      groupToPatch;
+    DynamicList<label>  pointId;
+    DynamicList<Face>   faceLst;
+    DynamicList<label>  regionLst;
+    HashTable<label>    groupToPatch;
 
     // From face groupId to patchId
     Map<label> groupIdToPatchId;
@@ -307,6 +276,7 @@ bool Foam::fileFormats::NASfileFormat::read
         else if (cmd == "CQUAD4")
         {
             face fQuad(4);
+            UList<label>& f = static_cast<UList<label>&>(fQuad);
 
             label groupId = readLabel(IStringStream(line.substr(16,8))());
             fQuad[0] = readLabel(IStringStream(line.substr(24,8))());
@@ -329,19 +299,19 @@ bool Foam::fileFormats::NASfileFormat::read
                 patchI = iter();
             }
 
-            if (triangulate)
+            if (mustTriangulate)
             {
                 triFace fTri;
 
                 // simple face triangulation about f[0].
                 // cannot use face::triangulation since points are incomplete
-                fTri[0] = fQuad[0];
-                for (label fp1 = 1; fp1 < fQuad.size() - 1; fp1++)
+                fTri[0] = f[0];
+                for (label fp1 = 1; fp1 < f.size() - 1; fp1++)
                 {
-                    label fp2 = (fp1 + 1) % fQuad.size();
+                    label fp2 = (fp1 + 1) % f.size();
 
-                    fTri[1] = fQuad[fp1];
-                    fTri[2] = fQuad[fp2];
+                    fTri[1] = f[fp1];
+                    fTri[2] = f[fp2];
 
                     faceLst.append(fTri);
                     regionLst.append(patchI);
@@ -349,7 +319,7 @@ bool Foam::fileFormats::NASfileFormat::read
             }
             else
             {
-                faceLst.append(fQuad);
+                faceLst.append(Face(f));
                 regionLst.append(patchI);
             }
         }
@@ -391,7 +361,7 @@ bool Foam::fileFormats::NASfileFormat::read
             {
                 FatalErrorIn
                 (
-                    "fileFormats::NASfileFormat::read(const fileName&)"
+                    "fileFormats::NASsurfaceFormat::read(const fileName&)"
                 )
                     << "Expected continuation symbol '*' when reading GRID*"
                     << " (double precision coordinate) output" << nl
@@ -420,8 +390,8 @@ bool Foam::fileFormats::NASfileFormat::read
 
 
     // transfer to normal lists
-    points().transfer(pointLst);
-    regions().transfer(regionLst);
+    ParentType::points().transfer(pointLst);
+    ParentType::regions().transfer(regionLst);
 
     pointId.shrink();
     faceLst.shrink();
@@ -439,7 +409,7 @@ bool Foam::fileFormats::NASfileFormat::read
         // Relabel faces
         forAll(faceLst, i)
         {
-            face& f = faceLst[i];
+            Face& f = faceLst[i];
             forAll(f, fp)
             {
                 f[fp] = nasToFoamPoint[f[fp]];
@@ -461,10 +431,9 @@ bool Foam::fileFormats::NASfileFormat::read
     }
 
     // transfer to normal lists
-    faces().transfer(faceLst);
-
-    setPatches(regionNames);
+    ParentType::faces().transfer(faceLst);
 
+    ParentType::setPatches(regionNames);
     return true;
 }
 
diff --git a/src/surfMesh/keyedSurface/fileFormats/nas/NASfileFormat.H b/src/surfMesh/surfaceFormats/nas/NASsurfaceFormat.H
similarity index 73%
rename from src/surfMesh/keyedSurface/fileFormats/nas/NASfileFormat.H
rename to src/surfMesh/surfaceFormats/nas/NASsurfaceFormat.H
index bef292f5f3..093ad170db 100644
--- a/src/surfMesh/keyedSurface/fileFormats/nas/NASfileFormat.H
+++ b/src/surfMesh/surfaceFormats/nas/NASsurfaceFormat.H
@@ -23,7 +23,7 @@ License
     Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 
 Class
-    Foam::fileFormats::NASfileFormat
+    Foam::fileFormats::NASsurfaceFormat
 
 Description
     Nastran surface reader.
@@ -37,17 +37,17 @@ Description
     @endverbatim
 
 SourceFiles
-    NASfileFormat.C
+    NASsurfaceFormat.C
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef NASfileFormat_H
-#define NASfileFormat_H
+#ifndef NASsurfaceFormat_H
+#define NASsurfaceFormat_H
 
 #include "Ostream.H"
 #include "OFstream.H"
-#include "keyedSurface.H"
-#include "meshedSurface.H"
+#include "MeshedSurface.H"
+#include "UnsortedMeshedSurface.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -57,13 +57,17 @@ namespace fileFormats
 {
 
 /*---------------------------------------------------------------------------*\
-                       Class NASfileFormat Declaration
+                       Class NASsurfaceFormat Declaration
 \*---------------------------------------------------------------------------*/
 
-class NASfileFormat
+template<class Face>
+class NASsurfaceFormat
 :
-    public keyedSurface
+    public UnsortedMeshedSurface<Face>
 {
+    //- Private typedefs for convenience
+    typedef NASsurfaceFormat<Face>      ThisType;
+    typedef UnsortedMeshedSurface<Face> ParentType;
 
     // Private Member Functions
 
@@ -71,42 +75,44 @@ class NASfileFormat
         static scalar parseNASCoord(const string&);
 
         //- Disallow default bitwise copy construct
-        NASfileFormat(const NASfileFormat&);
+        NASsurfaceFormat(const NASsurfaceFormat<Face>&);
 
         //- Disallow default bitwise assignment
-        void operator=(const NASfileFormat&);
+        void operator=(const NASsurfaceFormat<Face>&);
 
 public:
 
     // Constructors
 
         //- Construct null
-        NASfileFormat();
+        NASsurfaceFormat();
 
         //- Construct from file name
-        NASfileFormat(const fileName&, const bool triangulate=false);
+        NASsurfaceFormat(const fileName&);
 
     // Selectors
 
-        //- Read file and return keyedSurface
-        static autoPtr<keyedSurface> New
+        //- Read file and return surface
+        static autoPtr<UnsortedMeshedSurface<Face> > New
         (
-            const fileName& fName,
-            const bool triangulate=false
+            const fileName& fName
         )
         {
-            return autoPtr<keyedSurface>
+            return autoPtr<UnsortedMeshedSurface<Face> >
             (
-                new NASfileFormat(fName,triangulate)
+                new NASsurfaceFormat<Face>(fName)
             );
         }
 
     // Destructor
 
+        virtual ~NASsurfaceFormat()
+        {}
+
     // Member Functions
 
         //- Read from a file
-        virtual bool read(const fileName&, const bool triangulate);
+        virtual bool read(const fileName&);
 
 };
 
@@ -118,6 +124,10 @@ public:
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
+#ifdef NoRepository
+#   include "NASsurfaceFormat.C"
+#endif
+
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 #endif
diff --git a/src/surfMesh/surfaceFormats/nas/NASsurfaceFormatRunTime.C b/src/surfMesh/surfaceFormats/nas/NASsurfaceFormatRunTime.C
new file mode 100644
index 0000000000..fd07a95b1f
--- /dev/null
+++ b/src/surfMesh/surfaceFormats/nas/NASsurfaceFormatRunTime.C
@@ -0,0 +1,78 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+\*---------------------------------------------------------------------------*/
+
+#include "NASsurfaceFormat.H"
+#include "MeshedSurface.H"
+#include "UnsortedMeshedSurface.H"
+#include "addToRunTimeSelectionTable.H"
+#include "addToMemberFunctionSelectionTable.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+namespace Foam
+{
+namespace fileFormats
+{
+
+// .bdf (Bulk Data Format)
+addNamedTemplatedToRunTimeSelectionTable
+(
+    UnsortedMeshedSurface,
+    NASsurfaceFormat,
+    face,
+    fileExtension,
+    bdf
+);
+addNamedTemplatedToRunTimeSelectionTable
+(
+    UnsortedMeshedSurface,
+    NASsurfaceFormat,
+    triFace,
+    fileExtension,
+    bdf
+);
+
+// .nas (Nastran)
+addNamedTemplatedToRunTimeSelectionTable
+(
+    UnsortedMeshedSurface,
+    NASsurfaceFormat,
+    face,
+    fileExtension,
+    nas
+);
+addNamedTemplatedToRunTimeSelectionTable
+(
+    UnsortedMeshedSurface,
+    NASsurfaceFormat,
+    triFace,
+    fileExtension,
+    nas
+);
+
+}
+}
+
+// ************************************************************************* //
diff --git a/src/surfMesh/keyedSurface/fileFormats/obj/OBJfileFormat.C b/src/surfMesh/surfaceFormats/obj/OBJsurfaceFormat.C
similarity index 81%
rename from src/surfMesh/keyedSurface/fileFormats/obj/OBJfileFormat.C
rename to src/surfMesh/surfaceFormats/obj/OBJsurfaceFormat.C
index db9b0b9260..4920b12abc 100644
--- a/src/surfMesh/keyedSurface/fileFormats/obj/OBJfileFormat.C
+++ b/src/surfMesh/surfaceFormats/obj/OBJsurfaceFormat.C
@@ -24,56 +24,19 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-#include "OBJfileFormat.H"
-#include "triFace.H"
+#include "OBJsurfaceFormat.H"
 #include "clock.H"
 #include "IFstream.H"
 #include "IStringStream.H"
-#include "addToRunTimeSelectionTable.H"
-#include "addToMemberFunctionSelectionTable.H"
-
-// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
-namespace Foam
-{
-namespace fileFormats
-{
-
-addNamedToRunTimeSelectionTable
-(
-    keyedSurface,
-    OBJfileFormat,
-    fileExtension,
-    obj
-);
-
-addNamedToMemberFunctionSelectionTable
-(
-    keyedSurface,
-    OBJfileFormat,
-    write,
-    fileExtension,
-    obj
-);
-
-addNamedToMemberFunctionSelectionTable
-(
-    meshedSurface,
-    OBJfileFormat,
-    write,
-    fileExtension,
-    obj
-);
-
-}
-}
 
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 
-void Foam::fileFormats::OBJfileFormat::writeHead
+template<class Face>
+void Foam::fileFormats::OBJsurfaceFormat<Face>::writeHead
 (
     Ostream& os,
     const pointField& pointLst,
-    const List<FaceType>& faceLst,
+    const List<Face>& faceLst,
     const List<surfGroup>& patchLst
 )
 {
@@ -111,47 +74,58 @@ void Foam::fileFormats::OBJfileFormat::writeHead
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
-Foam::fileFormats::OBJfileFormat::OBJfileFormat()
+template<class Face>
+Foam::fileFormats::OBJsurfaceFormat<Face>::OBJsurfaceFormat()
 :
-    Foam::keyedSurface()
+    ParentType()
 {}
 
 
-Foam::fileFormats::OBJfileFormat::OBJfileFormat
+template<class Face>
+Foam::fileFormats::OBJsurfaceFormat<Face>::OBJsurfaceFormat
 (
-    const fileName& fName,
-    const bool triangulate
+    const fileName& fName
 )
 :
-    Foam::keyedSurface()
+    ParentType()
 {
-    read(fName,triangulate);
+    ThisType::read(fName);
 }
 
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
-bool Foam::fileFormats::OBJfileFormat::read
+template<class Face>
+bool Foam::fileFormats::OBJsurfaceFormat<Face>::read
 (
-    const fileName& fName,
-    const bool triangulate
+    const fileName& fName
 )
 {
-    clear();
-    IFstream is(fName);
+    ParentType::clear();
 
+    // triangulation required?
+    bool mustTriangulate = false;
+    {
+        Face f;
+        if (f.max_size() == 3)
+        {
+            mustTriangulate = true;
+        }
+    }
+
+    IFstream is(fName);
     if (!is.good())
     {
         FatalErrorIn
         (
-            "fileFormats::OBJfileFormat::read(const fileName&)"
+            "fileFormats::OBJsurfaceFormat::read(const fileName&)"
         )
             << "Cannot read file " << fName
             << exit(FatalError);
     }
 
     DynamicList<point>    pointLst;
-    DynamicList<FaceType> faceLst;
+    DynamicList<Face>     faceLst;
     DynamicList<label>    regionLst;
     HashTable<label>      groupToPatch;
 
@@ -161,13 +135,13 @@ bool Foam::fileFormats::OBJfileFormat::read
 
     while (is.good())
     {
-        string line = getLineNoComment(is);
+        string line = ParentType::getLineNoComment(is);
 
         // handle continuations
         if (line[line.size()-1] == '\\')
         {
             line.substr(0, line.size()-1);
-            line += getLineNoComment(is);
+            line += ParentType::getLineNoComment(is);
         }
 
         // Read first word
@@ -253,9 +227,9 @@ bool Foam::fileFormats::OBJfileFormat::read
             }
             dynVertices.shrink();
 
-            FaceType f(SubList<label>(dynVertices, dynVertices.size()));
+            UList<label>& f = static_cast<UList<label>&>(dynVertices);
 
-            if (triangulate && f.size() > 3)
+            if (mustTriangulate)
             {
                 triFace fTri;
 
@@ -275,30 +249,30 @@ bool Foam::fileFormats::OBJfileFormat::read
             }
             else
             {
-                faceLst.append(f);
+                faceLst.append(Face(f));
                 regionLst.append(groupID);
             }
         }
     }
 
     // transfer to normal lists
-    points().transfer(pointLst);
-    faces().transfer(faceLst);
-    regions().transfer(regionLst);
-
-    setPatches(groupToPatch);
+    ParentType::points().transfer(pointLst);
+    ParentType::faces().transfer(faceLst);
+    ParentType::regions().transfer(regionLst);
 
+    ParentType::setPatches(groupToPatch);
     return true;
 }
 
 
-void Foam::fileFormats::OBJfileFormat::write
+template<class Face>
+void Foam::fileFormats::OBJsurfaceFormat<Face>::write
 (
     Ostream& os,
-    const keyedSurface& surf
+    const UnsortedMeshedSurface<Face>& surf
 )
 {
-    const List<FaceType>& faceLst = surf.faces();
+    const List<Face>& faceLst = surf.faces();
 
     labelList faceMap;
     List<surfGroup> patchLst = surf.sortedRegions(faceMap);
@@ -330,13 +304,14 @@ void Foam::fileFormats::OBJfileFormat::write
 }
 
 
-void Foam::fileFormats::OBJfileFormat::write
+template<class Face>
+void Foam::fileFormats::OBJsurfaceFormat<Face>::write
 (
     Ostream& os,
-    const meshedSurface& surf
+    const MeshedSurface<Face>& surf
 )
 {
-    const List<FaceType>& faceLst = surf.faces();
+    const List<Face>& faceLst = surf.faces();
     const List<surfGroup>& patchLst = surf.patches();
 
     writeHead(os, surf.points(), faceLst, patchLst);
diff --git a/src/surfMesh/keyedSurface/fileFormats/obj/OBJfileFormat.H b/src/surfMesh/surfaceFormats/obj/OBJsurfaceFormat.H
similarity index 63%
rename from src/surfMesh/keyedSurface/fileFormats/obj/OBJfileFormat.H
rename to src/surfMesh/surfaceFormats/obj/OBJsurfaceFormat.H
index e9e202cf96..a0a31f641e 100644
--- a/src/surfMesh/keyedSurface/fileFormats/obj/OBJfileFormat.H
+++ b/src/surfMesh/surfaceFormats/obj/OBJsurfaceFormat.H
@@ -23,7 +23,7 @@ License
     Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 
 Class
-    Foam::fileFormats::OBJfileFormat
+    Foam::fileFormats::OBJsurfaceFormat
 
 Description
     Provide a means of reading/writing Alias/Wavefront OBJ format.
@@ -31,17 +31,17 @@ Description
     Does not handle negative face indices.
 
 SourceFiles
-    OBJfileFormat.C
+    OBJsurfaceFormat.C
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef OBJfileFormat_H
-#define OBJfileFormat_H
+#ifndef OBJsurfaceFormat_H
+#define OBJsurfaceFormat_H
 
 #include "Ostream.H"
 #include "OFstream.H"
-#include "keyedSurface.H"
-#include "meshedSurface.H"
+#include "MeshedSurface.H"
+#include "UnsortedMeshedSurface.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -51,27 +51,31 @@ namespace fileFormats
 {
 
 /*---------------------------------------------------------------------------*\
-                       Class OBJfileFormat Declaration
+                     Class OBJsurfaceFormat Declaration
 \*---------------------------------------------------------------------------*/
 
-class OBJfileFormat
+template<class Face>
+class OBJsurfaceFormat
 :
-    public keyedSurface
+    public UnsortedMeshedSurface<Face>
 {
+    //- Private typedefs for convenience
+    typedef OBJsurfaceFormat<Face>      ThisType;
+    typedef UnsortedMeshedSurface<Face> ParentType;
 
     // Private Member Functions
 
         //- Disallow default bitwise copy construct
-        OBJfileFormat(const OBJfileFormat&);
+        OBJsurfaceFormat(const OBJsurfaceFormat<Face>&);
 
         //- Disallow default bitwise assignment
-        void operator=(const OBJfileFormat&);
+        void operator=(const OBJsurfaceFormat<Face>&);
 
         static void writeHead
         (
             Ostream&,
             const pointField&,
-            const List<FaceType>&,
+            const List<Face>&,
             const List<surfGroup>&
         );
 
@@ -80,47 +84,66 @@ public:
     // Constructors
 
         //- Construct null
-        OBJfileFormat();
+        OBJsurfaceFormat();
 
         //- Construct from file name
-        OBJfileFormat(const fileName&, const bool triangulate=false);
+        OBJsurfaceFormat(const fileName&);
 
     // Selectors
 
-        //- Read file and return keyedSurface
-        static autoPtr<keyedSurface> New
+        //- Read file and return surface
+        static autoPtr<UnsortedMeshedSurface<Face> > New
         (
-            const fileName& fName,
-            const bool triangulate=false
+            const fileName& fName
         )
         {
-            return autoPtr<keyedSurface>
+            return autoPtr<UnsortedMeshedSurface<Face> >
             (
-                new OBJfileFormat(fName,triangulate)
+                new OBJsurfaceFormat<Face>(fName)
             );
         }
 
     // Destructor
 
+        virtual ~OBJsurfaceFormat()
+        {}
+
+
     // Member Functions
 
         //- Read from file
-        virtual bool read(const fileName&, const bool triangulate);
+        virtual bool read(const fileName&);
 
-        //- Write keyedSurface
-        static void write(Ostream&, const keyedSurface&);
+        //- Write UnsortedMeshedSurface
+        static void write
+        (
+            Ostream&,
+            const UnsortedMeshedSurface<Face>&
+        );
 
-        //- Write keyedSurface
-        static void write(const fileName& fName, const keyedSurface& surf)
+        //- Write UnsortedMeshedSurface
+        static void write
+        (
+            const fileName& fName,
+            const UnsortedMeshedSurface<Face>& surf
+        )
         {
             write(OFstream(fName)(), surf);
         }
 
-        //- Write meshedSurface
-        static void write(Ostream&, const meshedSurface&);
+        //- Write MeshedSurface
+        static void write
+        (
+            Ostream&,
+            const MeshedSurface<Face>&
+        );
 
-        //- Write meshedSurface
-        static void write(const fileName& fName, const meshedSurface& surf)
+        //- Write MeshedSurface
+        static void write
+        (
+            const fileName& fName,
+            const MeshedSurface<Face>& surf
+        )
         {
             write(OFstream(fName)(), surf);
         }
@@ -141,6 +164,10 @@ public:
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
+#ifdef NoRepository
+#   include "OBJsurfaceFormat.C"
+#endif
+
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 #endif
diff --git a/src/surfMesh/surfaceFormats/obj/OBJsurfaceFormatRunTime.C b/src/surfMesh/surfaceFormats/obj/OBJsurfaceFormatRunTime.C
new file mode 100644
index 0000000000..f7ec748294
--- /dev/null
+++ b/src/surfMesh/surfaceFormats/obj/OBJsurfaceFormatRunTime.C
@@ -0,0 +1,99 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+\*---------------------------------------------------------------------------*/
+
+#include "OBJsurfaceFormat.H"
+#include "MeshedSurface.H"
+#include "UnsortedMeshedSurface.H"
+#include "addToRunTimeSelectionTable.H"
+#include "addToMemberFunctionSelectionTable.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+namespace Foam
+{
+namespace fileFormats
+{
+
+addNamedTemplatedToRunTimeSelectionTable
+(
+    UnsortedMeshedSurface,
+    OBJsurfaceFormat,
+    face,
+    fileExtension,
+    obj
+);
+addNamedTemplatedToRunTimeSelectionTable
+(
+    UnsortedMeshedSurface,
+    OBJsurfaceFormat,
+    triFace,
+    fileExtension,
+    obj
+);
+
+
+addNamedTemplatedToMemberFunctionSelectionTable
+(
+    UnsortedMeshedSurface,
+    OBJsurfaceFormat,
+    face,
+    write,
+    fileExtension,
+    obj
+);
+addNamedTemplatedToMemberFunctionSelectionTable
+(
+    UnsortedMeshedSurface,
+    OBJsurfaceFormat,
+    triFace,
+    write,
+    fileExtension,
+    obj
+);
+
+
+addNamedTemplatedToMemberFunctionSelectionTable
+(
+    MeshedSurface,
+    OBJsurfaceFormat,
+    face,
+    write,
+    fileExtension,
+    obj
+);
+addNamedTemplatedToMemberFunctionSelectionTable
+(
+    MeshedSurface,
+    OBJsurfaceFormat,
+    triFace,
+    write,
+    fileExtension,
+    obj
+);
+
+}
+}
+
+// ************************************************************************* //
diff --git a/src/surfMesh/keyedSurface/fileFormats/off/OFFfileFormat.C b/src/surfMesh/surfaceFormats/off/OFFsurfaceFormat.C
similarity index 74%
rename from src/surfMesh/keyedSurface/fileFormats/off/OFFfileFormat.C
rename to src/surfMesh/surfaceFormats/off/OFFsurfaceFormat.C
index fb18ef5790..19a06b752e 100644
--- a/src/surfMesh/keyedSurface/fileFormats/off/OFFfileFormat.C
+++ b/src/surfMesh/surfaceFormats/off/OFFsurfaceFormat.C
@@ -24,56 +24,21 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-#include "OFFfileFormat.H"
-#include "triFace.H"
+#include "OFFsurfaceFormat.H"
 #include "clock.H"
 #include "IFstream.H"
 #include "IStringStream.H"
-#include "addToRunTimeSelectionTable.H"
-#include "addToMemberFunctionSelectionTable.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
-namespace Foam
-{
-namespace fileFormats
-{
-
-addNamedToRunTimeSelectionTable
-(
-    keyedSurface,
-    OFFfileFormat,
-    fileExtension,
-    off
-);
-
-addNamedToMemberFunctionSelectionTable
-(
-    keyedSurface,
-    OFFfileFormat,
-    write,
-    fileExtension,
-    off
-);
-
-addNamedToMemberFunctionSelectionTable
-(
-    meshedSurface,
-    OFFfileFormat,
-    write,
-    fileExtension,
-    off
-);
-
-}
-}
 
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 
-void Foam::fileFormats::OFFfileFormat::writeHead
+template<class Face>
+void Foam::fileFormats::OFFsurfaceFormat<Face>::writeHead
 (
     Ostream& os,
     const pointField& pointLst,
-    const List<FaceType>& faceLst,
+    const List<Face>& faceLst,
     const List<surfGroup>& patchLst
 )
 {
@@ -116,52 +81,63 @@ void Foam::fileFormats::OFFfileFormat::writeHead
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
-Foam::fileFormats::OFFfileFormat::OFFfileFormat()
+template<class Face>
+Foam::fileFormats::OFFsurfaceFormat<Face>::OFFsurfaceFormat()
 :
-    keyedSurface()
+    ParentType()
 {}
 
 
-Foam::fileFormats::OFFfileFormat::OFFfileFormat
+template<class Face>
+Foam::fileFormats::OFFsurfaceFormat<Face>::OFFsurfaceFormat
 (
-    const fileName& fName,
-    const bool triangulate
+    const fileName& fName
 )
 :
-    keyedSurface()
+    ParentType()
 {
-    read(fName,triangulate);
+    ThisType::read(fName);
 }
 
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
-bool Foam::fileFormats::OFFfileFormat::read
+template<class Face>
+bool Foam::fileFormats::OFFsurfaceFormat<Face>::read
 (
-    const fileName& fName,
-    const bool triangulate
+    const fileName& fName
 )
 {
-    clear();
-    IFstream is(fName);
+    ParentType::clear();
 
+    // triangulation required?
+    bool mustTriangulate = false;
+    {
+        Face f;
+        if (f.max_size() == 3)
+        {
+            mustTriangulate = true;
+        }
+    }
+
+    IFstream is(fName);
     if (!is.good())
     {
         FatalErrorIn
         (
-            "fileFormats::OFFfileFormat::read(const fileName&)"
+            "fileFormats::OFFsurfaceFormat<Face>::read(const fileName&)"
         )
             << "Cannot read file " << fName
             << exit(FatalError);
     }
 
     // Read header
-    string hdr = getLineNoComment(is);
+    string hdr = ParentType::getLineNoComment(is);
     if (hdr != "OFF")
     {
         FatalErrorIn
         (
-            "fileFormats::OFFfileFormat::read(const fileName&)"
+            "fileFormats::OFFsurfaceFormat<Face>::read(const fileName&)"
         )
             << "OFF file " << fName << " does not start with 'OFF'"
             << exit(FatalError);
@@ -171,7 +147,7 @@ bool Foam::fileFormats::OFFfileFormat::read
     // get dimensions
     label nPoints, nEdges, nElems;
 
-    string line = getLineNoComment(is);
+    string line = ParentType::getLineNoComment(is);
     {
         IStringStream lineStream(line);
         lineStream >> nPoints >> nElems >> nEdges;
@@ -182,7 +158,7 @@ bool Foam::fileFormats::OFFfileFormat::read
     forAll(pointLst, pointI)
     {
         scalar x, y, z;
-        line = getLineNoComment(is);
+        line = ParentType::getLineNoComment(is);
         {
             IStringStream lineStream(line);
             lineStream >> x >> y >> z;
@@ -192,25 +168,27 @@ bool Foam::fileFormats::OFFfileFormat::read
 
     // Read faces - ignore optional region information
     // use a DynamicList for possible on-the-fly triangulation
-    DynamicList<FaceType>  faceLst(nElems);
+    DynamicList<Face>  faceLst(nElems);
 
     forAll(faceLst, faceI)
     {
-        line = getLineNoComment(is);
+        line = ParentType::getLineNoComment(is);
         {
             IStringStream lineStream(line);
 
             label nVerts;
             lineStream >> nVerts;
 
-            face f(nVerts);
+            List<label> verts(nVerts);
 
-            forAll(f, fp)
+            forAll(verts, vertI)
             {
-                lineStream >> f[fp];
+                lineStream >> verts[vertI];
             }
 
-            if (triangulate && f.size() > 3)
+            UList<label>& f = static_cast<UList<label>&>(verts);
+
+            if (mustTriangulate)
             {
                 triFace fTri;
 
@@ -229,31 +207,32 @@ bool Foam::fileFormats::OFFfileFormat::read
             }
             else
             {
-                faceLst.append(f);
+                faceLst.append(Face(f));
             }
         }
     }
 
     // transfer to normal lists
-    points().transfer(pointLst);
-    faces().transfer(faceLst);
+    ParentType::points().transfer(pointLst);
+    ParentType::faces().transfer(faceLst);
 
     // no region information
-    regions().setSize(size());
-    regions() = 0;
+    ParentType::regions().setSize(ThisType::size());
+    ParentType::regions() = 0;
 
-    setPatches(0);
+    ParentType::setPatches(0);
     return true;
 }
 
 
-void Foam::fileFormats::OFFfileFormat::write
+template<class Face>
+void Foam::fileFormats::OFFsurfaceFormat<Face>::write
 (
     Ostream& os,
-    const keyedSurface& surf
+    const UnsortedMeshedSurface<Face>& surf
 )
 {
-    const List<FaceType>& faceLst = surf.faces();
+    const List<Face>& faceLst = surf.faces();
 
     labelList faceMap;
     List<surfGroup> patchLst = surf.sortedRegions(faceMap);
@@ -267,7 +246,7 @@ void Foam::fileFormats::OFFfileFormat::write
 
         forAll(patchLst[patchI], patchFaceI)
         {
-            const face& f = faceLst[faceMap[faceIndex++]];
+            const Face& f = faceLst[faceMap[faceIndex++]];
 
             os  << f.size();
             forAll(f, fp)
@@ -284,13 +263,14 @@ void Foam::fileFormats::OFFfileFormat::write
 }
 
 
-void Foam::fileFormats::OFFfileFormat::write
+template<class Face>
+void Foam::fileFormats::OFFsurfaceFormat<Face>::write
 (
     Ostream& os,
-    const meshedSurface& surf
+    const MeshedSurface<Face>& surf
 )
 {
-    const List<FaceType>& faceLst = surf.faces();
+    const List<Face>& faceLst = surf.faces();
     const List<surfGroup>& patchLst = surf.patches();
 
     writeHead(os, surf.points(), faceLst, patchLst);
@@ -302,7 +282,7 @@ void Foam::fileFormats::OFFfileFormat::write
 
         forAll(patchLst[patchI], patchFaceI)
         {
-            const face& f = faceLst[faceIndex++];
+            const Face& f = faceLst[faceIndex++];
 
             os  << f.size();
             forAll(f, fp)
diff --git a/src/surfMesh/keyedSurface/fileFormats/off/OFFfileFormat.H b/src/surfMesh/surfaceFormats/off/OFFsurfaceFormat.H
similarity index 66%
rename from src/surfMesh/keyedSurface/fileFormats/off/OFFfileFormat.H
rename to src/surfMesh/surfaceFormats/off/OFFsurfaceFormat.H
index b9012b00c6..c3ac05591a 100644
--- a/src/surfMesh/keyedSurface/fileFormats/off/OFFfileFormat.H
+++ b/src/surfMesh/surfaceFormats/off/OFFsurfaceFormat.H
@@ -23,7 +23,7 @@ License
     Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 
 Class
-    Foam::fileFormats::OFFfileFormat
+    Foam::fileFormats::OFFsurfaceFormat
 
 Description
     Provide a means of reading/writing Geomview OFF polyList format.
@@ -43,13 +43,13 @@ SourceFiles
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef OFFfileFormat_H
-#define OFFfileFormat_H
+#ifndef OFFsurfaceFormat_H
+#define OFFsurfaceFormat_H
 
 #include "Ostream.H"
 #include "OFstream.H"
-#include "keyedSurface.H"
-#include "meshedSurface.H"
+#include "MeshedSurface.H"
+#include "UnsortedMeshedSurface.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -59,26 +59,31 @@ namespace fileFormats
 {
 
 /*---------------------------------------------------------------------------*\
-                       Class OFFfileFormat Declaration
+                     Class OFFsurfaceFormat Declaration
 \*---------------------------------------------------------------------------*/
 
-class OFFfileFormat
+template<class Face>
+class OFFsurfaceFormat
 :
-    public keyedSurface
+    public UnsortedMeshedSurface<Face>
 {
+    //- Private typedefs for convenience
+    typedef OFFsurfaceFormat<Face>      ThisType;
+    typedef UnsortedMeshedSurface<Face> ParentType;
+
     // Private Member Functions
 
         //- Disallow default bitwise copy construct
-        OFFfileFormat(const OFFfileFormat&);
+        OFFsurfaceFormat(const OFFsurfaceFormat&);
 
         //- Disallow default bitwise assignment
-        void operator=(const OFFfileFormat&);
+        void operator=(const OFFsurfaceFormat&);
 
         static void writeHead
         (
             Ostream&,
             const pointField&,
-            const List<FaceType>&,
+            const List<Face>&,
             const List<surfGroup>&
         );
 
@@ -87,47 +92,64 @@ public:
     // Constructors
 
         //- Construct null
-        OFFfileFormat();
+        OFFsurfaceFormat();
 
         //- Construct from file name
-        OFFfileFormat(const fileName&, const bool triangulate=false);
+        OFFsurfaceFormat(const fileName&);
 
     // Selectors
 
-        //- Read file and return keyedSurface
-        static autoPtr<keyedSurface> New
+        //- Read file and return surface
+        static autoPtr<UnsortedMeshedSurface<Face> > New
         (
-            const fileName& fName,
-            const bool triangulate=false
+            const fileName& fName
         )
         {
-            return autoPtr<keyedSurface>
+            return autoPtr<UnsortedMeshedSurface<Face> >
             (
-                new OFFfileFormat(fName,triangulate)
+                new OFFsurfaceFormat(fName)
             );
         }
 
     // Destructor
+        virtual ~OFFsurfaceFormat()
+        {}
 
     // Member Functions
 
         //- Read from file
-        virtual bool read(const fileName&, const bool triangulate);
+        virtual bool read(const fileName&);
 
-        //- Write keyedSurface
-        static void write(Ostream&, const keyedSurface&);
+        //- Write UnsortedMeshedSurface
+        static void write
+        (
+            Ostream&,
+            const UnsortedMeshedSurface<Face>&
+        );
 
-        //- Write keyedSurface
-        static void write(const fileName& fName, const keyedSurface& surf)
+        //- Write UnsortedMeshedSurface
+        static void write
+        (
+            const fileName& fName,
+            const UnsortedMeshedSurface<Face>& surf
+        )
         {
             write(OFstream(fName)(), surf);
         }
 
-        //- Write meshedSurface
-        static void write(Ostream&, const meshedSurface&);
+        //- Write MeshedSurface
+        static void write
+        (
+            Ostream&,
+            const MeshedSurface<Face>&
+        );
 
-        //- Write meshedSurface
-        static void write(const fileName& fName, const meshedSurface& surf)
+        //- Write MeshedSurface
+        static void write
+        (
+            const fileName& fName,
+            const MeshedSurface<Face>& surf
+        )
         {
             write(OFstream(fName)(), surf);
         }
@@ -148,6 +170,11 @@ public:
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
+
+#ifdef NoRepository
+#   include "OFFsurfaceFormat.C"
+#endif
+
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 #endif
diff --git a/src/surfMesh/surfaceFormats/off/OFFsurfaceFormatRunTime.C b/src/surfMesh/surfaceFormats/off/OFFsurfaceFormatRunTime.C
new file mode 100644
index 0000000000..40b92b244f
--- /dev/null
+++ b/src/surfMesh/surfaceFormats/off/OFFsurfaceFormatRunTime.C
@@ -0,0 +1,99 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+\*---------------------------------------------------------------------------*/
+
+#include "OFFsurfaceFormat.H"
+#include "MeshedSurface.H"
+#include "UnsortedMeshedSurface.H"
+#include "addToRunTimeSelectionTable.H"
+#include "addToMemberFunctionSelectionTable.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+namespace Foam
+{
+namespace fileFormats
+{
+
+addNamedTemplatedToRunTimeSelectionTable
+(
+    UnsortedMeshedSurface,
+    OFFsurfaceFormat,
+    face,
+    fileExtension,
+    off
+);
+addNamedTemplatedToRunTimeSelectionTable
+(
+    UnsortedMeshedSurface,
+    OFFsurfaceFormat,
+    triFace,
+    fileExtension,
+    off
+);
+
+
+addNamedTemplatedToMemberFunctionSelectionTable
+(
+    UnsortedMeshedSurface,
+    OFFsurfaceFormat,
+    face,
+    write,
+    fileExtension,
+    off
+);
+addNamedTemplatedToMemberFunctionSelectionTable
+(
+    UnsortedMeshedSurface,
+    OFFsurfaceFormat,
+    triFace,
+    write,
+    fileExtension,
+    off
+);
+
+
+addNamedTemplatedToMemberFunctionSelectionTable
+(
+    MeshedSurface,
+    OFFsurfaceFormat,
+    face,
+    write,
+    fileExtension,
+    off
+);
+addNamedTemplatedToMemberFunctionSelectionTable
+(
+    MeshedSurface,
+    OFFsurfaceFormat,
+    triFace,
+    write,
+    fileExtension,
+    off
+);
+
+}
+}
+
+// ************************************************************************* //
diff --git a/src/surfMesh/keyedSurface/fileFormats/smesh/SMESHfileFormat.C b/src/surfMesh/surfaceFormats/smesh/SMESHsurfaceFormat.C
similarity index 79%
rename from src/surfMesh/keyedSurface/fileFormats/smesh/SMESHfileFormat.C
rename to src/surfMesh/surfaceFormats/smesh/SMESHsurfaceFormat.C
index e27406bfd7..fa5b2c9bcf 100644
--- a/src/surfMesh/keyedSurface/fileFormats/smesh/SMESHfileFormat.C
+++ b/src/surfMesh/surfaceFormats/smesh/SMESHsurfaceFormat.C
@@ -24,47 +24,21 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-#include "SMESHfileFormat.H"
+#include "SMESHsurfaceFormat.H"
 #include "clock.H"
 #include "IStringStream.H"
 #include "addToRunTimeSelectionTable.H"
-#include "addToMemberFunctionSelectionTable.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
-namespace Foam
-{
-namespace fileFormats
-{
-
-addNamedToMemberFunctionSelectionTable
-(
-    keyedSurface,
-    SMESHfileFormat,
-    write,
-    fileExtension,
-    smesh
-);
-
-addNamedToMemberFunctionSelectionTable
-(
-    meshedSurface,
-    SMESHfileFormat,
-    write,
-    fileExtension,
-    smesh
-);
-
-}
-}
 
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 
-
-void Foam::fileFormats::SMESHfileFormat::writeHead
+template<class Face>
+void Foam::fileFormats::SMESHsurfaceFormat<Face>::writeHead
 (
     Ostream& os,
     const pointField& pointLst,
-    const List<face>& faceLst
+    const List<Face>& faceLst
 )
 {
     // Write header
@@ -88,7 +62,8 @@ void Foam::fileFormats::SMESHfileFormat::writeHead
 }
 
 
-void Foam::fileFormats::SMESHfileFormat::writeTail(Ostream& os)
+template<class Face>
+void Foam::fileFormats::SMESHsurfaceFormat<Face>::writeTail(Ostream& os)
 {
     os  << "# </faces>" << nl
         << nl
@@ -100,21 +75,22 @@ void Foam::fileFormats::SMESHfileFormat::writeTail(Ostream& os)
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
-Foam::fileFormats::SMESHfileFormat::SMESHfileFormat()
+template<class Face>
+Foam::fileFormats::SMESHsurfaceFormat<Face>::SMESHsurfaceFormat()
 :
-    keyedSurface()
+    ParentType()
 {}
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
-void
-Foam::fileFormats::SMESHfileFormat::write
+template<class Face>
+void Foam::fileFormats::SMESHsurfaceFormat<Face>::write
 (
     Ostream& os,
-    const keyedSurface& surf
+    const UnsortedMeshedSurface<Face>& surf
 )
 {
-    const List<face>& faceLst = surf.faces();
+    const List<Face>& faceLst = surf.faces();
 
     writeHead(os, surf.points(), faceLst);
 
@@ -126,7 +102,7 @@ Foam::fileFormats::SMESHfileFormat::write
     {
         forAll(patchLst[patchI], patchFaceI)
         {
-            const face& f = faceLst[faceMap[faceIndex++]];
+            const Face& f = faceLst[faceMap[faceIndex++]];
 
             os  << f.size();
             forAll(f, fp)
@@ -141,14 +117,14 @@ Foam::fileFormats::SMESHfileFormat::write
 }
 
 
-void
-Foam::fileFormats::SMESHfileFormat::write
+template<class Face>
+void Foam::fileFormats::SMESHsurfaceFormat<Face>::write
 (
     Ostream& os,
-    const meshedSurface& surf
+    const MeshedSurface<Face>& surf
 )
 {
-    const List<face>& faceLst = surf.faces();
+    const List<Face>& faceLst = surf.faces();
     const List<surfGroup>& patchLst = surf.patches();
 
     writeHead(os, surf.points(), faceLst);
@@ -172,5 +148,4 @@ Foam::fileFormats::SMESHfileFormat::write
     writeTail(os);
 }
 
-
 // ************************************************************************* //
diff --git a/src/surfMesh/keyedSurface/fileFormats/smesh/SMESHfileFormat.H b/src/surfMesh/surfaceFormats/smesh/SMESHsurfaceFormat.H
similarity index 66%
rename from src/surfMesh/keyedSurface/fileFormats/smesh/SMESHfileFormat.H
rename to src/surfMesh/surfaceFormats/smesh/SMESHsurfaceFormat.H
index d5807dc67d..341b90e726 100644
--- a/src/surfMesh/keyedSurface/fileFormats/smesh/SMESHfileFormat.H
+++ b/src/surfMesh/surfaceFormats/smesh/SMESHsurfaceFormat.H
@@ -23,7 +23,7 @@ License
     Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 
 Class
-    Foam::fileFormats::SMESHfileFormat
+    Foam::fileFormats::SMESHsurfaceFormat
 
 Description
     Provide a means of writing tetgen SMESH format.
@@ -35,18 +35,18 @@ See Also
     http://tetgen.berlios.de/fformats.smesh.html
 
 SourceFiles
-    SMESHfileFormat.C
+    SMESHsurfaceFormat.C
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef SMESHfileFormat_H
-#define SMESHfileFormat_H
+#ifndef SMESHsurfaceFormat_H
+#define SMESHsurfaceFormat_H
 
 #include "IFstream.H"
 #include "OFstream.H"
 #include "Ostream.H"
-#include "keyedSurface.H"
-#include "meshedSurface.H"
+#include "MeshedSurface.H"
+#include "UnsortedMeshedSurface.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -56,24 +56,27 @@ namespace fileFormats
 {
 
 /*---------------------------------------------------------------------------*\
-                      Class SMESHfileFormat Declaration
+                      Class SMESHsurfaceFormat Declaration
 \*---------------------------------------------------------------------------*/
 
-class SMESHfileFormat
+template<class Face>
+class SMESHsurfaceFormat
 :
-    public keyedSurface
+    public UnsortedMeshedSurface<Face>
 {
-    // Private data
+    //- Private typedefs for convenience
+    typedef SMESHsurfaceFormat<Face>    ThisType;
+    typedef UnsortedMeshedSurface<Face> ParentType;
 
     // Private Member Functions
 
         //- Disallow default bitwise copy construct
-        SMESHfileFormat(const SMESHfileFormat&);
+        SMESHsurfaceFormat(const SMESHsurfaceFormat<Face>&);
 
         //- Disallow default bitwise assignment
-        void operator=(const SMESHfileFormat&);
+        void operator=(const SMESHsurfaceFormat<Face>&);
 
-        static void writeHead(Ostream&, const pointField&, const List<face>&);
+        static void writeHead(Ostream&, const pointField&, const List<Face>&);
         static void writeTail(Ostream&);
 
 public:
@@ -81,28 +84,48 @@ public:
     // Constructors
 
         //- Construct null
-        SMESHfileFormat();
+        SMESHsurfaceFormat();
 
     // Selectors
 
     // Destructor
 
+        virtual ~SMESHsurfaceFormat()
+        {}
+
+
     // Member Functions
 
-        //- Write keyedSurface
-        static void write(Ostream&, const keyedSurface&);
+        //- Write UnsortedMeshedSurface
+        static void write
+        (
+            Ostream&,
+            const UnsortedMeshedSurface<Face>&
+        );
 
-        //- Write meshedSurface
-        static void write(Ostream&, const meshedSurface&);
-
-        //- Write keyedSurface
-        static void write(const fileName& fName, const keyedSurface& surf)
+        //- Write UnsortedMeshedSurface
+        static void write
+        (
+            const fileName& fName,
+            const UnsortedMeshedSurface<Face>& surf
+        )
         {
             write(OFstream(fName)(), surf);
         }
 
-        //- Write meshedSurface
-        static void write(const fileName& fName, const meshedSurface& surf)
+        //- Write MeshedSurface
+        static void write
+        (
+            Ostream&,
+            const MeshedSurface<Face>&
+        );
+
+        //- Write MeshedSurface
+        static void write
+        (
+            const fileName& fName,
+            const MeshedSurface<Face>& surf
+        )
         {
             write(OFstream(fName)(), surf);
         }
@@ -123,6 +146,10 @@ public:
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
+#ifdef NoRepository
+#   include "SMESHsurfaceFormat.C"
+#endif
+
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 #endif
diff --git a/src/surfMesh/surfaceFormats/smesh/SMESHsurfaceFormatRunTime.C b/src/surfMesh/surfaceFormats/smesh/SMESHsurfaceFormatRunTime.C
new file mode 100644
index 0000000000..16ab5a06dc
--- /dev/null
+++ b/src/surfMesh/surfaceFormats/smesh/SMESHsurfaceFormatRunTime.C
@@ -0,0 +1,81 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+\*---------------------------------------------------------------------------*/
+
+#include "SMESHsurfaceFormat.H"
+#include "MeshedSurface.H"
+#include "UnsortedMeshedSurface.H"
+#include "addToRunTimeSelectionTable.H"
+#include "addToMemberFunctionSelectionTable.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+namespace Foam
+{
+namespace fileFormats
+{
+
+addNamedTemplatedToMemberFunctionSelectionTable
+(
+    UnsortedMeshedSurface,
+    SMESHsurfaceFormat,
+    face,
+    write,
+    fileExtension,
+    smesh
+);
+addNamedTemplatedToMemberFunctionSelectionTable
+(
+    UnsortedMeshedSurface,
+    SMESHsurfaceFormat,
+    triFace,
+    write,
+    fileExtension,
+    smesh
+);
+
+
+addNamedTemplatedToMemberFunctionSelectionTable
+(
+    MeshedSurface,
+    SMESHsurfaceFormat,
+    face,
+    write,
+    fileExtension,
+    smesh
+);
+addNamedTemplatedToMemberFunctionSelectionTable
+(
+    MeshedSurface,
+    SMESHsurfaceFormat,
+    triFace,
+    write,
+    fileExtension,
+    smesh
+);
+
+}
+}
+
+// ************************************************************************* //
diff --git a/src/surfMesh/keyedSurface/fileFormats/starcd/STARCDfileFormat.C b/src/surfMesh/surfaceFormats/starcd/STARCDsurfaceFormat.C
similarity index 78%
rename from src/surfMesh/keyedSurface/fileFormats/starcd/STARCDfileFormat.C
rename to src/surfMesh/surfaceFormats/starcd/STARCDsurfaceFormat.C
index 0a50513b14..bedf9c5e88 100644
--- a/src/surfMesh/keyedSurface/fileFormats/starcd/STARCDfileFormat.C
+++ b/src/surfMesh/surfaceFormats/starcd/STARCDsurfaceFormat.C
@@ -24,47 +24,12 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-#include "STARCDfileFormat.H"
+#include "STARCDsurfaceFormat.H"
 #include "clock.H"
 #include "OSspecific.H"
 #include "IStringStream.H"
-#include "addToRunTimeSelectionTable.H"
-#include "addToMemberFunctionSelectionTable.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
-namespace Foam
-{
-namespace fileFormats
-{
-
-addNamedToRunTimeSelectionTable
-(
-    keyedSurface,
-    STARCDfileFormat,
-    fileExtension,
-    inp
-);
-
-addNamedToMemberFunctionSelectionTable
-(
-    keyedSurface,
-    STARCDfileFormat,
-    write,
-    fileExtension,
-    inp
-);
-
-addNamedToMemberFunctionSelectionTable
-(
-    meshedSurface,
-    STARCDfileFormat,
-    write,
-    fileExtension,
-    inp
-);
-
-}
-}
 
 //! @cond localscope
 const int starcdShellShape = 3;
@@ -74,7 +39,8 @@ const int starcdShellType  = 4;
 
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 
-bool Foam::fileFormats::STARCDfileFormat::readHeader
+template<class Face>
+bool Foam::fileFormats::STARCDsurfaceFormat<Face>::readHeader
 (
     IFstream& is,
     const word& signature
@@ -84,7 +50,7 @@ bool Foam::fileFormats::STARCDfileFormat::readHeader
     {
         FatalErrorIn
         (
-            "fileFormats::STARCDfileFormat::readHeader(...)"
+            "fileFormats::STARCDsurfaceFormat::readHeader(...)"
         )
             << "cannot read " << signature  << "  " << is.name()
             << abort(FatalError);
@@ -112,7 +78,8 @@ bool Foam::fileFormats::STARCDfileFormat::readHeader
 }
 
 
-void Foam::fileFormats::STARCDfileFormat::writeHeader
+template<class Face>
+void Foam::fileFormats::STARCDsurfaceFormat<Face>::writeHeader
 (
     Ostream& os,
     const char* filetype
@@ -131,7 +98,8 @@ void Foam::fileFormats::STARCDfileFormat::writeHeader
 }
 
 
-void Foam::fileFormats::STARCDfileFormat::writePoints
+template<class Face>
+void Foam::fileFormats::STARCDsurfaceFormat<Face>::writePoints
 (
     Ostream& os,
     const pointField& pointLst
@@ -157,10 +125,11 @@ void Foam::fileFormats::STARCDfileFormat::writePoints
 }
 
 
-inline void Foam::fileFormats::STARCDfileFormat::writeShell
+template<class Face>
+void Foam::fileFormats::STARCDsurfaceFormat<Face>::writeShell
 (
     Ostream& os,
-    const face& f,
+    const Face& f,
     const label cellId,
     const label cellTableId
 )
@@ -192,9 +161,10 @@ inline void Foam::fileFormats::STARCDfileFormat::writeShell
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
-Foam::fileFormats::STARCDfileFormat::STARCDfileFormat()
+template<class Face>
+Foam::fileFormats::STARCDsurfaceFormat<Face>::STARCDsurfaceFormat()
 :
-    Foam::keyedSurface()
+    ParentType()
 {}
 
 
@@ -211,27 +181,38 @@ Body:
 
 \*---------------------------------------------------------------------------*/
 
-Foam::fileFormats::STARCDfileFormat::STARCDfileFormat
+template<class Face>
+Foam::fileFormats::STARCDsurfaceFormat<Face>::STARCDsurfaceFormat
 (
-    const fileName& fName,
-    const bool triangulate
+    const fileName& fName
 )
 :
-    Foam::keyedSurface()
+    ParentType()
 {
-    read(fName, triangulate);
+    ThisType::read(fName);
 }
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
 
-bool Foam::fileFormats::STARCDfileFormat::read
+template<class Face>
+bool Foam::fileFormats::STARCDsurfaceFormat<Face>::read
 (
-    const fileName& fName,
-    const bool triangulate
+    const fileName& fName
 )
 {
-    clear();
+    ParentType::clear();
+
+    // triangulation required?
+    bool mustTriangulate = false;
+    {
+        Face f;
+        if (f.max_size() == 3)
+        {
+            mustTriangulate = true;
+        }
+    }
+
 
     fileName baseName = fName.lessExt();
     autoPtr<IFstream> isPtr;
@@ -250,7 +231,7 @@ bool Foam::fileFormats::STARCDfileFormat::read
     {
         FatalErrorIn
         (
-            "fileFormats::STARCDfileFormat::read(const fileName&)"
+            "fileFormats::STARCDsurfaceFormat::read(const fileName&)"
         )
             << "Cannot read file " << (baseName + ".vrt")
             << exit(FatalError);
@@ -271,7 +252,7 @@ bool Foam::fileFormats::STARCDfileFormat::read
     }
 
     // transfer to normal lists
-    points().transfer(pointLst);
+    ParentType::points().transfer(pointLst);
 
     // Build inverse mapping (index to point)
     pointId.shrink();
@@ -283,7 +264,7 @@ bool Foam::fileFormats::STARCDfileFormat::read
     pointId.clear();
 
 
-    DynamicList<face>  faceLst;
+    DynamicList<Face>  faceLst;
     DynamicList<label> regionLst;
 
     // From face cellTableId to patchId
@@ -300,7 +281,7 @@ bool Foam::fileFormats::STARCDfileFormat::read
     {
         FatalErrorIn
         (
-            "fileFormats::STARCDfileFormat::read(const fileName&)"
+            "fileFormats::STARCDsurfaceFormat::read(const fileName&)"
         )
             << "Cannot read file " << (baseName + ".cel")
             << exit(FatalError);
@@ -356,20 +337,27 @@ bool Foam::fileFormats::STARCDfileFormat::read
                 starLabels[i] = mapToFoamPointId[starLabels[i]];
             }
 
-            if (triangulate && nLabels > 3)
+            if (mustTriangulate && nLabels > 3)
             {
                 face f
                 (
                     SubList<label>(starLabels, nLabels)
                 );
 
-                faceList triFaces(f.nTriangles(points()));
+                faceList triFaces(f.nTriangles(ParentType::points()));
                 label nTri = 0;
-                f.triangles(points(), nTri, triFaces);
+                f.triangles(ParentType::points(), nTri, triFaces);
 
                 forAll(triFaces, faceI)
                 {
-                    faceLst.append(triFaces[faceI]);
+                    // a triangle, but not yet a triFace
+                    faceLst.append
+                    (
+                        triFace
+                        (
+                            static_cast<UList<label>&>(triFaces[faceI])
+                        )
+                    );
                     regionLst.append(patchI);
                 }
             }
@@ -377,7 +365,7 @@ bool Foam::fileFormats::STARCDfileFormat::read
             {
                 faceLst.append
                 (
-                    face(SubList<label>(starLabels, nLabels))
+                    Face(SubList<label>(starLabels, nLabels))
                 );
                 regionLst.append(patchI);
             }
@@ -398,22 +386,23 @@ bool Foam::fileFormats::STARCDfileFormat::read
     }
 
     // transfer to normal lists
-    faces().transfer(faceLst);
-    regions().transfer(regionLst);
+    ParentType::faces().transfer(faceLst);
+    ParentType::regions().transfer(regionLst);
 
-    setPatches(regionNames);
+    ParentType::setPatches(regionNames);
 
     return true;
 }
 
 
-void Foam::fileFormats::STARCDfileFormat::write
+template<class Face>
+void Foam::fileFormats::STARCDsurfaceFormat<Face>::write
 (
     const fileName& fName,
-    const keyedSurface& surf
+    const UnsortedMeshedSurface<Face>& surf
 )
 {
-    const List<face>& faceLst = surf.faces();
+    const List<Face>& faceLst = surf.faces();
 
     fileName baseName = fName.lessExt();
     autoPtr<OFstream> osPtr;
@@ -436,7 +425,7 @@ void Foam::fileFormats::STARCDfileFormat::write
 
         forAll(patch, patchFaceI)
         {
-            const face& f = faceLst[faceMap[faceIndex++]];
+            const Face& f = faceLst[faceMap[faceIndex++]];
 
             writeShell(osPtr(), f, faceIndex, patchI + 1);
         }
@@ -444,13 +433,14 @@ void Foam::fileFormats::STARCDfileFormat::write
 }
 
 
-void Foam::fileFormats::STARCDfileFormat::write
+template<class Face>
+void Foam::fileFormats::STARCDsurfaceFormat<Face>::write
 (
     const fileName& fName,
-    const meshedSurface& surf
+    const MeshedSurface<Face>& surf
 )
 {
-    const List<face>& faceLst = surf.faces();
+    const List<Face>& faceLst = surf.faces();
     const List<surfGroup>& patchLst = surf.patches();
 
 
@@ -471,7 +461,7 @@ void Foam::fileFormats::STARCDfileFormat::write
 
         forAll(patch, patchFaceI)
         {
-            const face& f = faceLst[faceIndex++];
+            const Face& f = faceLst[faceIndex++];
             writeShell(osPtr(), f, faceIndex, patchI + 1);
         }
     }
diff --git a/src/surfMesh/keyedSurface/fileFormats/starcd/STARCDfileFormat.H b/src/surfMesh/surfaceFormats/starcd/STARCDsurfaceFormat.H
similarity index 70%
rename from src/surfMesh/keyedSurface/fileFormats/starcd/STARCDfileFormat.H
rename to src/surfMesh/surfaceFormats/starcd/STARCDsurfaceFormat.H
index 4f566ec0ea..02fca9b175 100644
--- a/src/surfMesh/keyedSurface/fileFormats/starcd/STARCDfileFormat.H
+++ b/src/surfMesh/surfaceFormats/starcd/STARCDsurfaceFormat.H
@@ -23,7 +23,7 @@ License
     Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 
 Class
-    Foam::fileFormats::STARCDfileFormat
+    Foam::fileFormats::STARCDsurfaceFormat
 
 Description
     Read/write the surface shells from pro-STAR vrt/cel files.
@@ -35,19 +35,18 @@ See Also
     Foam::meshReaders::STARCD
 
 SourceFiles
-    STARCDfileFormat.C
+    STARCDsurfaceFormat.C
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef STARCDfileFormat_H
-#define STARCDfileFormat_H
+#ifndef STARCDsurfaceFormat_H
+#define STARCDsurfaceFormat_H
 
-#include "STLtriangle.H"
 #include "IFstream.H"
 #include "Ostream.H"
 #include "OFstream.H"
-#include "keyedSurface.H"
-#include "meshedSurface.H"
+#include "MeshedSurface.H"
+#include "UnsortedMeshedSurface.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -57,22 +56,25 @@ namespace fileFormats
 {
 
 /*---------------------------------------------------------------------------*\
-                     Class STARCDfileFormat Declaration
+                     Class STARCDsurfaceFormat Declaration
 \*---------------------------------------------------------------------------*/
 
-class STARCDfileFormat
+template<class Face>
+class STARCDsurfaceFormat
 :
-    public keyedSurface
+    public UnsortedMeshedSurface<Face>
 {
-    // Private data
+    //- Private typedefs for convenience
+    typedef STARCDsurfaceFormat<Face>   ThisType;
+    typedef UnsortedMeshedSurface<Face> ParentType;
 
     // Private Member Functions
 
         //- Disallow default bitwise copy construct
-        STARCDfileFormat(const STARCDfileFormat&);
+        STARCDsurfaceFormat(const STARCDsurfaceFormat<Face>&);
 
         //- Disallow default bitwise assignment
-        void operator=(const STARCDfileFormat&);
+        void operator=(const STARCDsurfaceFormat<Face>&);
 
 
         static bool readHeader(IFstream&, const word&);
@@ -84,7 +86,7 @@ class STARCDfileFormat
         static inline void writeShell
         (
             Ostream&,
-            const face&,
+            const Face&,
             const label cellId,
             const label cellTableId
         );
@@ -94,43 +96,45 @@ public:
     // Constructors
 
         //- Construct null
-        STARCDfileFormat();
+        STARCDsurfaceFormat();
 
         //- Construct from file name
-        STARCDfileFormat(const fileName&, const bool triangulate=true);
+        STARCDsurfaceFormat(const fileName&);
 
     // Selectors
 
         //- Read file and return keyedSurface
-        static autoPtr<keyedSurface> New
+        static autoPtr<UnsortedMeshedSurface<Face> > New
         (
-            const fileName& fName,
-            const bool triangulate=true
+            const fileName& fName
         )
         {
-            return autoPtr<keyedSurface>
+            return autoPtr<UnsortedMeshedSurface<Face> >
             (
-                new STARCDfileFormat(fName, triangulate)
+                new STARCDsurfaceFormat<Face>(fName)
             );
         }
 
     // Destructor
+        virtual ~STARCDsurfaceFormat()
+        {}
+
 
     // Member Functions
 
         //- Read from file
-        virtual bool read(const fileName&, const bool triangulate);
+        virtual bool read(const fileName&);
 
-        //- Write keyedSurface
-        static void write(const fileName&, const keyedSurface&);
+        //- Write UnsortedMeshedSurface
+        static void write(const fileName&, const UnsortedMeshedSurface<Face>&);
 
-        //- Write meshedSurface
-        static void write(const fileName&, const meshedSurface&);
+        //- Write MeshedSurface
+        static void write(const fileName&, const MeshedSurface<Face>&);
 
         //- Write to Ostream as one large file - not really useful
         virtual void write(Ostream&) const
         {
-            notImplemented("fileFormats::STARCDfileFormat::write(Ostream&)");
+            notImplemented("fileFormats::STARCDsurfaceFormat::write(Ostream&)");
         }
 
 };
@@ -143,6 +147,10 @@ public:
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
+#ifdef NoRepository
+#   include "STARCDsurfaceFormat.C"
+#endif
+
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 #endif
diff --git a/src/surfMesh/surfaceFormats/starcd/STARCDsurfaceFormatRunTime.C b/src/surfMesh/surfaceFormats/starcd/STARCDsurfaceFormatRunTime.C
new file mode 100644
index 0000000000..7f34860fea
--- /dev/null
+++ b/src/surfMesh/surfaceFormats/starcd/STARCDsurfaceFormatRunTime.C
@@ -0,0 +1,99 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+\*---------------------------------------------------------------------------*/
+
+#include "STARCDsurfaceFormat.H"
+#include "MeshedSurface.H"
+#include "UnsortedMeshedSurface.H"
+#include "addToRunTimeSelectionTable.H"
+#include "addToMemberFunctionSelectionTable.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+namespace Foam
+{
+namespace fileFormats
+{
+
+addNamedTemplatedToRunTimeSelectionTable
+(
+    UnsortedMeshedSurface,
+    STARCDsurfaceFormat,
+    face,
+    fileExtension,
+    inp
+);
+addNamedTemplatedToRunTimeSelectionTable
+(
+    UnsortedMeshedSurface,
+    STARCDsurfaceFormat,
+    triFace,
+    fileExtension,
+    inp
+);
+
+
+addNamedTemplatedToMemberFunctionSelectionTable
+(
+    UnsortedMeshedSurface,
+    STARCDsurfaceFormat,
+    face,
+    write,
+    fileExtension,
+    inp
+);
+addNamedTemplatedToMemberFunctionSelectionTable
+(
+    UnsortedMeshedSurface,
+    STARCDsurfaceFormat,
+    triFace,
+    write,
+    fileExtension,
+    inp
+);
+
+
+addNamedTemplatedToMemberFunctionSelectionTable
+(
+    MeshedSurface,
+    STARCDsurfaceFormat,
+    face,
+    write,
+    fileExtension,
+    inp
+);
+addNamedTemplatedToMemberFunctionSelectionTable
+(
+    MeshedSurface,
+    STARCDsurfaceFormat,
+    triFace,
+    write,
+    fileExtension,
+    inp
+);
+
+}
+}
+
+// ************************************************************************* //
diff --git a/src/surfMesh/keyedSurface/fileFormats/stl/STLpoint.H b/src/surfMesh/surfaceFormats/stl/STLpoint.H
similarity index 100%
rename from src/surfMesh/keyedSurface/fileFormats/stl/STLpoint.H
rename to src/surfMesh/surfaceFormats/stl/STLpoint.H
diff --git a/src/surfMesh/keyedSurface/fileFormats/stl/STLpointI.H b/src/surfMesh/surfaceFormats/stl/STLpointI.H
similarity index 100%
rename from src/surfMesh/keyedSurface/fileFormats/stl/STLpointI.H
rename to src/surfMesh/surfaceFormats/stl/STLpointI.H
diff --git a/src/surfMesh/surfaceFormats/stl/STLsurfaceFormat.C b/src/surfMesh/surfaceFormats/stl/STLsurfaceFormat.C
new file mode 100644
index 0000000000..c2570befe1
--- /dev/null
+++ b/src/surfMesh/surfaceFormats/stl/STLsurfaceFormat.C
@@ -0,0 +1,386 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+\*---------------------------------------------------------------------------*/
+
+#include "STLsurfaceFormat.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+template<class Face>
+inline void Foam::fileFormats::STLsurfaceFormat<Face>::writeShell
+(
+    Ostream& os,
+    const pointField& pointLst,
+    const Face& f,
+    const vector& norm
+)
+{
+    // simple triangulation about f[0].
+    // better triangulation should have been done before
+    const point& p0 = pointLst[f[0]];
+    for (label fp1 = 1; fp1 < f.size() - 1; ++fp1)
+    {
+        label fp2 = (fp1 + 1) % f.size();
+
+        const point& p1 = pointLst[f[fp1]];
+        const point& p2 = pointLst[f[fp2]];
+
+        // write STL triangle
+        os  << "  facet normal "
+            << norm.x() << ' ' << norm.y() << ' ' << norm.z() << nl
+            << "    outer loop\n"
+            << "       vertex "
+            << p0.x() << ' ' << p0.y() << ' ' << p0.z() << nl
+            << "       vertex "
+            << p1.x() << ' ' << p1.y() << ' ' << p1.z() << nl
+            << "       vertex "
+            << p2.x() << ' ' << p2.y() << ' ' << p2.z() << nl
+            << "    endloop\n"
+            << "  endfacet" << endl;
+    }
+}
+
+
+template<class Face>
+inline void Foam::fileFormats::STLsurfaceFormat<Face>::writeShell
+(
+    ostream& os,
+    const pointField& pointLst,
+    const Face& f,
+    const vector& norm,
+    const label patchI
+)
+{
+    // simple triangulation about f[0].
+    // better triangulation should have been done before
+    const point& p0 = pointLst[f[0]];
+    for (label fp1 = 1; fp1 < f.size() - 1; ++fp1)
+    {
+        label fp2 = (fp1 + 1) % f.size();
+
+        STLtriangle stlTri
+        (
+            norm,
+            p0,
+            pointLst[f[fp1]],
+            pointLst[f[fp2]],
+            patchI
+        );
+
+        stlTri.write(os);
+    }
+}
+
+
+// write sorted:
+template<class Face>
+void Foam::fileFormats::STLsurfaceFormat<Face>::writeASCII
+(
+    Ostream& os,
+    const UnsortedMeshedSurface<Face>& surf
+)
+{
+    const pointField& pointLst = surf.points();
+    const List<Face>& faceLst  = surf.faces();
+    const vectorField& normLst = surf.faceNormals();
+
+    labelList faceMap;
+    List<surfGroup> patchLst = surf.sortedRegions(faceMap);
+
+    label faceIndex = 0;
+    forAll(patchLst, patchI)
+    {
+        // Print all faces belonging to this region
+        const surfGroup& patch = patchLst[patchI];
+
+        os  << "solid " << patch.name() << endl;
+        forAll(patch, patchFaceI)
+        {
+            const label faceI = faceMap[faceIndex++];
+            writeShell(os, pointLst, faceLst[faceI], normLst[faceI]);
+        }
+
+        os  << "endsolid " << patch.name() << endl;
+    }
+}
+
+
+
+// write sorted:
+template<class Face>
+void Foam::fileFormats::STLsurfaceFormat<Face>::writeASCII
+(
+    Ostream& os,
+    const MeshedSurface<Face>& surf
+)
+{
+    const pointField& pointLst = surf.points();
+    const List<Face>& faceLst = surf.faces();
+    const List<surfGroup>& patchLst = surf.patches();
+    const vectorField& normLst = surf.faceNormals();
+
+    // force triangulation, but just do the cheapest form possible
+    label faceIndex = 0;
+    forAll(patchLst, patchI)
+    {
+        // Print all faces belonging to this region
+        const surfGroup& patch = patchLst[patchI];
+
+        os << "solid " << patch.name() << endl;
+
+        forAll(patch, patchFaceI)
+        {
+            const label faceI = faceIndex++;
+            writeShell(os, pointLst, faceLst[faceI], normLst[faceI]);
+        }
+
+        os << "endsolid " << patch.name() << endl;
+    }
+}
+
+
+// write unsorted:
+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>& regionLst = surf.regions();
+    const vectorField& normLst = surf.faceNormals();
+
+    // Write the STL header
+    STLsurfaceFormatCore::writeHeaderBINARY(os);
+
+    // force triangulation, but just do the cheapest form possible
+    unsigned int nTris = 0;
+    forAll(faceLst, faceI)
+    {
+        nTris += faceLst[faceI].size() - 2;
+    }
+
+    os.write(reinterpret_cast<char*>(&nTris), sizeof(unsigned int));
+
+    // always write unsorted
+    forAll(faceLst, faceI)
+    {
+        writeShell
+        (
+            os,
+            pointLst,
+            faceLst[faceI],
+            normLst[faceI],
+            regionLst[faceI]
+        );
+    }
+}
+
+
+template<class Face>
+void Foam::fileFormats::STLsurfaceFormat<Face>::writeBINARY
+(
+    ostream& os,
+    const MeshedSurface<Face>& surf
+)
+{
+    const pointField& pointLst = surf.points();
+    const List<Face>& faceLst  = surf.faces();
+    const vectorField& normLst = surf.faceNormals();
+    const List<surfGroup>& patchLst = surf.patches();
+
+    // Write the STL header
+    STLsurfaceFormatCore::writeHeaderBINARY(os);
+
+    // force triangulation, but just do the cheapest form possible
+    unsigned int nTris = 0;
+    forAll(faceLst, faceI)
+    {
+        nTris += faceLst[faceI].size() - 2;
+    }
+
+    os.write(reinterpret_cast<char*>(&nTris), sizeof(unsigned int));
+
+    label faceIndex = 0;
+    forAll(patchLst, patchI)
+    {
+        forAll(patchLst[patchI], patchFaceI)
+        {
+            writeShell
+            (
+                os,
+                pointLst,
+                faceLst[faceIndex],
+                normLst[faceIndex],
+                patchI
+            );
+
+            ++faceIndex;
+        }
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+template<class Face>
+Foam::fileFormats::STLsurfaceFormat<Face>::STLsurfaceFormat()
+:
+    ParentType()
+{}
+
+
+template<class Face>
+Foam::fileFormats::STLsurfaceFormat<Face>::STLsurfaceFormat
+(
+    const fileName& fName
+)
+:
+    ParentType()
+{
+    ThisType::read(fName);
+}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+template<class Face>
+bool Foam::fileFormats::STLsurfaceFormat<Face>::read
+(
+    const fileName& fName
+)
+{
+    ParentType::clear();
+
+    // read in the values
+    STLsurfaceFormatCore reader(fName);
+
+    pointField&  pointLst  = ParentType::points();
+    List<Face>&  faceLst   = ParentType::faces();
+    List<label>& regionLst = ParentType::regions();
+
+    // transfer
+    pointLst.transfer(reader.points());
+    regionLst.transfer(reader.regions());
+
+    // assemble the faces:
+    faceLst.setSize(regionLst.size());
+
+    label ptI = 0;
+    forAll(faceLst, faceI)
+    {
+        triFace fTri;
+
+        fTri[0] = ptI++;
+        fTri[1] = ptI++;
+        fTri[2] = ptI++;
+
+        faceLst[faceI] = fTri;
+    }
+
+    if (reader.binary())
+    {
+        ParentType::setPatches(reader.maxRegionId());
+    }
+    else
+    {
+        ParentType::setPatches(reader.groupToPatch());
+    }
+
+    ParentType::stitchFaces(SMALL);
+    return true;
+}
+
+
+template<class Face>
+void Foam::fileFormats::STLsurfaceFormat<Face>::write
+(
+    Ostream& os,
+    const UnsortedMeshedSurface<Face>& surf
+)
+{
+    writeASCII(os, surf);
+}
+
+
+template<class Face>
+void Foam::fileFormats::STLsurfaceFormat<Face>::write
+(
+    Ostream& os,
+    const MeshedSurface<Face>& surf
+)
+{
+    writeASCII(os, surf);
+}
+
+
+template<class Face>
+void Foam::fileFormats::STLsurfaceFormat<Face>::write
+(
+    const fileName& fName,
+    const UnsortedMeshedSurface<Face>& surf
+)
+{
+    const word ext = fName.ext();
+
+    // handle 'stlb' as binary directly
+    if (ext == "stlb")
+    {
+        std::ofstream ofs(fName.c_str(), std::ios::binary);
+        writeBINARY(ofs, surf);
+    }
+    else
+    {
+        writeASCII(OFstream(fName)(), surf);
+    }
+}
+
+
+template<class Face>
+void Foam::fileFormats::STLsurfaceFormat<Face>::write
+(
+    const fileName& fName,
+    const MeshedSurface<Face>& surf
+)
+{
+    const word ext = fName.ext();
+
+    // handle 'stlb' as binary directly
+    if (ext == "stlb")
+    {
+        std::ofstream ofs(fName.c_str(), std::ios::binary);
+        writeBINARY(ofs, surf);
+    }
+    else
+    {
+        writeASCII(OFstream(fName)(), surf);
+    }
+}
+
+// ************************************************************************* //
diff --git a/src/surfMesh/keyedSurface/fileFormats/stl/STLfileFormat.H b/src/surfMesh/surfaceFormats/stl/STLsurfaceFormat.H
similarity index 56%
rename from src/surfMesh/keyedSurface/fileFormats/stl/STLfileFormat.H
rename to src/surfMesh/surfaceFormats/stl/STLsurfaceFormat.H
index dd9146ab30..5d18416774 100644
--- a/src/surfMesh/keyedSurface/fileFormats/stl/STLfileFormat.H
+++ b/src/surfMesh/surfaceFormats/stl/STLsurfaceFormat.H
@@ -23,26 +23,23 @@ License
     Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 
 Class
-    Foam::fileFormats::STLfileFormat
+    Foam::fileFormats::STLsurfaceFormat
 
 Description
     Provide a means of reading/writing STL files (ASCII and binary).
 
 SourceFiles
-    STLfileFormat.C
-    STLfileFormatASCII.L
+    STLsurfaceFormat.C
+    STLsurfaceFormatASCII.L
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef STLfileFormat_H
-#define STLfileFormat_H
+#ifndef STLsurfaceFormat_H
+#define STLsurfaceFormat_H
 
-#include "STLtriangle.H"
-#include "IFstream.H"
-#include "Ostream.H"
-#include "OFstream.H"
-#include "keyedSurface.H"
-#include "meshedSurface.H"
+#include "STLsurfaceFormatCore.H"
+#include "MeshedSurface.H"
+#include "UnsortedMeshedSurface.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -52,110 +49,125 @@ namespace fileFormats
 {
 
 /*---------------------------------------------------------------------------*\
-                       Class STLfileFormat Declaration
+                       Class STLsurfaceFormat Declaration
 \*---------------------------------------------------------------------------*/
 
-class STLfileFormat
+template<class Face>
+class STLsurfaceFormat
 :
-    public keyedSurface
+    public UnsortedMeshedSurface<Face>
 {
-    // Private data
+    //- Private typedefs for convenience
+    typedef STLsurfaceFormat<Face>      ThisType;
+    typedef UnsortedMeshedSurface<Face> ParentType;
 
-        //- The number of bytes in the STL binary header
-        static const int headerSize=80;
+    // Private data
 
     // Private Member Functions
 
         //- Disallow default bitwise copy construct
-        STLfileFormat(const STLfileFormat&);
+        STLsurfaceFormat(const STLsurfaceFormat<Face>&);
 
         //- Disallow default bitwise assignment
-        void operator=(const STLfileFormat&);
+        void operator=(const STLsurfaceFormat<Face>&);
 
-        bool readASCII(IFstream&, const off_t);
-        bool readBINARY(IFstream&, const off_t);
-
-        static bool detectBINARY(const fileName&);
-
-        //- write face in ASCII
+        //- Write Face in ASCII
         static inline void writeShell
         (
             Ostream&,
             const pointField&,
-            const face&,
+            const Face&,
             const vector& norm
         );
 
-        //- write face in BINARY
+        //- Write Face in BINARY
         static inline void writeShell
         (
             ostream&,
             const pointField&,
-            const face&,
+            const Face&,
             const vector&,
             const label patchI
         );
 
 
-        //- Write keySurface
-        static void writeASCII(Ostream&, const keyedSurface&);
+        //- Write UnsortedMeshedSurface
+        static void writeASCII(Ostream&, const UnsortedMeshedSurface<Face>&);
 
-        //- Write keyedSurface
-        static void writeBINARY(ostream&, const keyedSurface&);
+        //- Write UnsortedMeshedSurface
+        static void writeBINARY(ostream&, const UnsortedMeshedSurface<Face>&);
 
-        //- Write meshedSurface
-        static void writeASCII(Ostream&, const meshedSurface&);
+        //- Write MeshedSurface
+        static void writeASCII(Ostream&, const MeshedSurface<Face>&);
 
-        //- Write meshedSurface
-        static void writeBINARY(ostream&, const meshedSurface&);
+        //- Write MeshedSurface
+        static void writeBINARY(ostream&, const MeshedSurface<Face>&);
 
 public:
 
     // Constructors
 
         //- Construct null
-        STLfileFormat();
+        STLsurfaceFormat();
 
         //- Construct from file name
-        STLfileFormat(const fileName&, const bool triangulate=true);
+        STLsurfaceFormat(const fileName&);
 
     // Selectors
 
         //- Read file and return keyedSurface
-        static autoPtr<keyedSurface> New
+        //- Read file and return surface
+        static autoPtr<UnsortedMeshedSurface<Face> > New
         (
-            const fileName& fName,
-            const bool triangulate=true
+            const fileName& fName
         )
         {
-            return autoPtr<keyedSurface>
+            return autoPtr<UnsortedMeshedSurface<Face> >
             (
-                new STLfileFormat(fName,true)
+                new STLsurfaceFormat<Face>(fName)
             );
         }
 
     // Destructor
+        virtual ~STLsurfaceFormat()
+        {}
 
     // Member Functions
 
         //- Read from file
-        virtual bool read(const fileName&, const bool triangulate);
+        virtual bool read(const fileName&);
 
-        //- Write keyedSurface
+        //- Write UnsortedMeshedSurface (as ASCII)
+        static void write
+        (
+            Ostream&,
+            const UnsortedMeshedSurface<Face>&
+        );
+
+        //- Write MeshedSurface (as ASCII)
+        static void write
+        (
+            Ostream&,
+            const MeshedSurface<Face>&
+        );
+
+        //- Write UnsortedMeshedSurface
         //  The ASCII output is sorted by patch, the binary output is unsorted
-        static void write(Ostream&, const keyedSurface&);
+        static void write
+        (
+            const fileName&,
+            const UnsortedMeshedSurface<Face>&
+        );
 
-        //- Write keyedSurface
+        //- Write MeshedSurface
         //  The ASCII output is sorted by patch, the binary output is unsorted
-        static void write(const fileName&, const keyedSurface&);
+        static void write
+        (
+            const fileName&,
+            const MeshedSurface<Face>&
+        );
 
-        //- Write meshedSurface
-        static void write(Ostream&, const meshedSurface&);
-
-        //- Write meshedSurface
-        static void write(const fileName&, const meshedSurface&);
-
-        //- Write object
+        //- Write object (only ASCII output)
         virtual void write(Ostream& os) const
         {
             write(os, *this);
@@ -171,6 +183,10 @@ public:
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
+#ifdef NoRepository
+#   include "STLsurfaceFormat.C"
+#endif
+
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 #endif
diff --git a/src/surfMesh/keyedSurface/fileFormats/stl/STLfileFormatASCII.L b/src/surfMesh/surfaceFormats/stl/STLsurfaceFormatASCII.L
similarity index 93%
rename from src/surfMesh/keyedSurface/fileFormats/stl/STLfileFormatASCII.L
rename to src/surfMesh/surfaceFormats/stl/STLsurfaceFormatASCII.L
index 7a0e503480..0d38a882a5 100644
--- a/src/surfMesh/keyedSurface/fileFormats/stl/STLfileFormatASCII.L
+++ b/src/surfMesh/surfaceFormats/stl/STLsurfaceFormatASCII.L
@@ -32,8 +32,7 @@ License
    ------ local definitions
  \* ------------------------------------------------------------------------ */
 
-#include "STLfileFormat.H"
-#include "triFace.H"
+#include "STLsurfaceFormatCore.H"
 
 using namespace Foam;
 
@@ -111,7 +110,7 @@ public:
         }
 
         //- region names
-        const HashTable<label>& groupToPatch() const
+        HashTable<label>& groupToPatch()
         {
             return groupToPatch_;
         }
@@ -360,7 +359,7 @@ endsolid              {space}("endsolid"|"ENDSOLID")({some_space}{word})*
         yy_pop_state();
         FatalErrorIn
         (
-            "fileFormats::STLfileFormat::readASCII(const fileName&)"
+            "fileFormats::STLsurfaceFormatCore::readASCII(const fileName&)"
         )   << "while " << stateNames[YY_START] << " on line " << lineNo_ << nl
             << "    expected " << stateExpects[YY_START]
             << " but found '" << startError_.c_str() << YYText() << "'"
@@ -379,14 +378,13 @@ endsolid              {space}("endsolid"|"ENDSOLID")({some_space}{word})*
 //
 // member function
 //
-bool
-Foam::fileFormats::STLfileFormat::readASCII
+bool Foam::fileFormats::STLsurfaceFormatCore::readASCII
 (
     IFstream& ifs,
     const off_t fileSize
 )
 {
-    clear();
+    binary_ = false;
 
     // Create the lexer with the approximate number of vertices in the STL
     // from the file size
@@ -394,32 +392,12 @@ Foam::fileFormats::STLfileFormat::readASCII
     while (lexer.lex() != 0) {}
 
     // transfer to normal lists
-    points().transfer(lexer.points());
-    regions().transfer(lexer.facets());
-
-    // make our triangles directly
-    List<FaceType>& faceLst = faces();
-    faceLst.setSize(regions().size());
-
-    label ptI = 0;
-    forAll(faceLst, faceI)
-    {
-        triFace fTri;
-
-        fTri[0] = ptI++;
-        fTri[1] = ptI++;
-        fTri[2] = ptI++;
-
-        faceLst[faceI] = fTri;
-    }
-
-    setPatches(lexer.groupToPatch());
-    stitchFaces(SMALL);
-
+    points_.transfer(lexer.points());
+    regions_.transfer(lexer.facets());
+    groupToPatch_.transfer(lexer.groupToPatch());
     return true;
 }
 
-
  /* ------------------------------------------------------------------------ *\
     ------ End of STLfileFormatASCII.L
  \* ------------------------------------------------------------------------ */
diff --git a/src/surfMesh/surfaceFormats/stl/STLsurfaceFormatCore.C b/src/surfMesh/surfaceFormats/stl/STLsurfaceFormatCore.C
new file mode 100644
index 0000000000..7a7aa05ecf
--- /dev/null
+++ b/src/surfMesh/surfaceFormats/stl/STLsurfaceFormatCore.C
@@ -0,0 +1,236 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+\*---------------------------------------------------------------------------*/
+
+#include "STLsurfaceFormatCore.H"
+#include "OSspecific.H"
+
+#undef DEBUG_STLBINARY
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+// check binary by getting the header and number of facets
+// this seems to work better than the old token-based method
+// - some programs (eg, pro-STAR) have 'solid' as the first word in
+//   the binary header.
+// - using wordToken can cause an abort if non-word (binary) content
+//   is detected ... this is not exactly what we want.
+int Foam::fileFormats::STLsurfaceFormatCore::detectBINARY
+(
+    const fileName& fName
+)
+{
+    off_t fileSize = Foam::size(fName);
+
+    IFstream ifs(fName, IOstream::BINARY);
+    istream& is = ifs.stdStream();
+
+    // Read the STL header
+    char header[headerSize];
+    is.read(header, headerSize);
+
+    // Check that stream is OK, if not this may be an ASCII file
+    if (!is.good())
+    {
+        return 0;
+    }
+
+    // Read the number of triangles in the STl file
+    // (note: read as int so we can check whether >2^31)
+    int nTris;
+    is.read(reinterpret_cast<char*>(&nTris), sizeof(unsigned int));
+
+    // Check that stream is OK and number of triangles is positive,
+    // if not this may be an ASCII file
+    //
+    // Also compare the file size with that expected from the number of tris
+    // If the comparison is not sensible then it may be an ASCII file
+    if
+    (
+        !is
+     || nTris < 0
+     || nTris < (fileSize - headerSize)/50
+     || nTris > (fileSize - headerSize)/25
+    )
+    {
+        return 0;
+    }
+
+    // looks like it might be BINARY, return number of triangles
+    return nTris;
+}
+
+
+bool Foam::fileFormats::STLsurfaceFormatCore::readBINARY
+(
+    IFstream& ifs,
+    const off_t fileSize
+)
+{
+    binary_ = true;
+    istream& is = ifs.stdStream();
+
+    // Read the STL header
+    char header[headerSize];
+    is.read(header, headerSize);
+
+    // Check that stream is OK, if not this may be an ASCII file
+    if (!is.good())
+    {
+        FatalErrorIn
+        (
+            "fileFormats::STLsurfaceFormatCore::readBINARY(IFstream&)"
+        )
+            << "problem reading header, perhaps file is not binary "
+            << exit(FatalError);
+    }
+
+    // Read the number of triangles in the STl file
+    // (note: read as int so we can check whether >2^31)
+    int nTris;
+    is.read(reinterpret_cast<char*>(&nTris), sizeof(unsigned int));
+
+    // Check that stream is OK and number of triangles is positive,
+    // if not this maybe an ASCII file
+    //
+    // Also compare the file size with that expected from the number of tris
+    // If the comparison is not sensible then it may be an ASCII file
+    if
+    (
+        !is
+     || nTris < 0
+     || nTris < (fileSize - headerSize)/50
+     || nTris > (fileSize - headerSize)/25
+    )
+    {
+        FatalErrorIn
+        (
+            "fileFormats::STLsurfaceFormatCore::readBINARY(IFstream&)"
+        )
+            << "problem reading number of triangles, perhaps file is not binary"
+            << exit(FatalError);
+    }
+
+#ifdef DEBUG_STLBINARY
+    Info<< "# " << nTris << " facets" << endl;
+    label prevRegion = -1;
+#endif
+
+    points_.setSize(3*nTris);
+    regions_.setSize(nTris);
+
+    label ptI = 0;
+    forAll(regions_, faceI)
+    {
+        // Read an STL triangle
+        STLtriangle stlTri(is);
+
+        // transcript the vertices of the STL triangle -> points
+        points_[ptI++] = stlTri.a();
+        points_[ptI++] = stlTri.b();
+        points_[ptI++] = stlTri.c();
+
+        // interprete colour as a region
+        regions_[faceI] = stlTri.region();
+        if (maxRegionId_ < stlTri.region())
+        {
+            maxRegionId_ = stlTri.region();
+        }
+
+#ifdef DEBUG_STLBINARY
+        if (prevRegion != stlTri.region())
+        {
+            if (prevRegion != -1)
+            {
+                Info<< "endsolid region" << prevRegion << nl;
+            }
+            prevRegion = stlTri.region();
+
+            Info<< "solid region" << prevRegion << nl;
+        }
+
+        Info<< "  facet normal " << stlTri.normal() << nl;
+        Info<< "    outer loop" << nl;
+        Info<< "      vertex " << stlTri.a() << nl;
+        Info<< "      vertex " << stlTri.b() << nl;
+        Info<< "      vertex " << stlTri.c() << nl;
+        Info<< "    outer loop" << nl;
+        Info<< "  endfacet" << endl;
+#endif
+    }
+
+    return true;
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::fileFormats::STLsurfaceFormatCore::STLsurfaceFormatCore
+(
+    const fileName& fName
+)
+:
+    binary_(false),
+    points_(0),
+    regions_(0),
+    maxRegionId_(0),
+    groupToPatch_(0)
+{
+    off_t fileSize = Foam::size(fName);
+
+    // auto-detect ascii/binary
+    if (detectBINARY(fName))
+    {
+        readBINARY(IFstream(fName, IOstream::BINARY)(), fileSize);
+    }
+    else
+    {
+        readASCII(IFstream(fName)(), fileSize);
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * Destructors * * * * * * * * * * * * * * * //
+
+Foam::fileFormats::STLsurfaceFormatCore::~STLsurfaceFormatCore()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+void Foam::fileFormats::STLsurfaceFormatCore::writeHeaderBINARY(ostream& os)
+{
+    // Write the STL header, avoid possible trailing junk
+    string header("STL binary file", headerSize);
+    for (label i = header.size(); i < headerSize; ++i)
+    {
+        header[i] = 0;
+    }
+    os.write(header.c_str(), headerSize);
+}
+
+// ************************************************************************* //
diff --git a/src/surfMesh/surfaceFormats/stl/STLsurfaceFormatCore.H b/src/surfMesh/surfaceFormats/stl/STLsurfaceFormatCore.H
new file mode 100644
index 0000000000..c7b93a96ed
--- /dev/null
+++ b/src/surfMesh/surfaceFormats/stl/STLsurfaceFormatCore.H
@@ -0,0 +1,173 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Class
+    Foam::fileFormats::STLsurfaceFormatCore
+
+Description
+    Internal class used by the STLsurfaceFormat
+
+SourceFiles
+    STLsurfaceFormatCore.C
+    STLsurfaceFormatASCII.L
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef STLsurfaceFormatCore_H
+#define STLsurfaceFormatCore_H
+
+#include "STLtriangle.H"
+#include "triFace.H"
+#include "IFstream.H"
+#include "Ostream.H"
+#include "OFstream.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace fileFormats
+{
+
+/*---------------------------------------------------------------------------*\
+                   Class STLsurfaceFormatCore Declaration
+\*---------------------------------------------------------------------------*/
+
+class STLsurfaceFormatCore
+{
+    // Private Data
+
+        bool binary_;
+
+        //- The points supporting the facets
+        pointField points_;
+
+        //- The regions associated with the faces
+        List<label> regions_;
+
+        label maxRegionId_;
+
+        HashTable<label> groupToPatch_;
+
+    // Private Member Functions
+
+        //- Disallow default bitwise copy construct
+        STLsurfaceFormatCore(const STLsurfaceFormatCore&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const STLsurfaceFormatCore&);
+
+        //- Determine the file type
+        static int detectBINARY(const fileName&);
+
+        //- Read ASCII, set groupToPatch
+        bool readASCII(IFstream&, const off_t);
+
+        //- Read BINARY, set maxRegionId
+        bool readBINARY(IFstream&, const off_t);
+
+public:
+
+    // Static Data
+
+        //- The number of bytes in the STL binary header
+        static const int headerSize = 80;
+
+    // Static Member Functions
+
+        //- Write "STL binary file" to stream
+        static void writeHeaderBINARY(ostream&);
+
+    // Constructors
+
+        //- Read from file, filling in the information
+        STLsurfaceFormatCore
+        (
+            const fileName&
+        );
+
+    // Destructor
+        ~STLsurfaceFormatCore();
+
+    // Member Functions
+
+        //- File was detected to be STL binary
+        bool binary() const
+        {
+            return binary_;
+        }
+
+        //- The number of facets is the number of regions
+        label size() const
+        {
+            return regions_.size();
+        }
+
+        //- Flush all values
+        void clear()
+        {
+            points_.clear();
+            regions_.clear();
+            groupToPatch_.clear();
+        }
+
+        //- Return full access to the faces
+        pointField& points()
+        {
+            return points_;
+        }
+
+        //- Return full access to the regions
+        List<label>& regions()
+        {
+            return regions_;
+        }
+
+        //- The max regionId when reading binary files
+        label maxRegionId() const
+        {
+            return maxRegionId_;
+        }
+
+        //- The group/patch information when reading ASCII files
+        const HashTable<label>& groupToPatch() const
+        {
+            return groupToPatch_;
+        }
+
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace fileFormats
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/surfMesh/surfaceFormats/stl/STLsurfaceFormatRunTime.C b/src/surfMesh/surfaceFormats/stl/STLsurfaceFormatRunTime.C
new file mode 100644
index 0000000000..6c8f0744bd
--- /dev/null
+++ b/src/surfMesh/surfaceFormats/stl/STLsurfaceFormatRunTime.C
@@ -0,0 +1,154 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+\*---------------------------------------------------------------------------*/
+
+#include "STLsurfaceFormat.H"
+#include "MeshedSurface.H"
+#include "UnsortedMeshedSurface.H"
+#include "addToRunTimeSelectionTable.H"
+#include "addToMemberFunctionSelectionTable.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+namespace Foam
+{
+namespace fileFormats
+{
+
+addNamedTemplatedToRunTimeSelectionTable
+(
+    UnsortedMeshedSurface,
+    STLsurfaceFormat,
+    face,
+    fileExtension,
+    stl
+);
+addNamedTemplatedToRunTimeSelectionTable
+(
+    UnsortedMeshedSurface,
+    STLsurfaceFormat,
+    triFace,
+    fileExtension,
+    stl
+);
+
+addNamedTemplatedToRunTimeSelectionTable
+(
+    UnsortedMeshedSurface,
+    STLsurfaceFormat,
+    face,
+    fileExtension,
+    stlb
+);
+addNamedTemplatedToRunTimeSelectionTable
+(
+    UnsortedMeshedSurface,
+    STLsurfaceFormat,
+    triFace,
+    fileExtension,
+    stlb
+);
+
+
+addNamedTemplatedToMemberFunctionSelectionTable
+(
+    UnsortedMeshedSurface,
+    STLsurfaceFormat,
+    face,
+    write,
+    fileExtension,
+    stl
+);
+addNamedTemplatedToMemberFunctionSelectionTable
+(
+    UnsortedMeshedSurface,
+    STLsurfaceFormat,
+    triFace,
+    write,
+    fileExtension,
+    stl
+);
+
+addNamedTemplatedToMemberFunctionSelectionTable
+(
+    UnsortedMeshedSurface,
+    STLsurfaceFormat,
+    face,
+    write,
+    fileExtension,
+    stlb
+);
+addNamedTemplatedToMemberFunctionSelectionTable
+(
+    UnsortedMeshedSurface,
+    STLsurfaceFormat,
+    triFace,
+    write,
+    fileExtension,
+    stlb
+);
+
+
+addNamedTemplatedToMemberFunctionSelectionTable
+(
+    MeshedSurface,
+    STLsurfaceFormat,
+    face,
+    write,
+    fileExtension,
+    stl
+);
+addNamedTemplatedToMemberFunctionSelectionTable
+(
+    MeshedSurface,
+    STLsurfaceFormat,
+    triFace,
+    write,
+    fileExtension,
+    stl
+);
+
+addNamedTemplatedToMemberFunctionSelectionTable
+(
+    MeshedSurface,
+    STLsurfaceFormat,
+    face,
+    write,
+    fileExtension,
+    stlb
+);
+addNamedTemplatedToMemberFunctionSelectionTable
+(
+    MeshedSurface,
+    STLsurfaceFormat,
+    triFace,
+    write,
+    fileExtension,
+    stlb
+);
+
+}
+}
+
+// ************************************************************************* //
diff --git a/src/surfMesh/keyedSurface/fileFormats/stl/STLtriangle.H b/src/surfMesh/surfaceFormats/stl/STLtriangle.H
similarity index 100%
rename from src/surfMesh/keyedSurface/fileFormats/stl/STLtriangle.H
rename to src/surfMesh/surfaceFormats/stl/STLtriangle.H
diff --git a/src/surfMesh/keyedSurface/fileFormats/stl/STLtriangleI.H b/src/surfMesh/surfaceFormats/stl/STLtriangleI.H
similarity index 100%
rename from src/surfMesh/keyedSurface/fileFormats/stl/STLtriangleI.H
rename to src/surfMesh/surfaceFormats/stl/STLtriangleI.H
diff --git a/src/surfMesh/keyedSurface/fileFormats/tri/TRIfileFormat.C b/src/surfMesh/surfaceFormats/tri/TRIsurfaceFormat.C
similarity index 77%
rename from src/surfMesh/keyedSurface/fileFormats/tri/TRIfileFormat.C
rename to src/surfMesh/surfaceFormats/tri/TRIsurfaceFormat.C
index 86841066a0..0fdc37c1c5 100644
--- a/src/surfMesh/keyedSurface/fileFormats/tri/TRIfileFormat.C
+++ b/src/surfMesh/surfaceFormats/tri/TRIsurfaceFormat.C
@@ -24,57 +24,22 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-#include "TRIfileFormat.H"
-#include "triFace.H"
+#include "TRIsurfaceFormat.H"
 #include "clock.H"
 #include "IFstream.H"
 #include "IOmanip.H"
 #include "IStringStream.H"
-#include "addToRunTimeSelectionTable.H"
-#include "addToMemberFunctionSelectionTable.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
-namespace Foam
-{
-namespace fileFormats
-{
-
-addNamedToRunTimeSelectionTable
-(
-    keyedSurface,
-    TRIfileFormat,
-    fileExtension,
-    tri
-);
-
-addNamedToMemberFunctionSelectionTable
-(
-    keyedSurface,
-    TRIfileFormat,
-    write,
-    fileExtension,
-    tri
-);
-
-addNamedToMemberFunctionSelectionTable
-(
-    meshedSurface,
-    TRIfileFormat,
-    write,
-    fileExtension,
-    tri
-);
-
-}
-}
 
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 
-inline void Foam::fileFormats::TRIfileFormat::writeShell
+template<class Face>
+inline void Foam::fileFormats::TRIsurfaceFormat<Face>::writeShell
 (
     Ostream& os,
     const pointField& pointLst,
-    const face& f,
+    const Face& f,
     const label patchI
 )
 {
@@ -99,40 +64,41 @@ inline void Foam::fileFormats::TRIfileFormat::writeShell
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
-Foam::fileFormats::TRIfileFormat::TRIfileFormat()
+template<class Face>
+Foam::fileFormats::TRIsurfaceFormat<Face>::TRIsurfaceFormat()
 :
-    Foam::keyedSurface()
+    ParentType()
 {}
 
 
-Foam::fileFormats::TRIfileFormat::TRIfileFormat
+template<class Face>
+Foam::fileFormats::TRIsurfaceFormat<Face>::TRIsurfaceFormat
 (
-    const fileName& fName,
-    const bool
+    const fileName& fName
 )
 :
-    Foam::keyedSurface()
+    ParentType()
 {
-    read(fName, true);
+    read(fName);
 }
 
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
-bool Foam::fileFormats::TRIfileFormat::read
+template<class Face>
+bool Foam::fileFormats::TRIsurfaceFormat<Face>::read
 (
-    const fileName& fName,
-    const bool
+    const fileName& fName
 )
 {
-    clear();
-    IFstream is(fName);
+    ParentType::clear();
 
+    IFstream is(fName);
     if (!is.good())
     {
         FatalErrorIn
         (
-            "fileFormats::TRIfileFormat::read(const fileName&)"
+            "fileFormats::TRIsurfaceFormat::read(const fileName&)"
         )
             << "Cannot read file " << fName
             << exit(FatalError);
@@ -150,13 +116,13 @@ bool Foam::fileFormats::TRIfileFormat::read
 
     while (is.good())
     {
-        string line = getLineNoComment(is);
+        string line = ParentType::getLineNoComment(is);
 
         // handle continuations ?
         //          if (line[line.size()-1] == '\\')
         //          {
         //              line.substr(0, line.size()-1);
-        //              line += getLineNoComment(is);
+        //              line += ParentType::getLineNoComment(is);
         //          }
 
         IStringStream lineStream(line);
@@ -224,12 +190,12 @@ bool Foam::fileFormats::TRIfileFormat::read
     }
 
     // transfer to normal list
-    points().transfer(pointLst);
-    regions().transfer(regionLst);
+    ParentType::points().transfer(pointLst);
+    ParentType::regions().transfer(regionLst);
 
     // make our triangles directly
-    List<FaceType>& faceLst = faces();
-    faceLst.setSize(regions().size());
+    List<Face>& faceLst = ParentType::faces();
+    faceLst.setSize(ParentType::regions().size());
 
     label ptI = 0;
     forAll(faceLst, faceI)
@@ -243,21 +209,21 @@ bool Foam::fileFormats::TRIfileFormat::read
         faceLst[faceI] = fTri;
     }
 
-    setPatches(groupToPatch);
-    stitchFaces(SMALL);
-
+    ParentType::setPatches(groupToPatch);
+    ParentType::stitchFaces(SMALL);
     return true;
 }
 
 
-void Foam::fileFormats::TRIfileFormat::write
+template<class Face>
+void Foam::fileFormats::TRIsurfaceFormat<Face>::write
 (
     Ostream& os,
-    const keyedSurface& surf
+    const UnsortedMeshedSurface<Face>& surf
 )
 {
     const pointField& pointLst = surf.points();
-    const List<face>& faceLst  = surf.faces();
+    const List<Face>& faceLst  = surf.faces();
 
     labelList faceMap;
     List<surfGroup> patchLst = surf.sortedRegions(faceMap);
@@ -267,21 +233,22 @@ void Foam::fileFormats::TRIfileFormat::write
     {
         forAll(patchLst[patchI], patchFaceI)
         {
-            const face& f = faceLst[faceMap[faceIndex++]];
+            const Face& f = faceLst[faceMap[faceIndex++]];
             writeShell(os, pointLst, f, patchI);
         }
     }
 }
 
 
-void Foam::fileFormats::TRIfileFormat::write
+template<class Face>
+void Foam::fileFormats::TRIsurfaceFormat<Face>::write
 (
     Ostream& os,
-    const meshedSurface& surf
+    const MeshedSurface<Face>& surf
 )
 {
     const pointField& pointLst = surf.points();
-    const List<face>& faceLst  = surf.faces();
+    const List<Face>& faceLst  = surf.faces();
     const List<surfGroup>& patchLst = surf.patches();
 
     label faceIndex = 0;
@@ -289,7 +256,7 @@ void Foam::fileFormats::TRIfileFormat::write
     {
         forAll(patchLst[patchI], patchFaceI)
         {
-            const face& f = faceLst[faceIndex++];
+            const Face& f = faceLst[faceIndex++];
             writeShell(os, pointLst, f, patchI);
         }
     }
diff --git a/src/surfMesh/keyedSurface/fileFormats/tri/TRIfileFormat.H b/src/surfMesh/surfaceFormats/tri/TRIsurfaceFormat.H
similarity index 63%
rename from src/surfMesh/keyedSurface/fileFormats/tri/TRIfileFormat.H
rename to src/surfMesh/surfaceFormats/tri/TRIsurfaceFormat.H
index 5e59c7724d..9f9f1420f9 100644
--- a/src/surfMesh/keyedSurface/fileFormats/tri/TRIfileFormat.H
+++ b/src/surfMesh/surfaceFormats/tri/TRIsurfaceFormat.H
@@ -23,23 +23,23 @@ License
     Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 
 Class
-    Foam::fileFormats::TRIfileFormat
+    Foam::fileFormats::TRIsurfaceFormat
 
 Description
     Provide a means of reading/writing .tri format.
 
 SourceFiles
-    TRIfileFormat.C
+    TRIsurfaceFormat.C
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef TRIfileFormat_H
-#define TRIfileFormat_H
+#ifndef TRIsurfaceFormat_H
+#define TRIsurfaceFormat_H
 
 #include "Ostream.H"
 #include "OFstream.H"
-#include "keyedSurface.H"
-#include "meshedSurface.H"
+#include "MeshedSurface.H"
+#include "UnsortedMeshedSurface.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -49,27 +49,31 @@ namespace fileFormats
 {
 
 /*---------------------------------------------------------------------------*\
-                       Class TRIfileFormat Declaration
+                       Class TRIsurfaceFormat Declaration
 \*---------------------------------------------------------------------------*/
 
-class TRIfileFormat
+template<class Face>
+class TRIsurfaceFormat
 :
-    public keyedSurface
+    public UnsortedMeshedSurface<Face>
 {
+    //- Private typedefs for convenience
+    typedef TRIsurfaceFormat<Face>      ThisType;
+    typedef UnsortedMeshedSurface<Face> ParentType;
 
     // Private Member Functions
 
         //- Disallow default bitwise copy construct
-        TRIfileFormat(const TRIfileFormat&);
+        TRIsurfaceFormat(const TRIsurfaceFormat<Face>&);
 
         //- Disallow default bitwise assignment
-        void operator=(const TRIfileFormat&);
+        void operator=(const TRIsurfaceFormat<Face>&);
 
         static inline void writeShell
         (
             Ostream&,
             const pointField&,
-            const face&,
+            const Face&,
             const label patchI
         );
 
@@ -78,47 +82,64 @@ public:
     // Constructors
 
         //- Construct null
-        TRIfileFormat();
+        TRIsurfaceFormat();
 
         //- Construct from file name
-        TRIfileFormat(const fileName&, const bool triangulate=true);
+        TRIsurfaceFormat(const fileName&);
 
     // Selectors
 
-        //- Read file and return keyedSurface
-        static autoPtr<keyedSurface> New
+        //- Read file and return surface
+        static autoPtr<UnsortedMeshedSurface<Face> > New
         (
-            const fileName& fName,
-            const bool triangulate=true
+            const fileName& fName
         )
         {
-            return autoPtr<keyedSurface>
+            return autoPtr<UnsortedMeshedSurface<Face> >
             (
-                new TRIfileFormat(fName,true)
+                new TRIsurfaceFormat<Face>(fName)
             );
         }
 
     // Destructor
+        virtual ~TRIsurfaceFormat()
+        {}
 
     // Member Functions
 
         //- Read from file
-        virtual bool read(const fileName&, const bool triangulate);
+        virtual bool read(const fileName&);
 
-        //- Write keyedSurface
-        static void write(Ostream&, const keyedSurface&);
+        //- Write UnsortedMeshedSurface
+        static void write
+        (
+            Ostream&,
+            const UnsortedMeshedSurface<Face>&
+        );
 
-        //- Write keyedSurface
-        static void write(const fileName& fName, const keyedSurface& surf)
+        //- Write UnsortedMeshedSurface
+        static void write
+        (
+            const fileName& fName,
+            const UnsortedMeshedSurface<Face>& surf
+        )
         {
             write(OFstream(fName)(), surf);
         }
 
-        //- Write meshedSurface
-        static void write(Ostream&, const meshedSurface&);
+        //- Write MeshedSurface
+        static void write
+        (
+            Ostream&,
+            const MeshedSurface<Face>&
+        );
 
-        //- Write meshedSurface
-        static void write(const fileName& fName, const meshedSurface& surf)
+        //- Write MeshedSurface
+        static void write
+        (
+            const fileName& fName,
+            const MeshedSurface<Face>& surf
+        )
         {
             write(OFstream(fName)(), surf);
         }
@@ -139,6 +160,10 @@ public:
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
+#ifdef NoRepository
+#   include "TRIsurfaceFormat.C"
+#endif
+
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 #endif
diff --git a/src/surfMesh/surfaceFormats/tri/TRIsurfaceFormatRunTime.C b/src/surfMesh/surfaceFormats/tri/TRIsurfaceFormatRunTime.C
new file mode 100644
index 0000000000..558109bc0d
--- /dev/null
+++ b/src/surfMesh/surfaceFormats/tri/TRIsurfaceFormatRunTime.C
@@ -0,0 +1,99 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+\*---------------------------------------------------------------------------*/
+
+#include "TRIsurfaceFormat.H"
+#include "MeshedSurface.H"
+#include "UnsortedMeshedSurface.H"
+#include "addToRunTimeSelectionTable.H"
+#include "addToMemberFunctionSelectionTable.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+namespace Foam
+{
+namespace fileFormats
+{
+
+addNamedTemplatedToRunTimeSelectionTable
+(
+    UnsortedMeshedSurface,
+    TRIsurfaceFormat,
+    face,
+    fileExtension,
+    tri
+);
+addNamedTemplatedToRunTimeSelectionTable
+(
+    UnsortedMeshedSurface,
+    TRIsurfaceFormat,
+    triFace,
+    fileExtension,
+    tri
+);
+
+
+addNamedTemplatedToMemberFunctionSelectionTable
+(
+    UnsortedMeshedSurface,
+    TRIsurfaceFormat,
+    face,
+    write,
+    fileExtension,
+    tri
+);
+addNamedTemplatedToMemberFunctionSelectionTable
+(
+    UnsortedMeshedSurface,
+    TRIsurfaceFormat,
+    triFace,
+    write,
+    fileExtension,
+    tri
+);
+
+
+addNamedTemplatedToMemberFunctionSelectionTable
+(
+    MeshedSurface,
+    TRIsurfaceFormat,
+    face,
+    write,
+    fileExtension,
+    tri
+);
+addNamedTemplatedToMemberFunctionSelectionTable
+(
+    MeshedSurface,
+    TRIsurfaceFormat,
+    triFace,
+    write,
+    fileExtension,
+    tri
+);
+
+}
+}
+
+// ************************************************************************* //
diff --git a/src/surfMesh/keyedSurface/fileFormats/vtk/VTKfileFormat.C b/src/surfMesh/surfaceFormats/vtk/VTKsurfaceFormat.C
similarity index 83%
rename from src/surfMesh/keyedSurface/fileFormats/vtk/VTKfileFormat.C
rename to src/surfMesh/surfaceFormats/vtk/VTKsurfaceFormat.C
index c2e789f8f2..70f095c7cb 100644
--- a/src/surfMesh/keyedSurface/fileFormats/vtk/VTKfileFormat.C
+++ b/src/surfMesh/surfaceFormats/vtk/VTKsurfaceFormat.C
@@ -24,48 +24,20 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-#include "VTKfileFormat.H"
+#include "VTKsurfaceFormat.H"
 #include "clock.H"
 #include "IFstream.H"
 #include "IStringStream.H"
-#include "addToRunTimeSelectionTable.H"
-#include "addToMemberFunctionSelectionTable.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-namespace Foam
-{
-namespace fileFormats
-{
-
-addNamedToMemberFunctionSelectionTable
-(
-    keyedSurface,
-    VTKfileFormat,
-    write,
-    fileExtension,
-    vtk
-);
-
-addNamedToMemberFunctionSelectionTable
-(
-    meshedSurface,
-    VTKfileFormat,
-    write,
-    fileExtension,
-    vtk
-);
-
-}
-}
-
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
-
-void Foam::fileFormats::VTKfileFormat::writeHead
+template<class Face>
+void Foam::fileFormats::VTKsurfaceFormat<Face>::writeHead
 (
     Ostream& os,
     const pointField& pointLst,
-    const List<face>& faceLst
+    const List<Face>& faceLst
 )
 {
     // Write header
@@ -96,7 +68,8 @@ void Foam::fileFormats::VTKfileFormat::writeHead
 }
 
 
-void Foam::fileFormats::VTKfileFormat::writeTail
+template<class Face>
+void Foam::fileFormats::VTKsurfaceFormat<Face>::writeTail
 (
     Ostream& os,
     const List<surfGroup>& patchLst
@@ -139,21 +112,23 @@ void Foam::fileFormats::VTKfileFormat::writeTail
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
-Foam::fileFormats::VTKfileFormat::VTKfileFormat()
+template<class Face>
+Foam::fileFormats::VTKsurfaceFormat<Face>::VTKsurfaceFormat()
 :
-    Foam::keyedSurface()
+    ParentType()
 {}
 
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
-void Foam::fileFormats::VTKfileFormat::write
+template<class Face>
+void Foam::fileFormats::VTKsurfaceFormat<Face>::write
 (
     Ostream& os,
-    const keyedSurface& surf
+    const UnsortedMeshedSurface<Face>& surf
 )
 {
-    const List<face>& faceLst = surf.faces();
+    const List<Face>& faceLst = surf.faces();
 
     writeHead(os, surf.points(), faceLst);
 
@@ -181,13 +156,14 @@ void Foam::fileFormats::VTKfileFormat::write
 }
 
 
-void Foam::fileFormats::VTKfileFormat::write
+template<class Face>
+void Foam::fileFormats::VTKsurfaceFormat<Face>::write
 (
     Ostream& os,
-    const meshedSurface& surf
+    const MeshedSurface<Face>& surf
 )
 {
-    const List<face>& faceLst = surf.faces();
+    const List<Face>& faceLst = surf.faces();
     const List<surfGroup>& patchLst = surf.patches();
 
     writeHead(os, surf.points(), faceLst);
diff --git a/src/surfMesh/keyedSurface/fileFormats/vtk/VTKfileFormat.H b/src/surfMesh/surfaceFormats/vtk/VTKsurfaceFormat.H
similarity index 66%
rename from src/surfMesh/keyedSurface/fileFormats/vtk/VTKfileFormat.H
rename to src/surfMesh/surfaceFormats/vtk/VTKsurfaceFormat.H
index 082b795ed4..066501457d 100644
--- a/src/surfMesh/keyedSurface/fileFormats/vtk/VTKfileFormat.H
+++ b/src/surfMesh/surfaceFormats/vtk/VTKsurfaceFormat.H
@@ -23,23 +23,23 @@ License
     Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 
 Class
-    Foam::fileFormats::VTKfileFormat
+    Foam::fileFormats::VTKsurfaceFormat
 
 Description
     Provide a means of writing VTK legacy format.
 
 SourceFiles
-    VTKfileFormat.C
+    VTKsurfaceFormat.C
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef VTKfileFormat_H
-#define VTKfileFormat_H
+#ifndef VTKsurfaceFormat_H
+#define VTKsurfaceFormat_H
 
 #include "Ostream.H"
 #include "OFstream.H"
-#include "keyedSurface.H"
-#include "meshedSurface.H"
+#include "MeshedSurface.H"
+#include "UnsortedMeshedSurface.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -49,23 +49,27 @@ namespace fileFormats
 {
 
 /*---------------------------------------------------------------------------*\
-                       Class VTKfileFormat Declaration
+                     Class VTKsurfaceFormat Declaration
 \*---------------------------------------------------------------------------*/
 
-class VTKfileFormat
+template<class Face>
+class VTKsurfaceFormat
 :
-    public keyedSurface
+    public UnsortedMeshedSurface<Face>
 {
+    //- Private typedefs for convenience
+    typedef VTKsurfaceFormat<Face>      ThisType;
+    typedef UnsortedMeshedSurface<Face> ParentType;
 
     // Private Member Functions
 
         //- Disallow default bitwise copy construct
-        VTKfileFormat(const VTKfileFormat&);
+        VTKsurfaceFormat(const VTKsurfaceFormat<Face>&);
 
         //- Disallow default bitwise assignment
-        void operator=(const VTKfileFormat&);
+        void operator=(const VTKsurfaceFormat<Face>&);
 
-        static void writeHead(Ostream&, const pointField&, const List<face>&);
+        static void writeHead(Ostream&, const pointField&, const List<Face>&);
         static void writeTail(Ostream&, const List<surfGroup>&);
 
 public:
@@ -73,30 +77,49 @@ public:
     // Constructors
 
         //- Construct null
-        VTKfileFormat();
+        VTKsurfaceFormat();
 
     // Selectors
 
     // Destructor
 
+        virtual ~VTKsurfaceFormat()
+        {}
+
     // Member Functions
 
         // Write
 
-        //- Write keyedSurface
-        static void write(Ostream&, const keyedSurface&);
+        //- Write UnsortedMeshedSurface
+        static void write
+        (
+            Ostream&,
+            const UnsortedMeshedSurface<Face>&
+        );
 
-        //- Write keyedSurface
-        static void write(const fileName& fName, const keyedSurface& surf)
+        //- Write UnsortedMeshedSurface
+        static void write
+        (
+            const fileName& fName,
+            const UnsortedMeshedSurface<Face>& surf
+        )
         {
             write(OFstream(fName)(), surf);
         }
 
-        //- Write meshedSurface
-        static void write(Ostream&, const meshedSurface&);
+        //- Write MeshedSurface
+        static void write
+        (
+            Ostream&,
+            const MeshedSurface<Face>&
+        );
 
-        //- Write meshedSurface
-        static void write(const fileName& fName, const meshedSurface& surf)
+        //- Write MeshedSurface
+        static void write
+        (
+            const fileName& fName,
+            const MeshedSurface<Face>& surf
+        )
         {
             write(OFstream(fName)(), surf);
         }
@@ -117,6 +140,10 @@ public:
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
+#ifdef NoRepository
+#   include "VTKsurfaceFormat.C"
+#endif
+
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 #endif
diff --git a/src/surfMesh/surfaceFormats/vtk/VTKsurfaceFormatRunTime.C b/src/surfMesh/surfaceFormats/vtk/VTKsurfaceFormatRunTime.C
new file mode 100644
index 0000000000..8bcfea2355
--- /dev/null
+++ b/src/surfMesh/surfaceFormats/vtk/VTKsurfaceFormatRunTime.C
@@ -0,0 +1,81 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+\*---------------------------------------------------------------------------*/
+
+#include "VTKsurfaceFormat.H"
+#include "MeshedSurface.H"
+#include "UnsortedMeshedSurface.H"
+#include "addToRunTimeSelectionTable.H"
+#include "addToMemberFunctionSelectionTable.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+namespace Foam
+{
+namespace fileFormats
+{
+
+addNamedTemplatedToMemberFunctionSelectionTable
+(
+    UnsortedMeshedSurface,
+    VTKsurfaceFormat,
+    face,
+    write,
+    fileExtension,
+    vtk
+);
+addNamedTemplatedToMemberFunctionSelectionTable
+(
+    UnsortedMeshedSurface,
+    VTKsurfaceFormat,
+    triFace,
+    write,
+    fileExtension,
+    vtk
+);
+
+
+addNamedTemplatedToMemberFunctionSelectionTable
+(
+    MeshedSurface,
+    VTKsurfaceFormat,
+    face,
+    write,
+    fileExtension,
+    vtk
+);
+addNamedTemplatedToMemberFunctionSelectionTable
+(
+    MeshedSurface,
+    VTKsurfaceFormat,
+    triFace,
+    write,
+    fileExtension,
+    vtk
+);
+
+}
+}
+
+// ************************************************************************* //