From 6fffe6ff3f134030e8f8bd8965f83a9bf1403c53 Mon Sep 17 00:00:00 2001
From: henry <Henry Weller h.weller@opencfd.co.uk>
Date: Mon, 9 Jun 2008 13:39:39 +0100
Subject: [PATCH] New foamToEnsight with support for binary files contributed
 by Francesco.

---
 .../dataConversion/foamToEnsight/Make/files   |    8 +
 .../dataConversion/foamToEnsight/Make/options |    8 +
 .../dataConversion/foamToEnsight/cellSets.H   |  102 ++
 .../dataConversion/foamToEnsight/checkData.H  |   18 +
 .../foamToEnsight/checkMeshMoving.H           |   21 +
 .../foamToEnsight/checkSprayData.H            |   13 +
 .../foamToEnsight/ensightCaseHeader.H         |    5 +
 .../foamToEnsight/ensightCaseTail.H           |   33 +
 .../foamToEnsight/ensightField.C              |  898 ++++++++++
 .../foamToEnsight/ensightField.H              |   80 +
 .../foamToEnsight/ensightMesh.C               | 1533 +++++++++++++++++
 .../foamToEnsight/ensightMesh.H               |  268 +++
 .../foamToEnsight/ensightParticlePositions.C  |   91 +
 .../foamToEnsight/ensightParticlePositions.H  |   54 +
 .../foamToEnsight/ensightSprayField.C         |  115 ++
 .../foamToEnsight/ensightSprayField.H         |   64 +
 .../foamToEnsight/ensightWriteBinary.C        |   79 +
 .../foamToEnsight/ensightWriteBinary.H        |   68 +
 .../dataConversion/foamToEnsight/faceSets.H   |   88 +
 .../foamToEnsight/foamToEnsight.C             |  396 +++++
 .../dataConversion/foamToEnsight/itoa.C       |   62 +
 .../dataConversion/foamToEnsight/itoa.H       |   48 +
 .../dataConversion/foamToEnsight/moveMesh.H   |   28 +
 23 files changed, 4080 insertions(+)
 create mode 100644 applications/utilities/postProcessing/dataConversion/foamToEnsight/Make/files
 create mode 100644 applications/utilities/postProcessing/dataConversion/foamToEnsight/Make/options
 create mode 100644 applications/utilities/postProcessing/dataConversion/foamToEnsight/cellSets.H
 create mode 100644 applications/utilities/postProcessing/dataConversion/foamToEnsight/checkData.H
 create mode 100644 applications/utilities/postProcessing/dataConversion/foamToEnsight/checkMeshMoving.H
 create mode 100644 applications/utilities/postProcessing/dataConversion/foamToEnsight/checkSprayData.H
 create mode 100644 applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightCaseHeader.H
 create mode 100644 applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightCaseTail.H
 create mode 100644 applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightField.C
 create mode 100644 applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightField.H
 create mode 100644 applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightMesh.C
 create mode 100644 applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightMesh.H
 create mode 100644 applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightParticlePositions.C
 create mode 100644 applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightParticlePositions.H
 create mode 100644 applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightSprayField.C
 create mode 100644 applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightSprayField.H
 create mode 100644 applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightWriteBinary.C
 create mode 100644 applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightWriteBinary.H
 create mode 100644 applications/utilities/postProcessing/dataConversion/foamToEnsight/faceSets.H
 create mode 100644 applications/utilities/postProcessing/dataConversion/foamToEnsight/foamToEnsight.C
 create mode 100644 applications/utilities/postProcessing/dataConversion/foamToEnsight/itoa.C
 create mode 100644 applications/utilities/postProcessing/dataConversion/foamToEnsight/itoa.H
 create mode 100644 applications/utilities/postProcessing/dataConversion/foamToEnsight/moveMesh.H

