diff --git a/applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightField.C b/applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightField.C
index 1204ac5976..e446dcac89 100644
--- a/applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightField.C
+++ b/applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightField.C
@@ -110,40 +110,30 @@ void writeAllData
 {
     if (nPrims)
     {
-        PstreamBuffers pBufs(Pstream::nonBlocking);
-
-        if (!Pstream::master())
-        {
-            UOPstream toMaster(Pstream::masterNo(), pBufs);
-            for (direction cmpt=0; cmpt<pTraits<Type>::nComponents; cmpt++)
-            {
-                toMaster<< map(vf, prims, cmpt);
-            }
-        }
-
-        pBufs.finishedSends();
-
         if (Pstream::master())
         {
             ensightFile << key << nl;
 
-            PtrList<UIPstream> fromSlaves(Pstream::nProcs());
-            for (int slave=1; slave<Pstream::nProcs(); slave++)
-            {
-                fromSlaves.set(slave, new UIPstream(slave, pBufs));
-            }
-
             for (direction cmpt=0; cmpt<pTraits<Type>::nComponents; cmpt++)
             {
                 writeData(map(vf, prims, cmpt), ensightFile);
 
                 for (int slave=1; slave<Pstream::nProcs(); slave++)
                 {
-                    scalarField data(fromSlaves[slave]);
+                    IPstream fromSlave(Pstream::scheduled, slave);
+                    scalarField data(fromSlave);
                     writeData(data, ensightFile);
                 }
             }
         }
+        else
+        {
+            for (direction cmpt=0; cmpt<pTraits<Type>::nComponents; cmpt++)
+            {
+                OPstream toMaster(Pstream::scheduled, Pstream::masterNo());
+                toMaster<< map(vf, prims, cmpt);
+            }
+        }
     }
 }
 
@@ -160,40 +150,30 @@ void writeAllDataBinary
 {
     if (nPrims)
     {
-        PstreamBuffers pBufs(Pstream::nonBlocking);
-
-        if (!Pstream::master())
-        {
-            UOPstream toMaster(Pstream::masterNo(), pBufs);
-            for (direction cmpt=0; cmpt<pTraits<Type>::nComponents; cmpt++)
-            {
-                toMaster<< map(vf, prims, cmpt);
-            }
-        }
-
-        pBufs.finishedSends();
-
         if (Pstream::master())
         {
             writeEnsDataBinary(key,ensightFile);
 
-            PtrList<UIPstream> fromSlaves(Pstream::nProcs());
-            for (int slave=1; slave<Pstream::nProcs(); slave++)
-            {
-                fromSlaves.set(slave, new UIPstream(slave, pBufs));
-            }
-
             for (direction cmpt=0; cmpt<pTraits<Type>::nComponents; cmpt++)
             {
                 writeEnsDataBinary(map(vf, prims, cmpt), ensightFile);
 
                 for (int slave=1; slave<Pstream::nProcs(); slave++)
                 {
-                    scalarField data(fromSlaves[slave]);
+                    IPstream fromSlave(Pstream::scheduled, slave);
+                    scalarField data(fromSlave);
                     writeEnsDataBinary(data, ensightFile);
                 }
             }
         }
+        else
+        {
+            for (direction cmpt=0; cmpt<pTraits<Type>::nComponents; cmpt++)
+            {
+                OPstream toMaster(Pstream::scheduled, Pstream::masterNo());
+                toMaster<< map(vf, prims, cmpt);
+            }
+        }
     }
 }
 
@@ -210,40 +190,31 @@ void writeAllFaceData
 {
     if (nPrims)
     {
-        PstreamBuffers pBufs(Pstream::nonBlocking);
-
-        if (!Pstream::master())
-        {
-            UOPstream toMaster(Pstream::masterNo(), pBufs);
-            for (direction cmpt=0; cmpt<pTraits<Type>::nComponents; cmpt++)
-            {
-                toMaster<< map(pf, prims, cmpt);
-            }
-        }
-
-        pBufs.finishedSends();
-
         if (Pstream::master())
         {
             ensightFile << key << nl;
 
-            PtrList<UIPstream> fromSlaves(Pstream::nProcs());
-            for (int slave=1; slave<Pstream::nProcs(); slave++)
-            {
-                fromSlaves.set(slave, new UIPstream(slave, pBufs));
-            }
-
             for (direction cmpt=0; cmpt<pTraits<Type>::nComponents; cmpt++)
             {
                 writeData(map(pf, prims, cmpt), ensightFile);
 
                 for (int slave=1; slave<Pstream::nProcs(); slave++)
                 {
-                    scalarField pf(fromSlaves[slave]);
+                    IPstream fromSlave(Pstream::scheduled, slave);
+                    scalarField pf(fromSlave);
+
                     writeData(pf, ensightFile);
                 }
             }
         }
+        else
+        {
+            for (direction cmpt=0; cmpt<pTraits<Type>::nComponents; cmpt++)
+            {
+                OPstream toMaster(Pstream::scheduled, Pstream::masterNo());
+                toMaster<< map(pf, prims, cmpt);
+            }
+        }
     }
 }
 
@@ -260,40 +231,31 @@ void writeAllFaceDataBinary
 {
     if (nPrims)
     {
-        PstreamBuffers pBufs(Pstream::nonBlocking);
-
-        if (!Pstream::master())
-        {
-            UOPstream toMaster(Pstream::masterNo(), pBufs);
-            for (direction cmpt=0; cmpt<pTraits<Type>::nComponents; cmpt++)
-            {
-                toMaster<< map(pf, prims, cmpt);
-            }
-        }
-
-        pBufs.finishedSends();
-
         if (Pstream::master())
         {
             writeEnsDataBinary(key,ensightFile);
 
-            PtrList<UIPstream> fromSlaves(Pstream::nProcs());
-            for (int slave=1; slave<Pstream::nProcs(); slave++)
-            {
-                fromSlaves.set(slave, new UIPstream(slave, pBufs));
-            }
-
             for (direction cmpt=0; cmpt<pTraits<Type>::nComponents; cmpt++)
             {
                 writeEnsDataBinary(map(pf, prims, cmpt), ensightFile);
 
                 for (int slave=1; slave<Pstream::nProcs(); slave++)
                 {
-                    scalarField pf(fromSlaves[slave]);
+                    IPstream fromSlave(Pstream::scheduled, slave);
+                    scalarField pf(fromSlave);
+
                     writeEnsDataBinary(pf, ensightFile);
                 }
             }
         }
+        else
+        {
+            for (direction cmpt=0; cmpt<pTraits<Type>::nComponents; cmpt++)
+            {
+                OPstream toMaster(Pstream::scheduled, Pstream::masterNo());
+                toMaster<< map(pf, prims, cmpt);
+            }
+        }
     }
 }
 
@@ -539,6 +501,10 @@ void ensightFieldAscii
     const wordHashSet& patchNames = eMesh.patchNames();
     const HashTable<ensightMesh::nFacePrimitives>&
         nPatchPrims = eMesh.nPatchPrims();
+    const List<faceSets>& faceZoneFaceSets = eMesh.faceZoneFaceSets();
+    const wordHashSet& faceZoneNames = eMesh.faceZoneNames();
+    const HashTable<ensightMesh::nFacePrimitives>&
+        nFaceZonePrims = eMesh.nFaceZonePrims();
 
     const labelList& tets = meshCellSets.tets;
     const labelList& pyrs = meshCellSets.pyrs;
@@ -557,7 +523,7 @@ void ensightFieldAscii
             postProcPath/ensightFileName,
             runTime.writeFormat(),
             runTime.writeVersion(),
-            runTime.writeCompression()
+            IOstream::UNCOMPRESSED
         );
     }
 
