GIT: Resolved conflicts arising from merge with develop branch

applications/test/fvc2D/Make/files

@@ -0,0 +1,3 @@
+Test-fvc2D.C
+
+EXE = $(FOAM_USER_APPBIN)/Test-fvc2D

applications/test/fvc2D/Make/options

@@ -0,0 +1,7 @@
+EXE_INC = \
+    -I$(LIB_SRC)/finiteVolume/lnInclude \
+    -I$(LIB_SRC)/meshTools/lnInclude
+
+EXE_LIBS = \
+    -lfiniteVolume \
+    -lmeshTools

applications/test/fvc2D/Test-fvc2D.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2016 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -21,27 +21,52 @@ License
     You should have received a copy of the GNU General Public License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
-InApplication
+Application
-    foamToEnsight
+    test
 
 Description
+    Finite volume method test code for 2-D space.
 
 \*---------------------------------------------------------------------------*/
 
-#include "word.H"
+#include "fvCFD.H"
-#include "label.H"
+#include "vector2D.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
 namespace Foam
 {
+    typedef GeometricField<vector2D, fvPatchField, volMesh> volVector2DField;
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+    defineTemplate2TypeNameAndDebug(volVector2DField::Internal, 0);
+    defineTemplateTypeNameAndDebug(volVector2DField, 0);
 
-word itoa(const label n);
+    typedef fvPatchField<vector2D> fvPatchVector2DField;
+    makeFvPatchField(fvPatchVector2DField)
+}
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-} // End namespace Foam
+int main(int argc, char *argv[])
+{
+    #include "setRootCase.H"
+
+    #include "createTime.H"
+    #include "createMesh.H"
+
+    GeometricField<vector2D, fvPatchField, volMesh> fld
+    (
+        IOobject
+        (
+            "U",
+            runTime.timeName(),
+            mesh,
+            IOobject::MUST_READ,
+            IOobject::AUTO_WRITE
+        ),
+        mesh
+    );
+
+    Info<< "end" << endl;
+}
+
 
 // ************************************************************************* //

applications/utilities/postProcessing/dataConversion/foamToEnsight/Make/files

@@ -1,6 +1,5 @@
-itoa.C
 ensightMesh.C
-ensightParticlePositions.C
+ensightCloud.C
 foamToEnsight.C
 
 EXE = $(FOAM_APPBIN)/foamToEnsight

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

@@ -4,11 +4,13 @@ EXE_INC = \
     -I$(LIB_SRC)/dynamicMesh/lnInclude \
     -I$(LIB_SRC)/fileFormats/lnInclude \
     -I$(LIB_SRC)/sampling/lnInclude \
-    -I$(LIB_SRC)/lagrangian/basic/lnInclude
+    -I$(LIB_SRC)/lagrangian/basic/lnInclude \
+    -I$(LIB_SRC)/conversion/lnInclude
 
 EXE_LIBS = \
     -ldynamicMesh \
     -lfileFormats \
     -lsampling \
     -lgenericPatchFields \
-    -llagrangian
+    -llagrangian \
+    -lconversion

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

@@ -1,21 +1,33 @@
-// ignore special fields or fields that we don't handle
+// ignore special fields (_0 fields),
-//
+// ignore fields we don't handle,
-bool variableGood = true;
+// ignore fields that are not available for all time-steps
-for (label n1=0; n1<Times.size() && variableGood; ++n1)
+
+// hash by field-name in fieldsToUse
+if (!fieldsToUse.found(fieldName))
 {
-    // ignore _0 fields
+    bool variableGood = false;
-    if (fieldName.size() > 2 && fieldName(fieldName.size() - 2, 2) == "_0")
+
+    forAll(timeDirs, n1)
     {
-        variableGood = false;
+        variableGood =
-    }
-    else
-    {
-        variableGood = IOobject
         (
-            fieldName,
+            fieldName.size() > 2 && fieldName(fieldName.size()-2, 2) == "_0"
-            Times[n1].name(),
+          ? false
-            mesh,
+          : IOobject
-            IOobject::NO_READ
+            (
-        ).typeHeaderOk<volScalarField>(false);
+                fieldName,
+                timeDirs[n1].name(),
+                mesh,
+                IOobject::NO_READ
+            ).typeHeaderOk<volScalarField>(false)
+        );
+
+        if (variableGood)
+        {
+            break;
+        }
     }
+
+    reduce(variableGood, andOp<bool>());
+    fieldsToUse.set(fieldName, variableGood);
 }

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

@@ -1,27 +1,50 @@
 // check for "points" in any of the result directories
 
 bool meshMoving = false;
-if (Times.size() > 1)
+
+if (timeDirs.size() > 1 && Pstream::master())
 {
-    // We already loaded a mesh (usually from constant). See if any other
+    // We already loaded a mesh (usually from constant).
-    // points files
+    // See if any other "polyMesh/points" files exist too.
-    forAll(Times, timeI)
+
+    const fileName& baseDir = mesh.time().path();
+
+    Info<< "Search for moving mesh ... " << flush;
+    forAll(timeDirs, timeI)
     {
-        if (Times[timeI].name() != mesh.pointsInstance())
+        const word& timeName = timeDirs[timeI].name();
-        {
+
-            IOobject io
+        meshMoving =
+        (
+            timeName != mesh.pointsInstance()
+         && isDir(baseDir/timeName/polyMesh::meshSubDir)
+         && IOobject
             (
                 "points",
-                Times[timeI].name(),
+                timeName,
                 polyMesh::meshSubDir,
                 mesh,
-                IOobject::NO_READ
+                IOobject::NO_READ,
-            );
+                IOobject::NO_WRITE,
-            if (io.typeHeaderOk<pointIOField>(true))
+                false  // no register
-            {
+            ).typeHeaderOk<pointIOField>(true)
-                meshMoving = true;
+        );
-                break;
+
-            }
+        if (meshMoving)
+        {
+            break;
         }
     }
+
+    if (meshMoving)
+    {
+        Info<< "found." << nl
+            << "    Writing meshes for every timestep." << endl;
+    }
+    else
+    {
+        Info<< "none detected." << endl;
+    }
 }
+
+reduce(meshMoving, orOp<bool>());

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

@@ -3,7 +3,7 @@
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
     \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
-     \\/     M anipulation  |
+     \\/     M anipulation  | Copyright (C) 2016 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -52,17 +52,17 @@ class ensightAsciiStream
 {
     // Private data
 
-        //- Description of data_
+        //- Output file stream
         OFstream str_;
 
 
     // Private Member Functions
 
         //- Disallow default bitwise copy construct
-        ensightAsciiStream(const ensightAsciiStream&);
+        ensightAsciiStream(const ensightAsciiStream&) = delete;
 
         //- Disallow default bitwise assignment
-        void operator=(const ensightAsciiStream&);
+        void operator=(const ensightAsciiStream&) = delete;
 
 
 public:
@@ -70,14 +70,14 @@ public:
     // Constructors
 
         //- Construct from components
-        ensightAsciiStream(const fileName& f, const Time& runTime)
+        ensightAsciiStream(const fileName& f)
         :
             ensightStream(f),
             str_
             (
                 f,
-                runTime.writeFormat(),
+                IOstream::ASCII,
-                runTime.writeVersion(),
+                IOstream::currentVersion,
                 IOstream::UNCOMPRESSED
             )
         {
@@ -139,14 +139,6 @@ public:
                 << setw(10) << partI << nl;
         }
 
-    // Member Operators
-
-    // Friend Functions
-
-    // Friend Operators
-
-    // IOstream Operators
-
 };
 
 

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

@@ -51,17 +51,17 @@ class ensightBinaryStream
 {
     // Private data
 
-        //- Description of data_
+        //- Output file stream
         autoPtr<std::ofstream> str_;
 
 
     // Private Member Functions
 
         //- Disallow default bitwise copy construct
-        ensightBinaryStream(const ensightBinaryStream&);
+        ensightBinaryStream(const ensightBinaryStream&) = delete;
 
         //- Disallow default bitwise assignment
-        void operator=(const ensightBinaryStream&);
+        void operator=(const ensightBinaryStream&) = delete;
 
 
 public:
@@ -69,7 +69,7 @@ public:
     // Constructors
 
         //- Construct from components
-        ensightBinaryStream(const fileName& f, const Time&)
+        ensightBinaryStream(const fileName& f)
         :
             ensightStream(f),
             str_
@@ -90,11 +90,6 @@ public:
 
     // Member Functions
 
-        virtual bool ascii() const
-        {
-            return false;
-        }
-
         virtual void write(const char* val)
         {
             char buffer[80];
@@ -141,14 +136,6 @@ public:
             write(partI);
         }
 
-    // Member Operators
-
-    // Friend Functions
-
-    // Friend Operators
-
-    // IOstream Operators
-
 };
 
 

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

@@ -1,5 +1,8 @@
 if (Pstream::master())
 {
+    ensightCaseFile.setf(ios_base::scientific, ios_base::floatfield);
+    ensightCaseFile.precision(5);
+
     ensightCaseFile << nl << "TIME" << nl
         << "time set:                      " << 1 << nl
         << "number of steps:               " << nTimeSteps << nl
@@ -8,20 +11,17 @@ if (Pstream::master())
 
     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)
+    if (timeDirs[0].value() < 0)
     {
-        Tcorr = - Times[0].value();
+        Tcorr = -timeDirs[0].value();
         Info<< "Correcting time values. Adding " << Tcorr << endl;
     }
 