diff --git a/applications/utilities/postProcessing/dataConversion/foamToEnsight/Make/files b/applications/utilities/postProcessing/dataConversion/foamToEnsight/Make/files
new file mode 100644
index 0000000000..d4c28fa64c
--- /dev/null
+++ b/applications/utilities/postProcessing/dataConversion/foamToEnsight/Make/files
@@ -0,0 +1,8 @@
+itoa.C
+ensightMesh.C
+ensightParticlePositions.C
+foamToEnsight.C
+ensightWriteBinary.C
+
+EXE = $(FOAM_APPBIN)/foamToEnsight
+//EXE = $(FOAM_USER_APPBIN)/foamToEnsight
diff --git a/applications/utilities/postProcessing/dataConversion/foamToEnsight/Make/options b/applications/utilities/postProcessing/dataConversion/foamToEnsight/Make/options
new file mode 100644
index 0000000000..db2e26ca8b
--- /dev/null
+++ b/applications/utilities/postProcessing/dataConversion/foamToEnsight/Make/options
@@ -0,0 +1,8 @@
+EXE_INC = \
+    -I$(LIB_SRC)/finiteVolume/lnInclude \
+    -I$(LIB_SRC)/lagrangian/basic/lnInclude
+
+EXE_LIBS = \
+    -lfiniteVolume \
+    -llagrangian \
+   
diff --git a/applications/utilities/postProcessing/dataConversion/foamToEnsight/cellSets.H b/applications/utilities/postProcessing/dataConversion/foamToEnsight/cellSets.H
new file mode 100644
index 0000000000..72859dff2b
--- /dev/null
+++ b/applications/utilities/postProcessing/dataConversion/foamToEnsight/cellSets.H
@@ -0,0 +1,102 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2007 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::cellSets
+
+Description
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef cellSets_H
+#define cellSets_H
+
+#include "labelList.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                           Class cellSets Declaration
+\*---------------------------------------------------------------------------*/
+
+class cellSets
+{
+    // Private Member Functions
+
+        //- Disallow default bitwise copy construct
+        cellSets(const cellSets&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const cellSets&);
+
+
+public:
+
+        label nHexesWedges;
+        label nPrisms;
+        label nPyrs;
+        label nTets;
+        label nPolys;
+
+        labelList tets;
+        labelList pyrs;
+        labelList prisms;
+        labelList wedges;
+        labelList hexes;
+        labelList polys;
+
+
+    // Constructors
+
+        //- Construct given the number ov cells
+        cellSets(const label nCells)
+        :
+            nHexesWedges(0),
+            nPrisms(0),
+            nPyrs(0),
+            nTets(0),
+            nPolys(0),
+
+            tets(nCells),
+            pyrs(nCells),
+            prisms(nCells),
+            wedges(nCells),
+            hexes(nCells),
+            polys(nCells)
+        {}
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/applications/utilities/postProcessing/dataConversion/foamToEnsight/checkData.H b/applications/utilities/postProcessing/dataConversion/foamToEnsight/checkData.H
new file mode 100644
index 0000000000..59be3c5dc9
--- /dev/null
+++ b/applications/utilities/postProcessing/dataConversion/foamToEnsight/checkData.H
@@ -0,0 +1,18 @@
+for (int n1=startTime; n1<endTime; n1++)
+{
+    if (fieldName.size() > 2 && fieldName(fieldName.size() - 2, 2) == "_0")
+    {
+        variableGood = false;
+        break;
+    }
+
+    IOobject fieldObjectHeader
+    (
+        fieldName,
+        Times[n1].name(),
+        mesh,
+        IOobject::NO_READ
+    );
+
+    variableGood = variableGood && fieldObjectHeader.headerOk();
+}
diff --git a/applications/utilities/postProcessing/dataConversion/foamToEnsight/checkMeshMoving.H b/applications/utilities/postProcessing/dataConversion/foamToEnsight/checkMeshMoving.H
new file mode 100644
index 0000000000..e6e46c8f86
--- /dev/null
+++ b/applications/utilities/postProcessing/dataConversion/foamToEnsight/checkMeshMoving.H
@@ -0,0 +1,21 @@
+bool meshMoving = true;
+
+if (Times.size() > 2)
+{
+   for(label n2=2; n2<Times.size(); n2++)
+   {
+       IOobject tmpPoints
+       (
+           "points",
+           Times[n2].name(),
+           polyMesh::meshSubDir,
+           mesh,
+           IOobject::NO_READ
+       );
+       meshMoving = meshMoving && tmpPoints.headerOk();
+   }
+}
+else
+{
+    meshMoving = false;
+}
diff --git a/applications/utilities/postProcessing/dataConversion/foamToEnsight/checkSprayData.H b/applications/utilities/postProcessing/dataConversion/foamToEnsight/checkSprayData.H
new file mode 100644
index 0000000000..6a581184dc
--- /dev/null
+++ b/applications/utilities/postProcessing/dataConversion/foamToEnsight/checkSprayData.H
@@ -0,0 +1,13 @@
+forAll(Times, n1)
+{
+    IOobject fieldObjectHeader
+    (
+        fieldName,
+        Times[n1].name(),
+        "lagrangian",
+        mesh,
+        IOobject::NO_READ
+    );
+
+    variableGood = variableGood && fieldObjectHeader.headerOk();
+}
diff --git a/applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightCaseHeader.H b/applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightCaseHeader.H
new file mode 100644
index 0000000000..cc81cb4659
--- /dev/null
+++ b/applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightCaseHeader.H
@@ -0,0 +1,5 @@
+if (Pstream::master())
+{
+    ensightCaseFile << "FORMAT" << nl;
+    ensightCaseFile << "type: ensight gold" << nl << nl;
+}
diff --git a/applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightCaseTail.H b/applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightCaseTail.H
new file mode 100644
index 0000000000..43c1a3f801
--- /dev/null
+++ b/applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightCaseTail.H
@@ -0,0 +1,33 @@
+if (Pstream::master())
+{
+    ensightCaseFile << nl << "TIME" << nl
+        << "time set:                      " << 1 << nl
+        << "number of steps:               " << nTimeSteps << nl
+        << "filename start number:         " << 0 << nl
+        << "filename increment:            " << 1 << nl;
+
+    ensightCaseFile << "time values:" << nl;
+
+    ensightCaseFile.setf(ios_base::scientific, ios_base::floatfield);
+    ensightCaseFile.precision(5);
+
+    label count = 0;
+    scalar Tcorr = 0.0;
+    if (Times[0].value() < 0)
+    {
+        Tcorr = - Times[0].value();
+        Info << "Correcting time values. Adding " << Tcorr << endl;
+    }
+
+    for (int n=startTime; n<endTime; n++)
+    {
+        ensightCaseFile << setw(12) << Times[n].value() + Tcorr << " ";
+
+        if (++count % 6 == 0)
+        {
+            ensightCaseFile << nl;
+        }
+    }
+
+    ensightCaseFile << nl;
+}
diff --git a/applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightField.C b/applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightField.C
new file mode 100644
index 0000000000..4561a0b077
--- /dev/null
+++ b/applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightField.C
@@ -0,0 +1,898 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2007 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 "ensightField.H"
+#include "fvMesh.H"
+#include "volFields.H"
+#include "OFstream.H"
+#include "IOmanip.H"
+#include "itoa.H"
+#include "ensightWriteBinary.H"
+
+using namespace Foam;
+
+// * * * * * * * * * * * * * * * Global Functions  * * * * * * * * * * * * * //
+
+void writeData(const scalarField& sf, OFstream& ensightFile)
+{
+    forAll(sf, i)
+    {
+        if (mag( sf[i] ) >= scalar(floatScalarVSMALL))
+        {
+            ensightFile << setw(12) << sf[i] << nl;
+        }
+        else
+        {
+            ensightFile << setw(12) << scalar(0) << nl;
+        }
+    }
+}
+
+
+template<class Type>
+scalarField map
+(
+    const Field<Type>& vf,
+    const labelList& map,
+    const label cmpt
+)
+{
+    scalarField mf(map.size());
+
+    forAll(map, i)
+    {
+        mf[i] = component(vf[map[i]], cmpt);
+    }
+
+    return mf;
+}
+
+
+template<class Type>
+scalarField map
+(
+    const Field<Type>& vf,
+    const labelList& map1,
+    const labelList& map2,
+    const label cmpt
+)
+{
+    scalarField mf(map1.size() + map2.size());
+
+    forAll(map1, i)
+    {
+        mf[i] = component(vf[map1[i]], cmpt);
+    }
+
+    label offset = map1.size();
+
+    forAll(map2, i)
+    {
+        mf[i + offset] = component(vf[map2[i]], cmpt);
+    }
+
+    return mf;
+}
+
+
+template<class Type>
+void writeAllData
+(
+    const char* key,
+    const Field<Type>& vf,
+    const labelList& prims,
+    const label nPrims,
+    OFstream& ensightFile
+)
+{
+    if (nPrims)
+    {
+        if (Pstream::master())
+        {
+            ensightFile << key << nl;
+
+            for (direction cmpt=0; cmpt<pTraits<Type>::nComponents; cmpt++)
+            {
+                writeData(map(vf, prims, cmpt), ensightFile);
+
+                for (int slave=1; slave<Pstream::nProcs(); 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);
+            }
+        }
+    }
+}
+
+
+template<class Type>
+void writeAllDataBinary
+(
+    const char* key,
+    const Field<Type>& vf,
+    const labelList& prims,
+    const label nPrims,
+    std::ofstream& ensightFile
+)
+{
+    if (nPrims)
+    {
+        if (Pstream::master())
+        {
+            writeEnsDataBinary(key,ensightFile);
+
+            for (direction cmpt=0; cmpt<pTraits<Type>::nComponents; cmpt++)
+            {
+                writeEnsDataBinary(map(vf, prims, cmpt), ensightFile);
+
+                for (int slave=1; slave<Pstream::nProcs(); 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);
+            }
+        }
+    }
+}
+
+
+
+template<class Type>
+void writeAllFaceData
+(
+    const char* key,
+    const labelList& prims,
+    const label nPrims,
+    const Field<Type>& pf,
+    const labelList& patchProcessors,
+    OFstream& ensightFile
+)
+{
+    if (nPrims)
+    {
+        if (Pstream::master())
+        {
+            ensightFile << key << nl;
+
+            for (direction cmpt=0; cmpt<pTraits<Type>::nComponents; cmpt++)
+            {
+                writeData(map(pf, prims, cmpt), ensightFile);
+
+                forAll (patchProcessors, i)
+                {
+                    if (patchProcessors[i] != 0)
+                    {
+                        label slave = patchProcessors[i];
+                        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);
+            }
+        }
+    }
+}
+
+
+template<class Type>
+void writeAllFaceDataBinary
+(
+    const char* key,
+    const labelList& prims,
+    const label nPrims,
+    const Field<Type>& pf,
+    const labelList& patchProcessors,
+    std::ofstream& ensightFile
+)
+{
+    if (nPrims)
+    {
+        if (Pstream::master())
+        {
+            writeEnsDataBinary(key,ensightFile);
+
+            for (direction cmpt=0; cmpt<pTraits<Type>::nComponents; cmpt++)
+            {
+                writeEnsDataBinary(map(pf, prims, cmpt), ensightFile);
+
+                forAll (patchProcessors, i)
+                {
+                    if (patchProcessors[i] != 0)
+                    {
+                        label slave = patchProcessors[i];
+                        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);
+            }
+        }
+    }
+}
+
+
+template<class Type>
+bool writePatchField
+(
+    const Foam::Field<Type>& pf,
+    const Foam::label patchi,
+    const Foam::label ensightPatchi,
+    const Foam::faceSets& boundaryFaceSet,
+    const Foam::ensightMesh::nFacePrims& nfp,
+    const Foam::labelList& patchProcessors,
+    Foam::OFstream& ensightFile
+)
+{
+    if (nfp.nTris || nfp.nQuads || nfp.nPolys)
+    {
+        if (Pstream::master())
+        {
+            ensightFile
+                << "part" << nl
+                << setw(10) << ensightPatchi << nl;
+        }
+
+        writeAllFaceData
+        (
+            "tria3",
+            boundaryFaceSet.tris,
+            nfp.nTris,
+            pf,
+            patchProcessors,
+            ensightFile
+        );
+
+        writeAllFaceData
+        (
+            "quad4",
+            boundaryFaceSet.quads,
+            nfp.nQuads,
+            pf,
+            patchProcessors,
+            ensightFile
+        );
+
+        writeAllFaceData
+        (
+            "nsided",
+            boundaryFaceSet.polys,
+            nfp.nPolys,
+            pf,
+            patchProcessors,
+            ensightFile
+        );
+
+        return true;
+    }
+    else
+    {
+        return false;
+    }
+}
+
+
+template<class Type>
+bool writePatchFieldBinary
+(
+    const Foam::Field<Type>& pf,
+    const Foam::label patchi,
+    const Foam::label ensightPatchi,
+    const Foam::faceSets& boundaryFaceSet,
+    const Foam::ensightMesh::nFacePrims& nfp,
+    const Foam::labelList& patchProcessors,
+    std::ofstream& ensightFile
+)
+{
+    if (nfp.nTris || nfp.nQuads || nfp.nPolys)
+    {
+        if (Pstream::master())
+        {
+            writeEnsDataBinary("part",ensightFile);
+            writeEnsDataBinary(ensightPatchi,ensightFile);
+        }
+
+        writeAllFaceDataBinary
+        (
+            "tria3",
+            boundaryFaceSet.tris,
+            nfp.nTris,
+            pf,
+            patchProcessors,
+            ensightFile
+        );
+
+        writeAllFaceDataBinary
+        (
+            "quad4",
+            boundaryFaceSet.quads,
+            nfp.nQuads,
+            pf,
+            patchProcessors,
+            ensightFile
+        );
+
+        writeAllFaceDataBinary
+        (
+            "nsided",
+            boundaryFaceSet.polys,
+            nfp.nPolys,
+            pf,
+            patchProcessors,
+            ensightFile
+        );
+
+        return true;
+    }
+    else
+    {
+        return false;
+    }
+}
+
+
+template<class Type>
+void writePatchField
+(
+    const Foam::word& fieldName,
+    const Foam::Field<Type>& pf,
+    const Foam::word& patchName,
+    const Foam::ensightMesh& eMesh,
+    const Foam::fileName& postProcPath,
+    const Foam::word& prepend,
+    const Foam::label timeIndex,
+    Foam::Ostream& ensightCaseFile
+)
+{
+    const Time& runTime = eMesh.mesh.time();
+
+    const List<faceSets>& boundaryFaceSets = eMesh.boundaryFaceSets;
+    const HashTable<labelList>& allPatchNames = eMesh.allPatchNames;
+    const HashTable<label>& patchIndices = eMesh.patchIndices;
+    const HashTable<ensightMesh::nFacePrims>& nPatchPrims = eMesh.nPatchPrims;
+
+    label patchi = -1;
+
+    if (patchIndices.found(patchName))
+    {
+        patchi = patchIndices.find(patchName)();
+    }
+
+    label ensightPatchi = 2;
+
+    for
+    (
+        HashTable<labelList>::const_iterator iter =
+            allPatchNames.begin();
+        iter != allPatchNames.end();
+        ++iter
+    )
+    {
+        if (iter.key() == patchName) break;
+        ensightPatchi++;
+    }
+
+
+    const labelList& patchProcessors = allPatchNames.find(patchName)();
+
+    word pfName = patchName + '.' + fieldName;
+
+    word timeFile = prepend + itoa(timeIndex);
+
+    OFstream *ensightFilePtr = NULL;
+    if (Pstream::master())
+    {
+        if (timeIndex == 0)
+        {
+            ensightCaseFile.setf(ios_base::left);
+
+            ensightCaseFile
+                << pTraits<Type>::typeName
+                << " per element:            1       "
+                << setw(15) << pfName
+                << (' ' + prepend + "***." + pfName).c_str()
+                << nl;
+        }
+
+        // set the filename of the ensight file
+        fileName ensightFileName(timeFile + "." + pfName);
+        ensightFilePtr = new OFstream
+        (
+            postProcPath/ensightFileName,
+            runTime.writeFormat(),
+            runTime.writeVersion(),
+            runTime.writeCompression()
+        );
+    }
+
+    OFstream& ensightFile = *ensightFilePtr;
+
+    if (Pstream::master())
+    {
+        ensightFile << pTraits<Type>::typeName << nl;
+    }
+
+    if (patchi >= 0)
+    {
+        writePatchField
+        (
+            pf,
+            patchi,
+            ensightPatchi,
+            boundaryFaceSets[patchi],
+            nPatchPrims.find(patchName)(),
+            patchProcessors,
+            ensightFile
+        );
+    }
+    else
+    {
+        faceSets nullFaceSets;
+
+        writePatchField
+        (
+            Field<Type>(),
+            -1,
+            ensightPatchi,
+            nullFaceSets,
+            nPatchPrims.find(patchName)(),
+            patchProcessors,
+            ensightFile
+        );
+    }
+
+    if (Pstream::master())
+    {
+        delete ensightFilePtr;
+    }
+}
+
+template<class Type>
+void ensightFieldAscii
+(
+    const Foam::IOobject& fieldObject,
+    const Foam::ensightMesh& eMesh,
+    const Foam::fileName& postProcPath,
+    const Foam::word& prepend,
+    const Foam::label timeIndex,
+    Foam::Ostream& ensightCaseFile
+)
+{
+    Info<< "Converting field " << fieldObject.name() << endl;
+
+    word timeFile = prepend + itoa(timeIndex);
+
+    const fvMesh& mesh = eMesh.mesh;
+    const Time& runTime = mesh.time();
+
+    const cellSets& meshCellSets = eMesh.meshCellSets;
+    const List<faceSets>& boundaryFaceSets = eMesh.boundaryFaceSets;
+    const HashTable<labelList>& allPatchNames = eMesh.allPatchNames;
+    const HashTable<label>& patchIndices = eMesh.patchIndices;
+    const wordHashSet& patchNames = eMesh.patchNames;
+    const HashTable<ensightMesh::nFacePrims>& nPatchPrims = eMesh.nPatchPrims;
+
+    const labelList& tets = meshCellSets.tets;
+    const labelList& pyrs = meshCellSets.pyrs;
+    const labelList& prisms = meshCellSets.prisms;
+    const labelList& wedges = meshCellSets.wedges;
+    const labelList& hexes = meshCellSets.hexes;
+    const labelList& polys = meshCellSets.polys;
+
+    OFstream *ensightFilePtr = NULL;
+    if (Pstream::master())
+    {
+        // set the filename of the ensight file
+        fileName ensightFileName(timeFile + "." + fieldObject.name());
+        ensightFilePtr = new OFstream
+        (
+            postProcPath/ensightFileName,
+            runTime.writeFormat(),
+            runTime.writeVersion(),
+            runTime.writeCompression()
+        );
+    }
+
+    OFstream& ensightFile = *ensightFilePtr;
+
+    GeometricField<Type, fvPatchField, volMesh> vf(fieldObject, mesh);
+
+    if (!patchNames.size())
+    {
+        if (Pstream::master())
+        {
+            if (timeIndex == 0)
+            {
+                ensightCaseFile.setf(ios_base::left);
+
+                ensightCaseFile
+                    << pTraits<Type>::typeName
+                    << " per element:            1       "
+                    << setw(15) << vf.name()
+                    << (' ' + prepend + "***." + vf.name()).c_str()
+                    << nl;
+            }
+
+            ensightFile
+                << pTraits<Type>::typeName << nl
+                << "part" << nl
+                << setw(10) << 1 << nl;
+
+            ensightFile.setf(ios_base::scientific, ios_base::floatfield);
+            ensightFile.precision(5);
+        }
+
+        if (meshCellSets.nHexesWedges)
+        {
+            if (Pstream::master())
+            {
+                ensightFile << "hexa8" << nl;
+
+                for (direction cmpt=0; cmpt<pTraits<Type>::nComponents; cmpt++)
+                {
+                    writeData
+                    (
+                        map(vf, hexes, wedges, cmpt),
+                        ensightFile
+                    );
+
+                    for (int slave=1; slave<Pstream::nProcs(); 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);
+    }
+
+    label ensightPatchi = 2;
+
+    for
+    (
+        HashTable<labelList>::const_iterator iter = allPatchNames.begin();
+        iter != allPatchNames.end();
+        ++iter
+    )
+    {
+        const word& patchName = iter.key();
+        const labelList& patchProcessors = iter();
+
+        if (!patchNames.size() || patchNames.found(patchName))
+        {
+            if (patchIndices.found(patchName))
+            {
+                label patchi = patchIndices.find(patchName)();
+
+                if
+                (
+                    writePatchField
+                    (
+                        vf.boundaryField()[patchi],
+                        patchi,
+                        ensightPatchi,
+                        boundaryFaceSets[patchi],
+                        nPatchPrims.find(patchName)(),
+                        patchProcessors,
+                        ensightFile
+                    )
+                )
+                {
+                    ensightPatchi++;
+                }
+
+            }
+            else if (Pstream::master())
+            {
+                faceSets nullFaceSet;
+
+                if
+                (
+                    writePatchField
+                    (
+                        Field<Type>(),
+                        -1,
+                        ensightPatchi,
+                        nullFaceSet,
+                        nPatchPrims.find(patchName)(),
+                        patchProcessors,
+                        ensightFile
+                    )
+                )
+                {
+                    ensightPatchi++;
+                }
+            }
+        }
+    }
+
+    if (Pstream::master())
+    {
+        delete ensightFilePtr;
+    }
+}
+
+
+template<class Type>
+void ensightFieldBinary
+(
+    const Foam::IOobject& fieldObject,
+    const Foam::ensightMesh& eMesh,
+    const Foam::fileName& postProcPath,
+    const Foam::word& prepend,
+    const Foam::label timeIndex,
+    Foam::Ostream& ensightCaseFile
+)
+{
+    Info<< "Converting field (binary) " << fieldObject.name() << endl;
+
+    word timeFile = prepend + itoa(timeIndex);
+
+    const fvMesh& mesh = eMesh.mesh;
+    //const Time& runTime = mesh.time();
+
+    const cellSets& meshCellSets = eMesh.meshCellSets;
+    const List<faceSets>& boundaryFaceSets = eMesh.boundaryFaceSets;
+    const HashTable<labelList>& allPatchNames = eMesh.allPatchNames;
+    const HashTable<label>& patchIndices = eMesh.patchIndices;
+    const wordHashSet& patchNames = eMesh.patchNames;
+    const HashTable<ensightMesh::nFacePrims>& nPatchPrims = eMesh.nPatchPrims;
+
+    const labelList& tets = meshCellSets.tets;
+    const labelList& pyrs = meshCellSets.pyrs;
+    const labelList& prisms = meshCellSets.prisms;
+    const labelList& wedges = meshCellSets.wedges;
+    const labelList& hexes = meshCellSets.hexes;
+    const labelList& polys = meshCellSets.polys;
+
+    std::ofstream *ensightFilePtr = NULL;
+    if (Pstream::master())
+    {
+        // set the filename of the ensight file
+        fileName ensightFileName(timeFile + "." + fieldObject.name());
+        ensightFilePtr = new std::ofstream((postProcPath/ensightFileName).c_str(), ios_base::out | ios_base::binary | ios_base::trunc);
+        // Check on file opened?
+    }
+
+    std::ofstream& ensightFile = *ensightFilePtr;
+
+    GeometricField<Type, fvPatchField, volMesh> vf(fieldObject, mesh);
+
+    if (!patchNames.size())
+    {
+        if (Pstream::master())
+        {
+            if (timeIndex == 0)
+            {
+                ensightCaseFile.setf(ios_base::left);
+
+                ensightCaseFile
+                    << pTraits<Type>::typeName
+                    << " per element:            1       "
+                    << setw(15) << vf.name()
+                    << (' ' + prepend + "***." + vf.name()).c_str()
+                    << nl;
+            }
+
+            writeEnsDataBinary(pTraits<Type>::typeName,ensightFile);
+            writeEnsDataBinary("part",ensightFile);
+            writeEnsDataBinary(1,ensightFile);
+        }
+
+        if (meshCellSets.nHexesWedges)
+        {
+            if (Pstream::master())
+            {
+                writeEnsDataBinary("hexa8",ensightFile);
+
+                for (direction cmpt=0; cmpt<pTraits<Type>::nComponents; cmpt++)
+                {
+                    writeEnsDataBinary
+                    (
+                        map(vf, hexes, wedges, cmpt),
+                        ensightFile
+                    );
+
+                    for (int slave=1; slave<Pstream::nProcs(); 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("penta6", vf, prisms, meshCellSets.nPrisms, ensightFile);
+        writeAllDataBinary("pyramid5", vf, pyrs, meshCellSets.nPyrs, ensightFile);
+        writeAllDataBinary("tetra4", vf, tets, meshCellSets.nTets, ensightFile);
+        writeAllDataBinary("nfaced", vf, polys, meshCellSets.nPolys, ensightFile);
+    }
+
+    label ensightPatchi = 2;
+
+    for
+    (
+        HashTable<labelList>::const_iterator iter = allPatchNames.begin();
+        iter != allPatchNames.end();
+        ++iter
+    )
+    {
+        const word& patchName = iter.key();
+        const labelList& patchProcessors = iter();
+
+        if (!patchNames.size() || patchNames.found(patchName))
+        {
+            if (patchIndices.found(patchName))
+            {
+                label patchi = patchIndices.find(patchName)();
+
+                if
+                (
+                    writePatchFieldBinary
+                    (
+                        vf.boundaryField()[patchi],
+                        patchi,
+                        ensightPatchi,
+                        boundaryFaceSets[patchi],
+                        nPatchPrims.find(patchName)(),
+                        patchProcessors,
+                        ensightFile
+                    )
+                )
+                {
+                    ensightPatchi++;
+                }
+
+            }
+            else if (Pstream::master())
+            {
+                faceSets nullFaceSet;
+
+                if
+                (
+                    writePatchFieldBinary
+                    (
+                        Field<Type>(),
+                        -1,
+                        ensightPatchi,
+                        nullFaceSet,
+                        nPatchPrims.find(patchName)(),
+                        patchProcessors,
+                        ensightFile
+                    )
+                )
+                {
+                    ensightPatchi++;
+                }
+            }
+        }
+    }
+
+    if (Pstream::master())
+    {
+        ensightFile.close();
+    }
+}
+
+template<class Type>
+void ensightField
+(
+    const Foam::IOobject& fieldObject,
+    const Foam::ensightMesh& eMesh,
+    const Foam::fileName& postProcPath,
+    const Foam::word& prepend,
+    const Foam::label timeIndex,
+    const bool binary,
+    Foam::Ostream& ensightCaseFile
+)
+{
+    if (binary)
+    {
+        ensightFieldBinary<Type>
+        (
+            fieldObject,
+            eMesh,
+            postProcPath,
+            prepend,
+            timeIndex,
+            ensightCaseFile
+        );
+    }
+    else
+    {
+        ensightFieldAscii<Type>
+        (
+            fieldObject,
+            eMesh,
+            postProcPath,
+            prepend,
+            timeIndex,
+            ensightCaseFile
+        );
+    }
+}
+
+
+// ************************************************************************* //
diff --git a/applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightField.H b/applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightField.H
new file mode 100644
index 0000000000..2b860365dd
--- /dev/null
+++ b/applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightField.H
@@ -0,0 +1,80 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2007 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
+
+InApplication
+    foamToEnsight
+
+Description
+
+SourceFiles
+    ensightField.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef ensightField_H
+#define ensightField_H
+
+#include "ensightMesh.H"
+#include "HashSet.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+template<class Type>
+void ensightField
+(
+    const Foam::IOobject& fieldObject,
+    const Foam::ensightMesh& eMesh,
+    const Foam::fileName& postProcPath,
+    const Foam::word& prepend,
+    const Foam::label timeIndex,
+    const bool binary,
+    Foam::Ostream& ensightCaseFile
+);
+
+
+template<class Type>
+void writePatchField
+(
+    const Foam::word& fieldName,
+    const Foam::Field<Type>& pf,
+    const Foam::word& patchName,
+    const Foam::ensightMesh& eMesh,
+    const Foam::fileName& postProcPath,
+    const Foam::word& prepend,
+    const Foam::label timeIndex,
+    Foam::Ostream& ensightCaseFile
+);
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+#   include "ensightField.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightMesh.C b/applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightMesh.C
new file mode 100644
index 0000000000..6aad34abea
--- /dev/null
+++ b/applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightMesh.C
@@ -0,0 +1,1533 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2007 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 "argList.H"
+#include "Time.H"
+#include "ensightMesh.H"
+#include "fvMesh.H"
+#include "PstreamCombineReduceOps.H"
+#include "processorPolyPatch.H"
+#include "cellModeller.H"
+#include "IOmanip.H"
+#include "itoa.H"
+#include "ensightWriteBinary.H"
+#include <fstream>
+
+// * * * * * * * * * * * * * Private Functions * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+class concatPatchNames
+{
+
+public:
+
+    void operator()
+    (
+        HashTable<labelList>& x,
+        const HashTable<labelList>& y
+    ) const
+    {
+        for
+        (
+            HashTable<labelList>::const_iterator iter = y.begin();
+            iter != y.end();
+            ++iter
+        )
+        {
+            HashTable<labelList>::iterator xiter = x.find(iter.key());
+
+            if (xiter == x.end())
+            {
+                x.insert(iter.key(), iter());
+            }
+            else
+            {
+                labelList& xPatches = xiter();
+                const labelList& yPatches = iter();
+
+                label offset = xPatches.size();
+                xPatches.setSize(offset + yPatches.size());
+
+                forAll(yPatches, i)
+                {
+                    xPatches[i + offset] = yPatches[i];
+                }
+            }
+        }
+    }
+};
+
+} // End namespace Foam
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::ensightMesh::ensightMesh
+(
+    const fvMesh& fMesh,
+    const argList& args,
+    const bool binary
+)
+:
+    binary_(binary),
+    mesh(fMesh),
+    meshCellSets(mesh.nCells()),
+    boundaryFaceSets(mesh.boundary().size())
+{
+    forAll (mesh.boundaryMesh(), patchi)
+    {
+        if (typeid(mesh.boundaryMesh()[patchi]) != typeid(processorPolyPatch))
+        {
+            if (!allPatchNames.found(mesh.boundaryMesh()[patchi].name()))
+            {
+                allPatchNames.insert
+                (
+                    mesh.boundaryMesh()[patchi].name(),
+                    labelList(1, Pstream::myProcNo())
+                );
+
+                patchIndices.insert
+                (
+                    mesh.boundaryMesh()[patchi].name(),
+                    patchi
+                );
+            }
+        }
+    }
+
+    combineReduce(allPatchNames, concatPatchNames());
+
+    if (args.options().found("patches"))
+    {
+        wordList patchNameList(IStringStream(args.options()["patches"])());
+
+        if (!patchNameList.size())
+        {
+            patchNameList = allPatchNames.toc();
+        }
+
+        forAll (patchNameList, i)
+        {
+            patchNames.insert(patchNameList[i]);
+        }
+    }
+
+    const cellShapeList& cellShapes = mesh.cellShapes();
+
+    const cellModel& tet = *(cellModeller::lookup("tet"));
+    const cellModel& pyr = *(cellModeller::lookup("pyr"));
+    const cellModel& prism = *(cellModeller::lookup("prism"));
+    const cellModel& wedge = *(cellModeller::lookup("wedge"));
+    const cellModel& hex = *(cellModeller::lookup("hex"));
+
+    labelList& tets = meshCellSets.tets;
+    labelList& pyrs = meshCellSets.pyrs;
+    labelList& prisms = meshCellSets.prisms;
+    labelList& wedges = meshCellSets.wedges;
+    labelList& hexes = meshCellSets.hexes;
+    labelList& polys = meshCellSets.polys;
+
+    // Count the shapes
+    label nTets = 0;
+    label nPyrs = 0;
+    label nPrisms = 0;
+    label nWedges = 0;
+    label nHexes = 0;
+    label nPolys = 0;
+
+    if (!patchNames.size())
+    {
+        forAll(cellShapes, celli)
+        {
+            const cellShape& cellShape = cellShapes[celli];
+            const cellModel& cellModel = cellShape.model();
+
+            if (cellModel == tet)
+            {
+                tets[nTets++] = celli;
+            }
+            else if (cellModel == pyr)
+            {
+                pyrs[nPyrs++] = celli;
+            }
+            else if (cellModel == prism)
+            {
+                prisms[nPrisms++] = celli;
+            }
+            else if (cellModel == wedge)
+            {
+                wedges[nWedges++] = celli;
+            }
+            else if (cellModel == hex)
+            {
+                hexes[nHexes++] = celli;
+            }
+            else
+            {
+                polys[nPolys++] = celli;
+            }
+        }
+
+        tets.setSize(nTets);
+        pyrs.setSize(nPyrs);
+        prisms.setSize(nPrisms);
+        wedges.setSize(nWedges);
+        hexes.setSize(nHexes);
+        polys.setSize(nPolys);
+
+        meshCellSets.nTets = nTets;
+        reduce(meshCellSets.nTets, sumOp<label>());
+
+        meshCellSets.nPyrs = nPyrs;
+        reduce(meshCellSets.nPyrs, sumOp<label>());
+
+        meshCellSets.nPrisms = nPrisms;
+        reduce(meshCellSets.nPrisms, sumOp<label>());
+
+        meshCellSets.nHexesWedges = nHexes + nWedges;
+        reduce(meshCellSets.nHexesWedges, sumOp<label>());
+
+        meshCellSets.nPolys = nPolys;
+        reduce(meshCellSets.nPolys, sumOp<label>());
+    }
+
+
+    forAll (mesh.boundary(), patchi)
+    {
+        if (mesh.boundary()[patchi].size())
+        {
+            const polyPatch& p = mesh.boundaryMesh()[patchi];
+
+            labelList& tris = boundaryFaceSets[patchi].tris;
+            labelList& quads = boundaryFaceSets[patchi].quads;
+            labelList& polys = boundaryFaceSets[patchi].polys;
+
+            tris.setSize(p.size());
+            quads.setSize(p.size());
+            polys.setSize(p.size());
+
+            label nTris = 0;
+            label nQuads = 0;
+            label nPolys = 0;
+
+            forAll(p, facei)
+            {
+                const face& f = p[facei];
+
+                if (f.size() == 3)
+                {
+                    tris[nTris++] = facei;
+                }
+                else if (f.size() == 4)
+                {
+                    quads[nQuads++] = facei;
+                }
+                else
+                {
+                    polys[nPolys++] = facei;
+                }
+            }
+
+            tris.setSize(nTris);
+            quads.setSize(nQuads);
+            polys.setSize(nPolys);
+        }
+    }
+
+    for
+    (
+        HashTable<labelList>::const_iterator iter = allPatchNames.begin();
+        iter != allPatchNames.end();
+        ++iter
+    )
+    {
+        const word& patchName = iter.key();
+        nFacePrims nfp;
+
+        if (!patchNames.size() || patchNames.found(patchName))
+        {
+            if (patchIndices.found(patchName))
+            {
+                label patchi = patchIndices.find(patchName)();
+
+                nfp.nPoints = mesh.boundaryMesh()[patchi].localPoints().size();
+                nfp.nTris = boundaryFaceSets[patchi].tris.size();
+                nfp.nQuads = boundaryFaceSets[patchi].quads.size();
+                nfp.nPolys = boundaryFaceSets[patchi].polys.size();
+            }
+        }
+
+        reduce(nfp.nPoints, sumOp<label>());
+        reduce(nfp.nTris, sumOp<label>());
+        reduce(nfp.nQuads, sumOp<label>());
+        reduce(nfp.nPolys, sumOp<label>());
+
+        nPatchPrims.insert(patchName, nfp);
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::ensightMesh::~ensightMesh()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+void Foam::ensightMesh::writePoints
+(
+    const scalarField& pointsComponent,
+    OFstream& ensightGeometryFile
+) const
+{
+    forAll(pointsComponent, pointi)
+    {
+        ensightGeometryFile << setw(12) << float(pointsComponent[pointi]) << nl;
+    }
+}
+
+
+Foam::cellShapeList Foam::ensightMesh::map
+(
+    const cellShapeList& cellShapes,
+    const labelList& prims
+) const
+{
+    cellShapeList mcsl(prims.size());
+
+    forAll(prims, i)
+    {
+        mcsl[i] = cellShapes[prims[i]];
+    }
+
+    return mcsl;
+}
+
+
+Foam::cellShapeList Foam::ensightMesh::map
+(
+    const cellShapeList& cellShapes,
+    const labelList& hexes,
+    const labelList& wedges
+) const
+{
+    cellShapeList mcsl(hexes.size() + wedges.size());
+
+    forAll(hexes, i)
+    {
+        mcsl[i] = cellShapes[hexes[i]];
+    }
+
+    label offset = hexes.size();
+
+    const cellModel& hex = *(cellModeller::lookup("hex"));
+    labelList hexLabels(8);
+
+    forAll(wedges, i)
+    {
+        const cellShape& cellPoints = cellShapes[wedges[i]];
+
+        hexLabels[0] = cellPoints[0];
+        hexLabels[1] = cellPoints[1];
+        hexLabels[2] = cellPoints[0];
+        hexLabels[3] = cellPoints[2];
+        hexLabels[4] = cellPoints[3];
+        hexLabels[5] = cellPoints[4];
+        hexLabels[6] = cellPoints[6];
+        hexLabels[7] = cellPoints[5];
+
+        mcsl[i + offset] = cellShape(hex, hexLabels);
+    }
+
+    return mcsl;
+}
+
+
+void Foam::ensightMesh::writePrims
+(
+    const cellShapeList& cellShapes,
+    const label pointOffset,
+    OFstream& ensightGeometryFile
+) const
+{
+    label po = pointOffset + 1;
+
+    forAll(cellShapes, i)
+    {
+        const cellShape& cellPoints = cellShapes[i];
+
+        forAll(cellPoints, pointi)
+        {
+            ensightGeometryFile<< setw(10) << cellPoints[pointi] + po;
+        }
+        ensightGeometryFile << nl;
+    }
+}
+
+
+void Foam::ensightMesh::writePrimsBinary
+(
+    const cellShapeList& cellShapes,
+    const label pointOffset,
+    std::ofstream& ensightGeometryFile
+) const
+{
+    label po = pointOffset + 1;
+
+    // Create a temp int array
+    int numElem;
+
+    numElem = cellShapes.size();
+
+    if (cellShapes.size() > 0)
+    {
+        // All the cellShapes have the same number of elements!
+        int numIntElem = cellShapes.size() * cellShapes[0].size();
+        List<int> temp(numIntElem);
+
+        int n = 0;
+
+        forAll(cellShapes, i)
+        {
+            const cellShape& cellPoints = cellShapes[i];
+
+            forAll(cellPoints, pointi)
+            {
+                temp[n] = cellPoints[pointi] + po;
+                n++;
+            }
+        }
+
+        ensightGeometryFile.write
+        (
+            reinterpret_cast<char*>(temp.begin()),
+            numIntElem*sizeof(int)
+        );
+    }
+}
+
+
+void Foam::ensightMesh::writePolys
+(
+    const labelList& polys,
+    const cellList& cellFaces,
+    const faceList& faces,
+    const label pointOffset,
+    OFstream& ensightGeometryFile
+) const
+{
+    if (polys.size())
+    {
+        ensightGeometryFile
+            << "nfaced" << nl << setw(10) << polys.size() << nl;
+
+        label po = pointOffset + 1;
+
+        forAll(polys, i)
+        {
+            ensightGeometryFile
+                << setw(10) << cellFaces[polys[i]].size() << nl;
+        }
+
+        forAll(polys, i)
+        {
+            const labelList& cf = cellFaces[polys[i]];
+
+            forAll(cf, facei)
+            {
+                ensightGeometryFile
+                    << setw(10) << faces[cf[facei]].size() << nl;
+            }
+        }
+
+        forAll(polys, i)
+        {
+            const labelList& cf = cellFaces[polys[i]];
+
+            forAll(cf, facei)
+            {
+                const face& f = faces[cf[facei]];
+
+                forAll(f, pointi)
+                {
+                    ensightGeometryFile << setw(10) << f[pointi] + po;
+                }
+                ensightGeometryFile << nl;
+            }
+        }
+    }
+}
+
+
+void Foam::ensightMesh::writePolysBinary
+(
+    const labelList& polys,
+    const cellList& cellFaces,
+    const faceList& faces,
+    const label pointOffset,
+    std::ofstream& ensightGeometryFile
+) const
+{
+    if (polys.size())
+    {
+        writeEnsDataBinary("nfaced",ensightGeometryFile);
+        writeEnsDataBinary(polys.size(),ensightGeometryFile);
+
+        label po = pointOffset + 1;
+
+        //TODO No buffer at the moment. To be done for speed purposes!
+        forAll(polys, i)
+        {
+            writeEnsDataBinary
+            (
+                cellFaces[polys[i]].size(),
+                ensightGeometryFile
+            );
+        }
+
+        forAll(polys, i)
+        {
+            const labelList& cf = cellFaces[polys[i]];
+
+            forAll(cf, facei)
+            {
+                writeEnsDataBinary
+                (
+                    faces[cf[facei]].size(),
+                    ensightGeometryFile
+                );
+            }
+        }
+
+        forAll(polys, i)
+        {
+            const labelList& cf = cellFaces[polys[i]];
+
+            forAll(cf, facei)
+            {
+                const face& f = faces[cf[facei]];
+
+                forAll(f, pointi)
+                {
+                    writeEnsDataBinary(f[pointi] + po,ensightGeometryFile);
+                }
+            }
+        }
+    }
+}
+
+
+void Foam::ensightMesh::writeAllPrims
+(
+    const char* key,
+    const label nPrims,
+    const cellShapeList& cellShapes,
+    const labelList& pointOffsets,
+    OFstream& ensightGeometryFile
+) const
+{
+    if (nPrims)
+    {
+        if (Pstream::master())
+        {
+            ensightGeometryFile << key << nl << setw(10) << nPrims << nl;
+
+            writePrims(cellShapes, 0, ensightGeometryFile);
+
+            for (int slave=1; slave<Pstream::nProcs(); slave++)
+            {
+                IPstream fromSlave(Pstream::scheduled, slave);
+                cellShapeList cellShapes(fromSlave);
+
+                writePrims
+                (
+                    cellShapes,
+                    pointOffsets[slave-1],
+                    ensightGeometryFile
+                );
+            }
+        }
+        else
+        {
+            OPstream toMaster(Pstream::scheduled, Pstream::masterNo());
+            toMaster<< cellShapes;
+        }
+    }
+}
+
+
+void Foam::ensightMesh::writeAllPrimsBinary
+(
+    const char* key,
+    const label nPrims,
+    const cellShapeList& cellShapes,
+    const labelList& pointOffsets,
+    std::ofstream& ensightGeometryFile
+) const
+{
+    if (nPrims)
+    {
+        if (Pstream::master())
+        {
+            writeEnsDataBinary(key,ensightGeometryFile);
+            writeEnsDataBinary(nPrims,ensightGeometryFile);
+
+            writePrimsBinary(cellShapes, 0, ensightGeometryFile);
+
+            for (int slave=1; slave<Pstream::nProcs(); slave++)
+            {
+                IPstream fromSlave(Pstream::scheduled, slave);
+                cellShapeList cellShapes(fromSlave);
+
+                writePrimsBinary
+                (
+                    cellShapes,
+                    pointOffsets[slave-1],
+                    ensightGeometryFile
+                );
+            }
+        }
+        else
+        {
+            OPstream toMaster(Pstream::scheduled, Pstream::masterNo());
+            toMaster<< cellShapes;
+        }
+    }
+}
+
+
+void Foam::ensightMesh::writeFacePrims
+(
+    const char* key,
+    const faceList& patchFaces,
+    const label pointOffset,
+    OFstream& ensightGeometryFile
+) const
+{
+    if (patchFaces.size())
+    {
+        if (word(key) == "nsided")
+        {
+            ensightGeometryFile
+                << key << nl << setw(10) << patchFaces.size() << nl;
+
+            forAll(patchFaces, i)
+            {
+                ensightGeometryFile
+                    << setw(10) << patchFaces[i].size() << nl;
+            }
+        }
+
+        label po = pointOffset + 1;
+
+        forAll(patchFaces, i)
+        {
+            const face& patchFace = patchFaces[i];
+
+            forAll(patchFace, pointi)
+            {
+                ensightGeometryFile << setw(10) << patchFace[pointi] + po;
+            }
+            ensightGeometryFile << nl;
+        }
+    }
+}
+
+
+void Foam::ensightMesh::writeFacePrimsBinary
+(
+    const char* key,
+    const faceList& patchFaces,
+    const label pointOffset,
+    std::ofstream& ensightGeometryFile
+) const
+{
+    if (patchFaces.size())
+    {
+        //TODO No buffer at the moment. To be done for speed purposes!
+        if (word(key) == "nsided")
+        {
+            writeEnsDataBinary(key,ensightGeometryFile);
+            writeEnsDataBinary(patchFaces.size(),ensightGeometryFile);
+
+            forAll(patchFaces, i)
+            {
+                writeEnsDataBinary
+                (
+                    patchFaces[i].size(),
+                    ensightGeometryFile
+                );
+            }
+        }
+
+        label po = pointOffset + 1;
+
+        forAll(patchFaces, i)
+        {
+            const face& patchFace = patchFaces[i];
+
+            forAll(patchFace, pointi)
+            {
+                writeEnsDataBinary
+                (
+                    patchFace[pointi] + po,
+                    ensightGeometryFile
+                );
+            }
+        }
+    }
+}
+
+
+Foam::faceList Foam::ensightMesh::map
+(
+    const faceList& patchFaces,
+    const labelList& prims
+) const
+{
+    faceList ppf(prims.size());
+
+    forAll (prims, i)
+    {
+        ppf[i] = patchFaces[prims[i]];
+    }
+
+    return ppf;
+}
+
+
+void Foam::ensightMesh::writeAllFacePrims
+(
+    const char* key,
+    const labelList& prims,
+    const label nPrims,
+    const faceList& patchFaces,
+    const labelList& pointOffsets,
+    const labelList& patchProcessors,
+    OFstream& ensightGeometryFile
+) const
+{
+    if (nPrims)
+    {
+        if (Pstream::master())
+        {
+            if (word(key) != "nsided")
+            {
+                ensightGeometryFile << key << nl << setw(10) << nPrims << nl;
+            }
+
+            if (&prims != NULL)
+            {
+                writeFacePrims
+                (
+                    key,
+                    map(patchFaces, prims),
+                    0,
+                    ensightGeometryFile
+                );
+            }
+
+            forAll (patchProcessors, i)
+            {
+                if (patchProcessors[i] != 0)
+                {
+                    label slave = patchProcessors[i];
+                    IPstream fromSlave(Pstream::scheduled, slave);
+                    faceList patchFaces(fromSlave);
+
+                    writeFacePrims
+                    (
+                        key,
+                        patchFaces,
+                        pointOffsets[i],
+                        ensightGeometryFile
+                    );
+                }
+            }
+        }
+        else if (&prims != NULL)
+        {
+            OPstream toMaster(Pstream::scheduled, Pstream::masterNo());
+            toMaster<< map(patchFaces, prims);
+        }
+    }
+}
+
+
+void Foam::ensightMesh::writeAllFacePrimsBinary
+(
+    const char* key,
+    const labelList& prims,
+    const label nPrims,
+    const faceList& patchFaces,
+    const labelList& pointOffsets,
+    const labelList& patchProcessors,
+    std::ofstream& ensightGeometryFile
+) const
+{
+    if (nPrims)
+    {
+        if (Pstream::master())
+        {
+            if (word(key) != "nsided")
+            {
+                writeEnsDataBinary(key,ensightGeometryFile);
+                writeEnsDataBinary(nPrims,ensightGeometryFile);
+            }
+
+            if (&prims != NULL)
+            {
+                writeFacePrimsBinary
+                (
+                    key,
+                    map(patchFaces, prims),
+                    0,
+                    ensightGeometryFile
+                );
+            }
+
+            forAll (patchProcessors, i)
+            {
+                if (patchProcessors[i] != 0)
+                {
+                    label slave = patchProcessors[i];
+                    IPstream fromSlave(Pstream::scheduled, slave);
+                    faceList patchFaces(fromSlave);
+
+                    writeFacePrimsBinary
+                    (
+                        key,
+                        patchFaces,
+                        pointOffsets[i],
+                        ensightGeometryFile
+                    );
+                }
+            }
+        }
+        else if (&prims != NULL)
+        {
+            OPstream toMaster(Pstream::scheduled, Pstream::masterNo());
+            toMaster<< map(patchFaces, prims);
+        }
+    }
+}
+
+
+void Foam::ensightMesh::write
+(
+    const fileName& postProcPath,
+    const word& prepend,
+    const label timeIndex,
+    Ostream& ensightCaseFile
+) const
+{
+    if (binary_)
+    {
+        writeBinary(postProcPath, prepend, timeIndex, ensightCaseFile);
+    }
+    else
+    {
+        writeAscii(postProcPath, prepend, timeIndex, ensightCaseFile);
+    }
+}
+
+
+void Foam::ensightMesh::writeAscii
+(
+    const fileName& postProcPath,
+    const word& prepend,
+    const label timeIndex,
+    Ostream& ensightCaseFile
+) const
+{
+    const Time& runTime = mesh.time();
+    const pointField& points = mesh.points();
+    const cellList& cellFaces = mesh.cells();
+    const faceList& faces = mesh.faces();
+    const cellShapeList& cellShapes = mesh.cellShapes();
+
+    word timeFile = prepend;
+
+    if (timeIndex == 0)
+    {
+        timeFile += "000.";
+    }
+    else if (mesh.moving())
+    {
+        timeFile += itoa(timeIndex) + '.';
+    }
+
+    // set the filename of the ensight file
+    fileName ensightGeometryFileName = timeFile + "mesh";
+
+    OFstream *ensightGeometryFilePtr = NULL;
+    if (Pstream::master())
+    {
+        ensightGeometryFilePtr = new OFstream
+        (
+            postProcPath/ensightGeometryFileName,
+            runTime.writeFormat(),
+            runTime.writeVersion(),
+            runTime.writeCompression()
+        );
+    }
+
+    OFstream& ensightGeometryFile = *ensightGeometryFilePtr;
+
+    if (Pstream::master())
+    {
+        // Set Format
+        ensightGeometryFile.setf
+        (
+            ios_base::scientific,
+            ios_base::floatfield
+        );
+        ensightGeometryFile.precision(5);
+
+        ensightGeometryFile
+            << "OpenFOAM Geometry File " << nl
+            << "OpenFOAM version " << Foam::FOAMversion << nl
+            << "node id assign" << nl
+            << "element id assign" << nl;
+    }
+
+    labelList pointOffsets(Pstream::nProcs(), 0);
+
+    if (!patchNames.size())
+    {
+        label nPoints = points.size();
+        Pstream::gather(nPoints, sumOp<label>());
+
+        if (Pstream::master())
+        {
+            ensightGeometryFile
+                << "part" << nl
+                << setw(10) << 1 << nl
+                << "FOAM cells" << nl
+                << "coordinates" << nl
+                << setw(10) << nPoints
+                << endl;
+
+            for (direction d=0; d<vector::nComponents; d++)
+            {
+                writePoints(points.component(d), ensightGeometryFile);
+                pointOffsets[0] = points.size();
+
+                for (int slave=1; slave<Pstream::nProcs(); slave++)
+                {
+                    IPstream fromSlave(Pstream::scheduled, slave);
+                    scalarField pointsComponent(fromSlave);
+                    writePoints(pointsComponent, ensightGeometryFile);
+                    pointOffsets[slave] =
+                        pointOffsets[slave-1]
+                      + pointsComponent.size();
+                }
+            }
+        }
+        else
+        {
+            for (direction d=0; d<vector::nComponents; d++)
+            {
+                OPstream toMaster(Pstream::scheduled, Pstream::masterNo());
+                toMaster<< points.component(d);
+            }
+        }
+
+        writeAllPrims
+        (
+            "hexa8",
+            meshCellSets.nHexesWedges,
+            map(cellShapes, meshCellSets.hexes, meshCellSets.wedges),
+            pointOffsets,
+            ensightGeometryFile
+        );
+
+        writeAllPrims
+        (
+            "penta6",
+            meshCellSets.nPrisms,
+            map(cellShapes, meshCellSets.prisms),
+            pointOffsets,
+            ensightGeometryFile
+        );
+
+        writeAllPrims
+        (
+            "pyramid5",
+            meshCellSets.nPyrs,
+            map(cellShapes, meshCellSets.pyrs),
+            pointOffsets,
+            ensightGeometryFile
+        );
+
+        writeAllPrims
+        (
+            "tetra4",
+            meshCellSets.nTets,
+            map(cellShapes, meshCellSets.tets),
+            pointOffsets,
+            ensightGeometryFile
+        );
+
+
+        if (meshCellSets.nPolys)
+        {
+            if (Pstream::master())
+            {
+                /*
+                ensightGeometryFile
+                    << "nfaced" << nl
+                    << setw(10) << meshCellSets.nPolys << nl;
+                */
+                writePolys
+                (
+                    meshCellSets.polys,
+                    cellFaces,
+                    faces,
+                    0,
+                    ensightGeometryFile
+                );
+
+                for (int slave=1; slave<Pstream::nProcs(); slave++)
+                {
+                    IPstream fromSlave(Pstream::scheduled, slave);
+                    labelList polys(fromSlave);
+                    cellList cellFaces(fromSlave);
+                    faceList faces(fromSlave);
+
+                    writePolys
+                    (
+                        polys,
+                        cellFaces,
+                        faces,
+                        pointOffsets[slave-1],
+                        ensightGeometryFile
+                    );
+                }
+            }
+            else
+            {
+                OPstream toMaster(Pstream::scheduled, Pstream::masterNo());
+                toMaster<< meshCellSets.polys << cellFaces << faces;
+            }
+        }
+    }
+
+
+    label ensightPatchi = 2;
+
+    for
+    (
+        HashTable<labelList>::const_iterator iter = allPatchNames.begin();
+        iter != allPatchNames.end();
+        ++iter
+    )
+    {
+        const labelList& patchProcessors = iter();
+
+        if (!patchNames.size() || patchNames.found(iter.key()))
+        {
+            const word& patchName = iter.key();
+            const nFacePrims& nfp = nPatchPrims.find(patchName)();
+
+            const labelList *trisPtr = NULL;
+            const labelList *quadsPtr = NULL;
+            const labelList *polysPtr = NULL;
+
+            const pointField *patchPointsPtr = NULL;
+            const faceList *patchFacesPtr = NULL;
+
+            if (patchIndices.found(iter.key()))
+            {
+                label patchi = patchIndices.find(iter.key())();
+                const polyPatch& p = mesh.boundaryMesh()[patchi];
+
+                trisPtr = &boundaryFaceSets[patchi].tris;
+                quadsPtr = &boundaryFaceSets[patchi].quads;
+                polysPtr = &boundaryFaceSets[patchi].polys;
+
+                patchPointsPtr = &(p.localPoints());
+                patchFacesPtr = &(p.localFaces());
+            }
+
+            const labelList& tris = *trisPtr;
+            const labelList& quads = *quadsPtr;
+            const labelList& polys = *polysPtr;
+            const pointField& patchPoints = *patchPointsPtr;
+            const faceList& patchFaces = *patchFacesPtr;
+
+            if (nfp.nTris || nfp.nQuads || nfp.nPolys)
+            {
+                labelList patchPointOffsets(Pstream::nProcs(), 0);
+
+                if (Pstream::master())
+                {
+                    ensightGeometryFile
+                        << "part" << nl
+                        << setw(10) << ensightPatchi++ << nl
+                        << patchName << nl
+                        << "coordinates" << nl
+                        << setw(10) << nfp.nPoints
+                        << endl;
+
+                    for (direction d=0; d<vector::nComponents; d++)
+                    {
+                        if (patchPointsPtr)
+                        {
+                            writePoints
+                            (
+                                patchPoints.component(d),
+                                ensightGeometryFile
+                            );
+                        }
+
+                        patchPointOffsets = 0;
+
+                        forAll (patchProcessors, i)
+                        {
+                            if (patchProcessors[i] != 0)
+                            {
+                                label slave = patchProcessors[i];
+                                IPstream fromSlave(Pstream::scheduled, slave);
+                                scalarField patchPointsComponent(fromSlave);
+
+                                writePoints
+                                (
+                                    patchPointsComponent,
+                                    ensightGeometryFile
+                                );
+
+                                if (i < Pstream::nProcs()-1)
+                                {
+                                    patchPointOffsets[i+1] =
+                                        patchPointOffsets[i]
+                                      + patchPointsComponent.size();
+                                }
+                            }
+                            else
+                            {
+                                if (i < Pstream::nProcs()-1)
+                                {
+                                    patchPointOffsets[i+1] =
+                                        patchPointOffsets[i]
+                                      + patchPoints.size();
+                                }
+                            }
+                        }
+                    }
+                }
+                else if (patchPointsPtr)
+                {
+                    for (direction d=0; d<vector::nComponents; d++)
+                    {
+                        OPstream toMaster
+                        (
+                            Pstream::scheduled,
+                            Pstream::masterNo()
+                        );
+                        toMaster<< patchPoints.component(d);
+                    }
+                }
+
+                writeAllFacePrims
+                (
+                    "tria3",
+                    tris,
+                    nfp.nTris,
+                    patchFaces,
+                    patchPointOffsets,
+                    patchProcessors,
+                    ensightGeometryFile
+                );
+
+                writeAllFacePrims
+                (
+                    "quad4",
+                    quads,
+                    nfp.nQuads,
+                    patchFaces,
+                    patchPointOffsets,
+                    patchProcessors,
+                    ensightGeometryFile
+                );
+
+                writeAllFacePrims
+                (
+                    "nsided",
+                    polys,
+                    nfp.nPolys,
+                    patchFaces,
+                    patchPointOffsets,
+                    patchProcessors,
+                    ensightGeometryFile
+                );
+            }
+        }
+    }
+
+    if (Pstream::master())
+    {
+        delete ensightGeometryFilePtr;
+    }
+}
+
+
+void Foam::ensightMesh::writeBinary
+(
+    const fileName& postProcPath,
+    const word& prepend,
+    const label timeIndex,
+    Ostream& ensightCaseFile
+) const
+{
+    //const Time& runTime = mesh.time();
+    const pointField& points = mesh.points();
+    const cellList& cellFaces = mesh.cells();
+    const faceList& faces = mesh.faces();
+    const cellShapeList& cellShapes = mesh.cellShapes();
+
+    word timeFile = prepend;
+
+    if (timeIndex == 0)
+    {
+        timeFile += "000.";
+    }
+    else if (mesh.moving())
+    {
+        timeFile += itoa(timeIndex) + '.';
+    }
+
+    // set the filename of the ensight file
+    fileName ensightGeometryFileName = timeFile + "mesh";
+
+    std::ofstream *ensightGeometryFilePtr = NULL;
+
+    if (Pstream::master())
+    {
+        ensightGeometryFilePtr = new std::ofstream((postProcPath/ensightGeometryFileName).c_str(), ios_base::out | ios_base::binary | ios_base::trunc);
+        // Check on file opened?
+    }
+
+    std::ofstream& ensightGeometryFile = *ensightGeometryFilePtr;
+
+    if (Pstream::master())
+    {
+        writeEnsDataBinary("C binary",ensightGeometryFile);
+        writeEnsDataBinary("OpenFOAM Geometry File",ensightGeometryFile);
+        writeEnsDataBinary("Binary format",ensightGeometryFile);
+        writeEnsDataBinary("node id assign",ensightGeometryFile);
+        writeEnsDataBinary("element id assign",ensightGeometryFile);
+    }
+
+    labelList pointOffsets(Pstream::nProcs(), 0);
+
+    if (!patchNames.size())
+    {
+        label nPoints = points.size();
+        Pstream::gather(nPoints, sumOp<label>());
+
+        if (Pstream::master())
+        {
+            writeEnsDataBinary("part",ensightGeometryFile);
+            writeEnsDataBinary(1,ensightGeometryFile);
+            writeEnsDataBinary("FOAM cells",ensightGeometryFile);
+            writeEnsDataBinary("coordinates",ensightGeometryFile);
+            writeEnsDataBinary(nPoints,ensightGeometryFile);
+
+            for (direction d=0; d<vector::nComponents; d++)
+            {
+                //writePointsBinary(points.component(d), ensightGeometryFile);
+                writeEnsDataBinary(points.component(d), ensightGeometryFile);
+                pointOffsets[0] = points.size();
+
+                for (int slave=1; slave<Pstream::nProcs(); slave++)
+                {
+                    IPstream fromSlave(Pstream::scheduled, slave);
+                    scalarField pointsComponent(fromSlave);
+                    //writePointsBinary(pointsComponent, ensightGeometryFile);
+                    writeEnsDataBinary(pointsComponent, ensightGeometryFile);
+                    pointOffsets[slave] =
+                        pointOffsets[slave-1]
+                      + pointsComponent.size();
+                }
+            }
+        }
+        else
+        {
+            for (direction d=0; d<vector::nComponents; d++)
+            {
+                OPstream toMaster(Pstream::scheduled, Pstream::masterNo());
+                toMaster<< points.component(d);
+            }
+        }
+
+        writeAllPrimsBinary
+        (
+            "hexa8",
+            meshCellSets.nHexesWedges,
+            map(cellShapes, meshCellSets.hexes, meshCellSets.wedges),
+            pointOffsets,
+            ensightGeometryFile
+        );
+
+        writeAllPrimsBinary
+        (
+            "penta6",
+            meshCellSets.nPrisms,
+            map(cellShapes, meshCellSets.prisms),
+            pointOffsets,
+            ensightGeometryFile
+        );
+
+        writeAllPrimsBinary
+        (
+            "pyramid5",
+            meshCellSets.nPyrs,
+            map(cellShapes, meshCellSets.pyrs),
+            pointOffsets,
+            ensightGeometryFile
+        );
+
+        writeAllPrimsBinary
+        (
+            "tetra4",
+            meshCellSets.nTets,
+            map(cellShapes, meshCellSets.tets),
+            pointOffsets,
+            ensightGeometryFile
+        );
+
+        if (meshCellSets.nPolys)
+        {
+            if (Pstream::master())
+            {
+                /*
+                ensightGeometryFile
+                    << "nfaced" << nl
+                    << setw(10) << meshCellSets.nPolys << nl;
+                */
+                writePolysBinary
+                (
+                    meshCellSets.polys,
+                    cellFaces,
+                    faces,
+                    0,
+                    ensightGeometryFile
+                );
+
+                for (int slave=1; slave<Pstream::nProcs(); slave++)
+                {
+                    IPstream fromSlave(Pstream::scheduled, slave);
+                    labelList polys(fromSlave);
+                    cellList cellFaces(fromSlave);
+                    faceList faces(fromSlave);
+
+                    writePolysBinary
+                    (
+                        polys,
+                        cellFaces,
+                        faces,
+                        pointOffsets[slave-1],
+                        ensightGeometryFile
+                    );
+                }
+            }
+            else
+            {
+                OPstream toMaster(Pstream::scheduled, Pstream::masterNo());
+                toMaster<< meshCellSets.polys << cellFaces << faces;
+            }
+        }
+
+    }
+
+    label ensightPatchi = 2;
+
+    label iCount = 0;
+
+    for
+    (
+        HashTable<labelList>::const_iterator iter = allPatchNames.begin();
+        iter != allPatchNames.end();
+        ++iter
+    )
+    {
+        iCount ++;
+        const labelList& patchProcessors = iter();
+
+        if (!patchNames.size() || patchNames.found(iter.key()))
+        {
+            const word& patchName = iter.key();
+            const nFacePrims& nfp = nPatchPrims.find(patchName)();
+
+            const labelList *trisPtr = NULL;
+            const labelList *quadsPtr = NULL;
+            const labelList *polysPtr = NULL;
+
+            const pointField *patchPointsPtr = NULL;
+            const faceList *patchFacesPtr = NULL;
+
+            if (patchIndices.found(iter.key()))
+            {
+                label patchi = patchIndices.find(iter.key())();
+                const polyPatch& p = mesh.boundaryMesh()[patchi];
+
+                trisPtr = &boundaryFaceSets[patchi].tris;
+                quadsPtr = &boundaryFaceSets[patchi].quads;
+                polysPtr = &boundaryFaceSets[patchi].polys;
+
+                patchPointsPtr = &(p.localPoints());
+                patchFacesPtr = &(p.localFaces());
+            }
+
+            const labelList& tris = *trisPtr;
+            const labelList& quads = *quadsPtr;
+            const labelList& polys = *polysPtr;
+            const pointField& patchPoints = *patchPointsPtr;
+            const faceList& patchFaces = *patchFacesPtr;
+
+            if (nfp.nTris || nfp.nQuads || nfp.nPolys)
+            {
+                labelList patchPointOffsets(Pstream::nProcs(), 0);
+
+                if (Pstream::master())
+                {
+                    writeEnsDataBinary("part",ensightGeometryFile);
+                    writeEnsDataBinary(ensightPatchi++,ensightGeometryFile);
+                    //writeEnsDataBinary(patchName.c_str(),ensightGeometryFile);
+                    writeEnsDataBinary(iter.key().c_str(),ensightGeometryFile);
+                    writeEnsDataBinary("coordinates",ensightGeometryFile);
+                    writeEnsDataBinary(nfp.nPoints,ensightGeometryFile);
+
+                    for (direction d=0; d<vector::nComponents; d++)
+                    {
+                        if (patchPointsPtr)
+                        {
+                            //writePointsBinary
+                            writeEnsDataBinary
+                            (
+                                patchPoints.component(d),
+                                ensightGeometryFile
+                            );
+                        }
+
+                        patchPointOffsets = 0;
+
+
+                        forAll (patchProcessors, i)
+                        {
+                            if (patchProcessors[i] != 0)
+                            {
+                                label slave = patchProcessors[i];
+                                IPstream fromSlave(Pstream::scheduled, slave);
+                                scalarField patchPointsComponent(fromSlave);
+
+                                //writePointsBinary
+                                writeEnsDataBinary
+                                (
+                                    patchPointsComponent,
+                                    ensightGeometryFile
+                                );
+
+                                if (i < Pstream::nProcs()-1)
+                                {
+                                    patchPointOffsets[i+1] =
+                                        patchPointOffsets[i]
+                                      + patchPointsComponent.size();
+                                }
+                            }
+                            else
+                            {
+                                if (i < Pstream::nProcs()-1)
+                                {
+                                    patchPointOffsets[i+1] =
+                                        patchPointOffsets[i]
+                                      + patchPoints.size();
+                                }
+                            }
+                        }
+                    }
+                }
+                else if (patchPointsPtr)
+                {
+                    for (direction d=0; d<vector::nComponents; d++)
+                    {
+                        OPstream toMaster
+                        (
+                            Pstream::scheduled,
+                            Pstream::masterNo()
+                        );
+                        toMaster<< patchPoints.component(d);
+                    }
+                }
+
+                writeAllFacePrimsBinary
+                (
+                    "tria3",
+                    tris,
+                    nfp.nTris,
+                    patchFaces,
+                    patchPointOffsets,
+                    patchProcessors,
+                    ensightGeometryFile
+                );
+
+                writeAllFacePrimsBinary
+                (
+                    "quad4",
+                    quads,
+                    nfp.nQuads,
+                    patchFaces,
+                    patchPointOffsets,
+                    patchProcessors,
+                    ensightGeometryFile
+                );
+
+                writeAllFacePrimsBinary
+                (
+                    "nsided",
+                    polys,
+                    nfp.nPolys,
+                    patchFaces,
+                    patchPointOffsets,
+                    patchProcessors,
+                    ensightGeometryFile
+                );
+            }
+        }
+    }
+
+
+    if (Pstream::master())
+    {
+        delete ensightGeometryFilePtr;
+    }
+}
+
+// ************************************************************************* //
diff --git a/applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightMesh.H b/applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightMesh.H
new file mode 100644
index 0000000000..59c95bf4a7
--- /dev/null
+++ b/applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightMesh.H
@@ -0,0 +1,268 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2007 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::ensightMesh
+
+Description
+
+SourceFiles
+    ensightMesh.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef ensightMesh_H
+#define ensightMesh_H
+
+#include "cellSets.H"
+#include "faceSets.H"
+#include "HashTable.H"
+#include "HashSet.H"
+#include "fvMesh.H"
+#include "OFstream.H"
+#include <fstream>
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+class fvMesh;
+class argList;
+
+/*---------------------------------------------------------------------------*\
+                           Class ensightMesh Declaration
+\*---------------------------------------------------------------------------*/
+
+class ensightMesh
+{
+    // Private data
+
+        //- Set binary file output
+        bool binary_;
+
+
+    // Private Member Functions
+
+        //- Disallow default bitwise copy construct
+        ensightMesh(const ensightMesh&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const ensightMesh&);
+
+        void writePoints
+        (
+            const scalarField& pointsComponent,
+            OFstream& ensightGeometryFile
+        ) const;
+
+        cellShapeList map
+        (
+            const cellShapeList& cellShapes,
+            const labelList& prims
+        ) const;
+
+        cellShapeList map
+        (
+            const cellShapeList& cellShapes,
+            const labelList& hexes,
+            const labelList& wedges
+        ) const;
+
+        void writePrims
+        (
+            const cellShapeList& cellShapes,
+            const label pointOffset,
+            OFstream& ensightGeometryFile
+        ) const;
+
+        void writePolys
+        (
+            const labelList& polys,
+            const cellList& cellFaces,
+            const faceList& faces,
+            const label pointOffset,
+            OFstream& ensightGeometryFile
+        ) const;
+
+        void writeAllPrims
+        (
+            const char* key,
+            const label nPrims,
+            const cellShapeList& cellShapes,
+            const labelList& pointOffsets,
+            OFstream& ensightGeometryFile
+        ) const;
+
+        void writeFacePrims
+        (
+            const char* key,
+            const faceList& patchFaces,
+            const label pointOffset,
+            OFstream& ensightGeometryFile
+        ) const;
+
+        faceList map
+        (
+            const faceList& patchFaces,
+            const labelList& prims
+        ) const;
+
+        void writeAllFacePrims
+        (
+            const char* key,
+            const labelList& prims,
+            const label nPrims,
+            const faceList& patchFaces,
+            const labelList& pointOffsets,
+            const labelList& patchProcessors,
+            OFstream& ensightGeometryFile
+        ) const;
+
+        void writeAscii
+        (
+            const fileName& postProcPath,
+            const word& prepend,
+            const label timeIndex,
+            Ostream& ensightCaseFile
+        ) const;
+
+        void writeBinary
+        (
+            const fileName& postProcPath,
+            const word& prepend,
+            const label timeIndex,
+            Ostream& ensightCaseFile
+        ) const;
+
+        void writePrimsBinary
+        (
+            const cellShapeList& cellShapes,
+            const label pointOffset,
+            std::ofstream& ensightGeometryFile
+        ) const;
+
+        void writeAllPrimsBinary
+        (
+            const char* key,
+            const label nPrims,
+            const cellShapeList& cellShapes,
+            const labelList& pointOffsets,
+            std::ofstream& ensightGeometryFile
+        ) const;
+
+        void writePolysBinary
+        (
+            const labelList& polys,
+            const cellList& cellFaces,
+            const faceList& faces,
+            const label pointOffset,
+            std::ofstream& ensightGeometryFile
+        ) const;
+
+        void writeAllFacePrimsBinary
+        (
+            const char* key,
+            const labelList& prims,
+            const label nPrims,
+            const faceList& patchFaces,
+            const labelList& pointOffsets,
+            const labelList& patchProcessors,
+            std::ofstream& ensightGeometryFile
+        ) const;
+
+        void writeFacePrimsBinary
+        (
+            const char* key,
+            const faceList& patchFaces,
+            const label pointOffset,
+            std::ofstream& ensightGeometryFile
+        ) const;
+
+
+public:
+
+    // Public data
+
+        const fvMesh& mesh;
+        cellSets meshCellSets;
+        List<faceSets> boundaryFaceSets;
+
+        HashTable<labelList> allPatchNames;
+        HashTable<label> patchIndices;
+        wordHashSet patchNames;
+
+        class nFacePrims
+        {
+        public:
+
+            label nPoints;
+            label nTris;
+            label nQuads;
+            label nPolys;
+
+            nFacePrims()
+            :
+                nPoints(0),
+                nTris(0),
+                nQuads(0),
+                nPolys(0)
+            {}
+        };
+
+        HashTable<nFacePrims> nPatchPrims;
+
+
+    // Constructors
+
+        //- Construct from fvMesh
+        ensightMesh(const fvMesh&, const argList& args, const bool binary);
+
+
+    // Destructor
+
+        ~ensightMesh();
+
+
+    // Member Functions
+
+        void write
+        (
+            const fileName& postProcPath,
+            const word& prepend,
+            const label timeIndex,
+            Ostream& ensightCaseFile
+        ) const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightParticlePositions.C b/applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightParticlePositions.C
new file mode 100644
index 0000000000..5db4c0d591
--- /dev/null
+++ b/applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightParticlePositions.C
@@ -0,0 +1,91 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2007 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 "ensightParticlePositions.H"
+#include "fvMesh.H"
+#include "passiveParticle.H"
+#include "Cloud.H"
+#include "OFstream.H"
+#include "IOmanip.H"
+#include "itoa.H"
+
+using namespace Foam;
+
+// * * * * * * * * * * * * * * * Global Functions  * * * * * * * * * * * * * //
+
+void ensightParticlePositions
+(
+    const Foam::fvMesh& mesh,
+    const Foam::fileName& postProcPath,
+    const Foam::word& timeFile,
+    const Foam::word& sprayName
+)
+{
+    const Time& runTime = mesh.time();
+
+    Cloud<passiveParticle> parcels(mesh);
+
+    fileName ensightFileName(timeFile + "."+ sprayName);
+    OFstream ensightFile
+    (
+        postProcPath/ensightFileName,
+        runTime.writeFormat(),
+        runTime.writeVersion(),
+        runTime.writeCompression()
+    );
+
+    // Output header
+    ensightFile
+        << "lagrangian                                         " << nl
+        << "particle coordinates" << nl;
+
+    // Set Format
+    ensightFile.setf(ios_base::scientific, ios_base::floatfield);
+    ensightFile.precision(5);
+
+    ensightFile << setw(8) << parcels.size() << nl;
+
+    label nParcels = 0;
+
+    // Output position
+    for
+    (
+        Cloud<passiveParticle>::iterator elmnt = parcels.begin();
+        elmnt != parcels.end();
+        ++elmnt
+    )
+    {
+        const vector& p = elmnt().position();
+
+        ensightFile
+            << setw(8) << ++nParcels
+            << setw(12) << p.x() << setw(12) << p.y() << setw(12) << p.z()
+            << nl;
+    }
+}
+
+
+// ************************************************************************* //
diff --git a/applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightParticlePositions.H b/applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightParticlePositions.H
new file mode 100644
index 0000000000..8382e2050a
--- /dev/null
+++ b/applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightParticlePositions.H
@@ -0,0 +1,54 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2007 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
+
+InApplication
+    foamToEnsight
+
+Description
+
+SourceFiles
+    ensightParticlePositions.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef ensightParticlePositions_H
+#define ensightParticlePositions_H
+
+#include "fvMesh.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+void ensightParticlePositions
+(
+    const Foam::fvMesh& mesh,
+    const Foam::fileName& postProcPath,
+    const Foam::word& timeFile,
+    const Foam::word& sprayName
+);
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightSprayField.C b/applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightSprayField.C
new file mode 100644
index 0000000000..1b13698d68
--- /dev/null
+++ b/applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightSprayField.C
@@ -0,0 +1,115 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2007 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 "ensightSprayField.H"
+#include "Time.H"
+#include "IOField.H"
+#include "OFstream.H"
+#include "IOmanip.H"
+
+using namespace Foam;
+
+// * * * * * * * * * * * * * * * Global Functions  * * * * * * * * * * * * * //
+
+template<class Type>
+void ensightSprayField
+(
+    const Foam::IOobject& fieldObject,
+    const Foam::fileName& postProcPath,
+    const Foam::word& prepend,
+    const Foam::label timeIndex,
+    const Foam::word& sprayName,
+    Foam::Ostream& ensightCaseFile
+)
+{
+    Info<< "Converting spray field " << fieldObject.name() << endl;
+
+    word timeFile = prepend + itoa(timeIndex);
+
+    const Time& runTime = fieldObject.time();
+
+    if (timeIndex == 0)
+    {
+        ensightCaseFile
+            << pTraits<Type>::typeName << " per measured node:      1       ";
+        ensightCaseFile.width(15);
+        ensightCaseFile.setf(ios_base::left);
+        ensightCaseFile
+            << ("s" + fieldObject.name()).c_str()
+            << (' ' + prepend + "***." + sprayName
+              + "." + fieldObject.name()).c_str()
+            << nl;
+    }
+
+    // set the filename of the ensight file
+    fileName ensightFileName
+    (
+        timeFile + "." + sprayName +"." + fieldObject.name()
+    );
+
+    OFstream ensightFile
+    (
+        postProcPath/ensightFileName,
+        runTime.writeFormat(),
+        runTime.writeVersion(),
+        runTime.writeCompression()
+    );
+
+    ensightFile << pTraits<Type>::typeName << " values" << nl;
+
+    IOField<Type> vf(fieldObject);
+
+    ensightFile.setf(ios_base::scientific, ios_base::floatfield);
+    ensightFile.precision(5);
+
+    label count = 0;
+    forAll(vf, i)
+    {
+        Type v = vf[i];
+
+        if (mag(v) < 1.0e-90)
+        {
+            v = pTraits<Type>::zero;
+        }
+
+        for (direction cmpt=0; cmpt<pTraits<Type>::nComponents; cmpt++)
+        {
+            ensightFile << setw(12) << component(v, cmpt);
+            if (++count % 6 == 0)
+            {
+                ensightFile << nl;
+            }
+        }
+    }
+
+    if ( (count % 6 != 0) || (count==0) )
+    {
+        ensightFile << nl;
+    }
+}
+
+
+// ************************************************************************* //
diff --git a/applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightSprayField.H b/applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightSprayField.H
new file mode 100644
index 0000000000..1c6c682055
--- /dev/null
+++ b/applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightSprayField.H
@@ -0,0 +1,64 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2007 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
+
+InApplication
+    foamToEnsight
+
+Description
+
+SourceFiles
+    ensightSprayField.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef ensightSprayField_H
+#define ensightSprayField_H
+
+#include "IOobject.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+template<class Type>
+void ensightSprayField
+(
+    const Foam::IOobject& fieldObject,
+    const Foam::fileName& postProcPath,
+    const Foam::word& prepend,
+    const Foam::label timeIndex,
+    const Foam::word& timeFile,
+    const Foam::word& sprayName,
+    Foam::Ostream& ensightCaseFile
+);
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+#   include "ensightSprayField.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightWriteBinary.C b/applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightWriteBinary.C
new file mode 100644
index 0000000000..08fc02020c
--- /dev/null
+++ b/applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightWriteBinary.C
@@ -0,0 +1,79 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2007 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 "ensightWriteBinary.H"
+#include <fstream>
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+void writeEnsDataBinary
+(
+    const char* val,
+    std::ofstream& ensFile
+)
+{
+    char buffer[80] = {0};
+    strcpy(buffer, val);
+    ensFile.write(buffer, 80*sizeof(char));
+}
+
+
+void writeEnsDataBinary
+(
+    const int val,
+    std::ofstream& ensFile
+)
+{
+    ensFile.write(reinterpret_cast<const char*>(&val), sizeof(int));
+}
+
+
+void writeEnsDataBinary
+(
+    const scalarField& sf,
+    std::ofstream& ensightFile
+)
+{
+    if (sf.size() > 0)
+    {
+        List<float> temp(sf.size());
+
+        forAll(sf, i)
+        {
+            temp[i] = float(sf[i]);
+        }
+
+        ensightFile.write
+        (
+            reinterpret_cast<char*>(temp.begin()),
+            sf.size()*sizeof(float)
+        );
+    }
+}
+
+
+// ************************************************************************* //
+
diff --git a/applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightWriteBinary.H b/applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightWriteBinary.H
new file mode 100644
index 0000000000..1cd6ab30c3
--- /dev/null
+++ b/applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightWriteBinary.H
@@ -0,0 +1,68 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2007 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
+
+InApplication
+    foamToEnsight
+
+Description
+    Collection of functions for binary write in EnSight files
+
+SourceFiles
+    ensightWriteBinary.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef ensightWriteBinary_H
+#define ensightWriteBinary_H
+
+#include "ensightMesh.H"
+
+using namespace Foam;
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+void writeEnsDataBinary
+(
+    const char* val,
+    std::ofstream& ensFile
+);
+
+void writeEnsDataBinary
+(
+    const int val,
+    std::ofstream& ensFile
+);
+
+
+void writeEnsDataBinary
+(
+    const scalarField& sf,
+    std::ofstream& ensightFile
+);
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/applications/utilities/postProcessing/dataConversion/foamToEnsight/faceSets.H b/applications/utilities/postProcessing/dataConversion/foamToEnsight/faceSets.H
new file mode 100644
index 0000000000..c0f11b8b44
--- /dev/null
+++ b/applications/utilities/postProcessing/dataConversion/foamToEnsight/faceSets.H
@@ -0,0 +1,88 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2007 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::faceSets
+
+Description
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef faceSets_H
+#define faceSets_H
+
+#include "labelList.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                           Class faceSets Declaration
+\*---------------------------------------------------------------------------*/
+
+class faceSets
+{
+    // Private Member Functions
+
+        //- Disallow default bitwise copy construct
+        faceSets(const faceSets&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const faceSets&);
+
+
+public:
+
+        label nTris;
+        label nQuads;
+        label nPolys;
+
+        labelList tris;
+        labelList quads;
+        labelList polys;
+
+
+    // Constructors
+
+        //- Construct null
+        faceSets()
+        :
+            nTris(0),
+            nQuads(0),
+            nPolys(0)
+        {}
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/applications/utilities/postProcessing/dataConversion/foamToEnsight/foamToEnsight.C b/applications/utilities/postProcessing/dataConversion/foamToEnsight/foamToEnsight.C
new file mode 100644
index 0000000000..38880f63c3
--- /dev/null
+++ b/applications/utilities/postProcessing/dataConversion/foamToEnsight/foamToEnsight.C
@@ -0,0 +1,396 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2007 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
+
+Description
+    Translates FOAM data to EnSight format
+
+\*---------------------------------------------------------------------------*/
+
+#include "argList.H"
+#include "volFields.H"
+#include "tensorIOField.H"
+#include "IOobjectList.H"
+#include "OFstream.H"
+#include "IOmanip.H"
+#include "scalarIOField.H"
+
+#include "ensightMesh.H"
+#include "ensightField.H"
+
+#include "ensightParticlePositions.H"
+#include "ensightSprayField.H"
+
+#include "fvc.H"
+
+using namespace Foam;
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+// Main program:
+
+int main(int argc, char *argv[])
+{
+    argList::validOptions.insert("patches", "patch list");
+    argList::validOptions.insert("binary", "" );
+#   include "addTimeOptions.H"
+
+    const label nTypes = 2;
+    const word fieldTypes[] =
+    {
+        volScalarField::typeName,
+        volVectorField::typeName
+    };
+
+    const label nSprayFieldTypes = 2;
+    const word sprayFieldTypes[] =
+    {
+        scalarIOField::typeName,
+        vectorIOField::typeName
+    };
+
+#   include "setRootCase.H"
+#   include "createTime.H"
+
+    // get the available time-steps
+    instantList Times = runTime.times();
+
+#   include "checkTimeOptions.H"
+
+    runTime.setTime(Times[startTime], startTime);
+
+#   include "createMesh.H"
+
+    const word postProcDir = "EnSight";
+    const word prepend = args.globalCaseName() + '.';
+    const word sprayName = "lagrangian";
+
+    fileName postProcPath = args.rootPath()/args.globalCaseName()/postProcDir;
+
+    if (Pstream::master())
+    {
+        if (dir(postProcPath))
+        {
+            rmDir(postProcPath);
+        }
+
+        mkDir(postProcPath);
+    }
+
+    OFstream *ensightCaseFilePtr = NULL;
+
+    // Check options
+    bool binary = false;
+    if (args.options().found("binary"))
+    {
+        binary = true;
+    }
+
+    if (Pstream::master())
+    {
+        // Open the Case file
+        fileName ensightCaseFileName = prepend + "case";
+
+        if (!binary)
+        {
+            ensightCaseFilePtr = new OFstream
+            (
+                postProcPath/ensightCaseFileName,
+                runTime.writeFormat(),
+                runTime.writeVersion(),
+                runTime.writeCompression()
+            );
+        }
+        else
+        {
+            ensightCaseFilePtr = new OFstream
+            (
+                postProcPath/ensightCaseFileName,
+                runTime.writeFormat(),
+                runTime.writeVersion(),
+                IOstream::UNCOMPRESSED
+            );
+        }
+
+        Info<< nl << "Case file is " << ensightCaseFileName << endl;
+    }
+
+    OFstream& ensightCaseFile = *ensightCaseFilePtr;
+
+    // Construct the EnSight mesh
+    ensightMesh eMesh(mesh, args, binary);
+
+    // Set Time to the last time before looking for the spray objects
+    runTime.setTime(Times[Times.size()-1], Times.size()-1);
+
+    IOobjectList objects(mesh, runTime.timeName());
+    IOobjectList sprayObjects(mesh, runTime.timeName(), "lagrangian");
+
+    bool lagrangianExist = false;
+
+    if (!eMesh.patchNames.size())
+    {
+        IOobject lagrangianHeader
+        (
+            "positions",
+            runTime.timeName(),
+            "lagrangian",
+            mesh,
+            IOobject::NO_READ
+        );
+
+        if (lagrangianHeader.headerOk())
+        {
+            lagrangianExist = true;
+        }
+    }
+
+#   include "ensightCaseHeader.H"
+
+#   include "checkMeshMoving.H"
+
+    word geomCaseFileName = prepend + "000";
+    if (Pstream::master())
+    {
+        // test pre check variable if there is a moving mesh
+        if (meshMoving == true) geomCaseFileName = prepend + "***";
+        ensightCaseFile
+            << "GEOMETRY" << nl
+            << "model:        1     "
+            << (geomCaseFileName + ".mesh").c_str() << nl;
+    }
+
+    label nTimeSteps = 0;
+    for (label n=startTime; n<endTime; n++)
+    {
+        nTimeSteps++;
+        runTime.setTime(Times[n], n);
+        label timeIndex = n - startTime;
+
+        word timeName = itoa(timeIndex);
+        word timeFile = prepend + timeName;
+
+        Info << "Translating time = " << runTime.timeName() << nl;
+
+#       include "moveMesh.H"
+
+        if (timeIndex == 0 || mesh.moving())
+        {
+            eMesh.write
+            (
+                postProcPath,
+                prepend,
+                timeIndex,
+                ensightCaseFile
+            );
+        }
+
+        if (Pstream::master() && timeIndex == 0)
+        {
+            if (lagrangianExist)
+            {
+                ensightCaseFile
+                    <<  (
+                            "measured:     1     "
+                          + prepend
+                          + "***."
+                          + sprayName
+                        ).c_str()
+                    << nl;
+             }
+             ensightCaseFile << nl << "VARIABLE" << nl;
+        }
+
+        for (label i=0; i<nTypes; i++)
+        {
+            wordList fieldNames = objects.names(fieldTypes[i]);
+
+            for (label j=0; j<fieldNames.size(); j++)
+            {
+                word fieldName = fieldNames[j];
+
+                bool variableGood = true;
+
+#               include "checkData.H"
+
+                if (variableGood)
+                {
+                    IOobject fieldObject
+                    (
+                        fieldName,
+                        mesh.time().timeName(),
+                        mesh,
+                        IOobject::MUST_READ,
+                        IOobject::NO_WRITE
+                    );
+
+                    if (fieldTypes[i] == volScalarField::typeName)
+                    {
+                        ensightField<scalar>
+                        (
+                            fieldObject,
+                            eMesh,
+                            postProcPath,
+                            prepend,
+                            timeIndex,
+                            binary,
+                            ensightCaseFile
+                        );
+                    }
+                    else if (fieldTypes[i] == volVectorField::typeName)
+                    {
+                        ensightField<vector>
+                        (
+                            fieldObject,
+                            eMesh,
+                            postProcPath,
+                            prepend,
+                            timeIndex,
+                            binary,
+                            ensightCaseFile
+                        );
+                    }
+                    else if (fieldTypes[i] == volSphericalTensorField::typeName)
+                    {
+                        ensightField<sphericalTensor>
+                        (
+                            fieldObject,
+                            eMesh,
+                            postProcPath,
+                            prepend,
+                            timeIndex,
+                            binary,
+                            ensightCaseFile
+                        );
+                    }
+                    else if (fieldTypes[i] == volSymmTensorField::typeName)
+                    {
+                        ensightField<symmTensor>
+                        (
+                            fieldObject,
+                            eMesh,
+                            postProcPath,
+                            prepend,
+                            timeIndex,
+                            binary,
+                            ensightCaseFile
+                        );
+                    }
+                    else if (fieldTypes[i] == volTensorField::typeName)
+                    {
+                        ensightField<tensor>
+                        (
+                            fieldObject,
+                            eMesh,
+                            postProcPath,
+                            prepend,
+                            timeIndex,
+                            binary,
+                            ensightCaseFile
+                        );
+                    }
+                }
+            }
+        }
+
+        if (lagrangianExist)
+        {
+            ensightParticlePositions
+            (
+                mesh,
+                postProcPath,
+                timeFile,
+                sprayName
+            );
+
+            for (label i=0; i<nSprayFieldTypes; i++)
+            {
+                wordList fieldNames = sprayObjects.names(sprayFieldTypes[i]);
+
+                for (label j=0; j<fieldNames.size(); j++)
+                {
+                    word fieldName = fieldNames[j];
+
+                    IOobject fieldObject
+                    (
+                        fieldName,
+                        mesh.time().timeName(),
+                        "lagrangian",
+                        mesh,
+                        IOobject::MUST_READ,
+                        IOobject::NO_WRITE
+                    );
+
+                    if (sprayFieldTypes[i] == scalarIOField::typeName)
+                    {
+                        ensightSprayField<scalar>
+                        (
+                            fieldObject,
+                            postProcPath,
+                            prepend,
+                            timeIndex,
+                            sprayName,
+                            ensightCaseFile
+                        );
+                    }
+                    else if (sprayFieldTypes[i] == vectorIOField::typeName)
+                    {
+                        ensightSprayField<vector>
+                        (
+                            fieldObject,
+                            postProcPath,
+                            prepend,
+                            timeIndex,
+                            sprayName,
+                            ensightCaseFile
+                        );
+                    }
+                    else if (sprayFieldTypes[i] == tensorIOField::typeName)
+                    {
+                        ensightSprayField<tensor>
+                        (
+                            fieldObject,
+                            postProcPath,
+                            prepend,
+                            timeIndex,
+                            sprayName,
+                            ensightCaseFile
+                        );
+                    }
+                }
+            }
+        }
+    }
+
+#   include "ensightCaseTail.H"
+
+    if (Pstream::master())
+    {
+        delete ensightCaseFilePtr;
+    }
+
+    return 0;
+}
+
+
+// ************************************************************************* //
diff --git a/applications/utilities/postProcessing/dataConversion/foamToEnsight/itoa.C b/applications/utilities/postProcessing/dataConversion/foamToEnsight/itoa.C
new file mode 100644
index 0000000000..1539967ae3
--- /dev/null
+++ b/applications/utilities/postProcessing/dataConversion/foamToEnsight/itoa.C
@@ -0,0 +1,62 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2007 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 "itoa.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+word itoa(const label n)
+{
+    const label offset = '0';
+    const label length = 3;
+
+    char val[length + 1];
+
+    label leftOfN = n;
+
+    for (label i=0; i<length; i++)
+    {
+        label j = label(leftOfN/pow(10, length - i - 1));
+        leftOfN -= j*pow(10, length - i - 1);
+        val[i] = offset + j;
+    }
+
+    val[length] = 0;
+
+    return val;
+}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// ************************************************************************* //
diff --git a/applications/utilities/postProcessing/dataConversion/foamToEnsight/itoa.H b/applications/utilities/postProcessing/dataConversion/foamToEnsight/itoa.H
new file mode 100644
index 0000000000..2bed59cc5e
--- /dev/null
+++ b/applications/utilities/postProcessing/dataConversion/foamToEnsight/itoa.H
@@ -0,0 +1,48 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2007 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
+
+InApplication
+    foamToEnsight
+
+Description
+
+\*---------------------------------------------------------------------------*/
+
+#include "word.H"
+#include "label.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+word itoa(const label n);
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// ************************************************************************* //
diff --git a/applications/utilities/postProcessing/dataConversion/foamToEnsight/moveMesh.H b/applications/utilities/postProcessing/dataConversion/foamToEnsight/moveMesh.H
new file mode 100644
index 0000000000..a0b5ac1586
--- /dev/null
+++ b/applications/utilities/postProcessing/dataConversion/foamToEnsight/moveMesh.H
@@ -0,0 +1,28 @@
+{
+    IOobject ioPoints
+    (
+        "points",
+        runTime.timeName(),
+        polyMesh::meshSubDir,
+        mesh
+    );
+
+    if (ioPoints.headerOk())
+    {
+        // Reading new points
+        pointIOField newPoints
+        (
+            IOobject
+            (
+                "points",
+                mesh.time().timeName(),
+                polyMesh::meshSubDir,
+                mesh,
+                IOobject::MUST_READ,
+                IOobject::NO_WRITE
+            )
+        );
+
+        mesh.movePoints(newPoints);
+    }
+}