@@ -567,6 +533,8 @@ void ensightFieldAscii
 
     if (patchNames.empty())
     {
+        eMesh.barrier();
+
         if (Pstream::master())
         {
             if (timeIndex == 0)
@@ -592,29 +560,10 @@ void ensightFieldAscii
 
         if (meshCellSets.nHexesWedges)
         {
-            PstreamBuffers pBufs(Pstream::nonBlocking);
-
-            if (!Pstream::master())
-            {
-                UOPstream toMaster(Pstream::masterNo(), pBufs);
-                for (direction cmpt=0; cmpt<pTraits<Type>::nComponents; cmpt++)
-                {
-                    toMaster<< map(vf, hexes, wedges, cmpt);
-                }
-            }
-
-            pBufs.finishedSends();
-
             if (Pstream::master())
             {
                 ensightFile << "hexa8" << nl;
 
-                PtrList<UIPstream> fromSlaves(Pstream::nProcs());
-                for (int slave=1; slave<Pstream::nProcs(); slave++)
-                {
-                    fromSlaves.set(slave, new UIPstream(slave, pBufs));
-                }
-
                 for (direction cmpt=0; cmpt<pTraits<Type>::nComponents; cmpt++)
                 {
                     writeData
@@ -625,17 +574,57 @@ void ensightFieldAscii
 
                     for (int slave=1; slave<Pstream::nProcs(); slave++)
                     {
-                        scalarField data(fromSlaves[slave]);
+                        IPstream fromSlave(Pstream::scheduled, slave);
+                        scalarField data(fromSlave);
                         writeData(data, ensightFile);
                     }
                 }
             }
+            else
+            {
+                for (direction cmpt=0; cmpt<pTraits<Type>::nComponents; cmpt++)
+                {
+                    OPstream toMaster(Pstream::scheduled, Pstream::masterNo());
+                    toMaster<< map(vf, hexes, wedges, cmpt);
+                }
+            }
         }
 
-        writeAllData("penta6", vf, prisms, meshCellSets.nPrisms, ensightFile);
-        writeAllData("pyramid5", vf, pyrs, meshCellSets.nPyrs, ensightFile);
-        writeAllData("tetra4", vf, tets, meshCellSets.nTets, ensightFile);
-        writeAllData("nfaced", vf, polys, meshCellSets.nPolys, ensightFile);
+        writeAllData
+        (
+            "penta6",
+            vf,
+            prisms,
+            meshCellSets.nPrisms,
+            ensightFile
+        );
+
+        writeAllData
+        (
+            "pyramid5",
+            vf,
+            pyrs,
+            meshCellSets.nPyrs,
+            ensightFile
+        );
+
+        writeAllData
+        (
+            "tetra4",
+            vf,
+            tets,
+            meshCellSets.nTets,
+            ensightFile
+        );
+
+        writeAllData
+        (
+            "nfaced",
+            vf,
+            polys,
+            meshCellSets.nPolys,
+            ensightFile
+        );
     }
 
     label ensightPatchI = eMesh.patchPartOffset();
@@ -644,6 +633,8 @@ void ensightFieldAscii
     {
         const word& patchName = allPatchNames[patchi];
 
+        eMesh.barrier();
+
         if (patchNames.empty() || patchNames.found(patchName))
         {
             if
@@ -664,6 +655,80 @@ void ensightFieldAscii
         }
     }
 
+    // write faceZones, if requested
+    if (faceZoneNames.size())
+    {
+        // Interpolates cell values to faces - needed only when exporting
+        // faceZones...
+        GeometricField<Type, fvsPatchField, surfaceMesh> sf
+        (
+            linearInterpolate(vf)
+        );
+
+        forAllConstIter(wordHashSet, faceZoneNames, iter)
+        {
+            const word& faceZoneName = iter.key();
+
+            eMesh.barrier();
+
+            label zoneID = mesh.faceZones().findZoneID(faceZoneName);
+
+            const faceZone& fz = mesh.faceZones()[zoneID];
+
+            // Prepare data to write
+            label nIncluded = 0;
+            forAll(fz, i)
+            {
+                if (eMesh.faceToBeIncluded(fz[i]))
+                {
+                    ++nIncluded;
+                }
+            }
+
+            Field<Type> values(nIncluded);
+
+            // Loop on the faceZone and store the needed field values
+            label j = 0;
+            forAll(fz, i)
+            {
+                label faceI = fz[i];
+                if (mesh.isInternalFace(faceI))
+                {
+                    values[j] = sf[faceI];
+                    ++j;
+                }
+                else
+                {
+                    if (eMesh.faceToBeIncluded(faceI))
+                    {
+                        label patchI = mesh.boundaryMesh().whichPatch(faceI);
+                        const polyPatch& pp = mesh.boundaryMesh()[patchI];
+                        label patchFaceI = pp.whichFace(faceI);
+                        Type value = sf.boundaryField()[patchI][patchFaceI];
+                        values[j] = value;
+                        ++j;
+                    }
+                }
+            }
+
+            if
+            (
+                writePatchField
+                (
+                    values,
+                    zoneID,
+                    ensightPatchI,
+                    faceZoneFaceSets[zoneID],
+                    nFaceZonePrims.find(faceZoneName)(),
+                    ensightFile
+                )
+            )
+            {
+                ensightPatchI++;
+            }
+        }
+    }
+
     if (Pstream::master())
     {
         delete ensightFilePtr;
@@ -695,6 +760,10 @@ void ensightFieldBinary
     const wordHashSet& patchNames = eMesh.patchNames();
     const HashTable<ensightMesh::nFacePrimitives>&
         nPatchPrims = eMesh.nPatchPrims();
+    const List<faceSets>& faceZoneFaceSets = eMesh.faceZoneFaceSets();
+    const wordHashSet& faceZoneNames = eMesh.faceZoneNames();
+    const HashTable<ensightMesh::nFacePrimitives>&
+        nFaceZonePrims = eMesh.nFaceZonePrims();
 
     const labelList& tets = meshCellSets.tets;
     const labelList& pyrs = meshCellSets.pyrs;
@@ -722,6 +791,8 @@ void ensightFieldBinary
 
     if (patchNames.empty())
     {
+        eMesh.barrier();
+
         if (Pstream::master())
         {
             if (timeIndex == 0)
@@ -743,29 +814,10 @@ void ensightFieldBinary
 
         if (meshCellSets.nHexesWedges)
         {
-            PstreamBuffers pBufs(Pstream::nonBlocking);
-
-            if (!Pstream::master())
-            {
-                UOPstream toMaster(Pstream::masterNo(), pBufs);
-                for (direction cmpt=0; cmpt<pTraits<Type>::nComponents; cmpt++)
-                {
-                    toMaster<< map(vf, hexes, wedges, cmpt);
-                }
-            }
-
-            pBufs.finishedSends();
-
             if (Pstream::master())
             {
                 writeEnsDataBinary("hexa8",ensightFile);
 
-                PtrList<UIPstream> fromSlaves(Pstream::nProcs());
-                for (int slave=1; slave<Pstream::nProcs(); slave++)
-                {
-                    fromSlaves.set(slave, new UIPstream(slave, pBufs));
-                }
-
                 for (direction cmpt=0; cmpt<pTraits<Type>::nComponents; cmpt++)
                 {
                     writeEnsDataBinary
@@ -776,11 +828,20 @@ void ensightFieldBinary
 
                     for (int slave=1; slave<Pstream::nProcs(); slave++)
                     {
-                        scalarField data(fromSlaves[slave]);
+                        IPstream fromSlave(Pstream::scheduled, slave);
+                        scalarField data(fromSlave);
                         writeEnsDataBinary(data, ensightFile);
                     }
                 }
             }
+            else
+            {
+                for (direction cmpt=0; cmpt<pTraits<Type>::nComponents; cmpt++)
+                {
+                    OPstream toMaster(Pstream::scheduled, Pstream::masterNo());
+                    toMaster<< map(vf, hexes, wedges, cmpt);
+                }
+            }
         }
 
         writeAllDataBinary
@@ -826,6 +887,8 @@ void ensightFieldBinary
     {
         const word& patchName = allPatchNames[patchi];
 
+        eMesh.barrier();
+
         if (patchNames.empty() || patchNames.found(patchName))
         {
             if
@@ -844,6 +907,81 @@ void ensightFieldBinary
                 ensightPatchI++;
             }
         }
+
+    }
+
+    // write faceZones, if requested
+    if (faceZoneNames.size())
+    {
+        // Interpolates cell values to faces - needed only when exporting
+        // faceZones...
+        GeometricField<Type, fvsPatchField, surfaceMesh> sf
+        (
+            linearInterpolate(vf)
+        );
+
+        forAllConstIter(wordHashSet, faceZoneNames, iter)
+        {
+            const word& faceZoneName = iter.key();
+
+            eMesh.barrier();
+
+            label zoneID = mesh.faceZones().findZoneID(faceZoneName);
+
+            const faceZone& fz = mesh.faceZones()[zoneID];
+
+            // Prepare data to write
+            label nIncluded = 0;
+            forAll(fz, i)
+            {
+                if (eMesh.faceToBeIncluded(fz[i]))
+                {
+                    ++nIncluded;
+                }
+            }
+
+            Field<Type> values(nIncluded);
+
+            // Loop on the faceZone and store the needed field values
+            label j = 0;
+            forAll(fz, i)
+            {
+                label faceI = fz[i];
+                if (mesh.isInternalFace(faceI))
+                {
+                    values[j] = sf[faceI];
+                    ++j;
+                }
+                else
+                {
+                    if (eMesh.faceToBeIncluded(faceI))
+                    {
+                        label patchI = mesh.boundaryMesh().whichPatch(faceI);
+                        const polyPatch& pp = mesh.boundaryMesh()[patchI];
+                        label patchFaceI = pp.whichFace(faceI);
+                        Type value = sf.boundaryField()[patchI][patchFaceI];
+                        values[j] = value;
+                        ++j;
+                    }
+                }
+            }
+
+            if
+            (
+                writePatchFieldBinary
+                (
+                    values,
+                    zoneID,
+                    ensightPatchI,
+                    faceZoneFaceSets[zoneID],
+                    nFaceZonePrims.find(faceZoneName)(),
+                    ensightFile
+                )
+            )
+            {
+                ensightPatchI++;
+            }
+        }
     }
 
     if (Pstream::master())
diff --git a/applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightMesh.C b/applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightMesh.C
index 5f848736be..daece0473b 100644
--- a/applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightMesh.C
+++ b/applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightMesh.C
@@ -30,11 +30,14 @@ License
 #include "fvMesh.H"
 #include "globalMeshData.H"
 #include "PstreamCombineReduceOps.H"
+#include "processorPolyPatch.H"
 #include "cellModeller.H"
 #include "IOmanip.H"
 #include "itoa.H"
 #include "ensightWriteBinary.H"
+#include "globalIndex.H"
 #include "mapDistribute.H"
+#include "stringListOps.H"
 
 #include <fstream>
 
@@ -56,7 +59,11 @@ Foam::ensightMesh::ensightMesh
     boundaryFaceSets_(mesh_.boundary().size()),
     allPatchNames_(0),
     patchNames_(0),
-    nPatchPrims_(0)
+    nPatchPrims_(0),
+    faceZoneFaceSets_(mesh_.faceZones().size()),
+    faceZoneNames_(0),
+    nFaceZonePrims_(0),
+    boundaryFaceToBeIncluded_(0)
 {
     const cellShapeList& cellShapes = mesh.cellShapes();
 
@@ -80,10 +87,7 @@ Foam::ensightMesh::ensightMesh
 
         if (args.optionFound("patches"))
         {
-            wordList patchNameList
-            (
-                args.optionLookup("patches")()
-            );
+            wordList patchNameList(args.optionLookup("patches")());
 
             if (patchNameList.empty())
             {
@@ -218,7 +222,6 @@ Foam::ensightMesh::ensightMesh
         }
     }
 
-
     forAll(allPatchNames_, patchi)
     {
         const word& patchName = allPatchNames_[patchi];
@@ -240,6 +243,133 @@ Foam::ensightMesh::ensightMesh
 
         nPatchPrims_.insert(patchName, nfp);
     }
+
+    // faceZones
+    if (args.optionFound("faceZones"))
+    {
+        wordList patchNameList(args.optionLookup("faceZones")());
+
+        const wordList faceZoneNamesAll = mesh_.faceZones().names();
+
+        // Find out faceZone names that match with what requested at command
+        // line
+        forAll(patchNameList, i)
+        {
+            labelList matches = findStrings(patchNameList[i], faceZoneNamesAll);
+
+            forAll(matches, matchI)
+            {
+                faceZoneNames_.insert(faceZoneNamesAll[matches[matchI]]);
+            }
+        }
+
+        // Build list of boundary faces to be exported
+        boundaryFaceToBeIncluded_.setSize
+        (
+            mesh_.nFaces()
+          - mesh_.nInternalFaces(),
+            1
+        );
+
+        forAll(mesh_.boundaryMesh(), patchI)
+        {
+            const polyPatch& pp = mesh_.boundaryMesh()[patchI];
+            if
+            (
+                isA<processorPolyPatch>(pp)
+             && !refCast<const processorPolyPatch>(pp).owner()
+            )
+            {
+                label bFaceI = pp.start()-mesh_.nInternalFaces();
+                forAll(pp, i)
+                {
+                    boundaryFaceToBeIncluded_[bFaceI++] = 0;
+                }
+            }
+        }
+
+        // Count face types in each faceZone
+        forAll(faceZoneNamesAll, zoneI)
+        {
+            //const word& zoneName = faceZoneNamesAll[zoneI];
+
+            const faceZone& fz = mesh.faceZones()[zoneI];
+
+            if (fz.size())
+            {
+                labelList& tris = faceZoneFaceSets_[zoneI].tris;
+                labelList& quads = faceZoneFaceSets_[zoneI].quads;
+                labelList& polys = faceZoneFaceSets_[zoneI].polys;
+
+                tris.setSize(fz.size());
+                quads.setSize(fz.size());
+                polys.setSize(fz.size());
+
+                label nTris = 0;
+                label nQuads = 0;
+                label nPolys = 0;
+
+                label faceCounter = 0;
+
+                forAll(fz, i)
+                {
+                    label faceI = fz[i];
+
+                    // Avoid counting faces on processor boundaries twice
+                    if (faceToBeIncluded(faceI))
+                    {
+                        const face& f = mesh_.faces()[faceI];
+
+                        if (f.size() == 3)
+                        {
+                            tris[nTris++] = faceCounter;
+                        }
+                        else if (f.size() == 4)
+                        {
+                            quads[nQuads++] = faceCounter;
+                        }
+                        else
+                        {
+                            polys[nPolys++] = faceCounter;
+                        }
+
+                        ++faceCounter;
+                    }
+                }
+
+                tris.setSize(nTris);
+                quads.setSize(nQuads);
+                polys.setSize(nPolys);
+            }
+        }
+
+        forAll(faceZoneNamesAll, zoneI)
+        {
+            const word& zoneName = faceZoneNamesAll[zoneI];
+            nFacePrimitives nfp;
+
+            if (faceZoneNames_.found(zoneName))
+            {
+                if
+                (
+                    faceZoneFaceSets_[zoneI].tris.size()
+                 || faceZoneFaceSets_[zoneI].quads.size() ||
+                    faceZoneFaceSets_[zoneI].polys.size()
+                )
+                {
+                    nfp.nTris   = faceZoneFaceSets_[zoneI].tris.size();
+                    nfp.nQuads  = faceZoneFaceSets_[zoneI].quads.size();
+                    nfp.nPolys  = faceZoneFaceSets_[zoneI].polys.size();
+                }
+            }
+
+            reduce(nfp.nTris, sumOp<label>());
+            reduce(nfp.nQuads, sumOp<label>());
+            reduce(nfp.nPolys, sumOp<label>());
+
+            nFaceZonePrims_.insert(zoneName, nfp);
+        }
+    }
 }
 
 
@@ -251,6 +381,30 @@ Foam::ensightMesh::~ensightMesh()
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
+bool Foam::ensightMesh::faceToBeIncluded(const label faceI) const
+{
+    bool res = false;
+
+    if (mesh_.isInternalFace(faceI))
+    {
+        res = true;
+    }
+    else
+    {
+        res = boundaryFaceToBeIncluded_[faceI-mesh_.nInternalFaces()];
+    }
+
+    return res;
+}
+
+
+void Foam::ensightMesh::barrier()
+{
+    label appI = 0;
+    reduce(appI,maxOp<label>());
+}
+
+
 void Foam::ensightMesh::writePoints
 (
     const scalarField& pointsComponent,
@@ -470,125 +624,106 @@ void Foam::ensightMesh::writeAllPolys
         }
 
         // Number of faces for each poly cell
+
+        if (Pstream::master())
         {
-            PstreamBuffers pBufs(Pstream::nonBlocking);
-
-            if (!Pstream::master())
+            // Master
+            writePolysNFaces
+            (
+                meshCellSets_.polys,
+                cellFaces,
+                ensightGeometryFile
+            );
+            // Slaves
+            for (int slave=1; slave<Pstream::nProcs(); slave++)
             {
-                UOPstream toMaster(Pstream::masterNo(), pBufs);
-                toMaster<< meshCellSets_.polys << cellFaces;
-            }
+                IPstream fromSlave(Pstream::scheduled, slave);
+                labelList polys(fromSlave);
+                cellList cellFaces(fromSlave);
 
-            pBufs.finishedSends();
-
-            if (Pstream::master())
-            {
-                // Master
                 writePolysNFaces
                 (
-                    meshCellSets_.polys,
+                    polys,
                     cellFaces,
                     ensightGeometryFile
                 );
-                // Slaves
-                for (int slave=1; slave<Pstream::nProcs(); slave++)
-                {
-                    UIPstream fromSlave(slave, pBufs);
-                    labelList polys(fromSlave);
-                    cellList cellFaces(fromSlave);
-
-                    writePolysNFaces
-                    (
-                        polys,
-                        cellFaces,
-                        ensightGeometryFile
-                    );
-                }
             }
         }
+        else
+        {
+            OPstream toMaster(Pstream::scheduled, Pstream::masterNo());
+            toMaster<< meshCellSets_.polys << cellFaces;
+        }
 
 
         // Number of points for each face of the above list
+        if (Pstream::master())
         {
-            PstreamBuffers pBufs(Pstream::nonBlocking);
-
-            if (!Pstream::master())
+            // Master
+            writePolysNPointsPerFace
+            (
+                meshCellSets_.polys,
+                cellFaces,
+                faces,
+                ensightGeometryFile
+            );
+            // Slaves
+            for (int slave=1; slave<Pstream::nProcs(); slave++)
             {
-                UOPstream toMaster(Pstream::masterNo(), pBufs);
-                toMaster<< meshCellSets_.polys << cellFaces << faces;
-            }
-            pBufs.finishedSends();
+                IPstream fromSlave(Pstream::scheduled, slave);
+                labelList polys(fromSlave);
+                cellList cellFaces(fromSlave);
+                faceList faces(fromSlave);
 
-            if (Pstream::master())
-            {
-                // Master
                 writePolysNPointsPerFace
                 (
-                    meshCellSets_.polys,
+                    polys,
                     cellFaces,
                     faces,
                     ensightGeometryFile
                 );
-                // Slaves
-                for (int slave=1; slave<Pstream::nProcs(); slave++)
-                {
-                    UIPstream fromSlave(slave, pBufs);
-                    labelList polys(fromSlave);
-                    cellList cellFaces(fromSlave);
-                    faceList faces(fromSlave);
-
-                    writePolysNPointsPerFace
-                    (
-                        polys,
-                        cellFaces,
-                        faces,
-                        ensightGeometryFile
-                    );
-                }
             }
         }
+        else
+        {
+            OPstream toMaster(Pstream::scheduled, Pstream::masterNo());
+            toMaster<< meshCellSets_.polys << cellFaces << faces;
+        }
 
 
         // List of points id for each face of the above list
+        if (Pstream::master())
         {
-            PstreamBuffers pBufs(Pstream::nonBlocking);
-
-            if (!Pstream::master())
+            // Master
+            writePolysPoints
+            (
+                meshCellSets_.polys,
+                cellFaces,
+                faces,
+                ensightGeometryFile
+            );
+            // Slaves
+            for (int slave=1; slave<Pstream::nProcs(); slave++)
             {
-                UOPstream toMaster(Pstream::masterNo(), pBufs);
-                toMaster<< meshCellSets_.polys << cellFaces << faces;
-            }
+                IPstream fromSlave(Pstream::scheduled, slave);
+                labelList polys(fromSlave);
+                cellList cellFaces(fromSlave);
+                faceList faces(fromSlave);
 
-            pBufs.finishedSends();
-
-            if (Pstream::master())
-            {
-                // Master
                 writePolysPoints
                 (
-                    meshCellSets_.polys,
+                    polys,
                     cellFaces,
                     faces,
                     ensightGeometryFile
                 );
-                // Slaves
-                for (int slave=1; slave<Pstream::nProcs(); slave++)
-                {
-                    UIPstream fromSlave(slave, pBufs);
-                    labelList polys(fromSlave);
-                    cellList cellFaces(fromSlave);
-                    faceList faces(fromSlave);
-
-                    writePolysPoints
-                    (
-                        polys,
-                        cellFaces,
-                        faces,
-                        ensightGeometryFile
-                    );
-                }
             }
         }
+        else
+        {
+            OPstream toMaster(Pstream::scheduled, Pstream::masterNo());
+            toMaster<< meshCellSets_.polys << cellFaces << faces;
+        }
     }
 }
 
@@ -683,124 +818,103 @@ void Foam::ensightMesh::writeAllPolysBinary
         }
 
         // Number of faces for each poly cell