-    forAll(Times, n)
+    forAll(timeDirs, n)
     {
-        ensightCaseFile << setw(12) << Times[n].value() + Tcorr << " ";
+        ensightCaseFile << setw(12) << timeDirs[n].value() + Tcorr << " ";
 
         if (++count % 6 == 0)
         {

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

@@ -0,0 +1,180 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+     \\/     M anipulation  | Copyright (C) 2016 OpenCFD Ltd.
+-------------------------------------------------------------------------------
+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 3 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, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "ensightCloud.H"
+#include "ensightFile.H"
+#include "fvMesh.H"
+#include "passiveParticle.H"
+#include "Cloud.H"
+#include "pointList.H"
+
+// * * * * * * * * * * * * * * * Global Functions  * * * * * * * * * * * * * //
+
+void Foam::ensightParticlePositions
+(
+    const fvMesh& mesh,
+    const fileName& dataDir,
+    const label timeIndex,
+    const word& cloudName,
+    const bool dataExists,
+    IOstream::streamFormat format
+)
+{
+    if (dataExists)
+    {
+        Info<< " positions";
+    }
+    else
+    {
+        Info<< " positions{0}";
+    }
+
+    // Total number of parcels on all processes
+    label nTotParcels = 0;
+    autoPtr<Cloud<passiveParticle>> cloudPtr;
+
+    if (dataExists)
+    {
+        cloudPtr.reset(new Cloud<passiveParticle>(mesh, cloudName, false));
+        nTotParcels = cloudPtr().size();
+    }
+    reduce(nTotParcels, sumOp<label>());
+
+    if (Pstream::master())
+    {
+        const fileName postFileName =
+            ensightFile::subDir(timeIndex)/cloud::prefix/cloudName/"positions";
+
+        // the ITER/lagrangian subdirectory must exist
+        mkDir(dataDir/postFileName.path());
+
+        ensightFile os(dataDir, postFileName, format);
+
+        // tag binary format (just like geometry files)
+        os.writeBinaryHeader();
+        os.write(postFileName); // description
+        os.newline();
+        os.write("particle coordinates");
+        os.newline();
+        os.write(nTotParcels, 8);   // unusual width
+        os.newline();
+
+        if (!nTotParcels)
+        {
+            return;  // DONE
+        }
+
+        if (format == IOstream::BINARY)
+        {
+            // binary write is Ensight6 - first ids, then positions
+
+            // 1-index
+            for (label parcelId = 0; parcelId < nTotParcels; ++parcelId)
+            {
+                os.write(parcelId+1);
+            }
+
+            // Master
+            forAllConstIter(Cloud<passiveParticle>, cloudPtr(), elmnt)
+            {
+                const point& p = elmnt().position();
+
+                os.write(p.x());
+                os.write(p.y());
+                os.write(p.z());
+            }
+
+            // Slaves
+            for (int slave=1; slave<Pstream::nProcs(); ++slave)
+            {
+                IPstream fromSlave(Pstream::scheduled, slave);
+                pointList points(fromSlave);
+
+                forAll(points, pti)
+                {
+                    const point& p = points[pti];
+
+                    os.write(p.x());
+                    os.write(p.y());
+                    os.write(p.z());
+                }
+            }
+        }
+        else
+        {
+            // ASCII id + position together
+
+            label parcelId = 0;
+            forAllConstIter(Cloud<passiveParticle>, cloudPtr(), elmnt)
+            {
+                const point& p = elmnt().position();
+
+                os.write(++parcelId, 8);    // unusual width
+                os.write(p.x());
+                os.write(p.y());
+                os.write(p.z());
+                os.newline();
+            }
+
+            // Slaves
+            for (int slave=1; slave<Pstream::nProcs(); ++slave)
+            {
+                IPstream fromSlave(Pstream::scheduled, slave);
+                pointList points(fromSlave);
+
+                forAll(points, pti)
+                {
+                    const point& p = points[pti];
+
+                    os.write(++parcelId, 8);    // unusual width
+                    os.write(p.x());
+                    os.write(p.y());
+                    os.write(p.z());
+                    os.newline();
+                }
+            }
+        }
+    }
+    else if (nTotParcels)
+    {
+        // SLAVE, and data exist
+        pointList points(cloudPtr().size());
+
+        label pti = 0;
+        forAllConstIter(Cloud<passiveParticle>, cloudPtr(), elmnt)
+        {
+            const point& p = elmnt().position();
+            points[pti++] = p;
+        }
+
+        {
+            OPstream toMaster(Pstream::scheduled, Pstream::masterNo());
+            toMaster<< points;
+        }
+    }
+
+}
+
+// ************************************************************************* //

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

@@ -3,7 +3,7 @@
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
     \\  /    A nd           | Copyright (C) 2011-2015 OpenFOAM Foundation
-     \\/     M anipulation  |
+     \\/     M anipulation  | Copyright (C) 2016 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -27,35 +27,62 @@ InApplication
 Description
 
 SourceFiles
-    ensightCloudField.C
+    ensightCloud.C
+    ensightCloudTemplates.C
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef ensightCloudField_H
+#ifndef ensightCloud_H
-#define ensightCloudField_H
+#define ensightCloud_H
 
+#include "ensightFile.H"
+#include "fvMesh.H"
 #include "Cloud.H"
 #include "IOobject.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
+namespace Foam
+{
+
+void ensightParticlePositions
+(
+    const fvMesh& mesh,
+    const fileName& dataDir,
+    const label timeIndex,
+    const word& cloudName,
+    const bool dataExists,
+    const IOstream::streamFormat format
+);
+
+
 template<class Type>
 void ensightCloudField
 (
     const IOobject& fieldObject,
-    const fileName& postProcPath,
+    const fileName& dataDir,
-    const word& prepend,
     const label timeIndex,
-    const word& timeFile,
     const word& cloudName,
+    const label cloudNo,
     Ostream& ensightCaseFile,
-    const bool dataExists
+    const bool dataExists,
+    const IOstream::streamFormat format
 );
 
+
+template<class Type>
+void writeCloudField
+(
+    const IOField<Type>& field,
+    ensightFile& os
+);
+
+}
+
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 #ifdef NoRepository
-    #include "ensightCloudField.C"
+    #include "ensightCloudTemplates.C"
 #endif
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

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

@@ -1,129 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
-     \\/     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 3 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, see <http://www.gnu.org/licenses/>.
-
-\*---------------------------------------------------------------------------*/
-
-#include "ensightCloudField.H"
-#include "Time.H"
-#include "IOField.H"
-#include "OFstream.H"
-#include "IOmanip.H"
-#include "ensightPTraits.H"
-
-using namespace Foam;
-
-// * * * * * * * * * * * * * * * Global Functions  * * * * * * * * * * * * * //
-
-template<class Type>
-void ensightCloudField
-(
-    const IOobject& fieldObject,
-    const fileName& postProcPath,
-    const word& prepend,
-    const label timeIndex,
-    const word& cloudName,
-    Ostream& ensightCaseFile,
-    const bool dataExists
-)
-{
-    if (dataExists)
-    {
-        Info<< "Converting cloud " << cloudName
-            << " field " << fieldObject.name() << endl;
-    }
-    else
-    {
-        Info<< "Creating empty cloud " << cloudName
-            << " field "  << fieldObject.name() << endl;
-    }
-
-    word timeFile = prepend + itoa(timeIndex);
-
-    const Time& runTime = fieldObject.time();
-
-    if (timeIndex == 0 && Pstream::master())
-    {
-        ensightCaseFile
-            << pTraits<Type>::typeName << " per measured node:      1       ";
-        ensightCaseFile.width(15);
-        ensightCaseFile.setf(ios_base::left);
-        ensightCaseFile
-            << ("c" + fieldObject.name()).c_str()
-            << (' ' + prepend + "****." + cloudName
-              + "." + fieldObject.name()).c_str()
-            << nl;
-    }
-
-    fileName ensightFileName
-    (
-        timeFile + "." + cloudName +"." + fieldObject.name()
-    );
-
-    OFstream ensightFile
-    (
-        postProcPath/ensightFileName,
-        runTime.writeFormat(),
-        runTime.writeVersion(),
-        runTime.writeCompression()
-    );
-
-    ensightFile<< pTraits<Type>::typeName << " values" << nl;
-
-    if (dataExists)
-    {
-        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 = Zero;
-            }
-
-            for (direction i=0; i < pTraits<Type>::nComponents; ++i)
-            {
-                label cmpt = ensightPTraits<Type>::componentOrder[i];
-
-                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/ensightCloudTemplates.C

@@ -0,0 +1,192 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
+     \\/     M anipulation  | Copyright (C) 2016 OpenCFD Ltd.
+-------------------------------------------------------------------------------
+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 3 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, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "ensightCloud.H"
+#include "ensightFile.H"
+#include "Time.H"
+#include "IOField.H"
+#include "OFstream.H"
+#include "IOmanip.H"
+#include "ensightPTraits.H"
+
+// * * * * * * * * * * * * * * * Global Functions  * * * * * * * * * * * * * //
+
+template<class Type>
+void Foam::writeCloudField
+(
+    const Foam::IOField<Type>& field,
+    Foam::ensightFile& os
+)
+{
+    if (returnReduce(field.size(), sumOp<label>()) > 0)
+    {
+        if (Pstream::master())
+        {
+            // 6 values per line
+            label count = 0;
+
+            // Master
+            forAll(field, i)
+            {
+                Type val = field[i];
+
+                if (mag(val) < 1e-90)
+                {
+                    val = Zero;
+                }
+
+                for (direction d=0; d < pTraits<Type>::nComponents; ++d)
+                {
+                    label cmpt = ensightPTraits<Type>::componentOrder[d];
+                    os.write(component(val, cmpt));
+
+                    if (++count % 6 == 0)
+                    {
+                        os.newline();
+                    }
+                }
+            }
+
+            // Slaves
+            for (int slave=1; slave<Pstream::nProcs(); ++slave)
+            {
+                IPstream fromSlave(Pstream::scheduled, slave);
+                Field<Type> slaveData(fromSlave);
+
+                forAll(slaveData, i)
+                {
+                    Type val = slaveData[i];
+
+                    if (mag(val) < 1e-90)
+                    {
+                        val = Zero;
+                    }
+
+                    for (direction d=0; d < pTraits<Type>::nComponents; ++d)
+                    {
+                        label cmpt = ensightPTraits<Type>::componentOrder[d];
+                        os.write(component(val, cmpt));
+
+                        if (++count % 6 == 0)
+                        {
+                            os.newline();
+                        }
+                    }
+                }
+            }
+
+            // add final newline if required
+            if (count % 6)
+            {
+                os.newline();
+            }
+        }
+        else
+        {
+            OPstream toMaster(Pstream::scheduled, Pstream::masterNo());
+            toMaster<< field;
+        }
+    }
+}
+
+
+template<class Type>
+void Foam::ensightCloudField
+(
+    const Foam::IOobject& fieldObject,
+    const Foam::fileName& dataDir,
+    const Foam::label timeIndex,
+    const Foam::word& cloudName,
+    const Foam::label cloudNo,
+    Foam::Ostream& ensightCaseFile,
+    const bool dataExists,
+    Foam::IOstream::streamFormat format
+)
+{
+    const ensight::VarName varName(fieldObject.name());
+
+    if (dataExists)
+    {
+        Info<< ' ' << fieldObject.name();
+    }
+    else
+    {
+        Info<< ' ' << fieldObject.name() << "{0}"; // ie, empty field
+    }
+
+    ensightFile* filePtr(nullptr);
+    if (Pstream::master())
+    {
+        const fileName postFileName =
+            ensightFile::subDir(timeIndex)/cloud::prefix/cloudName/varName;
+
+        // the ITER/lagrangian subdirectory must exist
+        // the ITER/lagrangian subdirectory was already created
+        // when writing positions
+
+        mkDir(dataDir/postFileName.path());
+
+        if (timeIndex == 0)
+        {
+            const fileName dirName =
+                dataDir.name()/ensightFile::mask()/cloud::prefix/cloudName;
+
+            ensightCaseFile.setf(ios_base::left);
+
+            // prefix variables with 'c' (cloud)
+            ensightCaseFile
+                << ensightPTraits<Type>::typeName << " per "
+                << setw(20)
+                << "measured node:"
+                << " 1  "
+                << setw(15)
+                << ("c" + Foam::name(cloudNo) + varName).c_str() << ' '
+                << (dirName/varName).c_str()
+                << nl;
+        }
+
+        filePtr = new ensightFile(dataDir, postFileName, format);
+        // description
+        filePtr->write
+        (
+            string(postFileName + " <" + pTraits<Type>::typeName + ">")
+        );
+        filePtr->newline();
+    }
+
+    if (dataExists)
+    {
+        IOField<Type> field(fieldObject);
+        writeCloudField(field, *filePtr);
+    }
+
+    if (filePtr) // on master only
+    {
+        delete filePtr;
+    }
+}
+
+
+// ************************************************************************* //

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

@@ -23,12 +23,12 @@ License
 
 \*---------------------------------------------------------------------------*/
 
+#include "ensightFile.H"
 #include "ensightField.H"
 #include "fvMesh.H"
 #include "volFields.H"
 #include "OFstream.H"
 #include "IOmanip.H"
-#include "itoa.H"
 #include "volPointInterpolation.H"
 #include "ensightBinaryStream.H"
 #include "ensightAsciiStream.H"
@@ -76,7 +76,9 @@ volField
     // Construct volField (with zeroGradient) from dimensioned field
 
     IOobject io(df);
-    io.readOpt() = IOobject::NO_READ;
+    io.readOpt()  = IOobject::NO_READ;
+    io.writeOpt() = IOobject::NO_WRITE;
+    io.registerObject() = false;
 
     tmp<GeometricField<Type, fvPatchField, volMesh>> tvf
     (
@@ -84,16 +86,17 @@ volField
         (
             io,
             df.mesh(),
-            df.dimensions(),
+            dimensioned<Type>("0", df.dimensions(), Zero),
-            zeroGradientFvPatchField<scalar>::typeName
+            zeroGradientFvPatchField<Type>::typeName
         )
     );
     tvf.ref().primitiveFieldRef() = df;
     tvf.ref().correctBoundaryConditions();
-    const GeometricField<Type, fvPatchField, volMesh>& vf = tvf();
 
     if (meshSubsetter.hasSubMesh())
     {
+        const GeometricField<Type, fvPatchField, volMesh>& vf = tvf();
+
         tmp<GeometricField<Type, fvPatchField, volMesh>> tfld
         (
             meshSubsetter.interpolate(vf)
@@ -116,10 +119,8 @@ volField
 //    const IOobject& io,
 //    const fvMesh& mesh,
 //    const ensightMesh& eMesh,
-//    const fileName& postProcPath,
+//    const fileName& dataDir,
-//    const word& prepend,
 //    const label timeIndex,
-//    const bool binary,
 //    const bool nodeValues,
 //    Ostream& ensightCaseFile
 //)
@@ -129,10 +130,8 @@ volField
 //    (
 //        volField<typename Container::value_type>(meshSubsetter, fld),
 //        eMesh,
-//        postProcPath,
+//        dataDir,
-//        prepend,
 //        timeIndex,
-//        binary,
 //        nodeValues,
 //        ensightCaseFile
 //    );
@@ -170,26 +169,26 @@ void writeField
 (
     const char* key,
     const Field<Type>& vf,
-    ensightStream& ensightFile
+    ensightStream& os
 )
 {
     if (returnReduce(vf.size(), sumOp<label>()) > 0)
     {
         if (Pstream::master())
         {
-            ensightFile.write(key);
+            os.write(key);
 
             for (direction i=0; i < pTraits<Type>::nComponents; ++i)
             {
                 label cmpt = ensightPTraits<Type>::componentOrder[i];
 
-                ensightFile.write(vf.component(cmpt));
+                os.write(vf.component(cmpt));
 
                 for (int slave=1; slave<Pstream::nProcs(); slave++)
                 {
                     IPstream fromSlave(Pstream::scheduled, slave);
                     scalarField slaveData(fromSlave);
-                    ensightFile.write(slaveData);
+                    os.write(slaveData);
                 }
             }
         }
@@ -215,35 +214,35 @@ bool writePatchField
     const label ensightPatchi,
     const faceSets& boundaryFaceSet,
     const ensightMesh::nFacePrimitives& nfp,
-    ensightStream& ensightFile
+    ensightStream& os
 )
 {
     if (nfp.nTris || nfp.nQuads || nfp.nPolys)
     {
         if (Pstream::master())
         {
-            ensightFile.writePartHeader(ensightPatchi);
+            os.writePartHeader(ensightPatchi);
         }
 
         writeField
         (
             "tria3",
             Field<Type>(pf, boundaryFaceSet.tris),
-            ensightFile
+            os
         );
 
         writeField
         (
             "quad4",
             Field<Type>(pf, boundaryFaceSet.quads),
-            ensightFile
+            os
         );
 
         writeField
         (
             "nsided",
             Field<Type>(pf, boundaryFaceSet.polys),
-            ensightFile
+            os
         );
 
         return true;
@@ -262,15 +261,11 @@ void writePatchField
     const Field<Type>& pf,
     const word& patchName,
     const ensightMesh& eMesh,
-    const fileName& postProcPath,
+    const fileName& dataDir,
-    const word& prepend,
     const label timeIndex,
-    const bool binary,
     Ostream& ensightCaseFile
 )
 {
-    const Time& runTime = eMesh.mesh().time();
-
     const List<faceSets>& boundaryFaceSets = eMesh.boundaryFaceSets();
     const wordList& allPatchNames = eMesh.allPatchNames();
     const HashTable<ensightMesh::nFacePrimitives>&
@@ -290,53 +285,51 @@ void writePatchField
         ensightPatchi++;
     }
 
-
+    ensightStream* filePtr(nullptr);
-    word pfName = patchName + '.' + fieldName;
-
-    word timeFile = prepend + itoa(timeIndex);
-
-    ensightStream* ensightFilePtr = nullptr;
     if (Pstream::master())
     {
+        // TODO: verify that these are indeed valid ensight variable names
+        const word varName = patchName + '.' + fieldName;
+        const fileName postFileName = ensightFile::subDir(timeIndex)/varName;
+
+        // the data/ITER subdirectory must exist
+        mkDir(dataDir/postFileName.path());
+
         if (timeIndex == 0)
         {
-            ensightCaseFile.setf(ios_base::left);
+            const fileName dirName = dataDir.name()/ensightFile::mask();
 
+            ensightCaseFile.setf(ios_base::left);
             ensightCaseFile
-                << ensightPTraits<Type>::typeName
+                << ensightPTraits<Type>::typeName << " per "
-                << " per element:            1       "
+                << setw(20)
-                << setw(15) << pfName
+                << "element:"
-                << (' ' + prepend + "****." + pfName).c_str()
+                << " 1  "
+                << setw(15)
+                << varName.c_str() << ' '
+                << (dirName/varName).c_str()
                 << nl;
         }
 
-        // set the filename of the ensight file
+        if (eMesh.format() == IOstream::BINARY)
-        fileName ensightFileName(timeFile + "." + pfName);
-
-        if (binary)
         {
-            ensightFilePtr = new ensightBinaryStream
+            filePtr = new ensightBinaryStream
             (
-                postProcPath/ensightFileName,
+                dataDir/postFileName
-                runTime
             );
         }
         else
         {
-            ensightFilePtr = new ensightAsciiStream
+            filePtr = new ensightAsciiStream
             (
-                postProcPath/ensightFileName,
+                dataDir/postFileName
-                runTime
             );
         }
+
+        filePtr->write(ensightPTraits<Type>::typeName);
     }
 
-    ensightStream& ensightFile = *ensightFilePtr;
+    ensightStream& os = *filePtr;
-
-    if (Pstream::master())
-    {
-        ensightFile.write(ensightPTraits<Type>::typeName);
-    }
 
     if (patchi >= 0)
     {
@@ -347,7 +340,7 @@ void writePatchField
             ensightPatchi,
             boundaryFaceSets[patchi],
             nPatchPrims.find(patchName)(),
-            ensightFile
+            os
         );
     }
     else
@@ -361,13 +354,13 @@ void writePatchField
             ensightPatchi,
             nullFaceSets,
             nPatchPrims.find(patchName)(),
-            ensightFile
+            os
         );
     }
 
-    if (Pstream::master())
+    if (filePtr) // on master only
     {
-        delete ensightFilePtr;
+        delete filePtr;
     }
 }
 
@@ -377,19 +370,14 @@ void ensightField
 (
     const GeometricField<Type, fvPatchField, volMesh>& vf,
     const ensightMesh& eMesh,
-    const fileName& postProcPath,
+    const fileName& dataDir,
-    const word& prepend,
     const label timeIndex,
-    const bool binary,
     Ostream& ensightCaseFile
 )
 {
-    Info<< "Converting field " << vf.name() << endl;
+    Info<< ' ' << vf.name();
-
-    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();
@@ -409,48 +397,48 @@ void ensightField
     const labelList& hexes = meshCellSets.hexes;
     const labelList& polys = meshCellSets.polys;
 
-    ensightStream* ensightFilePtr = nullptr;
+    ensightStream* filePtr(nullptr);
     if (Pstream::master())
     {
-        // set the filename of the ensight file
+        const ensight::VarName varName(vf.name());
-        fileName ensightFileName(timeFile + "." + vf.name());
+        const fileName postFileName = ensightFile::subDir(timeIndex)/varName;
 
-        if (binary)
+        // the data/ITER subdirectory must exist
+        mkDir(dataDir/postFileName.path());
+
+        if (timeIndex == 0)
         {
-            ensightFilePtr = new ensightBinaryStream
+            const fileName dirName = dataDir.name()/ensightFile::mask();
+
+            ensightCaseFile.setf(ios_base::left);
+            ensightCaseFile
+                << ensightPTraits<Type>::typeName
+                << " per element:     1  "
+                << setw(15)
+                << varName.c_str() << ' '
+                << (dirName/varName).c_str()
+                << nl;
+        }
+
+        if (eMesh.format() == IOstream::BINARY)
+        {
+            filePtr = new ensightBinaryStream
             (
-                postProcPath/ensightFileName,
+                dataDir/postFileName
-                runTime
             );
         }
         else
         {
-            ensightFilePtr = new ensightAsciiStream
+            filePtr = new ensightAsciiStream
             (
-                postProcPath/ensightFileName,
+                dataDir/postFileName
-                runTime
             );
         }
+
+        filePtr->write(ensightPTraits<Type>::typeName);
     }
 
-    ensightStream& ensightFile = *ensightFilePtr;
+    ensightStream& os = *filePtr;
-
-    if (Pstream::master())
-    {
-        if (timeIndex == 0)
-        {
-            ensightCaseFile.setf(ios_base::left);
-
-            ensightCaseFile
-                << ensightPTraits<Type>::typeName
-                << " per element:            1       "
-                << setw(15) << vf.name()
-                << (' ' + prepend + "****." + vf.name()).c_str()
-                << nl;
-        }
-
-        ensightFile.write(ensightPTraits<Type>::typeName);
-    }
 
     if (patchNames.empty())
     {
@@ -458,42 +446,42 @@ void ensightField
 
         if (Pstream::master())
         {
-            ensightFile.writePartHeader(1);
+            os.writePartHeader(1);
         }
 
         writeField
         (
             "hexa8",
             map(vf, hexes, wedges),
-            ensightFile
+            os
         );
 
         writeField
         (
             "penta6",
             Field<Type>(vf, prisms),
-            ensightFile
+            os
         );
 
         writeField
         (
             "pyramid5",
             Field<Type>(vf, pyrs),
-            ensightFile
+            os
         );
 
         writeField
         (
             "tetra4",
             Field<Type>(vf, tets),
-            ensightFile
+            os
         );
 
         writeField
         (
             "nfaced",
             Field<Type>(vf, polys),
-            ensightFile
+            os
         );
     }
 
@@ -516,7 +504,7 @@ void ensightField
                     ensightPatchi,
                     boundaryFaceSets[patchi],
                     nPatchPrims.find(patchName)(),
-                    ensightFile
+                    os
                 )
             )
             {
@@ -541,8 +529,7 @@ void ensightField
 
             eMesh.barrier();
 
-            label zoneID = mesh.faceZones().findZoneID(faceZoneName);
+            const label zoneID = mesh.faceZones().findZoneID(faceZoneName);
-
             const faceZone& fz = mesh.faceZones()[zoneID];
 
             // Prepare data to write
@@ -590,7 +577,7 @@ void ensightField
                     ensightPatchi,
                     faceZoneFaceSets[zoneID],
                     nFaceZonePrims.find(faceZoneName)(),
-                    ensightFile
+                    os
                 )
             )
             {
@@ -598,9 +585,10 @@ void ensightField
             }
         }
     }
