extended the conversion library and utilities

library:
  * routines for managing cellTable and boundaryRegion
  * writing ensight files and parts
  * mesh reader/writer for STARCD

utils:
  * star4ToFoam
  * foamToStarMesh
  * foamToEnsightParts

applications/utilities/postProcessing/dataConversion/foamToEnsight/Make/options

@@ -5,5 +5,5 @@ EXE_INC = \
 
 EXE_LIBS = \
     -lfiniteVolume \
-    -llagrangian \
-   
+    -llagrangian
+

applications/utilities/postProcessing/dataConversion/foamToEnsight/foamToEnsight.C

@@ -24,6 +24,15 @@ License
 
 Description
     Translates FOAM data to EnSight format
+
+Usage
+    - foamToEnsight [OPTION] \n
+    Translates OpenFOAM data to Ensight format
+
+    @param -ascii \n
+    Write Ensight data in ASCII format instead of "C Binary"
+
+Note
     Parallel support for cloud data is not supported
 
 \*---------------------------------------------------------------------------*/
@@ -74,16 +83,16 @@ bool inFileNameList
 int main(int argc, char *argv[])
 {
     argList::validOptions.insert("patches", "patch list");
-    argList::validOptions.insert("binary", "" );
+    argList::validOptions.insert("ascii", "" );
 #   include "addTimeOptions.H"
 
 #   include "setRootCase.H"
 
     // Check options
-    bool binary = false;
-    if (args.options().found("binary"))
+    bool binary = true;
+    if (args.options().found("ascii"))
     {
-        binary = true;
+        binary = false;
     }
 
 #   include "createTime.H"

applications/utilities/postProcessing/dataConversion/foamToEnsightParts/Make/files

@@ -0,0 +1,3 @@
+foamToEnsightParts.C
+
+EXE = $(FOAM_APPBIN)/foamToEnsightParts

applications/utilities/postProcessing/dataConversion/foamToEnsightParts/Make/options

@@ -0,0 +1,9 @@
+EXE_INC = \
+    -I$(LIB_SRC)/finiteVolume/lnInclude \
+    -I$(LIB_SRC)/lagrangian/basic/lnInclude \
+    -I$(LIB_SRC)/conversion/lnInclude
+
+EXE_LIBS = \
+    -lfiniteVolume \
+    -llagrangian \
+    -lconversion

applications/utilities/postProcessing/dataConversion/foamToEnsightParts/checkHasLagrangian.H

@@ -0,0 +1,19 @@
+// check for lagrangian/positions information in the final directory
+
+bool hasLagrangian = false;
+if (timeDirs.size() > 1)
+{
+    IOobject io
+    (
+        "positions",
+        timeDirs[timeDirs.size() - 1].name(),
+        "lagrangian",
+        mesh,
+        IOobject::NO_READ
+    );
+
+    if (io.headerOk())
+    {
+        hasLagrangian = true;
+    }
+}

applications/utilities/postProcessing/dataConversion/foamToEnsightParts/checkHasMovingMesh.H

@@ -0,0 +1,20 @@
+// check for "points" in all of the result directories
+
+bool hasMovingMesh = false;
+if (timeDirs.size() > 1)
+{
+    hasMovingMesh = true;
+    for (label i=0; i < timeDirs.size() && hasMovingMesh; ++i)
+    {
+        IOobject io
+        (
+            "points",
+            timeDirs[i].name(),
+            polyMesh::meshSubDir,
+            mesh,
+            IOobject::NO_READ
+        );
+        
+        hasMovingMesh = io.headerOk();
+    }
+}

applications/utilities/postProcessing/dataConversion/foamToEnsightParts/checkHasSprayField.H

@@ -0,0 +1,15 @@
+// check that the spray variable is present for this time
+//
+bool hasSprayField = true;
+{
+    IOobject ioHeader
+    (
+        fieldName,
+        mesh.time().timeName(),
+        "lagrangian",
+        mesh,
+        IOobject::NO_READ
+    );
+
+    hasSprayField = ioHeader.headerOk();
+}

applications/utilities/postProcessing/dataConversion/foamToEnsightParts/checkHasValidField.H

@@ -0,0 +1,23 @@
+// check that the variable is present for all times
+//
+bool hasValidField = true;
+{
+    for (label i=0; i < timeDirs.size() && hasValidField; ++i)
+    {
+        if (fieldName.size() > 2 && fieldName(fieldName.size() - 2, 2) == "_0")
+        {
+            hasValidField = false;
+            break;
+        }
+
+        IOobject ioHeader
+        (
+            fieldName,
+            timeDirs[i].name(),
+            mesh,
+            IOobject::NO_READ
+        );
+
+        hasValidField = ioHeader.headerOk();
+    }
+}

applications/utilities/postProcessing/dataConversion/foamToEnsightParts/ensightCaseTimes.H

@@ -0,0 +1,91 @@
+// write time values to case file
+{
+    scalar timeCorrection = 0;
+    if (timeDirs[0].value() < 0)
+    {
+        timeCorrection = - timeDirs[0].value();
+        Info<< "Correcting time values. Adding " << timeCorrection << endl;
+    }
+
+    caseFile.setf(ios_base::scientific, ios_base::floatfield);
+    caseFile.precision(5);
+
+    // time set 1 - geometry and volume fields
+    if (fieldFileNumbers.size())
+    {
+        caseFile
+            << "time set:        " << 1 << nl
+            << "number of steps: " << fieldFileNumbers.size() << nl
+            << "filename numbers:" << nl;
+
+        label count = 0;
+        forAll (fieldFileNumbers, i)
+        {
+            caseFile
+                << " " << setw(12) << fieldFileNumbers[i];
+
+            if (++count % 6 == 0)
+            {
+                caseFile << nl;
+            }
+        }
+
+        caseFile
+            << nl << "time values:" << nl;
+
+        count = 0;
+        forAll (fieldFileNumbers, i)
+        {
+            caseFile
+                << " " << setw(12)
+                << timeIndices[fieldFileNumbers[i]] + timeCorrection;
+
+            if (++count % 6 == 0)
+            {
+                caseFile << nl;
+            }
+        }
+        caseFile << nl << nl;
+    }
+
+    // time set 2 - lagrangian fields
+    if (hasLagrangian && sprayFileNumbers.size())
+    {
+        caseFile
+            << "time set:        " << 2 << nl
+            << "number of steps: " << sprayFileNumbers.size() << nl
+            << "filename numbers:" << nl;
+
+        label count = 0;
+        forAll (sprayFileNumbers, i)
+        {
+            caseFile
+                << " " << setw(12) << sprayFileNumbers[i];
+
+            if (++count % 6 == 0)
+            {
+                caseFile << nl;
+            }
+        }
+
+        caseFile
+            << nl << "time values:" << nl;
+
+        count = 0;
+        forAll (sprayFileNumbers, i)
+        {
+            caseFile
+                << " " << setw(12)
+                << timeIndices[sprayFileNumbers[i]] + timeCorrection;
+
+            if (++count % 6 == 0)
+            {
+                caseFile << nl;
+            }
+        }
+        caseFile << nl << nl;
+    }
+
+
+    caseFile << "# end" << nl;
+}

applications/utilities/postProcessing/dataConversion/foamToEnsightParts/ensightOutputFunctions.C

@@ -0,0 +1,233 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  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
+
+    $Date: 2008/04/02 11:37:10 $
+\*---------------------------------------------------------------------------*/
+
+#include "ensightOutputFunctions.H"
+
+#include "passiveParticle.H"
+#include "Cloud.H"
+#include "IOField.H"
+#include "volFields.H"
+#include "surfaceFields.H"
+
+#include "OFstream.H"
+#include "IOmanip.H"
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * Global Functions  * * * * * * * * * * * * * //
+
+template<class Type>
+void ensightCaseEntry
+(
+    OFstream& caseFile,
+    const IOobject& fieldObject,
+    const fileName& dataMask,
+    bool measured
+)
+{
+    caseFile.setf(ios_base::left);
+
+    if (measured)
+    {
+        caseFile
+            << pTraits<Type>::typeName
+            << " per measured node: 2 "
+            << setw(15)
+            << ("s" + fieldObject.name()).c_str()
+            << " "
+            << (dataMask/"lagrangian"/fieldObject.name()).c_str()
+            << nl;
+    }
+    else
+    {
+        caseFile
+            << pTraits<Type>::typeName
+            << " per element:     "
+            << setw(15) << fieldObject.name()
+            << " "
+            << (dataMask/fieldObject.name()).c_str()
+            << nl;
+    }
+}
+
+
+void ensightParticlePositions
+(
+    const polyMesh& mesh,
+    const fileName& dataDir,
+    const fileName& subDir,
+    IOstream::streamFormat format
+)
+{
+    Cloud<passiveParticle> parcels(mesh);
+
+    fileName lagrangianDir = subDir/"lagrangian";
+    fileName postFileName = lagrangianDir/"positions";
+
+    // the ITER/lagrangian subdirectory must exist
+    mkDir(dataDir/lagrangianDir);
+    ensightFile os(dataDir/postFileName, format);
+
+    // tag binary format (just like geometry files)
+    os.writeBinaryHeader();
+    os.write(postFileName);
+    os.newline();
+    os.write("particle coordinates");
+    os.newline();
+    os.write(parcels.size(), 8);	// unusual width
+    os.newline();
+
+    // binary write is Ensight6 - first ids, then positions
+    if (format == IOstream::BINARY)
+    {
+        forAll (parcels, i)
+        {
+            os.write(i+1);
+        }
+
+        forAllIter(Cloud<passiveParticle>, parcels, elmnt)
+        {
+            const vector& p = elmnt().position();
+
+            os.write(p.x());
+            os.write(p.y());
+            os.write(p.z());
+        }
+    }
+    else
+    {
+        label nParcels = 0;
+
+        forAllIter(Cloud<passiveParticle>, parcels, elmnt)
+        {
+            const vector& p = elmnt().position();
+
+            os.write(++nParcels, 8);	// unusual width
+            os.write(p.x());
+            os.write(p.y());
+            os.write(p.z());
+            os.newline();
+        }
+    }
+}
+
+
+
+template<class Type>
+void ensightSprayField
+(
+    const IOobject& fieldObject,
+    const fileName& dataDir,
+    const fileName& subDir,
+    IOstream::streamFormat format
+)
+{
+    Info<< " " << fieldObject.name() << flush;
+
+    fileName lagrangianDir = subDir/"lagrangian";
+    fileName postFileName = lagrangianDir/fieldObject.name();
+
+    string title = postFileName + " with " + pTraits<Type>::typeName + " values";
+
+    ensightFile os(dataDir/postFileName, format);
+    os.write(title);
+    os.newline();
+
+    IOField<Type> field(fieldObject);
+
+    // 6 values per line
+    label count = 0;
+
+    forAll(field, i)
+    {
+        Type val = field[i];
+
+        if (mag(val) < 1.0e-90)
+        {
+            val = pTraits<Type>::zero;
+        }
+
+        for (direction cmpt=0; cmpt < pTraits<Type>::nComponents; cmpt++)
+        {
+            os.write( component(val, cmpt) );
+        }
+
+        count += pTraits<Type>::nComponents;
+
+        if (count % 6 == 0)
+        {
+            os.newline();
+        }
+    }
+
+    // add final newline if required
+    if (count % 6)
+    {
+        os.newline();
+    }
+}
+
+
+//- write generalized field components
+template <class Type>
+void ensightVolField
+(
+    const ensightParts& partsList,
+    const IOobject& fieldObject,
+    const fvMesh& mesh,
+    const fileName& dataDir,
+    const fileName& subDir,
+    IOstream::streamFormat format
+)
+{
+    Info<< " " << fieldObject.name() << flush;
+
+    fileName postFileName = subDir/fieldObject.name();
+
+    ensightFile os(dataDir/postFileName, format);
+    os.write(postFileName);
+    os.newline();
+
+    // ie, volField<Type>
+    partsList.writeField
+    (
+        os,
+        GeometricField<Type, fvPatchField, volMesh>
+        (
+            fieldObject,
+            mesh
+        )
+    );
+}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // end namespace Foam
+
+// ************************************************************************* //

applications/utilities/postProcessing/dataConversion/foamToEnsightParts/ensightOutputFunctions.H

@@ -0,0 +1,100 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  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
+
+    miscellaneous collection of functions and template related
+    to Ensight data
+
+SourceFiles
+    ensightOutputFunctions.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef ensightOutputFunctions_H
+#define ensightOutputFunctions_H
+
+#include "ensightFile.H"
+#include "polyMesh.H"
+#include "IOobject.H"
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+template<class Type>
+void ensightCaseEntry
+(
+    OFstream& caseFile,
+    const IOobject& fieldObject,
+    const fileName& dataMask,
+    bool measured = false
+);
+
+
+void ensightParticlePositions
+(
+    const polyMesh& mesh,
+    const fileName& dataDir,
+    const fileName& subDir,
+    IOstream::streamFormat format
+);
+
+
+//- write spray parcels
+template<class Type>
+void ensightSprayField
+(
+    const IOobject& fieldObject,
+    const fileName& dataDir,
+    const fileName& subDir,
+    IOstream::streamFormat format
+);
+
+//- write generalized field components
+template<class Type>
+void ensightVolField
+(
+    const ensightParts& partsList,
+    const IOobject& fieldObject,
+    const fvMesh& mesh,
+    const fileName& dataDir,
+    const fileName& subDir,
+    IOstream::streamFormat format
+);
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // end namespace Foam
+
+#ifdef NoRepository
+#   include "ensightOutputFunctions.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

applications/utilities/postProcessing/dataConversion/foamToEnsightParts/foamToEnsightParts.C

@@ -0,0 +1,499 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Application
+    foamToEnsightParts
+
+Description
+    Translates OpenFOAM data to Ensight format.
+    An Ensight part is created for each cellZone and patch.
+
+Usage
+    - foamToEnsightParts [OPTION] \n
+    Translates OpenFOAM data to Ensight format
+
+    @param -ascii \n
+    Write Ensight data in ASCII format instead of "C Binary"
+
+    @param -zeroTime \n
+    Include the often incomplete initial conditions.
+
+Note
+    - no parallel data.
+    - writes to @a Ensight directory to avoid collisions with foamToEnsight.
+
+\*---------------------------------------------------------------------------*/
+
+#include "argList.H"
+#include "timeSelector.H"
+
+#include "volFields.H"
+#include "OFstream.H"
+#include "IOmanip.H"
+#include "IOobjectList.H"
+#include "scalarIOField.H"
+#include "tensorIOField.H"
+
+#include "ensightParts.H"
+#include "ensightOutputFunctions.H"
+
+using namespace Foam;
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+// Main program:
+
+int main(int argc, char *argv[])
+{
+    // with -constant and -zeroTime
+    timeSelector::addOptions(true, false);
+    argList::noParallel();
+    argList::validOptions.insert("ascii", "");
+
+    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 times list
+    instantList timeDirs = timeSelector::select0(runTime, args);
+
+    // default to binary output, unless otherwise specified
+    IOstream::streamFormat format = IOstream::BINARY;
+    if (args.options().found("ascii"))
+    {
+        format = IOstream::ASCII;
+    }
+
+    fileName ensightDir = args.rootPath()/args.globalCaseName()/"Ensight";
+    fileName dataDir = ensightDir/"data";
+    fileName caseFileName = "Ensight.case";
+    fileName dataMask = fileName("data")/ensightFile::mask();
+
+    // Ensight and Ensight/data directories must exist
+    if (dir(ensightDir))
+    {
+        rmDir(ensightDir);
+    }
+    mkDir(ensightDir);
+    mkDir(dataDir);
+
+#   include "createMesh.H"
+    // Construct the list of ensight parts for the entire mesh
+    ensightParts partsList(mesh);
+
+    // write summary information
+    {
+        OFstream partsInfoFile(ensightDir/"partsInfo");
+
+        partsInfoFile
+            << "// summary of ensight parts" << nl << nl;
+        partsList.writeSummary(partsInfoFile);
+    }
+
+#   include "checkHasMovingMesh.H"
+#   include "checkHasLagrangian.H"
+
+    // only take the objects that exists at the end of the calculation
+    IOobjectList objects(mesh, timeDirs[timeDirs.size()-1].name());
+    IOobjectList sprayObjects(mesh, timeDirs[timeDirs.size()-1].name(), "lagrangian");
+
+    // write single geometry or one per time step
+    fileName geometryFileName("geometry");
+    if (hasMovingMesh)
+    {
+        geometryFileName = dataMask/geometryFileName;
+    }
+
+    // the case file is always ASCII
+    Info << "write case: " << caseFileName.c_str() << endl;
+
+    OFstream caseFile(ensightDir/caseFileName, IOstream::ASCII);
+    caseFile.setf(ios_base::left);
+    caseFile
+        << "FORMAT" << nl
+        << setw(16) << "type:" << "ensight gold" << nl << nl
+        << "GEOMETRY" << nl
+        << setw(16) << "model: 1" << geometryFileName.c_str() << nl;
+
+    if (hasLagrangian)
+    {
+        caseFile
+            << setw(16) << "measured: 2"
+            << fileName(dataMask/"lagrangian"/"positions").c_str() << nl;
+    }
+    caseFile
+        << nl << "VARIABLE" << nl;
+
+    label nFieldTime = timeDirs.size();
+    if (nFieldTime < 0)
+    {
+        nFieldTime = 0;
+    }
+
+    List<label> fieldFileNumbers(nFieldTime);
+    List<label> sprayFileNumbers(nFieldTime);
+
+    // map used times used
+    Map<scalar>  timeIndices;
+
+    nFieldTime = 0;
+    label nSprayTime = 0;
+
+    forAll(timeDirs, timeI)
+    {
+        runTime.setTime(timeDirs[timeI], timeI);
+
+#       include "getTimeIndex.H"
+
+        fieldFileNumbers[nFieldTime++] = timeIndex;
+
+        // the data/ITER subdirectory must exist
+        fileName subDir = ensightFile::subDir(timeIndex);
+        mkDir(dataDir/subDir);
+
+        // place a timestamp in the directory for future reference
+        {
+            OFstream timeStamp(dataDir/subDir/"time");
+            timeStamp
+                << "#   timestep time" << nl
+                << subDir.c_str() << " " << runTime.timeName() << nl;
+        }
+
+#       include "moveMesh.H"
+
+        if (nFieldTime == 1 || mesh.moving())
+        {
+            if (hasMovingMesh)
+            {
+                geometryFileName = dataDir/subDir/"geometry";
+            }
+            if (mesh.moving())
+            {
+                partsList.recalculate(mesh);
+            }
+
+            ensightGeoFile geoFile(ensightDir/geometryFileName, format);
+            partsList.writeGeometry(geoFile);
+            Info << nl;
+        }
+
+        Info<< "write volume field: " << flush;
+
+        for (label i=0; i < nTypes; i++)
+        {
+            wordList fieldNames = objects.names(fieldTypes[i]);
+
+            forAll (fieldNames, fieldI)
+            {
+                word fieldName = fieldNames[fieldI];
+
+#               include "checkHasValidField.H"
+
+                if (!hasValidField)
+                {
+                    continue;
+                }
+
+                IOobject fieldObject
+                (
+                    fieldName,
+                    mesh.time().timeName(),
+                    mesh,
+                    IOobject::MUST_READ,
+                    IOobject::NO_WRITE
+                );
+
+                if (fieldTypes[i] == volScalarField::typeName)
+                {
+                    if (nFieldTime == 1)
+                    {
+                        ensightCaseEntry<scalar>
+                        (
+                            caseFile,
+                            fieldObject,
+                            dataMask
+                        );
+                    }
+
+                    ensightVolField<scalar>
+                    (
+                        partsList,
+                        fieldObject,
+                        mesh,
+                        dataDir,
+                        subDir,
+                        format
+                    );
+
+                }
+                else if (fieldTypes[i] == volVectorField::typeName)
+                {
+                    if (nFieldTime == 1)
+                    {
+                        ensightCaseEntry<vector>
+                        (
+                            caseFile,
+                            fieldObject,
+                            dataMask
+                        );
+                    }
+
+                    ensightVolField<vector>
+                    (
+                        partsList,
+                        fieldObject,
+                        mesh,
+                        dataDir,
+                        subDir,
+                        format
+                    );
+
+                }
+                else if (fieldTypes[i] == volSphericalTensorField::typeName)
+                {
+                    if (nFieldTime == 1)
+                    {
+                        ensightCaseEntry<sphericalTensor>
+                        (
+                            caseFile,
+                            fieldObject,
+                            dataMask
+                        );
+                    }
+
+                    ensightVolField<sphericalTensor>
+                    (
+                        partsList,
+                        fieldObject,
+                        mesh,
+                        dataDir,
+                        subDir,
+                        format
+                    );
+
+                }
+                else if (fieldTypes[i] == volSymmTensorField::typeName)
+                {
+                    if (nFieldTime == 1)
+                    {
+                        ensightCaseEntry<symmTensor>
+                        (
+                            caseFile,
+                            fieldObject,
+                            dataMask
+                        );
+                    }
+
+                    ensightVolField<symmTensor>
+                    (
+                        partsList,
+                        fieldObject,
+                        mesh,
+                        dataDir,
+                        subDir,
+                        format
+                    );
+
+                }
+                else if (fieldTypes[i] == volTensorField::typeName)
+                {
+                    if (nFieldTime == 1)
+                    {
+                        ensightCaseEntry<tensor>
+                        (
+                            caseFile,
+                            fieldObject,
+                            dataMask
+                        );
+                    }
+
+                    ensightVolField<tensor>
+                    (
+                        partsList,
+                        fieldObject,
+                        mesh,
+                        dataDir,
+                        subDir,
+                        format
+                    );
+
+                }
+            }
+        }
+        Info<< endl;
+
+
+        if (hasLagrangian)
+        {
+            // check that the positions field is present for this time
+            {
+                IOobject ioHeader
+                (
+                    "positions",
+                    mesh.time().timeName(),
+                    "lagrangian",
+                    mesh,
+                    IOobject::NO_READ
+                );
+
+                if (ioHeader.headerOk())
+                {
+                    sprayFileNumbers[nSprayTime++] = timeIndex;
+                }
+            }
+
+            Info<< "write  spray field: " << flush;
+
+            ensightParticlePositions
+            (
+                mesh,
+                dataDir,
+                subDir,
+                format
+            );
+
+            for (label i=0; i < nSprayFieldTypes; i++)
+            {
+                wordList fieldNames = sprayObjects.names(sprayFieldTypes[i]);
+
+                forAll (fieldNames, fieldI)
+                {
+                    word fieldName = fieldNames[fieldI];
+
+#                   include "checkHasSprayField.H"
+
+                    if (!hasSprayField)
+                    {
+                        continue;
+                    }
+
+                    IOobject fieldObject
+                    (
+                        fieldName,
+                        mesh.time().timeName(),
+                        "lagrangian",
+                        mesh,
+                        IOobject::MUST_READ,
+                        IOobject::NO_WRITE
+                    );
+
+                    if (sprayFieldTypes[i] == scalarIOField::typeName)
+                    {
+                        if (nSprayTime == 1)
+                        {
+                            ensightCaseEntry<scalar>
+                            (
+                                caseFile,
+                                fieldObject,
+                                dataMask,
+                                true
+                            );
+                        }
+
+                        ensightSprayField<scalar>
+                        (
+                            fieldObject,
+                            dataDir,
+                            subDir,
+                            format
+                        );
+
+                    }
+                    else if (sprayFieldTypes[i] == vectorIOField::typeName)
+                    {
+                        if (nSprayTime == 1)
+                        {
+                            ensightCaseEntry<vector>
+                            (
+                                caseFile,
+                                fieldObject,
+                                dataMask,
+                                true
+                            );
+                        }
+
+                        ensightSprayField<vector>
+                        (
+                            fieldObject,
+                            dataDir,
+                            subDir,
+                            format
+                        );
+
+                    }
+                    else if (sprayFieldTypes[i] == tensorIOField::typeName)
+                    {
+                        if (nSprayTime == 1)
+                        {
+                            ensightCaseEntry<tensor>
+                            (
+                                caseFile,
+                                fieldObject,
+                                dataMask,
+                                true
+                            );
+                        }
+
+                        ensightSprayField<tensor>
+                        (
+                            fieldObject,
+                            dataDir,
+                            subDir,
+                            format
+                        );
+
+                    }
+                }
+            }
+            Info<< endl;
+        }
+    }
+
+    fieldFileNumbers.setSize(nFieldTime);
+    sprayFileNumbers.setSize(nSprayTime);
+
+    // add time values
+    caseFile << nl << "TIME" << nl;
+#   include "ensightCaseTimes.H"
+
+    Info<< "\nEnd\n"<< endl;
+
+    return 0;
+}
+
+
+// ************************************************************************* //

applications/utilities/postProcessing/dataConversion/foamToEnsightParts/getTimeIndex.H

@@ -0,0 +1,50 @@
+// Read time index from */uniform/time,
+// but treat 0 and constant specially
+
+    label timeIndex = 0;
+
+    if
+    (
+        runTime.timeName() != "constant"
+     && runTime.timeName() != "0"
+    )
+    {
+        IOobject io
+        (
+            "time",
+            runTime.timeName(),
+            "uniform",
+            runTime,
+            IOobject::READ_IF_PRESENT,
+            IOobject::NO_WRITE,
+            false
+        );
+
+        if (io.headerOk())
+        {
+            IOdictionary timeObject
+            (
+                IOobject
+                (
+                    "time",
+                    runTime.timeName(),
+                    "uniform",
+                    runTime,
+                    IOobject::MUST_READ,
+                    IOobject::NO_WRITE,
+                    false
+                )
+            );
+
+            timeObject.lookup("index") >> timeIndex;
+        }
+        else
+        {
+            Info<< "skip ... missing entry " << io.objectPath() << endl;
+            continue;
+        }
+    }
+
+    timeIndices.insert(timeIndex, timeDirs[timeI].value());
+    Info<< "\nTime [" << timeIndex << "] = " << runTime.timeName() << nl;
+

applications/utilities/postProcessing/dataConversion/foamToEnsightParts/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);
+    }
+}