+        if (Pstream::master())
         {
-            PstreamBuffers pBufs(Pstream::nonBlocking);
-
-            if (!Pstream::master())
+            // Master
+            writePolysNFacesBinary
+            (
+                meshCellSets_.polys,
+                cellFaces,
+                ensightGeometryFile
+            );
+            // Slaves
+            for (int slave=1; slave<Pstream::nProcs(); slave++)
             {
-                UOPstream toMaster(Pstream::masterNo(), pBufs);
-                toMaster<< meshCellSets_.polys << cellFaces;
-            }
+                IPstream fromSlave(Pstream::scheduled, slave);
+                labelList polys(fromSlave);
+                cellList cellFaces(fromSlave);
 
-            pBufs.finishedSends();
-
-            if (Pstream::master())
-            {
-                // Master
                 writePolysNFacesBinary
                 (
-                    meshCellSets_.polys,
+                    polys,
                     cellFaces,
                     ensightGeometryFile
                 );
-                // Slaves
-                for (int slave=1; slave<Pstream::nProcs(); slave++)
-                {
-                    UIPstream fromSlave(slave, pBufs);
-                    labelList polys(fromSlave);
-                    cellList cellFaces(fromSlave);
-
-                    writePolysNFacesBinary
-                    (
-                        polys,
-                        cellFaces,
-                        ensightGeometryFile
-                    );
-                }
             }
         }