-    if (Pstream::master())
+
+    if (filePtr) // on master only
     {
-        delete ensightFilePtr;
+        delete filePtr;
     }
 }
 
@@ -610,65 +598,63 @@ void ensightPointField
 (
     const GeometricField<Type, pointPatchField, pointMesh>& pf,
     const ensightMesh& eMesh,
-    const fileName& postProcPath,
+    const fileName& dataDir,
-    const word& prepend,
     const label timeIndex,
-    const bool binary,
     Ostream& ensightCaseFile
 )
 {
-    Info<< "Converting field " << pf.name() << endl;
+    Info<< ' ' << pf.name();
-
-    word timeFile = prepend + itoa(timeIndex);
 
     const fvMesh& mesh = eMesh.mesh();
     const wordList& allPatchNames = eMesh.allPatchNames();
     const wordHashSet& patchNames = eMesh.patchNames();
     const wordHashSet& faceZoneNames = eMesh.faceZoneNames();
 
-
+    ensightStream* filePtr(nullptr);
-    ensightStream* ensightFilePtr = nullptr;
     if (Pstream::master())
     {
-        // set the filename of the ensight file
+        const ensight::VarName varName(pf.name());
-        fileName ensightFileName(timeFile + "." + pf.name());
+        const fileName postFileName = ensightFile::subDir(timeIndex)/varName;
 
-        if (binary)
+        // the data/ITER subdirectory must exist
+        mkDir(dataDir/postFileName.path());
+
+        if (timeIndex == 0)
         {
-            ensightFilePtr = new ensightBinaryStream
+            const fileName dirName = dataDir.name()/ensightFile::mask();
+
+            ensightCaseFile.setf(ios_base::left);
+            ensightCaseFile
+                << ensightPTraits<Type>::typeName
+                << " per "
+                << setw(20)
+                << " node:"
+                << " 1  "
+                << setw(15)
+                << varName.c_str() << ' '
+                << (dirName/varName).c_str()
+                << nl;
+        }
+
+        if (eMesh.format() == IOstream::BINARY)
+        {
+            filePtr = new ensightBinaryStream
             (
-                postProcPath/ensightFileName,
+                dataDir/postFileName
-                mesh.time()
             );
         }
         else
         {
-            ensightFilePtr = new ensightAsciiStream
+            filePtr = new ensightAsciiStream
             (
-                postProcPath/ensightFileName,
+                dataDir/postFileName
-                mesh.time()
             );
         }
+
+        filePtr->write(ensightPTraits<Type>::typeName);
     }
 
-    ensightStream& ensightFile = *ensightFilePtr;
+    ensightStream& os = *filePtr;
-
-    if (Pstream::master())
-    {
-        if (timeIndex == 0)
-        {
-            ensightCaseFile.setf(ios_base::left);
-
-            ensightCaseFile
-                << ensightPTraits<Type>::typeName
-                << " per node:            1       "
-                << setw(15) << pf.name()
-                << (' ' + prepend + "****." + pf.name()).c_str()
-                << nl;
-        }
-
-        ensightFile.write(ensightPTraits<Type>::typeName);
-    }
 
     if (eMesh.patchNames().empty())
     {
@@ -676,14 +662,14 @@ void ensightPointField
 
         if (Pstream::master())
         {
-            ensightFile.writePartHeader(1);
+            os.writePartHeader(1);
         }
 
         writeField
         (
             "coordinates",
             Field<Type>(pf.primitiveField(), eMesh.uniquePointMap()),
-            ensightFile
+            os
         );
     }
 
@@ -699,11 +685,8 @@ void ensightPointField
         if (patchNames.empty() || patchNames.found(patchName))
         {
             const fvPatch& p = mesh.boundary()[patchi];
-            if
+
-            (
+            if (returnReduce(p.size(), sumOp<label>()) > 0)
-                returnReduce(p.size(), sumOp<label>())
-              > 0
-            )
             {
                 // Renumber the patch points/faces into unique points
                 labelList pointToGlobal;
@@ -719,14 +702,14 @@ void ensightPointField
 
                 if (Pstream::master())
                 {
-                    ensightFile.writePartHeader(ensightPatchi);
+                    os.writePartHeader(ensightPatchi);
                 }
 
                 writeField
                 (
                     "coordinates",
                     Field<Type>(pf.primitiveField(), uniqueMeshPointLabels),
-                    ensightFile
+                    os
                 );
 
                 ensightPatchi++;
@@ -743,8 +726,7 @@ void ensightPointField
 
             eMesh.barrier();
 
-            label zoneID = mesh.faceZones().findZoneID(faceZoneName);
+            const label zoneID = mesh.faceZones().findZoneID(faceZoneName);
-
             const faceZone& fz = mesh.faceZones()[zoneID];
 
             if (returnReduce(fz().nPoints(), sumOp<label>()) > 0)
@@ -753,17 +735,17 @@ void ensightPointField
                 labelList pointToGlobal;
                 labelList uniqueMeshPointLabels;
                 autoPtr<globalIndex> globalPointsPtr =
-                mesh.globalData().mergePoints
+                    mesh.globalData().mergePoints
-                (
+                    (
-                    fz().meshPoints(),
+                        fz().meshPoints(),
-                    fz().meshPointMap(),
+                        fz().meshPointMap(),
-                    pointToGlobal,
+                        pointToGlobal,
-                    uniqueMeshPointLabels
+                        uniqueMeshPointLabels
-                );
+                    );
 
                 if (Pstream::master())
                 {
-                    ensightFile.writePartHeader(ensightPatchi);
+                    os.writePartHeader(ensightPatchi);
                 }
 
                 writeField
@@ -774,7 +756,7 @@ void ensightPointField
                         pf.primitiveField(),
                         uniqueMeshPointLabels
                     ),
-                    ensightFile
+                    os
                 );
 
                 ensightPatchi++;
@@ -782,9 +764,9 @@ void ensightPointField
         }
     }
 
-    if (Pstream::master())
+    if (filePtr) // on master only
     {
-        delete ensightFilePtr;
+        delete filePtr;
     }
 }
 
@@ -794,10 +776,8 @@ void ensightField
 (
     const GeometricField<Type, fvPatchField, volMesh>& vf,
     const ensightMesh& eMesh,
-    const fileName& postProcPath,
+    const fileName& dataDir,
-    const word& prepend,
     const label timeIndex,
-    const bool binary,
     const bool nodeValues,
     Ostream& ensightCaseFile
 )
@@ -814,10 +794,8 @@ void ensightField
         (
             pfld,
             eMesh,
-            postProcPath,
+            dataDir,
-            prepend,
             timeIndex,
-            binary,
             ensightCaseFile
         );
     }
@@ -827,10 +805,8 @@ void ensightField
         (
             vf,
             eMesh,
-            postProcPath,
+            dataDir,
-            prepend,
             timeIndex,
-            binary,
             ensightCaseFile
         );
     }

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

@@ -69,10 +69,8 @@ void ensightField
 (
     const Foam::GeometricField<Type, Foam::fvPatchField, Foam::volMesh>& vf,
     const Foam::ensightMesh& eMesh,
-    const Foam::fileName& postProcPath,
+    const Foam::fileName& dataDir,
-    const Foam::word& prepend,
     const Foam::label timeIndex,
-    const bool binary,
     const bool nodeValues,
     Foam::Ostream& ensightCaseFile
 );
@@ -85,8 +83,7 @@ void writePatchField
     const Foam::Field<Type>& pf,
     const Foam::word& patchName,
     const Foam::ensightMesh& eMesh,
-    const Foam::fileName& postProcPath,
+    const Foam::fileName& dataDir,
-    const Foam::word& prepend,
     const Foam::label timeIndex,
     Foam::Ostream& ensightCaseFile
 );

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

@@ -3,7 +3,7 @@
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
     \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
-     \\/     M anipulation  |
+     \\/     M anipulation  | Copyright (C) 2016 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -32,16 +32,21 @@ License
 #include "processorPolyPatch.H"
 #include "cellModeller.H"
 #include "IOmanip.H"
-#include "itoa.H"
 #include "globalIndex.H"
 #include "mapDistribute.H"
 #include "stringListOps.H"
 
+#include "ensightFile.H"
 #include "ensightBinaryStream.H"
 #include "ensightAsciiStream.H"
 
 #include <fstream>
 
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+const char* Foam::ensightMesh::geometryName = "geometry";
+
+
 // * * * * * * * * * * * * * Private Functions * * * * * * * * * * * * * * //
 
 void Foam::ensightMesh::correct()
@@ -403,7 +408,7 @@ Foam::ensightMesh::ensightMesh
     const bool faceZones,
     const wordReList& faceZonePatterns,
 
-    const bool binary
+    const IOstream::streamFormat format
 )
 :
     mesh_(mesh),
@@ -412,7 +417,7 @@ Foam::ensightMesh::ensightMesh
     patchPatterns_(patchPatterns),
     faceZones_(faceZones),
     faceZonePatterns_(faceZonePatterns),
-    binary_(binary),
+    format_(format),
     meshCellSets_(mesh.nCells())
 {
     correct();
@@ -521,7 +526,7 @@ void Foam::ensightMesh::writePrims
     // Create a temp int array
     if (cellShapes.size())
     {
-        if (ensightGeometryFile.ascii())
+        if (format_ == IOstream::ASCII)
         {
             // Workaround for paraview issue : write one cell per line
 
@@ -1018,63 +1023,56 @@ void Foam::ensightMesh::writeAllPoints
 
 void Foam::ensightMesh::write
 (
-    const fileName& postProcPath,
+    const fileName& dataDir,
-    const word& prepend,
     const label timeIndex,
     const bool meshMoving,
     Ostream& ensightCaseFile
 ) const
 {
-    const Time& runTime = mesh_.time();
     const cellShapeList& cellShapes = mesh_.cellShapes();
 
-
+    ensightStream* filePtr(nullptr);
-    word timeFile = prepend;
-
-    if (timeIndex == 0)
-    {
-        timeFile += "0000.";
-    }
-    else if (meshMoving)
-    {
-        timeFile += itoa(timeIndex) + '.';
-    }
-
-    // set the filename of the ensight file
-    fileName ensightGeometryFileName = timeFile + "mesh";
-
-    ensightStream* ensightGeometryFilePtr = nullptr;
     if (Pstream::master())
     {
-        if (binary_)
+        // set the filename of the ensight file
+        fileName geoFileName = dataDir.path()/ensightMesh::geometryName;
+
+        if (meshMoving)
         {
-            ensightGeometryFilePtr = new ensightBinaryStream
+            geoFileName =
+                dataDir/ensightFile::subDir(timeIndex)
+               /ensightMesh::geometryName;
+
+            mkDir(geoFileName.path());
+        }
+
+        if (format_ == IOstream::BINARY)
+        {
+            filePtr = new ensightBinaryStream
             (
-                postProcPath/ensightGeometryFileName,
+                geoFileName
-                runTime
             );
-            ensightGeometryFilePtr->write("C binary");
+            filePtr->write("C binary");
         }
         else
         {
-            ensightGeometryFilePtr = new ensightAsciiStream
+            filePtr = new ensightAsciiStream
             (
-                postProcPath/ensightGeometryFileName,
+                geoFileName
-                runTime
             );
         }
     }
 
-    ensightStream& ensightGeometryFile = *ensightGeometryFilePtr;
+    ensightStream& os = *filePtr;
 
     if (Pstream::master())
     {
         string desc = string("written by OpenFOAM-") + Foam::FOAMversion;
 
-        ensightGeometryFile.write("EnSight Geometry File");
+        os.write("EnSight Geometry File");
-        ensightGeometryFile.write(desc.c_str());
+        os.write(desc.c_str());
-        ensightGeometryFile.write("node id assign");
+        os.write("node id assign");
-        ensightGeometryFile.write("element id assign");
+        os.write("element id assign");
     }
 
     if (patchNames_.empty())
@@ -1089,7 +1087,7 @@ void Foam::ensightMesh::write
             "internalMesh",
             uniquePoints,
             nPoints,
-            ensightGeometryFile
+            os
         );
 
         writeAllPrims
@@ -1103,7 +1101,7 @@ void Foam::ensightMesh::write
                 meshCellSets_.wedges,
                 pointToGlobal_
             ),
-            ensightGeometryFile
+            os
         );
 
         writeAllPrims
@@ -1111,7 +1109,7 @@ void Foam::ensightMesh::write
             "penta6",
             meshCellSets_.nPrisms,
             map(cellShapes, meshCellSets_.prisms, pointToGlobal_),
-            ensightGeometryFile
+            os
         );
 
         writeAllPrims
@@ -1119,7 +1117,7 @@ void Foam::ensightMesh::write
             "pyramid5",
             meshCellSets_.nPyrs,
             map(cellShapes, meshCellSets_.pyrs, pointToGlobal_),
-            ensightGeometryFile
+            os
         );
 
         writeAllPrims
@@ -1127,13 +1125,13 @@ void Foam::ensightMesh::write
             "tetra4",
             meshCellSets_.nTets,
             map(cellShapes, meshCellSets_.tets, pointToGlobal_),
-            ensightGeometryFile
+            os
         );
 
         writeAllPolys
         (
             pointToGlobal_,
-            ensightGeometryFile
+            os
         );
     }
 
@@ -1182,7 +1180,7 @@ void Foam::ensightMesh::write
                     patchName,
                     uniquePoints,
                     globalPointsPtr().size(),
-                    ensightGeometryFile
+                    os
                 );
 
                 writeAllFacePrims
@@ -1191,7 +1189,7 @@ void Foam::ensightMesh::write
                     tris,
                     nfp.nTris,
                     patchFaces,
-                    ensightGeometryFile
+                    os
                 );
 
                 writeAllFacePrims
@@ -1200,7 +1198,7 @@ void Foam::ensightMesh::write
                     quads,
                     nfp.nQuads,
                     patchFaces,
-                    ensightGeometryFile
+                    os
                 );
 
                 writeAllNSided
@@ -1208,7 +1206,7 @@ void Foam::ensightMesh::write
                     polys,
                     nfp.nPolys,
                     patchFaces,
-                    ensightGeometryFile
+                    os
                 );
             }
         }
@@ -1287,7 +1285,7 @@ void Foam::ensightMesh::write
                 faceZoneName,
                 uniquePoints,
                 globalPointsPtr().size(),
-                ensightGeometryFile
+                os
             );
 
             writeAllFacePrims
@@ -1296,7 +1294,7 @@ void Foam::ensightMesh::write
                 tris,
                 nfp.nTris,
                 faceZoneMasterFaces,
-                ensightGeometryFile
+                os
             );
 
             writeAllFacePrims
@@ -1305,7 +1303,7 @@ void Foam::ensightMesh::write
                 quads,
                 nfp.nQuads,
                 faceZoneMasterFaces,
-                ensightGeometryFile
+                os
             );
 
             writeAllNSided
@@ -1313,14 +1311,14 @@ void Foam::ensightMesh::write
                 polys,
                 nfp.nPolys,
                 faceZoneMasterFaces,
-                ensightGeometryFile
+                os
             );
         }
     }
 
-    if (Pstream::master())
+    if (filePtr) // only on master
     {
-        delete ensightGeometryFilePtr;
+        delete filePtr;
     }
 }
 

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

@@ -3,7 +3,7 @@
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
     \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
-     \\/     M anipulation  |
+     \\/     M anipulation  | Copyright (C) 2016 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -57,12 +57,17 @@ class globalIndex;
 class ensightStream;
 
 /*---------------------------------------------------------------------------*\
-                           Class ensightMesh Declaration
+                         Class ensightMesh Declaration
 \*---------------------------------------------------------------------------*/
 
 class ensightMesh
 {
 public:
+
+    //- The name for geometry files
+    static const char* geometryName;
+
+        //- Helper class for managing face primitives
         class nFacePrimitives
         {
         public:
@@ -97,8 +102,8 @@ private:
         const bool faceZones_;
         const wordReList faceZonePatterns_;
 
-        //- Set binary file output
+        //- Ascii/Binary file output
-        const bool binary_;
+        const IOstream::streamFormat format_;
 
         //- The ensight part id for the first patch
         label patchPartOffset_;
@@ -140,10 +145,10 @@ private:
     // Private Member Functions
 
         //- Disallow default bitwise copy construct
-        ensightMesh(const ensightMesh&);
+        ensightMesh(const ensightMesh&) = delete;
 
         //- Disallow default bitwise assignment
-        void operator=(const ensightMesh&);
+        void operator=(const ensightMesh&) = delete;
 
         void writePoints
         (
@@ -267,7 +272,7 @@ public:
             const wordReList& patchPatterns,
             const bool faceZones,
             const wordReList& faceZonePatterns,
-            const bool binary
+            const IOstream::streamFormat format = IOstream::BINARY
         );
 
 
@@ -284,6 +289,11 @@ public:
                 return mesh_;
             }
 
+            IOstream::streamFormat format() const
+            {
+                return format_;
+            }
+
             const cellSets& meshCellSets() const
             {
                 return meshCellSets_;
@@ -352,8 +362,6 @@ public:
             }
 
 
-
-
     // Other
 
         //- Update for new mesh
@@ -371,13 +379,11 @@ public:
 
         void write
         (
-            const fileName& postProcPath,
+            const fileName& ensightDir,
-            const word& prepend,
             const label timeIndex,
             const bool meshMoving,
             Ostream& ensightCaseFile
         ) const;
-
 };
 
 

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

