New foamToEnsight with support for binary files contributed by Francesco.

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

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 \
+   

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
+
+// ************************************************************************* //

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();
+}

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;
+}

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();
+}

applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightCaseHeader.H

@@ -0,0 +1,5 @@
+if (Pstream::master())
+{
+    ensightCaseFile << "FORMAT" << nl;
+    ensightCaseFile << "type: ensight gold" << nl << nl;
+}

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;
+}

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
+        );
+    }
+}
+
+
+// ************************************************************************* //

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
+
+// ************************************************************************* //

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
+
+// ************************************************************************* //

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;
+    }
+}
+
+
+// ************************************************************************* //

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
+
+// ************************************************************************* //

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;
+    }
+}
+
+
+// ************************************************************************* //

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
+
+// ************************************************************************* //

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)
+        );
+    }
+}
+
+
+// ************************************************************************* //
+

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
+
+// ************************************************************************* //

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
+
+// ************************************************************************* //

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;
+}
+
+
+// ************************************************************************* //

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
+
+// ************************************************************************* //

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
+
+// ************************************************************************* //

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);
+    }
+}