+        else
+        {
+            OPstream toMaster(Pstream::scheduled, Pstream::masterNo());
+            toMaster<< meshCellSets_.polys << cellFaces;
+        }
 
         // Number of points for each face of the above list
+        if (Pstream::master())
         {
-            PstreamBuffers pBufs(Pstream::nonBlocking);
-
-            if (!Pstream::master())
+            // Master
+            writePolysNPointsPerFaceBinary
+            (
+                meshCellSets_.polys,
+                cellFaces,
+                faces,
+                ensightGeometryFile
+            );
+            // Slaves
+            for (int slave=1; slave<Pstream::nProcs(); slave++)
             {
-                UOPstream toMaster(Pstream::masterNo(), pBufs);
-                toMaster<< meshCellSets_.polys << cellFaces << faces;
-            }
+                IPstream fromSlave(Pstream::scheduled, slave);
+                labelList polys(fromSlave);
+                cellList cellFaces(fromSlave);
+                faceList faces(fromSlave);
 
-            pBufs.finishedSends();
-
-            if (Pstream::master())
-            {
-                // Master
                 writePolysNPointsPerFaceBinary
                 (
-                    meshCellSets_.polys,
+                    polys,
                     cellFaces,
                     faces,
                     ensightGeometryFile
                 );
-                // Slaves
-                for (int slave=1; slave<Pstream::nProcs(); slave++)
-                {
-                    UIPstream fromSlave(slave, pBufs);
-                    labelList polys(fromSlave);
-                    cellList cellFaces(fromSlave);
-                    faceList faces(fromSlave);
-
-                    writePolysNPointsPerFaceBinary
-                    (
-                        polys,
-                        cellFaces,
-                        faces,
-                        ensightGeometryFile
-                    );
-                }
             }
         }
+        else
+        {
+            OPstream toMaster(Pstream::scheduled, Pstream::masterNo());
+            toMaster<< meshCellSets_.polys << cellFaces << faces;
+        }
 
         // List of points id for each face of the above list
+        if (Pstream::master())
         {
-            PstreamBuffers pBufs(Pstream::nonBlocking);
-
-            if (!Pstream::master())
+            // Master
+            writePolysPointsBinary
+            (
+                meshCellSets_.polys,
+                cellFaces,
+                faces,
+                ensightGeometryFile
+            );
+            // Slaves
+            for (int slave=1; slave<Pstream::nProcs(); slave++)
             {
-                UOPstream toMaster(Pstream::masterNo(), pBufs);
-                toMaster<< meshCellSets_.polys << cellFaces << faces;
-            }
+                IPstream fromSlave(Pstream::scheduled, slave);
+                labelList polys(fromSlave);
+                cellList cellFaces(fromSlave);
+                faceList faces(fromSlave);
 
-            pBufs.finishedSends();
-
-            if (Pstream::master())
-            {
-                // Master
                 writePolysPointsBinary
                 (
-                    meshCellSets_.polys,
+                    polys,
                     cellFaces,
                     faces,
                     ensightGeometryFile
                 );
-                // Slaves
-                for (int slave=1; slave<Pstream::nProcs(); slave++)
-                {
-                    UIPstream fromSlave(slave, pBufs);
-                    labelList polys(fromSlave);
-                    cellList cellFaces(fromSlave);
-                    faceList faces(fromSlave);
-
-                    writePolysPointsBinary
-                    (
-                        polys,
-                        cellFaces,
-                        faces,
-                        ensightGeometryFile
-                    );
-                }
             }
         }
+        else
+        {
+            OPstream toMaster(Pstream::scheduled, Pstream::masterNo());
+            toMaster<< meshCellSets_.polys << cellFaces << faces;
+        }
     }
 }
 
@@ -815,16 +929,6 @@ void Foam::ensightMesh::writeAllPrims
 {
     if (nPrims)
     {
-        PstreamBuffers pBufs(Pstream::nonBlocking);
-
-        if (!Pstream::master())
-        {
-            UOPstream toMaster(Pstream::masterNo(), pBufs);
-            toMaster<< cellShapes;
-        }
-
-        pBufs.finishedSends();
-
         if (Pstream::master())
         {
             ensightGeometryFile << key << nl << setw(10) << nPrims << nl;
@@ -833,12 +937,17 @@ void Foam::ensightMesh::writeAllPrims
 
             for (int slave=1; slave<Pstream::nProcs(); slave++)
             {
-                UIPstream fromSlave(slave, pBufs);
+                IPstream fromSlave(Pstream::scheduled, slave);
                 cellShapeList cellShapes(fromSlave);
 
                 writePrims(cellShapes, ensightGeometryFile);
             }
         }
+        else
+        {
+            OPstream toMaster(Pstream::scheduled, Pstream::masterNo());
+            toMaster<< cellShapes;
+        }
     }
 }
 