@@ -1,103 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
-     \\/     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 3 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, see <http://www.gnu.org/licenses/>.
-
-\*---------------------------------------------------------------------------*/
-
-#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 fvMesh& mesh,
-    const fileName& postProcPath,
-    const word& timeFile,
-    const word& cloudName,
-    const bool dataExists
-)
-{
-    if (dataExists)
-    {
-        Info<< "Converting cloud " << cloudName << " positions" <<  endl;
-    }
-    else
-    {
-        Info<< "Creating empty cloud " << cloudName << " positions" << endl;
-    }
-
-    const Time& runTime = mesh.time();
-
-    fileName ensightFileName(timeFile + "." + cloudName);
-    OFstream ensightFile
-    (
-        postProcPath/ensightFileName,
-        runTime.writeFormat(),
-        runTime.writeVersion(),
-        runTime.writeCompression()
-    );
-
-    // Output header
-    ensightFile
-        << cloudName.c_str() << nl
-        << "particle coordinates" << nl;
-
-    if (dataExists)
-    {
-        Cloud<passiveParticle> parcels(mesh, cloudName, false);
-
-        // Set Format
-        ensightFile.setf(ios_base::scientific, ios_base::floatfield);
-        ensightFile.precision(5);
-
-        ensightFile<< setw(8) << parcels.size() << nl;
-
-        label nParcels = 0;
-
-        // Output positions
-        forAllConstIter(Cloud<passiveParticle>, parcels, elmnt)
-        {
-            const vector& p = elmnt().position();
-
-            ensightFile
-                << setw(8) << ++nParcels
-                << setw(12) << p.x() << setw(12) << p.y() << setw(12) << p.z()
-                << nl;
-        }
-    }
-    else
-    {
-        label nParcels = 0;
-        ensightFile<< setw(8) << nParcels << nl;
-    }
-}
-
-
-// ************************************************************************* //

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

@@ -1,54 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
-     \\/     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 3 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, see <http://www.gnu.org/licenses/>.
-
-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& CloudName,
-    const bool dataExists
-);
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#endif
-
-// ************************************************************************* //

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

@@ -3,7 +3,7 @@
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
     \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
-     \\/     M anipulation  |
+     \\/     M anipulation  | Copyright (C) 2016 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -57,10 +57,10 @@ class ensightStream
     // Private Member Functions
 
         //- Disallow default bitwise copy construct
-        ensightStream(const ensightStream&);
+        ensightStream(const ensightStream&) = delete;
 
         //- Disallow default bitwise assignment
-        void operator=(const ensightStream&);
+        void operator=(const ensightStream&) = delete;
 
 
 public:
@@ -86,8 +86,6 @@ public:
             return name_;
         }
 
-        virtual bool ascii() const = 0;
-
         virtual void write(const char*) = 0;
 
         virtual void write(const int) = 0;
@@ -98,8 +96,6 @@ public:
 
         virtual void writePartHeader(const label) = 0;
 
-
-
 };
 
 

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

@@ -0,0 +1,93 @@
+// check all time directories for the following:
+
+// The fields for each cloud:
+HashTable<HashTable<word>> cloudFields;
+
+// Identify if lagrangian data exist at any time step.
+if (timeDirs.size() && !noLagrangian)
+{
+    const fileName& baseDir = mesh.time().path();
+    const fileName& cloudPrefix = regionPrefix/cloud::prefix;
+
+    Info<< "Searching for lagrangian ... " << flush;
+
+    forAll(timeDirs, timeI)
+    {
+        const word& timeName = timeDirs[timeI].name();
+
+        // DO NOT USE -->>  runTime.setTime(timeDirs[timeI], timeI);  <<--
+        // It incurs a large overhead when done so frequently.
+
+        fileNameList cloudDirs = readDir
+        (
+            baseDir/timeName/cloudPrefix,
+            fileName::DIRECTORY
+        );
+
+        forAll(cloudDirs, cloudI)
+        {
+            const word& cloudName = cloudDirs[cloudI];
+
+            IOobjectList cloudObjs
+            (
+                mesh,
+                timeName,
+                cloudPrefix/cloudName
+            );
+
+            // clouds always require "positions"
+            if (cloudObjs.found("positions"))
+            {
+                HashTable<HashTable<word>>::iterator cloudIter =
+                    cloudFields.find(cloudName);
+
+                if (cloudIter == cloudFields.end())
+                {
+                    // A newly discovered cloud
+                    cloudFields.insert(cloudName, HashTable<word>());
+                    cloudIter = cloudFields.find(cloudName);
+                }
+
+                forAllConstIter(IOobjectList, cloudObjs, fieldIter)
+                {
+                    const IOobject obj = *fieldIter();
+
+                    // Add field and field type
+                    cloudIter().insert
+                    (
+                        obj.name(),
+                        obj.headerClassName()
+                    );
+                }
+            }
+        }
+    }
+
+    // prune out "positions" again since it gets treated specially
+    forAllIter(HashTable<HashTable<word>>, cloudFields, cloudIter)
+    {
+        cloudIter().erase("positions");
+    }
+
+    if (cloudFields.empty())
+    {
+        Info<< "none detected." << endl;
+    }
+}
+
+
+// sorted list of cloud names
+const wordList cloudNames(cloudFields.sortedToc());
+
+if (cloudNames.size())
+{
+    // complete the echo information
+    Info<< "(";
+    forAll(cloudNames, cloudNo)
+    {
+        Info<< ' ' << cloudNames[cloudNo];
+    }
+    Info<< " ) " << endl;
+}
+
+// ************************************************************************* //

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

@@ -3,7 +3,7 @@
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
     \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
-     \\/     M anipulation  |
+     \\/     M anipulation  | Copyright (C) 2016 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -34,27 +34,38 @@ Description
 
 Usage
     \b foamToEnsight [OPTION]
+    Translates OpenFOAM data to EnSight format
 
     Options:
       - \par -ascii
         Write Ensight data in ASCII format instead of "C Binary"
 
-      - \par -patches patchList
+      - \par -noZero
-        Specify particular patches to write.
+        Exclude the often incomplete initial conditions.
-        Specifying an empty list suppresses writing the internalMesh.
+
+      - \par -noLagrangian \n
+        Suppress writing lagrangian positions and fields.
 
       - \par -noPatches
         Suppress writing any patches.
 
-      - \par -faceZones zoneList
+      - \par -patches patchList \n
+        Specify particular patches to write.
+        Specifying an empty list suppresses writing the internalMesh.
+
+      - \par -faceZones zoneList \n
         Specify faceZones to write, with wildcards
 
       - \par -cellZone zoneName
         Specify single cellZone to write (not lagrangian)
 
+      - \par -width \<n\>\n
+        Width of EnSight data subdir (default: 8)
+
 Note
     Parallel support for cloud data is not supported
-    - writes to \a EnSight directory to avoid collisions with foamToEnsightParts
+    - writes to \a EnSight directory to avoid collisions with
+      foamToEnsightParts
 
 \*---------------------------------------------------------------------------*/
 
@@ -70,14 +81,12 @@ Note
 #include "scalarIOField.H"
 #include "tensorIOField.H"
 
+#include "ensightFile.H"
 #include "ensightMesh.H"
 #include "ensightField.H"
-
+#include "ensightCloud.H"
-#include "ensightParticlePositions.H"
-#include "ensightCloudField.H"
 
 #include "fvc.H"
-
 #include "cellSet.H"
 #include "fvMeshSubset.H"
 
@@ -87,11 +96,7 @@ using namespace Foam;
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-bool inFileNameList
+bool inFileNameList(const fileNameList& nameList, const word& name)
-(
-    const fileNameList& nameList,
-    const word& name
-)
 {
     forAll(nameList, i)
     {
@@ -105,7 +110,6 @@ bool inFileNameList
 }
 
 
-
 int main(int argc, char *argv[])
 {
     timeSelector::addOptions();
@@ -122,6 +126,11 @@ int main(int argc, char *argv[])
         "write values in nodes"
     );
     argList::addBoolOption
+    (
+        "noLagrangian",
+        "suppress writing lagrangian positions and fields"
+    );
+    argList::addBoolOption
     (
         "noPatches",
         "suppress writing any patches"
@@ -151,32 +160,21 @@ int main(int argc, char *argv[])
         "word",
         "specify cellZone to write"
     );
+    argList::addOption
+    (
+        "name",
+        "subdir",
+        "define sub-directory name to use for ensight data "
+        "(default: 'EnSight')"
+    );
+    argList::addOption
+    (
+        "width",
+        "n",
+        "width of ensight data subdir"
+    );
 
-    #include "setRootCase.H"
+    // the volume field types that we handle
-
-    // Check options
-    const bool binary = !args.optionFound("ascii");
-    const bool nodeValues = args.optionFound("nodeValues");
-
-    cpuTime timer;
-    memInfo mem;
-    Info<< "Initial memory "
-        << mem.update().size() << " kB" << endl;
-
-    #include "createTime.H"
-
-    instantList Times = timeSelector::select0(runTime, args);
-
-    #include "createNamedMesh.H"
-
-    // Mesh instance (region0 gets filtered out)
-    fileName regionPrefix = "";
-
-    if (regionName != polyMesh::defaultRegion)
-    {
-        regionPrefix = regionName;
-    }
-
     const label nVolFieldTypes = 10;
     const word volFieldTypes[] =
     {
@@ -193,38 +191,90 @@ int main(int argc, char *argv[])
         volTensorField::Internal::typeName
     };
 
+    #include "setRootCase.H"
+
+    // default to binary output, unless otherwise specified
+    const IOstream::streamFormat format =
+    (
+        args.optionFound("ascii")
+      ? IOstream::ASCII
+      : IOstream::BINARY
+    );
+
+    const bool nodeValues = args.optionFound("nodeValues");
+
+    cpuTime timer;
+    memInfo mem;
+    Info<< "Initial memory "
+        << mem.update().size() << " kB" << endl;
+
+    #include "createTime.H"
+
+    instantList timeDirs = timeSelector::select0(runTime, args);
+
+    // adjust output width
+    if (args.optionFound("width"))
+    {
+        ensightFile::subDirWidth(args.optionRead<label>("width"));
+    }
+
+    // define sub-directory name to use for EnSight data
+    fileName ensightDir = "EnSight";
+    args.optionReadIfPresent("name", ensightDir);
+
     // Path to EnSight directory at case level only
     // - For parallel cases, data only written from master
-    fileName ensightDir = args.rootPath()/args.globalCaseName()/"EnSight";
+    if (!ensightDir.isAbsolute())
+    {
+        ensightDir = args.rootPath()/args.globalCaseName()/ensightDir;
+    }
+
+    const fileName dataDir  = ensightDir/"data";
+    const fileName dataMask = dataDir.name()/ensightFile::mask();
 
     if (Pstream::master())
     {
+        // EnSight and EnSight/data directories must exist
+        // - remove old data for a clean conversion of everything
         if (isDir(ensightDir))
         {
             rmDir(ensightDir);
         }
 
-        mkDir(ensightDir);
+        mkDir(dataDir);
+    }
+
+    #include "createNamedMesh.H"
+
+    // Mesh instance (region0 gets filtered out)
+    fileName regionPrefix;
+    if (regionName != polyMesh::defaultRegion)
+    {
+        regionPrefix = regionName;
     }
 
     // Start of case file header output
     // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-    const word prepend = args.globalCaseName() + '.';
+    OFstream *ensightCaseFilePtr(nullptr);
-
-    OFstream *ensightCaseFilePtr = nullptr;
     if (Pstream::master())
     {
-        fileName caseFileName = prepend + "case";
+        fileName caseFileName = args.globalCaseName() + ".case";
-        Info<< nl << "write case: " << caseFileName.c_str() << endl;
 
-        // the case file is always ASCII
+        Info<< "Converting " << timeDirs.size() << " time steps" << nl
+            << "Ensight case: " << caseFileName.c_str() << endl;
+
+        // The case file is always ASCII
         ensightCaseFilePtr = new OFstream
         (
             ensightDir/caseFileName,
             IOstream::ASCII
         );
 
+        ensightCaseFilePtr->setf(ios_base::left);
+        ensightCaseFilePtr->setf(ios_base::scientific, ios_base::floatfield);
+        ensightCaseFilePtr->precision(5);
+
         *ensightCaseFilePtr
             << "FORMAT" << nl
             << "type: ensight gold" << nl << nl;
@@ -253,6 +303,8 @@ int main(int argc, char *argv[])
         fieldPatterns = wordReList(args.optionLookup("fields")());
     }
 
+    const bool noLagrangian = args.optionFound("noLagrangian");
+
     word cellZoneName;
     const bool doCellZone = args.optionReadIfPresent("cellZone", cellZoneName);
 
@@ -280,133 +332,84 @@ int main(int argc, char *argv[])
         patchPatterns,
         selectedZones,
         zonePatterns,
-        binary
+        format
     );
 
     // Set Time to the last time before looking for the lagrangian objects
-    runTime.setTime(Times.last(), Times.size()-1);
+    runTime.setTime(timeDirs.last(), timeDirs.size()-1);
 
     IOobjectList objects(mesh, runTime.timeName());
 
     #include "checkMeshMoving.H"
+    #include "findCloudFields.H"
 
-    if (meshMoving)
-    {
-        Info<< "Detected a moving mesh (multiple polyMesh/points files)."
-            << " Writing meshes for every timestep." << endl;
-    }
-
-
-    wordHashSet allCloudNames;
     if (Pstream::master())
     {
-        word geomFileName = prepend + "0000";
+        // test the pre-check variable if there is a moving mesh
+        // time-set for geometries
+        // TODO: split off into separate time-set,
+        // but need to verify ensight spec
 
-        // test pre check variable if there is a moving mesh
         if (meshMoving)
         {
-            geomFileName = prepend + "****";
+            ensightCaseFile
+                << "GEOMETRY" << nl
+                << setw(16) << "model: 1"
+                << (dataMask/ensightMesh::geometryName).c_str() << nl;
         }
-
+        else
-        ensightCaseFile
-            << "GEOMETRY" << nl
-            << "model:        1     "
-            << (geomFileName + ".mesh").c_str() << nl;
-    }
-
-    // Identify if lagrangian data exists at each time, and add clouds
-    // to the 'allCloudNames' hash set
-    forAll(Times, timeI)
-    {
-        runTime.setTime(Times[timeI], timeI);
-
-        fileNameList cloudDirs = readDir
-        (
-            runTime.timePath()/regionPrefix/cloud::prefix,
-            fileName::DIRECTORY
-        );
-
-        forAll(cloudDirs, cloudI)
-        {
-            IOobjectList cloudObjs
-            (
-                mesh,
-                runTime.timeName(),
-                cloud::prefix/cloudDirs[cloudI]
-            );
-
-            IOobject* positionsPtr = cloudObjs.lookup(word("positions"));
-
-            if (positionsPtr)
-            {
-                allCloudNames.insert(cloudDirs[cloudI]);
-            }
-        }
-    }
-
-    HashTable<HashTable<word>> allCloudFields;
-    forAllConstIter(wordHashSet, allCloudNames, cloudIter)
-    {
-        // Add the name of the cloud(s) to the case file header
-        if (Pstream::master())
         {
             ensightCaseFile
-            <<  (
+                << "GEOMETRY" << nl
-                    "measured:     1     "
+                << setw(16) << "model:"
-                  + prepend
+                << ensightMesh::geometryName << nl;
-                  + "****."
-                  + cloudIter.key()
-                ).c_str()
-            << nl;
         }
 
-        // Create a new hash table for each cloud
-        allCloudFields.insert(cloudIter.key(), HashTable<word>());
 
-        // Identify the new cloud in the hash table
+        // Add the name of the cloud(s) to the case file header
-        HashTable<HashTable<word>>::iterator newCloudIter =
+        forAll(cloudNames, cloudNo)
-            allCloudFields.find(cloudIter.key());
-
-        // Loop over all times to build list of fields and field types
-        // for each cloud
-        forAll(Times, timeI)
         {
-            runTime.setTime(Times[timeI], timeI);
+            const word& cloudName = cloudNames[cloudNo];
 
-            IOobjectList cloudObjs
+            ensightCaseFile
-            (
+                << setw(16) << "measured: 1"
-                mesh,
+                << fileName
-                runTime.timeName(),
+                (
-                cloud::prefix/cloudIter.key()
+                    dataMask/cloud::prefix/cloudName/"positions"
-            );
+                ).c_str() << nl;
-
-            forAllConstIter(IOobjectList, cloudObjs, fieldIter)
-            {
-                const IOobject obj = *fieldIter();
-
-                if (obj.name() != "positions")
-                {
-                    // Add field and field type
-                    newCloudIter().insert
-                    (
-                        obj.name(),
-                        obj.headerClassName()
-                    );
-                }
-            }
         }
     }
 