@@ -853,16 +962,6 @@ void Foam::ensightMesh::writeAllPrimsBinary
 {
     if (nPrims)
     {
-        PstreamBuffers pBufs(Pstream::nonBlocking);
-
-        if (!Pstream::master())
-        {
-            UOPstream toMaster(Pstream::masterNo(), pBufs);
-            toMaster<< cellShapes;
-        }
-
-        pBufs.finishedSends();
-
         if (Pstream::master())
         {
             writeEnsDataBinary(key,ensightGeometryFile);
@@ -872,12 +971,17 @@ void Foam::ensightMesh::writeAllPrimsBinary
 
             for (int slave=1; slave<Pstream::nProcs(); slave++)
             {
-                UIPstream fromSlave(slave, pBufs);
+                IPstream fromSlave(Pstream::scheduled, slave);
                 cellShapeList cellShapes(fromSlave);
 
                 writePrimsBinary(cellShapes, ensightGeometryFile);
             }
         }
+        else
+        {
+            OPstream toMaster(Pstream::scheduled, Pstream::masterNo());
+            toMaster<< cellShapes;
+        }
     }
 }
 
@@ -930,16 +1034,6 @@ void Foam::ensightMesh::writeAllFacePrims
 {
     if (nPrims)
     {
-        PstreamBuffers pBufs(Pstream::nonBlocking);
-
-        if (!Pstream::master())
-        {
-            UOPstream toMaster(Pstream::masterNo(), pBufs);
-            toMaster<< UIndirectList<face>(patchFaces, prims);
-        }
-
-        pBufs.finishedSends();
-
         if (Pstream::master())
         {
             ensightGeometryFile << key << nl << setw(10) << nPrims << nl;
@@ -952,12 +1046,17 @@ void Foam::ensightMesh::writeAllFacePrims
 
             for (int slave=1; slave<Pstream::nProcs(); slave++)
             {
-                UIPstream fromSlave(slave, pBufs);
+                IPstream fromSlave(Pstream::scheduled, slave);
                 faceList patchFaces(fromSlave);
 
                 writeFacePrims(patchFaces, ensightGeometryFile);
             }
         }
+        else
+        {
+            OPstream toMaster(Pstream::scheduled, Pstream::masterNo());
+            toMaster<< UIndirectList<face>(patchFaces, prims);
+        }
     }
 }
 
@@ -1002,68 +1101,54 @@ void Foam::ensightMesh::writeAllNSided
         }
 
         // Number of points for each face
+        if (Pstream::master())
         {
-            PstreamBuffers pBufs(Pstream::nonBlocking);
+            writeNSidedNPointsPerFace
+            (
+                UIndirectList<face>(patchFaces, prims)(),
+                ensightGeometryFile
+            );
 
-            if (!Pstream::master())
+            for (int slave=1; slave<Pstream::nProcs(); slave++)
             {
-                UOPstream toMaster(Pstream::masterNo(), pBufs);
-                toMaster<< UIndirectList<face>(patchFaces, prims);
-            }
+                IPstream fromSlave(Pstream::scheduled, slave);
+                faceList patchFaces(fromSlave);
 
-            pBufs.finishedSends();
-
-            if (Pstream::master())
-            {
                 writeNSidedNPointsPerFace
                 (
-                    UIndirectList<face>(patchFaces, prims)(),
+                    patchFaces,
                     ensightGeometryFile
                 );
-
-                for (int slave=1; slave<Pstream::nProcs(); slave++)
-                {
-                    UIPstream fromSlave(slave, pBufs);
-                    faceList patchFaces(fromSlave);
-
-                    writeNSidedNPointsPerFace
-                    (
-                        patchFaces,
-                        ensightGeometryFile
-                    );
-                }
             }
         }
+        else
+        {
+            OPstream toMaster(Pstream::scheduled, Pstream::masterNo());
+            toMaster<< UIndirectList<face>(patchFaces, prims);
+        }
 
         // List of points id for each face
+        if (Pstream::master())
         {
-            PstreamBuffers pBufs(Pstream::nonBlocking);
+            writeNSidedPoints
+            (
+                UIndirectList<face>(patchFaces, prims)(),
+                ensightGeometryFile
+            );
 
-            if (!Pstream::master())
+            for (int slave=1; slave<Pstream::nProcs(); slave++)
             {
-                UOPstream toMaster(Pstream::masterNo(), pBufs);
-                toMaster<< UIndirectList<face>(patchFaces, prims);
-            }
-
-            pBufs.finishedSends();
-
-            if (Pstream::master())
-            {
-                writeNSidedPoints
-                (
-                    UIndirectList<face>(patchFaces, prims)(),
-                    ensightGeometryFile
-                );
-
-                for (int slave=1; slave<Pstream::nProcs(); slave++)
-                {
-                    UIPstream fromSlave(slave, pBufs);
-                    faceList patchFaces(fromSlave);
-
-                    writeNSidedPoints(patchFaces, ensightGeometryFile);
-                }
+                IPstream fromSlave(Pstream::scheduled, slave);
+                faceList patchFaces(fromSlave);
+
+                writeNSidedPoints(patchFaces, ensightGeometryFile);
             }
         }
+        else
+        {
+            OPstream toMaster(Pstream::scheduled, Pstream::masterNo());
+            toMaster<< UIndirectList<face>(patchFaces, prims);
+        }
     }
 }
 
@@ -1108,72 +1193,54 @@ void Foam::ensightMesh::writeAllNSidedBinary
         }
 
         // Number of points for each face
+        if (Pstream::master())
         {
-            PstreamBuffers pBufs(Pstream::nonBlocking);
+            writeNSidedNPointsPerFaceBinary
+            (
+                UIndirectList<face>(patchFaces, prims)(),
+                ensightGeometryFile
+            );
 
-            if (!Pstream::master())
+            for (int slave=1; slave<Pstream::nProcs(); slave++)
             {
-                UOPstream toMaster(Pstream::masterNo(), pBufs);
-                toMaster<< UIndirectList<face>(patchFaces, prims);
-            }
+                IPstream fromSlave(Pstream::scheduled, slave);
+                faceList patchFaces(fromSlave);
 
-            pBufs.finishedSends();
-
-            if (Pstream::master())
-            {
                 writeNSidedNPointsPerFaceBinary
                 (
-                    UIndirectList<face>(patchFaces, prims)(),
+                    patchFaces,
                     ensightGeometryFile
                 );
-
-                for (int slave=1; slave<Pstream::nProcs(); slave++)
-                {
-                    UIPstream fromSlave(slave, pBufs);
-                    faceList patchFaces(fromSlave);
-
-                    writeNSidedNPointsPerFaceBinary
-                    (
-                        patchFaces,
-                        ensightGeometryFile
-                    );
-                }
             }
         }
+        else
+        {
+            OPstream toMaster(Pstream::scheduled, Pstream::masterNo());
+            toMaster<< UIndirectList<face>(patchFaces, prims);
+        }
 
         // List of points id for each face
+        if (Pstream::master())
         {
-            PstreamBuffers pBufs(Pstream::nonBlocking);
+            writeNSidedPointsBinary
+            (
+                UIndirectList<face>(patchFaces, prims)(),
+                ensightGeometryFile
+            );
 
-            if (!Pstream::master())
+            for (int slave=1; slave<Pstream::nProcs(); slave++)
             {
-                UOPstream toMaster(Pstream::masterNo(), pBufs);
-                toMaster<< UIndirectList<face>(patchFaces, prims);
-            }
-
-            pBufs.finishedSends();
-
-            if (Pstream::master())
-            {
-                writeNSidedPointsBinary
-                (
-                    UIndirectList<face>(patchFaces, prims)(),
-                    ensightGeometryFile
-                );
-
-                for (int slave=1; slave<Pstream::nProcs(); slave++)
-                {
-                    UIPstream fromSlave(slave, pBufs);
-                    faceList patchFaces(fromSlave);
-
-                    writeNSidedPointsBinary
-                    (
-                        patchFaces,
-                        ensightGeometryFile
-                    );
-                }
+                IPstream fromSlave(Pstream::scheduled, slave);
+                faceList patchFaces(fromSlave);
+
+                writeNSidedPointsBinary(patchFaces, ensightGeometryFile);
             }
         }
+        else
+        {
+            OPstream toMaster(Pstream::scheduled, Pstream::masterNo());
+            toMaster<< UIndirectList<face>(patchFaces, prims);
+        }
     }
 }
 