+    Info<< "Startup in "
+        << timer.cpuTimeIncrement() << " s, "
+        << mem.update().size() << " kB" << nl << endl;
+
+    // ignore special fields (_0 fields),
+    // ignore fields we don't handle,
+    // ignore fields that are not available for all time-steps
+    HashTable<bool> fieldsToUse;
+
     label nTimeSteps = 0;
-    forAll(Times, timeIndex)
+    forAll(timeDirs, timeIndex)
     {
-        nTimeSteps++;
+        ++nTimeSteps;
-        runTime.setTime(Times[timeIndex], timeIndex);
+        runTime.setTime(timeDirs[timeIndex], timeIndex);
 
-        word timeName = itoa(timeIndex);
+        Info<< "Time [" << timeIndex << "] = " << runTime.timeName() << nl;
-        word timeFile = prepend + timeName;
 
-        Info<< "Translating time = " << runTime.timeName() << nl;
+        if (Pstream::master())
+        {
+            // the data/ITER subdirectory must exist
+            // Note that data/ITER is indeed a valid ensight::FileName
+            const 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;
+        }
 
         polyMesh::readUpdateState meshState = mesh.readUpdate();
         if (timeIndex != 0 && meshSubsetter.hasSubMesh())
@@ -420,7 +423,6 @@ int main(int argc, char *argv[])
             meshSubsetter.setLargeCellSubset(c0, 0);
         }
 
-
         if (meshState != polyMesh::UNCHANGED)
         {
             eMesh.correct();
@@ -430,8 +432,7 @@ int main(int argc, char *argv[])
         {
             eMesh.write
             (
-                ensightDir,
+                dataDir,
-                prepend,
                 timeIndex,
                 meshMoving,
                 ensightCaseFile
@@ -450,8 +451,9 @@ int main(int argc, char *argv[])
 
         // Cell field data output
         // ~~~~~~~~~~~~~~~~~~~~~~
+        Info<< "Write volume field (";
 
-        for (label i=0; i<nVolFieldTypes; i++)
+        for (label i=0; i<nVolFieldTypes; ++i)
         {
             wordList fieldNames = objects.names(volFieldTypes[i]);
 
@@ -470,7 +472,7 @@ int main(int argc, char *argv[])
 
                 #include "checkData.H"
 
-                if (!variableGood)
+                if (!fieldsToUse[fieldName])
                 {
                     continue;
                 }
@@ -491,10 +493,8 @@ int main(int argc, char *argv[])
                     (
                         volField(meshSubsetter, vf),
                         eMesh,
-                        ensightDir,
+                        dataDir,
-                        prepend,
                         timeIndex,
-                        binary,
                         nodeValues,
                         ensightCaseFile
                     );
@@ -506,10 +506,8 @@ int main(int argc, char *argv[])
                     (
                         volField(meshSubsetter, vf),
                         eMesh,
-                        ensightDir,
+                        dataDir,
-                        prepend,
                         timeIndex,
-                        binary,
                         nodeValues,
                         ensightCaseFile
                     );
@@ -521,10 +519,8 @@ int main(int argc, char *argv[])
                     (
                         volField(meshSubsetter, vf),
                         eMesh,
-                        ensightDir,
+                        dataDir,
-                        prepend,
                         timeIndex,
-                        binary,
                         nodeValues,
                         ensightCaseFile
                     );
@@ -536,10 +532,8 @@ int main(int argc, char *argv[])
                     (
                         volField(meshSubsetter, vf),
                         eMesh,
-                        ensightDir,
+                        dataDir,
-                        prepend,
                         timeIndex,
-                        binary,
                         nodeValues,
                         ensightCaseFile
                     );
@@ -551,10 +545,8 @@ int main(int argc, char *argv[])
                     (
                         volField(meshSubsetter, vf),
                         eMesh,
-                        ensightDir,
+                        dataDir,
-                        prepend,
                         timeIndex,
-                        binary,
                         nodeValues,
                         ensightCaseFile
                     );
@@ -570,10 +562,8 @@ int main(int argc, char *argv[])
                     (
                         volField<scalar>(meshSubsetter, df),
                         eMesh,
-                        ensightDir,
+                        dataDir,
-                        prepend,
                         timeIndex,
-                        binary,
                         nodeValues,
                         ensightCaseFile
                     );
@@ -588,10 +578,8 @@ int main(int argc, char *argv[])
                     (
                         volField<vector>(meshSubsetter, df),
                         eMesh,
-                        ensightDir,
+                        dataDir,
-                        prepend,
                         timeIndex,
-                        binary,
                         nodeValues,
                         ensightCaseFile
                     );
@@ -607,10 +595,8 @@ int main(int argc, char *argv[])
                     (
                         volField<sphericalTensor>(meshSubsetter, df),
                         eMesh,
-                        ensightDir,
+                        dataDir,
-                        prepend,
                         timeIndex,
-                        binary,
                         nodeValues,
                         ensightCaseFile
                     );
@@ -625,10 +611,8 @@ int main(int argc, char *argv[])
                     (
                         volField<symmTensor>(meshSubsetter, df),
                         eMesh,
-                        ensightDir,
+                        dataDir,
-                        prepend,
                         timeIndex,
-                        binary,
                         nodeValues,
                         ensightCaseFile
                     );
@@ -643,24 +627,29 @@ int main(int argc, char *argv[])
                     (
                         volField<tensor>(meshSubsetter, df),
                         eMesh,
-                        ensightDir,
+                        dataDir,
-                        prepend,
                         timeIndex,
-                        binary,
                         nodeValues,
                         ensightCaseFile
                     );
                 }
+                else
+                {
+                    // Do not currently handle this type - blacklist for the future.
+                    fieldsToUse.set(fieldName, false);
+                }
             }
         }
+        Info<< " )" << nl;
 
 
         // Cloud field data output
         // ~~~~~~~~~~~~~~~~~~~~~~~
 
-        forAllConstIter(HashTable<HashTable<word>>, allCloudFields, cloudIter)
+        forAll(cloudNames, cloudNo)
         {
-            const word& cloudName = cloudIter.key();
+            const word& cloudName = cloudNames[cloudNo];
+            const HashTable<word>& theseCloudFields = cloudFields[cloudName];
 
             fileNameList currentCloudDirs = readDir
             (
@@ -668,17 +657,22 @@ int main(int argc, char *argv[])
                 fileName::DIRECTORY
             );
 
+            Info<< "Write " << cloudName << " (";
+
             bool cloudExists = inFileNameList(currentCloudDirs, cloudName);
+            reduce(cloudExists, orOp<bool>());
+
             ensightParticlePositions
             (
                 mesh,
-                ensightDir,
+                dataDir,
-                timeFile,
+                timeIndex,
                 cloudName,
-                cloudExists
+                cloudExists,
+                format
             );
 
-            forAllConstIter(HashTable<word>, cloudIter(), fieldIter)
+            forAllConstIter(HashTable<word>, theseCloudFields, fieldIter)
             {
                 const word& fieldName = fieldIter.key();
                 const word& fieldType = fieldIter();
@@ -696,17 +690,20 @@ int main(int argc, char *argv[])
                 (
                     false
                 );
+                reduce(fieldExists, orOp<bool>());
+
                 if (fieldType == scalarIOField::typeName)
                 {
                     ensightCloudField<scalar>
                     (
                         fieldObject,
-                        ensightDir,
+                        dataDir,
-                        prepend,
                         timeIndex,
                         cloudName,
+                        cloudNo,
                         ensightCaseFile,
-                        fieldExists
+                        fieldExists,
+                        format
                     );
                 }
                 else if (fieldType == vectorIOField::typeName)
@@ -714,37 +711,34 @@ int main(int argc, char *argv[])
                     ensightCloudField<vector>
                     (
                         fieldObject,
-                        ensightDir,
+                        dataDir,
-                        prepend,
                         timeIndex,
                         cloudName,
+                        cloudNo,
                         ensightCaseFile,
-                        fieldExists
+                        fieldExists,
+                        format
                     );
                 }
-                else
-                {
-                    Info<< "Unable to convert field type " << fieldType
-                        << " for field " << fieldName << endl;
-                }
             }
+            Info<< " )" << nl;
         }
 
         Info<< "Wrote in "
             << timer.cpuTimeIncrement() << " s, "
-            << mem.update().size() << " kB" << endl;
+            << mem.update().size() << " kB" << nl << nl;
     }
 
     #include "ensightCaseTail.H"
 
-    if (Pstream::master())
+    if (ensightCaseFilePtr) // on master only
     {
         delete ensightCaseFilePtr;
     }
 
-    Info<< "\nEnd: "
+    Info<< "End: "
         << timer.elapsedCpuTime() << " s, "
-        << mem.update().peak() << " kB (peak)\n" << endl;
+        << mem.update().peak() << " kB (peak)" << nl << endl;
 
     return 0;
 }

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

@@ -1,61 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
-     \\/     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 3 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, see <http://www.gnu.org/licenses/>.
-
-\*---------------------------------------------------------------------------*/
-
-#include "itoa.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-namespace Foam
-{
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-word itoa(const label n)
-{
-    const label offset = '0';
-    const label length = 4;
-
-    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/foamToEnsightParts/checkHasMovingMesh.H

@@ -2,18 +2,47 @@
 // - could restrict to the selected times
 
 bool hasMovingMesh = false;
-if (timeDirs.size() > 1)
+
+if (timeDirs.size() > 1 && Pstream::master())
 {
-    hasMovingMesh = true;
+    // We already loaded a mesh (usually from constant).
-    for (label i=0; i < timeDirs.size() && hasMovingMesh; ++i)
+    // See if any other "polyMesh/points" files exist too.
+
+    const fileName& baseDir = mesh.time().path();
+
+    Info<< "Search for moving mesh ... " << flush;
+    forAll(timeDirs, timeI)
     {
-        hasMovingMesh = IOobject
+        hasMovingMesh =
         (
-            "points",
+            isDir(baseDir/timeDirs[timeI].name()/polyMesh::meshSubDir)
-            timeDirs[i].name(),
+         && IOobject
-            polyMesh::meshSubDir,
+            (
-            mesh,
+                "points",
-            IOobject::NO_READ
+                timeDirs[timeI].name(),
-        ).typeHeaderOk<pointIOField>(true);
+                polyMesh::meshSubDir,
+                mesh,
+                IOobject::NO_READ,
+                IOobject::NO_WRITE,
+                false  // no register
+            ).typeHeaderOk<pointIOField>(true)
+        );
+
+        if (hasMovingMesh)
+        {
+            break;
+        }
+    }
+
+    if (hasMovingMesh)
+    {
+        Info<< "found." << nl
+            << "    Writing meshes for every timestep." << endl;
+    }
+    else
+    {
+        Info<< "none detected." << endl;
     }
 }
+
+reduce(hasMovingMesh, orOp<bool>());

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

@@ -58,35 +58,36 @@ forAllConstIter(HashTable<word>, volumeFields, fieldIter)
 
     if (fieldType == volScalarField::typeName)
     {
-        ensightType = "scalar";
+        ensightType = ensightPTraits<scalar>::typeName;
     }
     else if (fieldType == volVectorField::typeName)
     {
-        ensightType = "vector";
+        ensightType = ensightPTraits<vector>::typeName;
     }
     else if (fieldType == volSphericalTensorField::typeName)
     {
-        ensightType = "tensor symm";
+        ensightType = ensightPTraits<sphericalTensor>::typeName;
     }
     else if (fieldType == volSymmTensorField::typeName)
     {
-        ensightType = "tensor symm";
+        ensightType = ensightPTraits<symmTensor>::typeName;
     }
     else if (fieldType == volTensorField::typeName)
     {
-        ensightType = "tensor asym";
+        ensightType = ensightPTraits<tensor>::typeName;
+    }
+    else
+    {
+        continue;
     }
 
-    if (ensightType.size())
+    ensightCaseEntry
-    {
+    (
-        ensightCaseEntry
+        caseFile,
-        (
+        ensightType,
-            caseFile,
+        fieldName,
-            ensightType,
+        dataMask
-            fieldName,
+    );
-            dataMask
-        );
-    }
 }
 
 
@@ -104,30 +105,31 @@ forAllConstIter(HashTable<HashTable<word>>, cloudFields, cloudIter)
 
         if (fieldType == scalarIOField::typeName)
         {
-            ensightType = "scalar";
+            ensightType = ensightPTraits<scalar>::typeName;
         }
         else if (fieldType == vectorIOField::typeName)
         {
-            ensightType = "vector";
+            ensightType = ensightPTraits<vector>::typeName;
         }
         else if (fieldType == tensorIOField::typeName)
         {
-            ensightType = "tensor";
+            ensightType = ensightPTraits<tensor>::typeName;
+        }
+        else
+        {
+            continue;
         }
 
-        if (ensightType.size())
+        ensightCaseEntry
-        {
+        (
-            ensightCaseEntry
+            caseFile,
-            (
+            ensightType,
-                caseFile,
+            fieldName,
-                ensightType,
+            dataMask,
-                fieldName,
+            cloud::prefix/cloudName,
-                dataMask,
+            cloudNo,
-                cloud::prefix/cloudName,
+            2
-                cloudNo,
+        );
-                2
-            );
-        }
     }
     cloudNo++;
 }