@@ -1189,16 +1256,6 @@ void Foam::ensightMesh::writeAllFacePrimsBinary
 {
     if (nPrims)
     {
-        PstreamBuffers pBufs(Pstream::nonBlocking);
-
-        if (!Pstream::master())
-        {
-            UOPstream toMaster(Pstream::masterNo(), pBufs);
-            toMaster<< UIndirectList<face>(patchFaces, prims);
-        }
-
-        pBufs.finishedSends();
-
         if (Pstream::master())
         {
             writeEnsDataBinary(key,ensightGeometryFile);
@@ -1212,12 +1269,17 @@ void Foam::ensightMesh::writeAllFacePrimsBinary
 
             for (int slave=1; slave<Pstream::nProcs(); slave++)
             {
-                UIPstream fromSlave(slave, pBufs);
+                IPstream fromSlave(Pstream::scheduled, slave);
                 faceList patchFaces(fromSlave);
 
                 writeFacePrimsBinary(patchFaces, ensightGeometryFile);
             }
         }
+        else
+        {
+            OPstream toMaster(Pstream::scheduled, Pstream::masterNo());
+            toMaster<< UIndirectList<face>(patchFaces, prims);
+        }
     }
 }
 
@@ -1269,6 +1331,206 @@ void Foam::ensightMesh::write
     }
 }
 
+void Foam::ensightMesh::writeAllInternalPoints
+(
+    const pointField& uniquePoints,
+    const label nPoints,
+    OFstream& ensightGeometryFile
+) const
+{
+    barrier();
+
+    if (Pstream::master())
+    {
+        ensightGeometryFile
+            << "part" << nl
+            << setw(10) << 1 << nl
+            << "internalMesh" << nl
+            << "coordinates" << nl
+            << setw(10) << nPoints
+            << endl;
+
+        for (direction d=0; d<vector::nComponents; d++)
+        {
+            writePoints(uniquePoints.component(d), ensightGeometryFile);
+
+            for (int slave=1; slave<Pstream::nProcs(); slave++)
+            {
+                IPstream fromSlave(Pstream::scheduled, slave);
+                scalarField pointsComponent(fromSlave);
+                writePoints(pointsComponent, ensightGeometryFile);
+            }
+        }
+    }
+    else
+    {
+        for (direction d=0; d<vector::nComponents; d++)
+        {
+            OPstream toMaster(Pstream::scheduled, Pstream::masterNo());
+            toMaster<< uniquePoints.component(d);
+        }
+    }
+}
+
+void Foam::ensightMesh::writeAllInternalPointsBinary
+(
+    const pointField& uniquePoints,
+    const label nPoints,
+    std::ofstream& ensightGeometryFile
+) const
+{
+    barrier();
+
+    if (Pstream::master())
+    {
+        writeEnsDataBinary("part",ensightGeometryFile);
+        writeEnsDataBinary(1,ensightGeometryFile);
+        writeEnsDataBinary("internalMesh",ensightGeometryFile);
+        writeEnsDataBinary("coordinates",ensightGeometryFile);
+        writeEnsDataBinary(nPoints,ensightGeometryFile);
+
+        for (direction d=0; d<vector::nComponents; d++)
+        {
+            writeEnsDataBinary
+            (
+                uniquePoints.component(d),
+                ensightGeometryFile
+            );
+
+            for (int slave=1; slave<Pstream::nProcs(); slave++)
+            {
+                IPstream fromSlave(Pstream::scheduled, slave);
+                scalarField pointsComponent(fromSlave);
+                writeEnsDataBinary(pointsComponent, ensightGeometryFile);
+            }
+        }
+    }
+    else
+    {
+        for (direction d=0; d<vector::nComponents; d++)
+        {
+            OPstream toMaster(Pstream::scheduled, Pstream::masterNo());
+            toMaster<< uniquePoints.component(d);
+        }
+    }
+}
+
+void Foam::ensightMesh::writeAllPatchPoints
+(
+    const label ensightPatchI,
+    const word& patchName,
+    const pointField& uniquePoints,
+    const label nPoints,
+    OFstream& ensightGeometryFile
+) const
+{
+    barrier();
+
+    if (Pstream::master())
+    {
+        ensightGeometryFile
+            << "part" << nl
+            << setw(10) << ensightPatchI << nl
+            << patchName << nl
+            << "coordinates" << nl
+            << setw(10) << nPoints // globalPointsPtr().size()
+            << endl;
+
+        for (direction d=0; d<vector::nComponents; d++)
+        {
+            writePoints
+            (
+                uniquePoints.component(d),
+                ensightGeometryFile
+            );
+
+            for (int slave=1; slave<Pstream::nProcs(); slave++)
+            {
+                IPstream fromSlave(Pstream::scheduled, slave);
+                scalarField patchPointsComponent(fromSlave);
+
+                writePoints
+                (
+                    patchPointsComponent,
+                    ensightGeometryFile
+                );
+            }
+        }
+    }
+    else
+    {
+        for (direction d=0; d<vector::nComponents; d++)
+        {
+            OPstream toMaster
+            (
+                Pstream::scheduled,
+                Pstream::masterNo()
+            );
+            toMaster<< uniquePoints.component(d);
+        }
+    }
+}
+
+void Foam::ensightMesh::writeAllPatchPointsBinary
+(
+    const label ensightPatchI,
+    const word& patchName,
+    const pointField& uniquePoints,
+    const label nPoints,
+    std::ofstream& ensightGeometryFile
+) const
+{
+    barrier();
+
+    if (Pstream::master())
+    {
+        writeEnsDataBinary("part",ensightGeometryFile);
+        writeEnsDataBinary(ensightPatchI,ensightGeometryFile);
+        //writeEnsDataBinary(patchName.c_str(),ensightGeometryFile);
+        writeEnsDataBinary(patchName.c_str(),ensightGeometryFile);
+        writeEnsDataBinary("coordinates",ensightGeometryFile);
+        writeEnsDataBinary
+        (
+            nPoints, //globalPointsPtr().size(),
+            ensightGeometryFile
+        );
+
+        for (direction d=0; d<vector::nComponents; d++)
+        {
+            //writePointsBinary
+            writeEnsDataBinary
+            (
+                uniquePoints.component(d),
+                ensightGeometryFile
+            );
+
+            for (int slave=1; slave<Pstream::nProcs(); slave++)
+            {
+                IPstream fromSlave(Pstream::scheduled, slave);
+                scalarField patchPointsComponent(fromSlave);
+
+                //writePointsBinary
+                writeEnsDataBinary
+                (
+                    patchPointsComponent,
+                    ensightGeometryFile
+                );
+            }
+        }
+    }
+    else
+    {
+        for (direction d=0; d<vector::nComponents; d++)
+        {
+            OPstream toMaster
+            (
+                Pstream::scheduled,
+                Pstream::masterNo()
+            );
+            toMaster<< uniquePoints.component(d);
+        }
+    }
+}
 
 void Foam::ensightMesh::writeAscii
 (
@@ -1286,7 +1548,6 @@ void Foam::ensightMesh::writeAscii
     const cellShapeList& cellShapes = mesh_.cellShapes();
 
 
-
     word timeFile = prepend;
 
     if (timeIndex == 0)
@@ -1327,7 +1588,7 @@ void Foam::ensightMesh::writeAscii
 
         ensightGeometryFile
             << "EnSight Geometry File" << nl
-            << "written from OpenFOAM-" << Foam::FOAMversion << nl
+            << "written by OpenFOAM-" << Foam::FOAMversion << nl
             << "node id assign" << nl
             << "element id assign" << nl;
     }