@@ -162,7 +164,7 @@ if (fieldTimesUsed.size())
     count = 0;
     forAll(fieldTimesUsed, i)
     {
-        const label& index = fieldTimesUsed[i];
+        const label index = fieldTimesUsed[i];
         caseFile
             << " " << setw(12) << timeIndices[index] + timeCorrection;
 
@@ -203,7 +205,7 @@ if (geometryTimesUsed.size())
     count = 0;
     forAll(geometryTimesUsed, i)
     {
-        const label& index = geometryTimesUsed[i];
+        const label index = geometryTimesUsed[i];
         caseFile
             << " " << setw(12) << timeIndices[index] + timeCorrection;
 
@@ -249,7 +251,7 @@ forAllConstIter(HashTable<DynamicList<label>>, cloudTimesUsed, cloudIter)
         count = 0;
         forAll(timesUsed, i)
         {
-            const label& index = timesUsed[i];
+            const label index = timesUsed[i];
             caseFile
                 << " " << setw(12) << timeIndices[index] + timeCorrection;
 

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

@@ -24,6 +24,7 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "ensightOutputFunctions.H"
+#include "ensightPTraits.H"
 
 #include "passiveParticle.H"
 #include "IOField.H"
@@ -171,11 +172,8 @@ void Foam::ensightLagrangianField
     // when writing positions
 
     ensightFile os(dataDir, postFileName, format);
-    os.write
+    // description
-    (
+    os.write(string(postFileName + " <" + pTraits<Type>::typeName + ">"));
-        // description
-        string(postFileName + " with " + pTraits<Type>::typeName + " values")
-    );
     os.newline();
 
     IOField<Type> field(fieldObject);
@@ -187,21 +185,20 @@ void Foam::ensightLagrangianField
     {
         Type val = field[i];
 
-        if (mag(val) < 1.0e-90)
+        if (mag(val) < 1e-90)
         {
             val = Zero;
         }
 
-        for (direction cmpt=0; cmpt < pTraits<Type>::nComponents; cmpt++)
+        for (direction d=0; d < pTraits<Type>::nComponents; ++d)
         {
-            os.write( component(val, cmpt) );
+            label cmpt = ensightPTraits<Type>::componentOrder[d];
-        }
+            os.write(component(val, cmpt));
 
-        count += pTraits<Type>::nComponents;
+            if (++count % 6 == 0)
-
+            {
-        if (count % 6 == 0)
+                os.newline();
-        {
+            }
-            os.newline();
         }
     }
 

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

@@ -8,7 +8,10 @@ HashTable<HashTable<word>> cloudFields;
 
 if (timeDirs.size())
 {
-    IOobjectList objs(mesh, timeDirs.last().name());
+    const fileName& cloudPrefix = regionPrefix/cloud::prefix;
+    const word& lastTimeName = timeDirs.last().name();
+
+    IOobjectList objs(mesh, lastTimeName);
 
     forAllConstIter(IOobjectList, objs, fieldIter)
     {
@@ -31,14 +34,17 @@ if (timeDirs.size())
     //
     // now check for lagrangian/<cloudName>
     //
-    fileNameList cloudDirs = readDir
+    fileNameList cloudDirs;
-    (
+    if (!noLagrangian)
-        runTime.path()
+    {
-      / timeDirs.last().name()
+        cloudDirs = readDir
-      / regionPrefix
+        (
-      / cloud::prefix,
+            runTime.path()
-        fileName::DIRECTORY
+          / lastTimeName
-    );
+          / cloudPrefix,
+            fileName::DIRECTORY
+        );
+    }
 
     forAll(cloudDirs, cloudI)
     {
@@ -54,8 +60,8 @@ if (timeDirs.size())
         IOobjectList objs
         (
             mesh,
-            timeDirs.last().name(),
+            lastTimeName,
-            cloud::prefix/cloudName
+            cloudPrefix/cloudName
         );
 
         bool hasPositions = false;
@@ -89,17 +95,27 @@ if (timeDirs.size())
     //
     for (label i=0; volumeFields.size() && i < timeDirs.size(); ++i)
     {
-        IOobjectList objs(mesh, timeDirs[i].name());
+        const word& timeName = timeDirs[i].name();
 
-        forAllIter(HashTable<word>, volumeFields, fieldIter)
+        // Everything is potentially missing, unless we discover otherwise
+        wordHashSet missing(volumeFields);
+
+        // Avoid  -->>  IOobjectList objs(mesh, timeName);  <<--
+        // Too much overhead when done so frequently.
+
+        fileNameList contents = readDir
+        (
+            runTime.path()
+          / timeName,
+            fileName::FILE
+        );
+
+        forAll(contents, fileI)
         {
-            const word& fieldName = fieldIter.key();
+            missing.erase(contents[fileI].name());
-
-            if (!objs.found(fieldName))
-            {
-                volumeFields.erase(fieldIter);
-            }
         }
+
+        volumeFields.erase(missing);
     }
 }
 

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

@@ -48,6 +48,13 @@ Usage
         Ignore the time index contained in the time file and use a
         simple indexing when creating the \c Ensight/data/######## files.
 
+      - \par -noLagrangian \n
+        Suppress writing lagrangian positions and fields.
+
+      - \par -index \<start\>\n
+        Ignore the time index contained in the time file and use a
+        simple indexing when creating the \c Ensight/data/######## files.
+
       - \par -noMesh
         Suppress writing the geometry. Can be useful for converting partial
         results for a static geometry.
@@ -83,8 +90,8 @@ using namespace Foam;
 
 int main(int argc, char *argv[])
 {
-    // enable -constant
+    // Enable -constant
-    // probably don't need -withZero though, since the fields are vetted
+    // Probably don't need -withZero though, since the fields are vetted
     // afterwards anyhow
     timeSelector::addOptions(true, false);
     argList::noParallel();
@@ -101,6 +108,11 @@ int main(int argc, char *argv[])
         "and use simple indexing when creating the files"
     );
     argList::addBoolOption
+    (
+        "noLagrangian",
+        "suppress writing lagrangian positions and fields"
+    );
+    argList::addBoolOption
     (
         "noMesh",
         "suppress writing the geometry. "
@@ -120,7 +132,7 @@ int main(int argc, char *argv[])
         "width of Ensight data subdir"
     );
 
-    // the volume field types that we handle
+    // The volume field types that we handle
     wordHashSet volFieldTypes;
     volFieldTypes.insert(volScalarField::typeName);
     volFieldTypes.insert(volVectorField::typeName);
@@ -128,7 +140,7 @@ int main(int argc, char *argv[])
     volFieldTypes.insert(volSymmTensorField::typeName);
     volFieldTypes.insert(volTensorField::typeName);
 
-    // the lagrangian field types that we handle
+    // The lagrangian field types that we handle
     wordHashSet cloudFieldTypes;
     cloudFieldTypes.insert(scalarIOField::typeName);
     cloudFieldTypes.insert(vectorIOField::typeName);
@@ -145,30 +157,32 @@ int main(int argc, char *argv[])
 
     #include "createTime.H"
 
-    // get times list
+    // Get times list
     instantList timeDirs = timeSelector::select0(runTime, args);
 
-    // default to binary output, unless otherwise specified
+    // Default to binary output, unless otherwise specified
-    IOstream::streamFormat format = IOstream::BINARY;
+    const IOstream::streamFormat format =
-    if (args.optionFound("ascii"))
+    (
-    {
+        args.optionFound("ascii")
-        format = IOstream::ASCII;
+      ? IOstream::ASCII
-    }
+      : IOstream::BINARY
+    );
 
-    // control for renumbering iterations
+    // Control for renumbering iterations
     label indexingNumber = 0;
-    bool optIndex = args.optionReadIfPresent("index", indexingNumber);
+    const bool optIndex = args.optionReadIfPresent("index", indexingNumber);
+    const bool noLagrangian = args.optionFound("noLagrangian");
 
-    // always write the geometry, unless the -noMesh option is specified
+    // Always write the geometry, unless the -noMesh option is specified
     bool optNoMesh = args.optionFound("noMesh");
 
-    // adjust output width
+    // Adjust output width
     if (args.optionFound("width"))
     {
         ensightFile::subDirWidth(args.optionRead<label>("width"));
     }
 
-    // define sub-directory name to use for Ensight data
+    // Define sub-directory name to use for Ensight data
     fileName ensightDir = "Ensight";
     args.optionReadIfPresent("name", ensightDir);
 
@@ -190,7 +204,7 @@ int main(int argc, char *argv[])
             << "    " << ensightDir << endl;
     }
 
-    // as per mkdir -p "Ensight/data"
+    // As per mkdir -p "Ensight/data"
     mkDir(ensightDir);
     mkDir(dataDir);
 
@@ -204,10 +218,15 @@ int main(int argc, char *argv[])
         regionPrefix = regionName;
     }
 
+    if (Pstream::master())
+    {
+        Info<< "Converting " << timeDirs.size() << " time steps" << endl;
+    }
+
     // Construct the list of ensight parts for the entire mesh
     ensightParts partsList(mesh);
 
-    // write summary information
+    // Write summary information
     {
         OFstream partsInfoFile(ensightDir/"partsInfo");
 
@@ -226,7 +245,7 @@ int main(int argc, char *argv[])
     }
 
 
-    // map times used
+    // Map times used
     Map<scalar>  timeIndices;
 
     // TODO: Track the time indices used by the geometry
@@ -244,6 +263,9 @@ int main(int argc, char *argv[])
         cloudTimesUsed.insert(cloudIter.key(), DynamicList<label>());
     }
 
+    Info<< "Startup in "
+        << timer.cpuTimeIncrement() << " s, "
+        << mem.update().size() << " kB" << nl << endl;
 
     forAll(timeDirs, timeI)
     {
@@ -251,15 +273,15 @@ int main(int argc, char *argv[])
 
         #include "getTimeIndex.H"
 
-        // remember the time index for the volume fields
+        // Remember the time index for the volume fields
         fieldTimesUsed.append(timeIndex);
 
-        // the data/ITER subdirectory must exist
+        // The data/ITER subdirectory must exist
         // Note that data/ITER is indeed a valid ensight::FileName
         const fileName subDir = ensightFile::subDir(timeIndex);
         mkDir(dataDir/subDir);
 
-        // place a timestamp in the directory for future reference
+        // Place a timestamp in the directory for future reference
         {
             OFstream timeStamp(dataDir/subDir/"time");
             timeStamp
@@ -280,7 +302,7 @@ int main(int argc, char *argv[])
             {
                 if (hasMovingMesh)
                 {
-                    // remember the time index for the geometry
+                    // Remember the time index for the geometry
                     geometryTimesUsed.append(timeIndex);
                 }
 
@@ -294,7 +316,7 @@ int main(int argc, char *argv[])
             }
         }
 
-        Info<< "write volume field (" << flush;
+        Info<< "Write volume field (" << flush;
 
         forAllConstIter(HashTable<word>, volumeFields, fieldIter)
         {
@@ -376,19 +398,13 @@ int main(int argc, char *argv[])
         }
         Info<< " )" << endl;
 
-        // check for clouds
+        // Check for clouds
         forAllConstIter(HashTable<HashTable<word>>, cloudFields, cloudIter)
         {
             const word& cloudName = cloudIter.key();
+            const fileName& cloudPrefix = regionPrefix/cloud::prefix;
 
-            if
+            if (!isDir(runTime.timePath()/cloudPrefix/cloudName))
-            (
-                !isDir
-                (
-                    runTime.timePath()/regionPrefix/
-                    cloud::prefix/cloudName
-                )
-            )
             {
                 continue;
             }
@@ -397,28 +413,25 @@ int main(int argc, char *argv[])
             (
                 mesh,
                 runTime.timeName(),
-                cloud::prefix/cloudName
+                cloudPrefix/cloudName
             );
 
-            // check that the positions field is present for this time
+            // Check that the positions field is present for this time
-            IOobject* positionPtr = cloudObjs.lookup(word("positions"));
+            if (!cloudObjs.found("positions"))
-            if (positionPtr != nullptr)
-            {
-                ensightParticlePositions
-                (
-                    mesh,
-                    dataDir,
-                    subDir,
-                    cloudName,
-                    format
-                );
-            }
-            else
             {
                 continue;
             }
 
-            Info<< "write " << cloudName << " (" << flush;
+            Info<< "Write " << cloudName << " ( positions" << flush;
+
+            ensightParticlePositions
+            (
+                mesh,
+                dataDir,
+                subDir,
+                cloudName,
+                format
+            );
 
             forAllConstIter(HashTable<word>, cloudIter(), fieldIter)
             {
@@ -430,7 +443,7 @@ int main(int argc, char *argv[])
                 if (!fieldObject)
                 {
                     Info<< "missing "
-                        << runTime.timeName()/cloud::prefix/cloudName
+                        << runTime.timeName()/cloudPrefix/cloudName
                         / fieldName
                         << endl;
                     continue;
@@ -476,7 +489,7 @@ int main(int argc, char *argv[])
 
             Info<< " )" << endl;
 
-            // remember the time index
+            // Remember the time index
             cloudTimesUsed[cloudName].append(timeIndex);
         }
 

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

@@ -39,5 +39,5 @@
     }
 
     timeIndices.insert(timeIndex, timeDirs[timeI].value());
-    Info<< "\nTime [" << timeIndex << "] = " << runTime.timeName() << nl;
+    Info<< nl << "Time [" << timeIndex << "] = " << runTime.timeName() << nl;
 

applications/utilities/postProcessing/dataConversion/foamToVTK/findClouds.H

@@ -0,0 +1,71 @@
+// check all time directories for the following:
+
+// Any cloud names:
+HashSet<fileName> allCloudDirs;
+
+if (timeDirs.size() && !noLagrangian)
+{
+    const fileName& baseDir = mesh.time().path();
+    const fileName& cloudPrefix = regionPrefix/cloud::prefix;
+
+    Info<< "Searching for lagrangian ... " << flush;
+
+    forAll(timeDirs, timeI)
+    {
+        const word& timeName = timeDirs[timeI].name();
+
+        // DO NOT USE -->>  runTime.setTime(timeDirs[timeI], timeI);  <<--
+        // It incurs a large overhead when done so frequently.
+
+        fileNameList cloudDirs = readDir
+        (
+            baseDir/timeName/cloudPrefix,
+            fileName::DIRECTORY
+        );
+
+        forAll(cloudDirs, cloudI)
+        {
+            const word& cloudName = cloudDirs[cloudI];
+
+            IOobjectList cloudObjs
+            (
+                mesh,
+                timeName,
+                cloudPrefix/cloudName
+            );
+
+            // clouds always require "positions"
+            if (cloudObjs.found("positions"))
+            {
+                if (allCloudDirs.insert(cloudName))
+                {
+                    Info<< "At time: " << timeName
+                        << " detected cloud directory : " << cloudName
+                        << endl;
+                }
+            }
+        }
+    }
+
+    if (allCloudDirs.empty())
+    {
+        Info<< "none detected." << endl;
+    }
+}
+
+// sorted list of cloud names
+const fileNameList cloudNames(allCloudDirs.sortedToc());
+
+if (cloudNames.size())
+{
+    // complete the echo information
+    Info<< "(";
+    forAll(cloudNames, cloudNo)
+    {
+        Info<< ' ' << cloudNames[cloudNo];
+    }
+    Info<< " ) " << endl;
+}
+
+
+// ************************************************************************* //

applications/utilities/postProcessing/dataConversion/foamToVTK/foamToVTK.C

@@ -72,7 +72,10 @@ Usage
       - \par -noInternal
         Do not generate file for mesh, only for patches
 
-      - \par -noPointValues
+      - \par -noLagrangian \n
+        Suppress writing lagrangian positions and fields.
+
+      - \par -noPointValues \n
         No pointFields
 
       - \par -noFaceZones
@@ -291,6 +294,12 @@ int main(int argc, char *argv[])
         "noInternal",
         "do not generate file for mesh, only for patches"
     );
+    argList::addBoolOption
+    (
+        "noLagrangian",
+        "suppress writing lagrangian positions and fields"
+    );
+
     argList::addBoolOption
     (
         "noPointValues",
@@ -337,6 +346,7 @@ int main(int argc, char *argv[])
     const bool doLinks         = !args.optionFound("noLinks");
     bool binary                = !args.optionFound("ascii");
     const bool useTimeName     = args.optionFound("useTimeName");
+    const bool noLagrangian    = args.optionFound("noLagrangian");
 
     // Decomposition of polyhedral cells into tets/pyramids cells
     vtkTopo::decomposePoly     = !args.optionFound("poly");
@@ -409,8 +419,7 @@ int main(int argc, char *argv[])
     fileName fvPath(runTime.path()/"VTK");
 
     // Directory of mesh (region0 gets filtered out)
-    fileName regionPrefix = "";
+    fileName regionPrefix;
-
     if (regionName != polyMesh::defaultRegion)
     {
         fvPath = fvPath/regionName;
@@ -448,43 +457,7 @@ int main(int argc, char *argv[])
         << timer.cpuTimeIncrement() << " s, "
         << mem.update().size() << " kB" << endl;
 
-
+    #include "findClouds.H"
-    // Scan for all possible lagrangian clouds
-    HashSet<fileName> allCloudDirs;
-    forAll(timeDirs, timeI)
-    {
-        runTime.setTime(timeDirs[timeI], timeI);
-        fileNameList cloudDirs
-        (
-            readDir
-            (
-                runTime.timePath()/regionPrefix/cloud::prefix,
-                fileName::DIRECTORY
-            )
-        );
-        forAll(cloudDirs, i)
-        {
-            IOobjectList sprayObjs
-            (
-                mesh,
-                runTime.timeName(),
-                cloud::prefix/cloudDirs[i]
-            );
-
-            IOobject* positionsPtr = sprayObjs.lookup(word("positions"));
-
-            if (positionsPtr)
-            {
-                if (allCloudDirs.insert(cloudDirs[i]))
-                {
-                    Info<< "At time: " << runTime.timeName()
-                        << " detected cloud directory : " << cloudDirs[i]
-                        << endl;
-                }
-            }
-        }
-    }
-
 
     forAll(timeDirs, timeI)
     {
@@ -492,7 +465,7 @@ int main(int argc, char *argv[])
 
         Info<< "Time: " << runTime.timeName() << endl;
 
-        word timeDesc =
+        const word timeDesc =
             useTimeName ? runTime.timeName() : Foam::name(runTime.timeIndex());
 
         // Check for new polyMesh/ and update mesh, fvMeshSubset and cell
@@ -664,7 +637,7 @@ int main(int argc, char *argv[])
               + dtf.size();
 
 
-        // Construct pointMesh only if nessecary since constructs edge
+        // Construct pointMesh only if necessary since constructs edge
         // addressing (expensive on polyhedral meshes)
         if (noPointValues)
         {
@@ -1152,9 +1125,9 @@ int main(int argc, char *argv[])
         //
         //---------------------------------------------------------------------
 
-        forAllConstIter(HashSet<fileName>, allCloudDirs, iter)
+        forAll(cloudNames, cloudNo)
         {
-            const fileName& cloudName = iter.key();
+            const fileName& cloudName = cloudNames[cloudNo];
 
             // Always create the cloud directory.
             mkDir(fvPath/cloud::prefix/cloudName);
@@ -1175,9 +1148,7 @@ int main(int argc, char *argv[])
                 cloud::prefix/cloudName
             );
 
-            IOobject* positionsPtr = sprayObjs.lookup(word("positions"));
+            if (sprayObjs.found("positions"))
-
-            if (positionsPtr)
             {
                 wordList labelNames(sprayObjs.names(labelIOField::typeName));
                 Info<< "        labels            :";

src/conversion/ensight/file/ensightGeoFile.C

@@ -24,14 +24,26 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "ensightGeoFile.H"
+#include "foamVersion.H"
+
+// Macros to stringify macro contents.
+#define STRINGIFY(content)      #content
+#define STRING_QUOTE(input)     STRINGIFY(input)
+
 
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 
 void Foam::ensightGeoFile::initialize()
 {
+    #ifdef OPENFOAM_PLUS
+    string desc2("Written by OpenFOAM+ " STRING_QUOTE(OPENFOAM_PLUS));
+    #else
+    string desc2("Written by OpenFOAM-" + string(Foam::FOAMversion));
+    #endif
+
     writeBinaryHeader();
     write("Ensight Geometry File");  newline(); // description line 1
-    write("=====================");  newline(); // description line 2
+    write(desc2);                    newline(); // description line 2
     write("node id assign");         newline();
     write("element id assign");      newline();
 }

src/conversion/ensight/part/ensightPart.H

@@ -311,27 +311,6 @@ public:
         //- Helper: write geometry given the pointField
         void writeGeometry(ensightGeoFile&, const pointField&) const;
 
-        //- Write scalar field
-        //  optionally write data per node
-        void writeScalarField
-        (
-            ensightFile&,
-            const List<scalar>& field,
-            const bool perNode = false
-        ) const;
-
-        //- Write vector field components
-        //  optionally write data per node
-        void writeVectorField
-        (
-            ensightFile&,
-            const List<scalar>& field0,
-            const List<scalar>& field1,
-            const List<scalar>& field2,
-            const bool perNode = false
-        ) const;
-
-
         //- Write generalized field components
         //  optionally write data per node
         template<class Type>

src/conversion/ensight/part/ensightPartIO.C

@@ -213,78 +213,6 @@ void Foam::ensightPart::writeGeometry
 }
 
 
-void Foam::ensightPart::writeScalarField
-(
-    ensightFile& os,
-    const List<scalar>& field,
-    const bool perNode
-) const
-{
-    if (size() && field.size() && (os.allowUndef() || isFieldDefined(field)))
-    {
-        writeHeader(os);
-
-        if (perNode)
-        {
-            os.writeKeyword("coordinates");
-            writeFieldList(os, field, labelUList::null());
-        }
-        else
-        {
-            forAll(elementTypes(), elemI)
-            {
-                const labelUList& idList = elemLists_[elemI];
-
-                if (idList.size())
-                {
-                    os.writeKeyword(elementTypes()[elemI]);
-                    writeFieldList(os, field, idList);
-                }
-            }
-        }
-    }
-}
-
-
-void Foam::ensightPart::writeVectorField
-(
-    ensightFile& os,
-    const List<scalar>& field0,
-    const List<scalar>& field1,
-    const List<scalar>& field2,
-    const bool perNode
-) const
-{
-    if (size() && field0.size() && (os.allowUndef() || isFieldDefined(field0)))
-    {
-        writeHeader(os);
-
-        if (perNode)
-        {
-            os.writeKeyword("coordinates");
-            writeFieldList(os, field0, labelUList::null());
-            writeFieldList(os, field1, labelUList::null());
-            writeFieldList(os, field2, labelUList::null());
-        }
-        else
-        {
-            forAll(elementTypes(), elemI)
-            {
-                const labelUList& idList = elemLists_[elemI];
-
-                if (idList.size())
-                {
-                    os.writeKeyword(elementTypes()[elemI]);
-                    writeFieldList(os, field0, idList);
-                    writeFieldList(os, field1, idList);
-                    writeFieldList(os, field2, idList);
-                }
-            }
-        }
-    }
-}
-
-
 // * * * * * * * * * * * * * * * IOstream Operators  * * * * * * * * * * * * //
 
 Foam::Ostream& Foam::operator<<

src/conversion/ensight/part/ensightPartTemplates.C

@@ -3,7 +3,7 @@
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
     \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
-     \\/     M anipulation  |
+     \\/     M anipulation  | Copyright (C) 2016 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -27,6 +27,7 @@ Description
 \*---------------------------------------------------------------------------*/
 
 #include "ensightPart.H"
+#include "ensightPTraits.H"
 
 // * * * * * * * * * * * * * * * Global Functions  * * * * * * * * * * * * * //
 
@@ -45,13 +46,9 @@ void Foam::ensightPart::writeField
         if (perNode)
         {
             os.writeKeyword("coordinates");
-            for
+            for (direction d=0; d < pTraits<Type>::nComponents; ++d)
-            (
-                direction cmpt=0;
-                cmpt < pTraits<Type>::nComponents;
-                ++cmpt
-            )
             {
+                label cmpt = ensightPTraits<Type>::componentOrder[d];
                 writeFieldList(os, field.component(cmpt), labelUList::null());
             }
         }
@@ -65,13 +62,9 @@ void Foam::ensightPart::writeField
                 {
                     os.writeKeyword(elementTypes()[elemI]);
 
-                    for
+                    for (direction d=0; d < pTraits<Type>::nComponents; ++d)
-                    (
-                        direction cmpt=0;
-                        cmpt < pTraits<Type>::nComponents;
-                        ++cmpt
-                    )
                     {
+                        label cmpt = ensightPTraits<Type>::componentOrder[d];
                         writeFieldList(os, field.component(cmpt), idList);
                     }
                 }

src/conversion/ensight/part/ensightParts.C

@@ -225,59 +225,6 @@ void Foam::ensightParts::writeData(Ostream& os) const
 }
 
 
-void Foam::ensightParts::writeScalarField
-(
-    ensightFile& os,
-    const List<scalar>& field,
-    const bool useFaceData,
-    const bool perNode
-) const
-{
-    forAll(partsList_, partI)
-    {
-        if
-        (
-            useFaceData
-          ? partsList_[partI].isFaceData()
-          : partsList_[partI].isCellData()
-        )
-        {
-            partsList_[partI].writeScalarField(os, field, perNode);
-        }
-    }
-}
-
-
-void Foam::ensightParts::writeVectorField
-(
-    ensightFile& os,
-    const List<scalar>& field0,
-    const List<scalar>& field1,
-    const List<scalar>& field2,
-    const bool useFaceData,
-    const bool perNode
-) const
-{
-    forAll(partsList_, partI)
-    {
-        if
-        (
-            useFaceData
-          ? partsList_[partI].isFaceData()
-          : partsList_[partI].isCellData()
-        )
-        {
-            partsList_[partI].writeVectorField
-            (
-                os,
-                field0, field1, field2,
-                perNode
-            );
-        }
-    }
-}
-
-
 // * * * * * * * * * * * * * * * *  IOStream operators * * * * * * * * * * * //
 
 Foam::ensightGeoFile& Foam::operator<<

src/conversion/ensight/part/ensightParts.H

@@ -115,31 +115,6 @@ public:
         //- Write the lists
         void writeData(Ostream&) const;
 
-        //- Write (volume) scalar field
-        //  optionally write data for face parts
-        //  optionally write data per node
-        void writeScalarField
-        (
-            ensightFile&,
-            const List<scalar>& field,
-            const bool useFaceData = false,
-            const bool perNode = false
-        ) const;
-
-        //- Write (volume) vector field components
-        //  optionally write data for face parts
-        //  optionally write data per node
-        void writeVectorField
-        (
-            ensightFile&,
-            const List<scalar>& field0,
-            const List<scalar>& field1,
-            const List<scalar>& field2,
-            const bool useFaceData = false,
-            const bool perNode = false
-        ) const;
-
-
         //- Write generalized volume field components
         template<class Type>
         void writeField

src/dummyThirdParty/metisDecomp/metis.h

@@ -1,5 +1,5 @@
 #ifndef METIS_H
-#define METIS_H 1
+#define METIS_H
 
 /* *** DUMMY VERSION of metis.h - this file should not be included if you have metis
  *     installed in the correct position in $WM_THIRD_PARTY_DIR - see
@@ -8,39 +8,52 @@
 
 #warning "Dummy metis.h - gets included since it cannot find metis installation."
 
-#define IDXTYPEWIDTH 32
+// Integer type: OpenFOAM uses WM_LABEL_SIZE, metis.h uses IDXTYPEWIDTH
+#if WM_LABEL_SIZE == 32
+  typedef int32_t idx_t;
 
-/*------------------------------------------------------------------------
+  #define IDXTYPEWIDTH 32
-* Undefine the following #define in order to use short idxtype as the idxtype 
-*-------------------------------------------------------------------------*/
-#if IDXTYPEWIDTH == 32
   #define SCNIDX  SCNd32
   #define PRIIDX  PRId32
+#elif WM_LABEL_SIZE == 64
+  typedef int64_t idx_t;
 
-  typedef int32_t idxtype;
+  #define IDXTYPEWIDTH 64
-#elif IDXTYPEWIDTH == 64
   #define SCNIDX  SCNd64
   #define PRIIDX  PRId64
-
-  typedef int64_t idxtype;
 #else
-  #error "Incorrect user-supplied value fo IDXTYPEWIDTH"
+  #error "Incorrect user-supplied value for WM_LABEL_SIZE  (metis IDXTYPEWIDTH)"
 #endif
 
 
-void METIS_WPartGraphRecursive(idxtype *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt,
+// Float type: OpenFOAM uses WM_SP, WM_DP, metis.h uses REALTYPEWIDTH
-                   idxtype *adjwgt, idxtype *wgtflag, idxtype *numflag, idxtype *nparts, float *tpwgts, 
+#if defined(WM_SP)
-                   idxtype *options, idxtype *edgecut, idxtype *part);
+  typedef float real_t;
-void METIS_PartGraphRecursive(idxtype *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt,
+  #define REALTYPEWIDTH 32
-                   idxtype *adjwgt, idxtype *wgtflag, idxtype *numflag, idxtype *nparts, idxtype *options, 
+#elif defined(WM_DP)
-                   idxtype *edgecut, idxtype *part);
+  typedef double real_t;
-void METIS_WPartGraphKway(idxtype *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, 
+  #define REALTYPEWIDTH 64
-                   idxtype *adjwgt, idxtype *wgtflag, idxtype *numflag, idxtype *nparts, float *tpwgts, 
+#else
-                   idxtype *options, idxtype *edgecut, idxtype *part); 
+  #error "Incorrect user-supplied value for WM_SP / WM_DP  (metis REALTYPEWIDTH)"
-void METIS_PartGraphKway(idxtype *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, 
+#endif
-                   idxtype *adjwgt, idxtype *wgtflag, idxtype *numflag, idxtype *nparts, idxtype *options, 
-                   idxtype *edgecut, idxtype *part); 
 
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+int            METIS_PartGraphRecursive(idx_t *nvtxs, idx_t *ncon, idx_t *xadj,
+                  idx_t *adjncy, idx_t *vwgt, idx_t *vsize, idx_t *adjwgt,
+                  idx_t *nparts, real_t *tpwgts, real_t *ubvec, idx_t *options,
+                  idx_t *edgecut, idx_t *part);
+
+int            METIS_PartGraphKway(idx_t *nvtxs, idx_t *ncon, idx_t *xadj,
+                  idx_t *adjncy, idx_t *vwgt, idx_t *vsize, idx_t *adjwgt,
+                  idx_t *nparts, real_t *tpwgts, real_t *ubvec, idx_t *options,
+                  idx_t *edgecut, idx_t *part);
+
+#ifdef __cplusplus
+}
+#endif
+
 
 #endif

src/functionObjects/field/Make/files

@@ -72,4 +72,7 @@ externalCoupled/externalCoupled.C
 externalCoupled/externalCoupledMixed/externalCoupledMixedFvPatchFields.C
 externalCoupled/externalCoupledTemperatureMixed/externalCoupledTemperatureMixedFvPatchScalarField.C
 
+ddt2/ddt2.C
+zeroGradient/zeroGradient.C
+
 LIB = $(FOAM_LIBBIN)/libfieldFunctionObjects

src/functionObjects/field/ddt2/ddt2.C

@@ -0,0 +1,269 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2016 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 3 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, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "ddt2.H"
+
+#include "volFields.H"
+#include "dictionary.H"
+#include "FieldFunctions.H"
+#include "steadyStateDdtScheme.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace functionObjects
+{
+    defineTypeNameAndDebug(ddt2, 0);
+
+    addToRunTimeSelectionTable
+    (
+        functionObject,
+        ddt2,
+        dictionary
+    );
+}
+}
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+bool Foam::functionObjects::ddt2::checkFormatName(const word& str)
+{
+    if (str.find("@@") == string::npos)
+    {
+        WarningInFunction
+            << "Bad result naming "
+            << "(no '@@' token found), deactivating."
+            << nl << endl;
+
+        return false;
+    }
+    else if (str == "@@")
+    {
+        WarningInFunction
+            << "Bad result naming "
+            << "(only a '@@' token found), deactivating."
+            << nl
+            << endl;
+
+        return false;
+    }
+    else
+    {
+        return true;
+    }
+}
+
+
+void Foam::functionObjects::ddt2::uniqWords(wordReList& lst)
+{
+    boolList retain(lst.size());
+    wordHashSet uniq;
+    forAll(lst, i)
+    {
+        const wordRe& select = lst[i];
+
+        retain[i] =
+        (
+            select.isPattern()
+         || uniq.insert(static_cast<const word&>(select))
+        );
+    }
+
+    inplaceSubset(retain, lst);
+}
+
+
+bool Foam::functionObjects::ddt2::accept(const word& fieldName) const
+{
+    // check input vs possible result names
+    // to avoid circular calculations
+    return !blacklist_.match(fieldName);
+}
+
+
+int Foam::functionObjects::ddt2::process(const word& fieldName)
+{
+    if (!accept(fieldName))
+    {
+        return -1;
+    }
+
+    int state = 0;
+
+    apply<volScalarField>(fieldName, state);
+    apply<volVectorField>(fieldName, state);
+
+    return state;
+}
+
+
+void Foam::functionObjects::ddt2::process()
+{
+    results_.clear();
+
+    wordHashSet candidates = subsetStrings(selectFields_, mesh_.names());
+    DynamicList<word> missing(selectFields_.size());
+    DynamicList<word> ignored(selectFields_.size());
+
+    // check exact matches first
+    forAll(selectFields_, i)
+    {
+        const wordRe& select = selectFields_[i];
+        if (!select.isPattern())
+        {
+            const word& fieldName = static_cast<const word&>(select);
+
+            if (!candidates.erase(fieldName))
+            {
+                missing.append(fieldName);
+            }
+            else if (process(fieldName) < 1)
+            {
+                ignored.append(fieldName);
+            }
+        }
+    }
+
+    forAllConstIter(wordHashSet, candidates, iter)
+    {
+        process(iter.key());
+    }
+
+    if (missing.size())
+    {
+        WarningInFunction
+            << "Missing field " << missing << endl;
+    }
+    if (ignored.size())
+    {
+        WarningInFunction
+            << "Unprocessed field " << ignored << endl;
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::functionObjects::ddt2::ddt2
+(
+    const word& name,
+    const Time& runTime,
+    const dictionary& dict
+)
+:
+    fvMeshFunctionObject(name, runTime, dict),
+    selectFields_(),
+    resultName_(word::null),
+    blacklist_(),
+    results_(),
+    mag_(dict.lookupOrDefault<Switch>("mag", false))
+{
+    read(dict);
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::functionObjects::ddt2::~ddt2()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+bool Foam::functionObjects::ddt2::read(const dictionary& dict)
+{
+    if (word(mesh_.ddtScheme("default")) == "steadyState")
+    {
+        WarningInFunction
+            << typeName << " function object not appropriate for steady-state"
+            << endl;
+        return false;
+    }
+
+    dict.lookup("fields") >> selectFields_;
+    uniqWords(selectFields_);
+
+    resultName_ = dict.lookupOrDefault<word>
+    (
+        "result",
+        ( mag_ ? "mag(ddt(@@))" : "magSqr(ddt(@@))" )
+    );
+
+    if (checkFormatName(resultName_))
+    {
+        blacklist_.set
+        (
+            string::quotemeta<regExp>
+            (
+                resultName_
+            ).replace("@@", "(.+)")
+        );
+
+        return true;
+    }
+    else
+    {
+        blacklist_.clear();
+        return false;
+    }
+}
+
+
+bool Foam::functionObjects::ddt2::execute()
+{
+    results_.clear();
+    process();
+
+    return true;
+}
+
+
+bool Foam::functionObjects::ddt2::write()
+{
+    // Consistent output order
+    const wordList outputList = results_.sortedToc();
+
+    forAll(outputList, i)
+    {
+        const word& fieldName = outputList[i];
+
+        if (foundObject<regIOobject>(fieldName))
+        {
+            const regIOobject& io = lookupObject<regIOobject>(fieldName);
+
+            Log << type() << " " << name()
+                << " write: writing field " << fieldName << endl;
+
+            io.write();
+        }
+    }
+
+    return true;
+}
+
+
+// ************************************************************************* //

src/functionObjects/field/ddt2/ddt2.H

@@ -0,0 +1,200 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2016 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 3 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, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::ddt2
+
+Group
+    grpFVFunctionObjects
+
+Description
+    This function object calculates the magnitude squared
+    of d(scalarField)/dt.
+
+    The result can be used further for determining variance or RMS values
+    (for example).
+
+    Example of function object specification:
+    \verbatim
+    dpdt2
+    {
+        type        ddt2;
+        libs        ("libfieldFunctionObjects.so");
+        fields      (p);
+        result      d@@dt2;
+        ...
+    }
+    \endverbatim
+
+    \heading Function object usage
+    \table
+        Property | Description                | Required  | Default value
+        type     | type name: ddt2            | yes       |
+        fields   | Name of fields to process  | yes       |
+        result   | Name of results            | no        | magSqr(ddt(@@))
+        log      | Log to standard output     | no        | yes
+        mag      | Use 'mag' instead of 'magSqr' | no     | false
+    \endtable
+
+    Note that the optional 'mag' entry cannot be changed during the simulation
+    since it alters the dimensions of the output field.
+
+    A list of fields can contain exact names or regular expressions.
+    The token '\@\@' in the result name is replaced by the name of the source
+    field.
+
+    The function object will skip over fields that appear to have
+    already been processed (ie, their names are similar to the output names).
+
+SourceFiles
+    ddt2.C
+    IOddt2.H
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef functionObjects_ddt2_H
+#define functionObjects_ddt2_H
+
+#include "fvMeshFunctionObject.H"
+#include "volFieldsFwd.H"
+#include "OFstream.H"
+#include "wordReList.H"
+#include "regExp.H"
+#include "HashSet.H"
+#include "Switch.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace functionObjects
+{
+
+/*---------------------------------------------------------------------------*\
+                            Class ddt2 Declaration
+\*---------------------------------------------------------------------------*/
+
+class ddt2
+:
+    public fvMeshFunctionObject
+{
+    // Private data
+
+        //- Name of fields to process
+        wordReList selectFields_;
+
+        //- Formatting for the result fields.
+        word resultName_;
+
+        //- Avoid processing the same field twice.
+        mutable regExp blacklist_;
+
+        //- Hashed names of result fields.
+        wordHashSet results_;
+
+        //- Use 'mag' instead of 'magSqr'.
+        //  Cannot be adjusted during the simulation since it alters the
+        //  dimensions of the output field.
+        const Switch mag_;
+
+
+    // Private Member Functions
+
+        //- Check that the word contains the appropriate substitution token(s).
+        static bool checkFormatName(const word&);
+
+        //- Eliminate duplicate 'word' entries
+        static void uniqWords(wordReList&);
+
+
+        //- Accept unless field name appears to have already been processed
+        bool accept(const word& fieldName) const;
+
+        //- Apply for the volume field type
+        template<class FieldType>
+        int apply(const word& inputName, int& state);
+
+        //- Process by trying to apply for various volume field types.
+        int process(const word& inputName);
+
+        //- Calculate the ddt2 fields
+        void process();
+
+
+        //- Disallow default bitwise copy construct
+        ddt2(const ddt2&) = delete;
+
+        //- Disallow default bitwise assignment
+        void operator=(const ddt2&) = delete;
+
+
+public:
+
+    //- Runtime type information
+    TypeName("ddt2");
+
+
+    // Constructors
+
+        //- Construct from Time and dictionary
+        ddt2
+        (
+            const word& name,
+            const Time& runTime,
+            const dictionary& dict
+        );
+
+
+    //- Destructor
+    virtual ~ddt2();
+
+
+    // Member Functions
+
+        //- Return name of the ddt2 function object
+        virtual bool read(const dictionary&);
+
+        //- Calculate the ddt2 fields
+        virtual bool execute();
+
+        //- Write the ddt fields
+        virtual bool write();
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace functionObjects
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+    #include "ddt2Templates.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/functionObjects/field/ddt2/ddt2Templates.C

@@ -0,0 +1,103 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2016 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 3 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, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "Time.H"
+#include "dimensionedType.H"
+#include "fvcDdt.H"
+
+template<class FieldType>
+int Foam::functionObjects::ddt2::apply(const word& inputName, int& state)
+{
+    // State: return 0 (not-processed), -1 (skip), +1 ok
+
+    // Already done, or not available
+    if (state || !foundObject<FieldType>(inputName))
+    {
+        return state;
+    }
+
+    const FieldType& input = lookupObject<FieldType>(inputName);
+
+    word outputName(resultName_);
+    outputName.replace("@@", inputName);
+
+    results_.set(outputName);
+
+    if (!foundObject<volScalarField>(outputName))
+    {
+        tmp<volScalarField> tddt2
+        (
+            new volScalarField
+            (
+                IOobject
+                (
+                    outputName,
+                    time_.timeName(),
+                    mesh_,
+                    IOobject::NO_READ,
+                    IOobject::NO_WRITE
+                ),
+                mesh_,
+                dimensionedScalar
+                (
+                    "0",
+                    (
+                        mag_
+                      ? mag(input.dimensions()/dimTime)
+                      : magSqr(input.dimensions()/dimTime)
+                    ),
+                    Zero
+                )
+            )
+        );
+
+        store(outputName, tddt2);
+    }
+
+    volScalarField& output = const_cast<volScalarField&>
+    (
+        lookupObject<volScalarField>(outputName)
+    );
+
+    if (mag_)
+    {
+        output = mag(fvc::ddt(input));
+    }
+    else
+    {
+        output = magSqr(fvc::ddt(input));
+    }
+
+    // Could add additional statistics here
+    Log << type() << " " << name()
+        << " field " << outputName
+        << " average: " << gAverage(output) << endl;
+
+    state = +1;
+    return state;
+}
+
+
+// ************************************************************************* //

src/functionObjects/field/zeroGradient/zeroGradient.C

@@ -0,0 +1,223 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2016 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 3 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, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "zeroGradient.H"
+
+#include "volFields.H"
+#include "dictionary.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace functionObjects
+{
+    defineTypeNameAndDebug(zeroGradient, 0);
+
+    addToRunTimeSelectionTable
+    (
+        functionObject,
+        zeroGradient,
+        dictionary
+    );
+}
+}
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+bool Foam::functionObjects::zeroGradient::checkFormatName(const word& str)
+{
+    if (str.find("@@") == string::npos)
+    {
+        WarningInFunction
+            << "Bad result naming "
+            << "(no '@@' token found), deactivating."
+            << nl << endl;
+
+        return false;
+    }
+    else if (str == "@@")
+    {
+        WarningInFunction
+            << "Bad result naming "
+            << "(only a '@@' token found), deactivating."
+            << nl
+            << endl;
+
+        return false;
+    }
+    else
+    {
+        return true;
+    }
+}
+
+
+void Foam::functionObjects::zeroGradient::uniqWords(wordReList& lst)
+{
+    boolList retain(lst.size());
+    wordHashSet uniq;
+    forAll(lst, i)
+    {
+        const wordRe& select = lst[i];
+
+        retain[i] =
+        (
+            select.isPattern()
+         || uniq.insert(static_cast<const word&>(select))
+        );
+    }
+
+    inplaceSubset(retain, lst);
+}
+
+
+int Foam::functionObjects::zeroGradient::process(const word& fieldName)
+{
+    int state = 0;
+    apply<scalar>(fieldName, state);
+    apply<vector>(fieldName, state);
+    apply<sphericalTensor>(fieldName, state);
+    apply<symmTensor>(fieldName, state);
+    apply<tensor>(fieldName, state);
+
+    return state;
+}
+
+
+void Foam::functionObjects::zeroGradient::process()
+{
+    results_.clear();
+
+    wordHashSet candidates = subsetStrings(selectFields_, mesh_.names());
+    DynamicList<word> missing(selectFields_.size());
+    DynamicList<word> ignored(selectFields_.size());
+
+    // check exact matches first
+    forAll(selectFields_, i)
+    {
+        const wordRe& select = selectFields_[i];
+        if (!select.isPattern())
+        {
+            const word& fieldName = static_cast<const word&>(select);
+
+            if (!candidates.erase(fieldName))
+            {
+                missing.append(fieldName);
+            }
+            else if (process(fieldName) < 1)
+            {
+                ignored.append(fieldName);
+            }
+        }
+    }
+
+    forAllConstIter(wordHashSet, candidates, iter)
+    {
+        process(iter.key());
+    }
+
+    if (missing.size())
+    {
+        WarningInFunction
+            << "Missing field " << missing << endl;
+    }
+    if (ignored.size())
+    {
+        WarningInFunction
+            << "Unprocessed field " << ignored << endl;
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::functionObjects::zeroGradient::zeroGradient
+(
+    const word& name,
+    const Time& runTime,
+    const dictionary& dict
+)
+:
+    fvMeshFunctionObject(name, runTime, dict),
+    selectFields_(),
+    resultName_(string::null),
+    results_()
+{
+    read(dict);
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::functionObjects::zeroGradient::~zeroGradient()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+bool Foam::functionObjects::zeroGradient::read(const dictionary& dict)
+{
+    dict.lookup("fields") >> selectFields_;
+    uniqWords(selectFields_);
+
+    resultName_ = dict.lookupOrDefault<word>("result", type() + "(@@)");
+    return checkFormatName(resultName_);
+}
+
+
+bool Foam::functionObjects::zeroGradient::execute()
+{
+    results_.clear();
+    return true;
+}
+
+
+bool Foam::functionObjects::zeroGradient::write()
+{
+    // Consistent output order
+    const wordList outputList = results_.sortedToc();
+
+    forAll(outputList, i)
+    {
+        const word& fieldName = outputList[i];
+
+        if (foundObject<regIOobject>(fieldName))
+        {
+            const regIOobject& io = lookupObject<regIOobject>(fieldName);
+
+            Log << type() << " " << name()
+                << " write: writing field " << fieldName << endl;
+
+            io.write();
+        }
+    }
+
+    return true;
+}
+
+
+// ************************************************************************* //

src/functionObjects/field/zeroGradient/zeroGradient.H

@@ -0,0 +1,188 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2016 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 3 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, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::zeroGradient
+
+Group
+    grpFVFunctionObjects
+
+Description
+    This function object creates a volume field with zero-gradient
+    boundary conditions from another volume field.
+
+    The result can be used, for example, to post-process near-wall
+    field values.
+
+    Example of function object specification:
+    \verbatim
+    zeroGrad
+    {
+        type        zeroGradient;
+        libs        ("libfieldFunctionObjects.so");
+        fields      (U "(T|k|epsilon|omega)");
+        result      @@nearWall;
+        ...
+    }
+    \endverbatim
+
+    \heading Function object usage
+    \table
+        Property | Description                | Required  | Default value
+        type     | type name: zeroGradient    | yes       |
+        fields   | Name of fields to process  | yes       |
+        result   | Name of results            | no        | zeroGradient(@@)
+        log      | Log to standard output     | no        | no
+    \endtable
+
+    A list of fields can contain exact names or regular expressions.
+    The token '\@\@' in the result name is replaced by the name of the source
+    field.
+
+    The function object will skip over fields that would not benefit
+    - ie, only processor, empty, zeroGradient, symmetry patches.
+    This check should also prevent processing fields multiple times.
+
+SourceFiles
+    zeroGradient.C
+    zeroGradientFunctionObject.C
+    IOzeroGradient.H
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef functionObjects_zeroGradient_H
+#define functionObjects_zeroGradient_H
+
+#include "fvMeshFunctionObject.H"
+#include "volFieldsFwd.H"
+#include "OFstream.H"
+#include "wordReList.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace functionObjects
+{
+
+/*---------------------------------------------------------------------------*\
+                        Class zeroGradient Declaration
+\*---------------------------------------------------------------------------*/
+
+class zeroGradient
+:
+    public fvMeshFunctionObject
+{
+    // Private data
+
+        //- Name of fields to process
+        wordReList selectFields_;
+
+        //- Formatting for the result fields.
+        word resultName_;
+
+        //- Hashed names of result fields, and their type
+        HashTable<word> results_;
+
+
+    // Private Member Functions
+
+        //- Check that the word contains the appropriate substitution token(s).
+        static bool checkFormatName(const word&);
+
+        //- Eliminate duplicate 'word' entries
+        static void uniqWords(wordReList&);
+
+
+        //- Accept unless field only has empty/zero-gradient/processor patches
+        template<class Type>
+        static bool accept(const GeometricField<Type, fvPatchField, volMesh>&);
+
+        //- Apply for the volume field type
+        template<class Type>
+        int apply(const word& inputName, int& state);
+
+        //- Process by trying to apply for various volume field types.
+        int process(const word& inputName);
+
+        //- Calculate the zeroGradient fields
+        void process();
+
+
+        //- Disallow default bitwise copy construct
+        zeroGradient(const zeroGradient&) = delete;
+
+        //- Disallow default bitwise assignment
+        void operator=(const zeroGradient&) = delete;
+
+
+public:
+
+    //- Runtime type information
+    TypeName("zeroGradient");
+
+
+    // Constructors
+
+        //- Construct from Time and dictionary
+        zeroGradient
+        (
+            const word& name,
+            const Time& runTime,
+            const dictionary& dict
+        );
+
+
+    //- Destructor
+    virtual ~zeroGradient();
+
+
+    // Member Functions
+
+        //- Read the zeroGradient specification
+        virtual bool read(const dictionary& dict);
+
+        //- Calculate the zeroGradient fields
+        virtual bool execute();
+
+        //- Write the zeroGradient fields
+        virtual bool write();
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace functionObjects
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+    #include "zeroGradientTemplates.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/functionObjects/field/zeroGradient/zeroGradientTemplates.C

@@ -0,0 +1,115 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2016 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 3 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, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "polyPatch.H"
+#include "Time.H"
+#include "zeroGradientFvPatchField.H"
+
+template<class Type>
+bool Foam::functionObjects::zeroGradient::accept
+(
+    const GeometricField<Type, fvPatchField, volMesh>& input
+)
+{
+    const typename GeometricField<Type, fvPatchField, volMesh>::Boundary&
+        patches = input.boundaryField();
+
+    forAll(patches, patchi)
+    {
+        const fvPatchField<Type>& p = patches[patchi];
+        const polyPatch& pp = p.patch().patch();
+
+        return !polyPatch::constraintType(pp.type());
+    }
+
+    return false;
+}
+
+
+template<class Type>
+int Foam::functionObjects::zeroGradient::apply
+(
+    const word& inputName,
+    int& state
+)
+{
+    typedef GeometricField<Type, fvPatchField, volMesh> VolFieldType;
+
+    // State: return 0 (not-processed), -1 (skip), +1 ok
+
+    // Already done, or not available
+    if (state || !foundObject<VolFieldType>(inputName))
+    {
+        return state;
+    }
+
+    const VolFieldType& input = lookupObject<VolFieldType>(inputName);
+
+    if (!returnReduce(accept(input), orOp<bool>()))
+    {
+        state = -1;
+        return state;
+    }
+
+    word outputName(resultName_);
+    outputName.replace("@@", inputName);
+
+    // Also save the field-type, just in case we want it later
+    results_.set(outputName, VolFieldType::typeName);
+
+    if (!foundObject<VolFieldType>(outputName))
+    {
+        tmp<VolFieldType> tzg
+        (
+            new VolFieldType
+            (
+                IOobject
+                (
+                    outputName,
+                    time_.timeName(),
+                    mesh_,
+                    IOobject::NO_READ,
+                    IOobject::NO_WRITE
+                ),
+                mesh_,
+                dimensioned<Type>("0", input.dimensions(), Zero),
+                zeroGradientFvPatchField<Type>::typeName
+            )
+        );
+
+        store(outputName, tzg);
+    }
+
+    VolFieldType& output =
+        const_cast<VolFieldType&>(lookupObject<VolFieldType>(outputName));
+    output = input;
+    output.correctBoundaryConditions();
+
+    state = +1;
+    return state;
+}
+
+
+// ************************************************************************* //

src/parallel/decompose/metisDecomp/metisDecomp.C

@@ -67,7 +67,7 @@ Foam::label Foam::metisDecomp::decompose
 
     // Processor weights initialised with no size, only used if specified in
     // a file
-    Field<floatScalar> processorWeights;
+    Field<scalar> processorWeights;
 
     // Cell weights (so on the vertices of the dual)
     List<label> cellWeights;

src/postProcessing/functionObjects/jobControl/Make/files

@@ -1,20 +0,0 @@
-abortCalculation/abortCalculation.C
-abortCalculation/abortCalculationFunctionObject.C
-
-runTimeControl/runTimeControl.C
-runTimeControl/runTimeControlFunctionObject.C
-runTimeControl/runTimeCondition/runTimeCondition/runTimeCondition.C
-runTimeControl/runTimeCondition/runTimeCondition/runTimeConditionNew.C
-runTimeControl/runTimeCondition/equationMaxIterCondition/equationMaxIterCondition.C
-runTimeControl/runTimeCondition/equationInitialResidualCondition/equationInitialResidualCondition.C
-runTimeControl/runTimeCondition/minMaxCondition/minMaxCondition.C
-runTimeControl/runTimeCondition/averageCondition/averageCondition.C
-runTimeControl/runTimeCondition/minTimeStepCondition/minTimeStepCondition.C
-
-externalCoupled = externalCoupled
-$(externalCoupled)/externalCoupledFunctionObject.C
-$(externalCoupled)/externalCoupledMixed/externalCoupledMixedFvPatchFields.C
-$(externalCoupled)/externalCoupledTemperatureMixed/externalCoupledTemperatureMixedFvPatchScalarField.C
-
-
-LIB = $(FOAM_LIBBIN)/libjobControl