@@ -1336,50 +1597,12 @@ void Foam::ensightMesh::writeAscii
     {
         label nPoints = globalPoints.size();
 
-        {
-            PstreamBuffers pBufs(Pstream::nonBlocking);
-
-            if (!Pstream::master())
-            {
-                UOPstream toMaster(Pstream::masterNo(), pBufs);
-                for (direction d=0; d<vector::nComponents; d++)
-                {
-                    toMaster<< uniquePoints.component(d);
-                }
-            }
-
-            pBufs.finishedSends();
-
-            if (Pstream::master())
-            {
-                ensightGeometryFile
-                    << "part" << nl
-                    << setw(10) << 1 << nl
-                    << "internalMesh" << nl
-                    << "coordinates" << nl
-                    << setw(10) << nPoints
-                    << endl;
-
-
-                PtrList<UIPstream> fromSlaves(Pstream::nProcs());
-                for (int slave=1; slave<Pstream::nProcs(); slave++)
-                {
-                    fromSlaves.set(slave, new UIPstream(slave, pBufs));
-                }
-
-                for (direction d=0; d<vector::nComponents; d++)
-                {
-                    writePoints(uniquePoints.component(d), ensightGeometryFile);
-
-                    for (int slave=1; slave<Pstream::nProcs(); slave++)
-                    {
-                        scalarField pointsComponent(fromSlaves[slave]);
-                        writePoints(pointsComponent, ensightGeometryFile);
-                    }
-                }
-            }
-        }
-
+        writeAllInternalPoints
+        (
+            uniquePoints,
+            nPoints,
+            ensightGeometryFile
+        );
 
         writeAllPrims
         (
@@ -1464,61 +1687,14 @@ void Foam::ensightMesh::writeAscii
                     inplaceRenumber(pointToGlobal, patchFaces[i]);
                 }
 
-
-                {
-                    PstreamBuffers pBufs(Pstream::nonBlocking);
-
-                    if (!Pstream::master())
-                    {
-                        UOPstream toMaster(Pstream::masterNo(), pBufs);
-                        for (direction d=0; d<vector::nComponents; d++)
-                        {
-                            toMaster<< uniquePoints.component(d);
-                        }
-                    }
-
-                    pBufs.finishedSends();
-
-                    if (Pstream::master())
-                    {
-                        ensightGeometryFile
-                            << "part" << nl
-                            << setw(10) << ensightPatchI++ << nl
-                            << patchName << nl
-                            << "coordinates" << nl
-                            << setw(10) << globalPointsPtr().size()
-                            << endl;
-
-                        PtrList<UIPstream> fromSlaves(Pstream::nProcs());
-                        for (int slave=1; slave<Pstream::nProcs(); slave++)
-                        {
-                            fromSlaves.set(slave, new UIPstream(slave, pBufs));
-                        }
-
-                        for (direction d=0; d<vector::nComponents; d++)
-                        {
-                            writePoints
-                            (
-                                uniquePoints.component(d),
-                                ensightGeometryFile
-                            );
-
-                            for (int slave=1; slave<Pstream::nProcs(); slave++)
-                            {
-                                scalarField patchPointsComponent
-                                (
-                                    fromSlaves[slave]
-                                );
-
-                                writePoints
-                                (
-                                    patchPointsComponent,
-                                    ensightGeometryFile
-                                );
-                            }
-                        }
-                    }
-                }
+                writeAllPatchPoints
+                (
+                    ensightPatchI++,
+                    patchName,
+                    uniquePoints,
+                    globalPointsPtr().size(),
+                    ensightGeometryFile
+                );
 
                 writeAllFacePrims
                 (
@@ -1549,6 +1725,111 @@ void Foam::ensightMesh::writeAscii
         }
     }
 
+    // write faceZones, if requested
+    forAllConstIter(wordHashSet, faceZoneNames_, iter)
+    {
+        const word& faceZoneName = iter.key();
+
+        label faceID = mesh_.faceZones().findZoneID(faceZoneName);
+
+        const faceZone& fz = mesh_.faceZones()[faceID];
+
+        const nFacePrimitives& nfp = nFaceZonePrims_[faceZoneName];
+
+        if (nfp.nTris || nfp.nQuads || nfp.nPolys)
+        {
+            const labelList& tris = faceZoneFaceSets_[faceID].tris;
+            const labelList& quads = faceZoneFaceSets_[faceID].quads;
+            const labelList& polys = faceZoneFaceSets_[faceID].polys;
+
+            // Renumber the faceZone points/faces into unique points
+            labelList pointToGlobal;
+            labelList uniqueMeshPointLabels;
+            autoPtr<globalIndex> globalPointsPtr =
+            mesh_.globalData().mergePoints
+            (
+                fz().meshPoints(),
+                fz().meshPointMap(),
+                pointToGlobal,
+                uniqueMeshPointLabels
+            );
+
+            pointField uniquePoints(mesh_.points(), uniqueMeshPointLabels);
+
+            // Find the list of master faces belonging to the faceZone,
+            // in loacal numbering
+            faceList faceZoneFaces(fz().localFaces());
+
+            // Count how many master faces belong to the faceZone. Is there
+            // a better way of doing this?
+            label nMasterFaces = 0;
+
+            forAll(fz, faceI)
+            {
+                if (faceToBeIncluded(fz[faceI]))
+                {
+                    ++nMasterFaces;
+                }
+            }
+
+            // Create the faceList for the master faces only and fill it.
+            faceList faceZoneMasterFaces(nMasterFaces);
+
+            label currentFace = 0;
+
+            forAll(fz, faceI)
+            {
+                if (faceToBeIncluded(fz[faceI]))
+                {
+                    faceZoneMasterFaces[currentFace] = faceZoneFaces[faceI];
+                    ++currentFace;
+                }
+            }
+
+            // Renumber the faceZone master faces
+            forAll(faceZoneMasterFaces, i)
+            {
+                inplaceRenumber(pointToGlobal, faceZoneMasterFaces[i]);
+            }
+
+            writeAllPatchPoints
+            (
+                ensightPatchI++,
+                faceZoneName,
+                uniquePoints,
+                globalPointsPtr().size(),
+                ensightGeometryFile
+            );
+
+            writeAllFacePrims
+            (
+                "tria3",
+                tris,
+                nfp.nTris,
+                faceZoneMasterFaces,
+                ensightGeometryFile
+            );
+
+            writeAllFacePrims
+            (
+                "quad4",
+                quads,
+                nfp.nQuads,
+                faceZoneMasterFaces,
+                ensightGeometryFile
+            );
+
+            writeAllNSided
+            (
+                polys,
+                nfp.nPolys,
+                faceZoneMasterFaces,
+                ensightGeometryFile
+            );
+        }
+    }
+
+
     if (Pstream::master())
     {
         delete ensightGeometryFilePtr;
@@ -1599,9 +1880,10 @@ void Foam::ensightMesh::writeBinary
 
     if (Pstream::master())
     {
+        string description = string("written by OpenFOAM-") + Foam::FOAMversion;
         writeEnsDataBinary("C binary", ensightGeometryFile);
         writeEnsDataBinary("EnSight Geometry File", ensightGeometryFile);
-        writeEnsDataBinary("written from OpenFOAM", ensightGeometryFile);
+        writeEnsDataBinary(description.c_str(), ensightGeometryFile);
         writeEnsDataBinary("node id assign", ensightGeometryFile);
         writeEnsDataBinary("element id assign", ensightGeometryFile);
     }
@@ -1611,54 +1893,12 @@ void Foam::ensightMesh::writeBinary
     {
         label nPoints = globalPoints.size();
 
-        {
-            PstreamBuffers pBufs(Pstream::nonBlocking);
-
-            if (!Pstream::master())
-            {
-                UOPstream toMaster(Pstream::masterNo(), pBufs);
-                for (direction d=0; d<vector::nComponents; d++)
-                {
-                    toMaster<< uniquePoints.component(d);
-                }
-            }
-
-            pBufs.finishedSends();
-
-            if (Pstream::master())
-            {
-                writeEnsDataBinary("part",ensightGeometryFile);
-                writeEnsDataBinary(1,ensightGeometryFile);
-                writeEnsDataBinary("internalMesh",ensightGeometryFile);
-                writeEnsDataBinary("coordinates",ensightGeometryFile);
-                writeEnsDataBinary(nPoints,ensightGeometryFile);
-
-                PtrList<UIPstream> fromSlaves(Pstream::nProcs());
-                for (int slave=1; slave<Pstream::nProcs(); slave++)
-                {
-                    fromSlaves.set(slave, new UIPstream(slave, pBufs));
-                }
-
-                for (direction d=0; d<vector::nComponents; d++)
-                {
-                    writeEnsDataBinary
-                    (
-                        uniquePoints.component(d),
-                        ensightGeometryFile
-                    );
-
-                    for (int slave=1; slave<Pstream::nProcs(); slave++)
-                    {
-                        scalarField pointsComponent(fromSlaves[slave]);
-                        writeEnsDataBinary
-                        (
-                            pointsComponent,
-                            ensightGeometryFile
-                        );
-                    }
-                }
-            }
-        }
+        writeAllInternalPointsBinary
+        (
+            uniquePoints,
+            nPoints,
+            ensightGeometryFile
+        );
 
         writeAllPrimsBinary
         (
@@ -1743,71 +1983,14 @@ void Foam::ensightMesh::writeBinary
                     inplaceRenumber(pointToGlobal, patchFaces[i]);
                 }
 
-
-                {
-                    PstreamBuffers pBufs(Pstream::nonBlocking);
-
-                    if (!Pstream::master())
-                    {
-                        UOPstream toMaster(Pstream::masterNo(), pBufs);
-                        for (direction d=0; d<vector::nComponents; d++)
-                        {
-                            toMaster<< uniquePoints.component(d);
-                        }
-                    }
-
-                    pBufs.finishedSends();
-
-                    if (Pstream::master())
-                    {
-                        writeEnsDataBinary("part",ensightGeometryFile);
-                        writeEnsDataBinary(ensightPatchI++,ensightGeometryFile);
-                        //writeEnsDataBinary
-                        //(patchName.c_str(),ensightGeometryFile);
-                        writeEnsDataBinary
-                        (   
-                            patchName.c_str(),
-                            ensightGeometryFile
-                        );
-                        writeEnsDataBinary("coordinates",ensightGeometryFile);
-                        writeEnsDataBinary
-                        (
-                            globalPointsPtr().size(),
-                            ensightGeometryFile
-                        );
-
-                        PtrList<UIPstream> fromSlaves(Pstream::nProcs());
-                        for (int slave=1; slave<Pstream::nProcs(); slave++)
-                        {
-                            fromSlaves.set(slave, new UIPstream(slave, pBufs));
-                        }
-
-                        for (direction d=0; d<vector::nComponents; d++)
-                        {
-                            //writePointsBinary
-                            writeEnsDataBinary
-                            (
-                                uniquePoints.component(d),
-                                ensightGeometryFile
-                            );
-
-                            for (int slave=1; slave<Pstream::nProcs(); slave++)
-                            {
-                                scalarField patchPointsComponent
-                                (
-                                    fromSlaves[slave]
-                                );
-
-                                //writePointsBinary
-                                writeEnsDataBinary
-                                (
-                                    patchPointsComponent,
-                                    ensightGeometryFile
-                                );
-                            }
-                        }
-                    }
-                }
+                writeAllPatchPointsBinary
+                (
+                    ensightPatchI++,
+                    patchName,
+                    uniquePoints,
+                    globalPointsPtr().size(),
+                    ensightGeometryFile
+                );
 
                 writeAllFacePrimsBinary
                 (
@@ -1838,6 +2021,111 @@ void Foam::ensightMesh::writeBinary
         }
     }
 
+    // write faceZones, if requested
+    forAllConstIter(wordHashSet, faceZoneNames_, iter)
+    {
+        const word& faceZoneName = iter.key();
+
+        label faceID = mesh_.faceZones().findZoneID(faceZoneName);
+
+        const faceZone& fz = mesh_.faceZones()[faceID];
+
+        const nFacePrimitives& nfp = nFaceZonePrims_[faceZoneName];
+
+        if (nfp.nTris || nfp.nQuads || nfp.nPolys)
+        {
+            const labelList& tris = faceZoneFaceSets_[faceID].tris;
+            const labelList& quads = faceZoneFaceSets_[faceID].quads;
+            const labelList& polys = faceZoneFaceSets_[faceID].polys;
+
+            // Renumber the faceZone points/faces into unique points
+            labelList pointToGlobal;
+            labelList uniqueMeshPointLabels;
+            autoPtr<globalIndex> globalPointsPtr =
+            mesh_.globalData().mergePoints
+            (
+                fz().meshPoints(),
+                fz().meshPointMap(),
+                pointToGlobal,
+                uniqueMeshPointLabels
+            );
+
+            pointField uniquePoints(mesh_.points(), uniqueMeshPointLabels);
+
+            // Find the list of master faces belonging to the faceZone,
+            // in loacal numbering
+            faceList faceZoneFaces(fz().localFaces());
+
+            // Count how many master faces belong to the faceZone. Is there
+            // a better way of doing this?
+            label nMasterFaces = 0;
+
+            forAll(fz, faceI)
+            {
+                if (faceToBeIncluded(fz[faceI]))
+                {
+                    ++nMasterFaces;
+                }
+            }
+
+            // Create the faceList for the master faces only and fill it.
+            faceList faceZoneMasterFaces(nMasterFaces);
+
+            label currentFace = 0;
+
+            forAll(fz, faceI)
+            {
+                if (faceToBeIncluded(fz[faceI]))
+                {
+                    faceZoneMasterFaces[currentFace] = faceZoneFaces[faceI];
+                    ++currentFace;
+                }
+            }
+
+            // Renumber the faceZone master faces
+
+            forAll(faceZoneMasterFaces, i)
+            {
+                inplaceRenumber(pointToGlobal, faceZoneMasterFaces[i]);
+            }
+
+            writeAllPatchPointsBinary
+            (
+                ensightPatchI++,
+                faceZoneName,
+                uniquePoints,
+                globalPointsPtr().size(),
+                ensightGeometryFile
+            );
+
+            writeAllFacePrimsBinary
+            (
+                "tria3",
+                tris,
+                nfp.nTris,
+                faceZoneMasterFaces,
+                ensightGeometryFile
+            );
+
+            writeAllFacePrimsBinary
+            (
+                "quad4",
+                quads,
+                nfp.nQuads,
+                faceZoneMasterFaces,
+                ensightGeometryFile
+            );
+
+            writeAllNSidedBinary
+            (
+                polys,
+                nfp.nPolys,
+                faceZoneMasterFaces,
+                ensightGeometryFile
+            );
+        }
+    }
+
 
     if (Pstream::master())
     {
diff --git a/applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightMesh.H b/applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightMesh.H
index d82e8d33b5..9762015eb0 100644
--- a/applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightMesh.H
+++ b/applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightMesh.H
@@ -42,7 +42,7 @@ SourceFiles
 #include "fvMesh.H"
 #include "OFstream.H"
 #include <fstream>
-#include "globalIndex.H"
+#include "PackedBoolList.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -51,6 +51,7 @@ namespace Foam
 
 class fvMesh;
 class argList;
+class globalIndex;
 
 /*---------------------------------------------------------------------------*\
                            Class ensightMesh Declaration
@@ -98,6 +99,16 @@ private:
 
         HashTable<nFacePrimitives> nPatchPrims_;
 
+        // faceZone - related variables
+        List<faceSets> faceZoneFaceSets_;
+
+        wordHashSet faceZoneNames_;
+
+        HashTable<nFacePrimitives> nFaceZonePrims_;
+
+        //- Per boundary face whether to include or not
+        PackedBoolList boundaryFaceToBeIncluded_;
+
 
     // Private Member Functions
 
@@ -206,6 +217,38 @@ private:
             OFstream& ensightGeometryFile
         ) const;
 
+        void writeAllInternalPoints
+        (
+            const pointField& uniquePoints,
+            const label nPoints,
+            OFstream& ensightGeometryFile
+        ) const;
+
+        void writeAllPatchPoints
+        (
+            label ensightPatchI,
+            const word& patchName,
+            const pointField& uniquePoints,
+            const label nPoints,
+            OFstream& ensightGeometryFile
+        ) const;
+
+        void writeAllInternalPointsBinary
+        (
+            const pointField& uniquePoints,
+            const label nPoints,
+            std::ofstream& ensightGeometryFile
+        ) const;
+
+        void writeAllPatchPointsBinary
+        (
+            label ensightPatchI,
+            const word& patchName,
+            const pointField& uniquePoints,
+            const label nPoints,
+            std::ofstream& ensightGeometryFile
+        ) const;
+
         void writeAscii
         (
             const fileName& postProcPath,
@@ -311,7 +354,12 @@ public:
     // Constructors
 
         //- Construct from fvMesh
-        ensightMesh(const fvMesh&, const argList& args, const bool binary);
+        ensightMesh
+        (
+            const fvMesh&,
+            const argList& args,
+            const bool binary
+        );
 
 
     //- Destructor
@@ -352,12 +400,36 @@ public:
                 return nPatchPrims_;
             }
 
+            const List<faceSets>& faceZoneFaceSets() const
+            {
+                return faceZoneFaceSets_;
+            }
+
+            const wordHashSet& faceZoneNames() const
+            {
+                return faceZoneNames_;
+            }
+
+            const HashTable<nFacePrimitives>& nFaceZonePrims() const
+            {
+                return nFaceZonePrims_;
+            }
+
             //- The ensight part id for the first patch
             label patchPartOffset() const
             {
                 return patchPartOffset_;
             }
 
+    // Other
+
+        //- When exporting faceZones, check if a given face has to be included
+        //  or not (i.e. faces on processor boundaries)
+        bool faceToBeIncluded(const label faceI) const;
+
+        //- Helper to cause barrier. Necessary on Quadrics.
+        static void barrier();
+
 
     // I-O
 
@@ -368,6 +440,7 @@ public:
             const label timeIndex,
             Ostream& ensightCaseFile
         ) const;
+
 };
 
 
diff --git a/applications/utilities/postProcessing/dataConversion/foamToEnsight/foamToEnsight.C b/applications/utilities/postProcessing/dataConversion/foamToEnsight/foamToEnsight.C
index 7378bdc7a4..6d2f56f3b8 100644
--- a/applications/utilities/postProcessing/dataConversion/foamToEnsight/foamToEnsight.C
+++ b/applications/utilities/postProcessing/dataConversion/foamToEnsight/foamToEnsight.C
@@ -41,6 +41,9 @@ Usage
     @param -noPatches \n
     Suppress writing any patches.
 
+    @param -faceZones zoneList \n
+    Specify faceZones to write, with wildcards
+
 Note
     Parallel support for cloud data is not supported
     - writes to @a EnSight directory to avoid collisions with foamToEnsightParts
@@ -113,6 +116,12 @@ int main(int argc, char *argv[])
         "specify particular patches to write - eg '(inlet outlet)'. "
         "An empty list suppresses writing the internalMesh."
     );
+    argList::addOption
+    (
+        "faceZones",
+        "wordList",
+        "specify faceZones to write, with wildcards - eg '(mfp-.*)'. "
+    );
 
 #   include "setRootCase.H"