From 6c103e247d1310c1ac4c11a88fd4eafbc2e0f8c1 Mon Sep 17 00:00:00 2001
From: Henry Weller <http://cfd.direct>
Date: Wed, 8 Mar 2017 11:48:06 +0000
Subject: [PATCH] decomposePar: Added 'copyZero' option

Using

decomposePar -copyZero

The mesh is decomposed as usual but the '0' directory is recursively copied to
the 'processor.*' directories rather than decomposing the fields.  This is a
convenient option to handle cases where the initial field files are generic and
can be used for serial or parallel running.  See for example the
incompressible/simpleFoam/motorBike tutorial case.
---
 .../decomposePar/decomposePar.C               | 1316 +++++++++--------
 src/OpenFOAM/db/Time/timeSelector.C           |    8 +-
 .../simpleFoam/motorBike/Allclean             |    5 +-
 .../simpleFoam/motorBike/Allrun               |   13 +-
 4 files changed, 700 insertions(+), 642 deletions(-)

diff --git a/applications/utilities/parallelProcessing/decomposePar/decomposePar.C b/applications/utilities/parallelProcessing/decomposePar/decomposePar.C
index bc9478264..f9425cc50 100644
--- a/applications/utilities/parallelProcessing/decomposePar/decomposePar.C
+++ b/applications/utilities/parallelProcessing/decomposePar/decomposePar.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2017 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -43,6 +43,9 @@ Usage
         Decompose all regions in regionProperties. Does not check for
         existence of processor*.
 
+      - \par -copyZero \n
+        Copy \a 0 directory to processor* rather than decompose the fields.
+
       - \par -copyUniform \n
         Copy any \a uniform directories too.
 
@@ -215,6 +218,11 @@ int main(int argc, char *argv[])
         "decomposition method or as a volScalarField for post-processing."
     );
     argList::addBoolOption
+    (
+        "copyZero",
+        "Copy \a 0 directory to processor* rather than decompose the fields"
+    );
+    argList::addBoolOption
     (
         "copyUniform",
         "copy any uniform/ directories too"
@@ -247,6 +255,7 @@ int main(int argc, char *argv[])
 
     bool allRegions              = args.optionFound("allRegions");
     bool writeCellDist           = args.optionFound("cellDist");
+    bool copyZero                = args.optionFound("copyZero");
     bool copyUniform             = args.optionFound("copyUniform");
     bool decomposeFieldsOnly     = args.optionFound("fields");
     bool decomposeSets           = !args.optionFound("noSets");
@@ -476,668 +485,715 @@ int main(int argc, char *argv[])
         }
 
 
-
-        // Caches
-        // ~~~~~~
-        // Cached processor meshes and maps. These are only preserved if running
-        // with multiple times.
-        PtrList<Time> processorDbList(mesh.nProcs());
-        PtrList<fvMesh> procMeshList(mesh.nProcs());
-        PtrList<labelIOList> faceProcAddressingList(mesh.nProcs());
-        PtrList<labelIOList> cellProcAddressingList(mesh.nProcs());
-        PtrList<labelIOList> boundaryProcAddressingList(mesh.nProcs());
-        PtrList<fvFieldDecomposer> fieldDecomposerList(mesh.nProcs());
-        PtrList<dimFieldDecomposer> dimFieldDecomposerList(mesh.nProcs());
-        PtrList<labelIOList> pointProcAddressingList(mesh.nProcs());
-        PtrList<pointFieldDecomposer> pointFieldDecomposerList(mesh.nProcs());
-
-
-
-        // Loop over all times
-        forAll(times, timeI)
+        if (copyZero)
         {
-            runTime.setTime(times[timeI], timeI);
-
-            Info<< "Time = " << runTime.timeName() << endl;
-
-            // Search for list of objects for this time
-            IOobjectList objects(mesh, runTime.timeName());
-
-
-            // Construct the vol fields
-            // ~~~~~~~~~~~~~~~~~~~~~~~~
-            PtrList<volScalarField> volScalarFields;
-            readFields(mesh, objects, volScalarFields);
-            PtrList<volVectorField> volVectorFields;
-            readFields(mesh, objects, volVectorFields);
-            PtrList<volSphericalTensorField> volSphericalTensorFields;
-            readFields(mesh, objects, volSphericalTensorFields);
-            PtrList<volSymmTensorField> volSymmTensorFields;
-            readFields(mesh, objects, volSymmTensorFields);
-            PtrList<volTensorField> volTensorFields;
-            readFields(mesh, objects, volTensorFields);
-
-
-            // Construct the dimensioned fields
-            // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-            PtrList<DimensionedField<scalar, volMesh>> dimScalarFields;
-            readFields(mesh, objects, dimScalarFields);
-            PtrList<DimensionedField<vector, volMesh>> dimVectorFields;
-            readFields(mesh, objects, dimVectorFields);
-            PtrList<DimensionedField<sphericalTensor, volMesh>>
-                dimSphericalTensorFields;
-            readFields(mesh, objects, dimSphericalTensorFields);
-            PtrList<DimensionedField<symmTensor, volMesh>> dimSymmTensorFields;
-            readFields(mesh, objects, dimSymmTensorFields);
-            PtrList<DimensionedField<tensor, volMesh>> dimTensorFields;
-            readFields(mesh, objects, dimTensorFields);
-
-
-            // Construct the surface fields
-            // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-            PtrList<surfaceScalarField> surfaceScalarFields;
-            readFields(mesh, objects, surfaceScalarFields);
-            PtrList<surfaceVectorField> surfaceVectorFields;
-            readFields(mesh, objects, surfaceVectorFields);
-            PtrList<surfaceSphericalTensorField> surfaceSphericalTensorFields;
-            readFields(mesh, objects, surfaceSphericalTensorFields);
-            PtrList<surfaceSymmTensorField> surfaceSymmTensorFields;
-            readFields(mesh, objects, surfaceSymmTensorFields);
-            PtrList<surfaceTensorField> surfaceTensorFields;
-            readFields(mesh, objects, surfaceTensorFields);
-
-
-            // Construct the point fields
-            // ~~~~~~~~~~~~~~~~~~~~~~~~~~
-            const pointMesh& pMesh = pointMesh::New(mesh);
-
-            PtrList<pointScalarField> pointScalarFields;
-            readFields(pMesh, objects, pointScalarFields);
-            PtrList<pointVectorField> pointVectorFields;
-            readFields(pMesh, objects, pointVectorFields);
-            PtrList<pointSphericalTensorField> pointSphericalTensorFields;
-            readFields(pMesh, objects, pointSphericalTensorFields);
-            PtrList<pointSymmTensorField> pointSymmTensorFields;
-            readFields(pMesh, objects, pointSymmTensorFields);
-            PtrList<pointTensorField> pointTensorFields;
-            readFields(pMesh, objects, pointTensorFields);
-
-
-            // Construct the Lagrangian fields
-            // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-            fileNameList cloudDirs
-            (
-                readDir(runTime.timePath()/cloud::prefix, fileName::DIRECTORY)
-            );
-
-            // Particles
-            PtrList<Cloud<indexedParticle>> lagrangianPositions
-            (
-                cloudDirs.size()
-            );
-            // Particles per cell
-            PtrList<List<SLList<indexedParticle*>*>> cellParticles
-            (
-                cloudDirs.size()
-            );
-
-            PtrList<PtrList<labelIOField>> lagrangianLabelFields
-            (
-                cloudDirs.size()
-            );
-            PtrList<PtrList<labelFieldCompactIOField>>
-            lagrangianLabelFieldFields
-            (
-                cloudDirs.size()
-            );
-            PtrList<PtrList<scalarIOField>> lagrangianScalarFields
-            (
-                cloudDirs.size()
-            );
-            PtrList<PtrList<scalarFieldCompactIOField>>
-            lagrangianScalarFieldFields
-            (
-                cloudDirs.size()
-            );
-            PtrList<PtrList<vectorIOField>> lagrangianVectorFields
-            (
-                cloudDirs.size()
-            );
-            PtrList<PtrList<vectorFieldCompactIOField>>
-            lagrangianVectorFieldFields
-            (
-                cloudDirs.size()
-            );
-            PtrList<PtrList<sphericalTensorIOField>>
-            lagrangianSphericalTensorFields
-            (
-                cloudDirs.size()
-            );
-            PtrList<PtrList<sphericalTensorFieldCompactIOField>>
-                lagrangianSphericalTensorFieldFields(cloudDirs.size());
-            PtrList<PtrList<symmTensorIOField>> lagrangianSymmTensorFields
-            (
-                cloudDirs.size()
-            );
-            PtrList<PtrList<symmTensorFieldCompactIOField>>
-            lagrangianSymmTensorFieldFields
-            (
-                cloudDirs.size()
-            );
-            PtrList<PtrList<tensorIOField>> lagrangianTensorFields
-            (
-                cloudDirs.size()
-            );
-            PtrList<PtrList<tensorFieldCompactIOField>>
-            lagrangianTensorFieldFields
-            (
-                cloudDirs.size()
-            );
-
-            label cloudI = 0;
-
-            forAll(cloudDirs, i)
+            // Link the 0 directory into each of the processor directories
+            for (label proci = 0; proci < mesh.nProcs(); proci++)
             {
-                IOobjectList sprayObjs
+                Time processorDb
                 (
-                    mesh,
-                    runTime.timeName(),
-                    cloud::prefix/cloudDirs[i],
-                    IOobject::MUST_READ,
-                    IOobject::NO_WRITE,
-                    false
+                    Time::controlDictName,
+                    args.rootPath(),
+                    args.caseName()/fileName(word("processor") + name(proci))
+                );
+                processorDb.setTime(runTime);
+
+                if (isDir(runTime.timePath()))
+                {
+                    const fileName timePath = processorDb.timePath();
+
+                    Info<< "Processor " << proci
+                        << ": linking " << runTime.timePath() << nl
+                        << " to " << processorDb.timePath() << endl;
+                    cp(runTime.timePath(), processorDb.timePath());
+                }
+            }
+        }
+        else
+        {
+            // Decompose the field files
+
+            // Cached processor meshes and maps. These are only preserved if
+            // running with multiple times.
+            PtrList<Time> processorDbList(mesh.nProcs());
+            PtrList<fvMesh> procMeshList(mesh.nProcs());
+            PtrList<labelIOList> faceProcAddressingList(mesh.nProcs());
+            PtrList<labelIOList> cellProcAddressingList(mesh.nProcs());
+            PtrList<labelIOList> boundaryProcAddressingList(mesh.nProcs());
+            PtrList<fvFieldDecomposer> fieldDecomposerList(mesh.nProcs());
+            PtrList<dimFieldDecomposer> dimFieldDecomposerList(mesh.nProcs());
+            PtrList<labelIOList> pointProcAddressingList(mesh.nProcs());
+            PtrList<pointFieldDecomposer> pointFieldDecomposerList
+            (
+                mesh.nProcs()
+            );
+
+
+            // Loop over all times
+            forAll(times, timeI)
+            {
+                runTime.setTime(times[timeI], timeI);
+
+                Info<< "Time = " << runTime.timeName() << endl;
+
+                // Search for list of objects for this time
+                IOobjectList objects(mesh, runTime.timeName());
+
+
+                // Construct the vol fields
+                // ~~~~~~~~~~~~~~~~~~~~~~~~
+                PtrList<volScalarField> volScalarFields;
+                readFields(mesh, objects, volScalarFields);
+                PtrList<volVectorField> volVectorFields;
+                readFields(mesh, objects, volVectorFields);
+                PtrList<volSphericalTensorField> volSphericalTensorFields;
+                readFields(mesh, objects, volSphericalTensorFields);
+                PtrList<volSymmTensorField> volSymmTensorFields;
+                readFields(mesh, objects, volSymmTensorFields);
+                PtrList<volTensorField> volTensorFields;
+                readFields(mesh, objects, volTensorFields);
+
+
+                // Construct the dimensioned fields
+                // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+                PtrList<DimensionedField<scalar, volMesh>> dimScalarFields;
+                readFields(mesh, objects, dimScalarFields);
+                PtrList<DimensionedField<vector, volMesh>> dimVectorFields;
+                readFields(mesh, objects, dimVectorFields);
+                PtrList<DimensionedField<sphericalTensor, volMesh>>
+                    dimSphericalTensorFields;
+                readFields(mesh, objects, dimSphericalTensorFields);
+                PtrList<DimensionedField<symmTensor, volMesh>>
+                    dimSymmTensorFields;
+                readFields(mesh, objects, dimSymmTensorFields);
+                PtrList<DimensionedField<tensor, volMesh>> dimTensorFields;
+                readFields(mesh, objects, dimTensorFields);
+
+
+                // Construct the surface fields
+                // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+                PtrList<surfaceScalarField> surfaceScalarFields;
+                readFields(mesh, objects, surfaceScalarFields);
+                PtrList<surfaceVectorField> surfaceVectorFields;
+                readFields(mesh, objects, surfaceVectorFields);
+                PtrList<surfaceSphericalTensorField>
+                    surfaceSphericalTensorFields;
+                readFields(mesh, objects, surfaceSphericalTensorFields);
+                PtrList<surfaceSymmTensorField> surfaceSymmTensorFields;
+                readFields(mesh, objects, surfaceSymmTensorFields);
+                PtrList<surfaceTensorField> surfaceTensorFields;
+                readFields(mesh, objects, surfaceTensorFields);
+
+
+                // Construct the point fields
+                // ~~~~~~~~~~~~~~~~~~~~~~~~~~
+                const pointMesh& pMesh = pointMesh::New(mesh);
+
+                PtrList<pointScalarField> pointScalarFields;
+                readFields(pMesh, objects, pointScalarFields);
+                PtrList<pointVectorField> pointVectorFields;
+                readFields(pMesh, objects, pointVectorFields);
+                PtrList<pointSphericalTensorField> pointSphericalTensorFields;
+                readFields(pMesh, objects, pointSphericalTensorFields);
+                PtrList<pointSymmTensorField> pointSymmTensorFields;
+                readFields(pMesh, objects, pointSymmTensorFields);
+                PtrList<pointTensorField> pointTensorFields;
+                readFields(pMesh, objects, pointTensorFields);
+
+
+                // Construct the Lagrangian fields
+                // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+                fileNameList cloudDirs
+                (
+                    readDir
+                    (
+                        runTime.timePath()/cloud::prefix, fileName::DIRECTORY
+                    )
                 );
 
-                IOobject* positionsPtr = sprayObjs.lookup(word("positions"));
+                // Particles
+                PtrList<Cloud<indexedParticle>> lagrangianPositions
+                (
+                    cloudDirs.size()
+                );
+                // Particles per cell
+                PtrList<List<SLList<indexedParticle*>*>> cellParticles
+                (
+                    cloudDirs.size()
+                );
 
-                if (positionsPtr)
+                PtrList<PtrList<labelIOField>> lagrangianLabelFields
+                (
+                    cloudDirs.size()
+                );
+                PtrList<PtrList<labelFieldCompactIOField>>
+                lagrangianLabelFieldFields
+                (
+                    cloudDirs.size()
+                );
+                PtrList<PtrList<scalarIOField>> lagrangianScalarFields
+                (
+                    cloudDirs.size()
+                );
+                PtrList<PtrList<scalarFieldCompactIOField>>
+                lagrangianScalarFieldFields
+                (
+                    cloudDirs.size()
+                );
+                PtrList<PtrList<vectorIOField>> lagrangianVectorFields
+                (
+                    cloudDirs.size()
+                );
+                PtrList<PtrList<vectorFieldCompactIOField>>
+                lagrangianVectorFieldFields
+                (
+                    cloudDirs.size()
+                );
+                PtrList<PtrList<sphericalTensorIOField>>
+                lagrangianSphericalTensorFields
+                (
+                    cloudDirs.size()
+                );
+                PtrList<PtrList<sphericalTensorFieldCompactIOField>>
+                    lagrangianSphericalTensorFieldFields(cloudDirs.size());
+                PtrList<PtrList<symmTensorIOField>> lagrangianSymmTensorFields
+                (
+                    cloudDirs.size()
+                );
+                PtrList<PtrList<symmTensorFieldCompactIOField>>
+                lagrangianSymmTensorFieldFields
+                (
+                    cloudDirs.size()
+                );
+                PtrList<PtrList<tensorIOField>> lagrangianTensorFields
+                (
+                    cloudDirs.size()
+                );
+                PtrList<PtrList<tensorFieldCompactIOField>>
+                lagrangianTensorFieldFields
+                (
+                    cloudDirs.size()
+                );
+
+                label cloudI = 0;
+
+                forAll(cloudDirs, i)
                 {
-                    // Read lagrangian particles
-                    // ~~~~~~~~~~~~~~~~~~~~~~~~~
-
-                    Info<< "Identified lagrangian data set: " << cloudDirs[i]
-                        << endl;
-
-                    lagrangianPositions.set
-                    (
-                        cloudI,
-                        new Cloud<indexedParticle>
-                        (
-                            mesh,
-                            cloudDirs[i],
-                            false
-                        )
-                    );
-
-
-                    // Sort particles per cell
-                    // ~~~~~~~~~~~~~~~~~~~~~~~
-
-                    cellParticles.set
-                    (
-                        cloudI,
-                        new List<SLList<indexedParticle*>*>
-                        (
-                            mesh.nCells(),
-                            static_cast<SLList<indexedParticle*>*>(nullptr)
-                        )
-                    );
-
-                    label i = 0;
-
-                    forAllIter
-                    (
-                        Cloud<indexedParticle>,
-                        lagrangianPositions[cloudI],
-                        iter
-                    )
-                    {
-                        iter().index() = i++;
-
-                        label celli = iter().cell();
-
-                        // Check
-                        if (celli < 0 || celli >= mesh.nCells())
-                        {
-                            FatalErrorInFunction
-                                << "Illegal cell number " << celli
-                                << " for particle with index " << iter().index()
-                                << " at position " << iter().position() << nl
-                                << "Cell number should be between 0 and "
-                                << mesh.nCells()-1 << nl
-                                << "On this mesh the particle should"
-                                << " be in cell "
-                                << mesh.findCell(iter().position())
-                                << exit(FatalError);
-                        }
-
-                        if (!cellParticles[cloudI][celli])
-                        {
-                            cellParticles[cloudI][celli] =
-                                new SLList<indexedParticle*>();
-                        }
-
-                        cellParticles[cloudI][celli]->append(&iter());
-                    }
-
-                    // Read fields
-                    // ~~~~~~~~~~~
-
-                    IOobjectList lagrangianObjects
+                    IOobjectList sprayObjs
                     (
                         mesh,
                         runTime.timeName(),
-                        cloud::prefix/cloudDirs[cloudI],
+                        cloud::prefix/cloudDirs[i],
                         IOobject::MUST_READ,
                         IOobject::NO_WRITE,
                         false
                     );
 
-                    lagrangianFieldDecomposer::readFields
+                    IOobject* positionsPtr = sprayObjs.lookup
                     (
-                        cloudI,
-                        lagrangianObjects,
-                        lagrangianLabelFields
+                        word("positions")
                     );
 
-                    lagrangianFieldDecomposer::readFieldFields
-                    (
-                        cloudI,
-                        lagrangianObjects,
-                        lagrangianLabelFieldFields
-                    );
-
-                    lagrangianFieldDecomposer::readFields
-                    (
-                        cloudI,
-                        lagrangianObjects,
-                        lagrangianScalarFields
-                    );
-
-                    lagrangianFieldDecomposer::readFieldFields
-                    (
-                        cloudI,
-                        lagrangianObjects,
-                        lagrangianScalarFieldFields
-                    );
-
-                    lagrangianFieldDecomposer::readFields
-                    (
-                        cloudI,
-                        lagrangianObjects,
-                        lagrangianVectorFields
-                    );
-
-                    lagrangianFieldDecomposer::readFieldFields
-                    (
-                        cloudI,
-                        lagrangianObjects,
-                        lagrangianVectorFieldFields
-                    );
-
-                    lagrangianFieldDecomposer::readFields
-                    (
-                        cloudI,
-                        lagrangianObjects,
-                        lagrangianSphericalTensorFields
-                    );
-
-                    lagrangianFieldDecomposer::readFieldFields
-                    (
-                        cloudI,
-                        lagrangianObjects,
-                        lagrangianSphericalTensorFieldFields
-                    );
-
-                    lagrangianFieldDecomposer::readFields
-                    (
-                        cloudI,
-                        lagrangianObjects,
-                        lagrangianSymmTensorFields
-                    );
-
-                    lagrangianFieldDecomposer::readFieldFields
-                    (
-                        cloudI,
-                        lagrangianObjects,
-                        lagrangianSymmTensorFieldFields
-                    );
-
-                    lagrangianFieldDecomposer::readFields
-                    (
-                        cloudI,
-                        lagrangianObjects,
-                        lagrangianTensorFields
-                    );
-
-                    lagrangianFieldDecomposer::readFieldFields
-                    (
-                        cloudI,
-                        lagrangianObjects,
-                        lagrangianTensorFieldFields
-                    );
-
-                    cloudI++;
-                }
-            }
-
-            lagrangianPositions.setSize(cloudI);
-            cellParticles.setSize(cloudI);
-            lagrangianLabelFields.setSize(cloudI);
-            lagrangianLabelFieldFields.setSize(cloudI);
-            lagrangianScalarFields.setSize(cloudI);
-            lagrangianScalarFieldFields.setSize(cloudI);
-            lagrangianVectorFields.setSize(cloudI);
-            lagrangianVectorFieldFields.setSize(cloudI);
-            lagrangianSphericalTensorFields.setSize(cloudI);
-            lagrangianSphericalTensorFieldFields.setSize(cloudI);
-            lagrangianSymmTensorFields.setSize(cloudI);
-            lagrangianSymmTensorFieldFields.setSize(cloudI);
-            lagrangianTensorFields.setSize(cloudI);
-            lagrangianTensorFieldFields.setSize(cloudI);
-
-            Info<< endl;
-
-            // split the fields over processors
-            for (label proci = 0; proci < mesh.nProcs(); proci++)
-            {
-                Info<< "Processor " << proci << ": field transfer" << endl;
-
-
-                // open the database
-                if (!processorDbList.set(proci))
-                {
-                    processorDbList.set
-                    (
-                        proci,
-                        new Time
-                        (
-                            Time::controlDictName,
-                            args.rootPath(),
-                            args.caseName()
-                           /fileName(word("processor") + name(proci))
-                        )
-                    );
-                }
-                Time& processorDb = processorDbList[proci];
-
-
-                processorDb.setTime(runTime);
-
-                // read the mesh
-                if (!procMeshList.set(proci))
-                {
-                    procMeshList.set
-                    (
-                        proci,
-                        new fvMesh
-                        (
-                            IOobject
-                            (
-                                regionName,
-                                processorDb.timeName(),
-                                processorDb
-                            )
-                        )
-                    );
-                }
-                const fvMesh& procMesh = procMeshList[proci];
-
-                const labelIOList& faceProcAddressing = procAddressing
-                (
-                    procMeshList,
-                    proci,
-                    "faceProcAddressing",
-                    faceProcAddressingList
-                );
-
-                const labelIOList& cellProcAddressing = procAddressing
-                (
-                    procMeshList,
-                    proci,
-                    "cellProcAddressing",
-                    cellProcAddressingList
-                );
-
-                const labelIOList& boundaryProcAddressing = procAddressing
-                (
-                    procMeshList,
-                    proci,
-                    "boundaryProcAddressing",
-                    boundaryProcAddressingList
-                );
-
-
-                // FV fields
-                {
-                    if (!fieldDecomposerList.set(proci))
+                    if (positionsPtr)
                     {
-                        fieldDecomposerList.set
+                        // Read lagrangian particles
+                        // ~~~~~~~~~~~~~~~~~~~~~~~~~
+
+                        Info<< "Identified lagrangian data set: "
+                            << cloudDirs[i] << endl;
+
+                        lagrangianPositions.set
+                        (
+                            cloudI,
+                            new Cloud<indexedParticle>
+                            (
+                                mesh,
+                                cloudDirs[i],
+                                false
+                            )
+                        );
+
+
+                        // Sort particles per cell
+                        // ~~~~~~~~~~~~~~~~~~~~~~~
+
+                        cellParticles.set
+                        (
+                            cloudI,
+                            new List<SLList<indexedParticle*>*>
+                            (
+                                mesh.nCells(),
+                                static_cast<SLList<indexedParticle*>*>(nullptr)
+                            )
+                        );
+
+                        label i = 0;
+
+                        forAllIter
+                        (
+                            Cloud<indexedParticle>,
+                            lagrangianPositions[cloudI],
+                            iter
+                        )
+                        {
+                            iter().index() = i++;
+
+                            label celli = iter().cell();
+
+                            // Check
+                            if (celli < 0 || celli >= mesh.nCells())
+                            {
+                                FatalErrorInFunction
+                                    << "Illegal cell number " << celli
+                                    << " for particle with index "
+                                    << iter().index()
+                                    << " at position "
+                                    << iter().position() << nl
+                                    << "Cell number should be between 0 and "
+                                    << mesh.nCells()-1 << nl
+                                    << "On this mesh the particle should"
+                                    << " be in cell "
+                                    << mesh.findCell(iter().position())
+                                    << exit(FatalError);
+                            }
+
+                            if (!cellParticles[cloudI][celli])
+                            {
+                                cellParticles[cloudI][celli] =
+                                    new SLList<indexedParticle*>();
+                            }
+
+                            cellParticles[cloudI][celli]->append(&iter());
+                        }
+
+                        // Read fields
+                        // ~~~~~~~~~~~
+
+                        IOobjectList lagrangianObjects
+                        (
+                            mesh,
+                            runTime.timeName(),
+                            cloud::prefix/cloudDirs[cloudI],
+                            IOobject::MUST_READ,
+                            IOobject::NO_WRITE,
+                            false
+                        );
+
+                        lagrangianFieldDecomposer::readFields
+                        (
+                            cloudI,
+                            lagrangianObjects,
+                            lagrangianLabelFields
+                        );
+
+                        lagrangianFieldDecomposer::readFieldFields
+                        (
+                            cloudI,
+                            lagrangianObjects,
+                            lagrangianLabelFieldFields
+                        );
+
+                        lagrangianFieldDecomposer::readFields
+                        (
+                            cloudI,
+                            lagrangianObjects,
+                            lagrangianScalarFields
+                        );
+
+                        lagrangianFieldDecomposer::readFieldFields
+                        (
+                            cloudI,
+                            lagrangianObjects,
+                            lagrangianScalarFieldFields
+                        );
+
+                        lagrangianFieldDecomposer::readFields
+                        (
+                            cloudI,
+                            lagrangianObjects,
+                            lagrangianVectorFields
+                        );
+
+                        lagrangianFieldDecomposer::readFieldFields
+                        (
+                            cloudI,
+                            lagrangianObjects,
+                            lagrangianVectorFieldFields
+                        );
+
+                        lagrangianFieldDecomposer::readFields
+                        (
+                            cloudI,
+                            lagrangianObjects,
+                            lagrangianSphericalTensorFields
+                        );
+
+                        lagrangianFieldDecomposer::readFieldFields
+                        (
+                            cloudI,
+                            lagrangianObjects,
+                            lagrangianSphericalTensorFieldFields
+                        );
+
+                        lagrangianFieldDecomposer::readFields
+                        (
+                            cloudI,
+                            lagrangianObjects,
+                            lagrangianSymmTensorFields
+                        );
+
+                        lagrangianFieldDecomposer::readFieldFields
+                        (
+                            cloudI,
+                            lagrangianObjects,
+                            lagrangianSymmTensorFieldFields
+                        );
+
+                        lagrangianFieldDecomposer::readFields
+                        (
+                            cloudI,
+                            lagrangianObjects,
+                            lagrangianTensorFields
+                        );
+
+                        lagrangianFieldDecomposer::readFieldFields
+                        (
+                            cloudI,
+                            lagrangianObjects,
+                            lagrangianTensorFieldFields
+                        );
+
+                        cloudI++;
+                    }
+                }
+
+                lagrangianPositions.setSize(cloudI);
+                cellParticles.setSize(cloudI);
+                lagrangianLabelFields.setSize(cloudI);
+                lagrangianLabelFieldFields.setSize(cloudI);
+                lagrangianScalarFields.setSize(cloudI);
+                lagrangianScalarFieldFields.setSize(cloudI);
+                lagrangianVectorFields.setSize(cloudI);
+                lagrangianVectorFieldFields.setSize(cloudI);
+                lagrangianSphericalTensorFields.setSize(cloudI);
+                lagrangianSphericalTensorFieldFields.setSize(cloudI);
+                lagrangianSymmTensorFields.setSize(cloudI);
+                lagrangianSymmTensorFieldFields.setSize(cloudI);
+                lagrangianTensorFields.setSize(cloudI);
+                lagrangianTensorFieldFields.setSize(cloudI);
+
+                Info<< endl;
+
+                // split the fields over processors
+                for (label proci = 0; proci < mesh.nProcs(); proci++)
+                {
+                    Info<< "Processor " << proci << ": field transfer" << endl;
+
+
+                    // open the database
+                    if (!processorDbList.set(proci))
+                    {
+                        processorDbList.set
                         (
                             proci,
-                            new fvFieldDecomposer
+                            new Time
+                            (
+                                Time::controlDictName,
+                                args.rootPath(),
+                                args.caseName()
+                               /fileName(word("processor") + name(proci))
+                            )
+                        );
+                    }
+                    Time& processorDb = processorDbList[proci];
+
+
+                    processorDb.setTime(runTime);
+
+                    // read the mesh
+                    if (!procMeshList.set(proci))
+                    {
+                        procMeshList.set
+                        (
+                            proci,
+                            new fvMesh
+                            (
+                                IOobject
+                                (
+                                    regionName,
+                                    processorDb.timeName(),
+                                    processorDb
+                                )
+                            )
+                        );
+                    }
+                    const fvMesh& procMesh = procMeshList[proci];
+
+                    const labelIOList& faceProcAddressing = procAddressing
+                    (
+                        procMeshList,
+                        proci,
+                        "faceProcAddressing",
+                        faceProcAddressingList
+                    );
+
+                    const labelIOList& cellProcAddressing = procAddressing
+                    (
+                        procMeshList,
+                        proci,
+                        "cellProcAddressing",
+                        cellProcAddressingList
+                    );
+
+                    const labelIOList& boundaryProcAddressing = procAddressing
+                    (
+                        procMeshList,
+                        proci,
+                        "boundaryProcAddressing",
+                        boundaryProcAddressingList
+                    );
+
+
+                    // FV fields
+                    {
+                        if (!fieldDecomposerList.set(proci))
+                        {
+                            fieldDecomposerList.set
+                            (
+                                proci,
+                                new fvFieldDecomposer
+                                (
+                                    mesh,
+                                    procMesh,
+                                    faceProcAddressing,
+                                    cellProcAddressing,
+                                    boundaryProcAddressing
+                                )
+                            );
+                        }
+                        const fvFieldDecomposer& fieldDecomposer =
+                            fieldDecomposerList[proci];
+
+                        fieldDecomposer.decomposeFields(volScalarFields);
+                        fieldDecomposer.decomposeFields(volVectorFields);
+                        fieldDecomposer.decomposeFields
+                        (
+                            volSphericalTensorFields
+                        );
+                        fieldDecomposer.decomposeFields(volSymmTensorFields);
+                        fieldDecomposer.decomposeFields(volTensorFields);
+
+                        fieldDecomposer.decomposeFields(surfaceScalarFields);
+                        fieldDecomposer.decomposeFields(surfaceVectorFields);
+                        fieldDecomposer.decomposeFields
+                        (
+                            surfaceSphericalTensorFields
+                        );
+                        fieldDecomposer.decomposeFields
+                        (
+                            surfaceSymmTensorFields
+                        );
+                        fieldDecomposer.decomposeFields(surfaceTensorFields);
+
+                        if (times.size() == 1)
+                        {
+                            // Clear cached decomposer
+                            fieldDecomposerList.set(proci, nullptr);
+                        }
+                    }
+
+                    // Dimensioned fields
+                    {
+                        if (!dimFieldDecomposerList.set(proci))
+                        {
+                            dimFieldDecomposerList.set
+                            (
+                                proci,
+                                new dimFieldDecomposer
+                                (
+                                    mesh,
+                                    procMesh,
+                                    faceProcAddressing,
+                                    cellProcAddressing
+                                )
+                            );
+                        }
+                        const dimFieldDecomposer& dimDecomposer =
+                            dimFieldDecomposerList[proci];
+
+                        dimDecomposer.decomposeFields(dimScalarFields);
+                        dimDecomposer.decomposeFields(dimVectorFields);
+                        dimDecomposer.decomposeFields(dimSphericalTensorFields);
+                        dimDecomposer.decomposeFields(dimSymmTensorFields);
+                        dimDecomposer.decomposeFields(dimTensorFields);
+
+                        if (times.size() == 1)
+                        {
+                            dimFieldDecomposerList.set(proci, nullptr);
+                        }
+                    }
+
+
+                    // Point fields
+                    if
+                    (
+                        pointScalarFields.size()
+                     || pointVectorFields.size()
+                     || pointSphericalTensorFields.size()
+                     || pointSymmTensorFields.size()
+                     || pointTensorFields.size()
+                    )
+                    {
+                        const labelIOList& pointProcAddressing = procAddressing
+                        (
+                            procMeshList,
+                            proci,
+                            "pointProcAddressing",
+                            pointProcAddressingList
+                        );
+
+                        const pointMesh& procPMesh = pointMesh::New(procMesh);
+
+                        if (!pointFieldDecomposerList.set(proci))
+                        {
+                            pointFieldDecomposerList.set
+                            (
+                                proci,
+                                new pointFieldDecomposer
+                                (
+                                    pMesh,
+                                    procPMesh,
+                                    pointProcAddressing,
+                                    boundaryProcAddressing
+                                )
+                            );
+                        }
+                        const pointFieldDecomposer& pointDecomposer =
+                            pointFieldDecomposerList[proci];
+
+                        pointDecomposer.decomposeFields(pointScalarFields);
+                        pointDecomposer.decomposeFields(pointVectorFields);
+                        pointDecomposer.decomposeFields
+                        (
+                            pointSphericalTensorFields
+                        );
+                        pointDecomposer.decomposeFields(pointSymmTensorFields);
+                        pointDecomposer.decomposeFields(pointTensorFields);
+
+
+                        if (times.size() == 1)
+                        {
+                            pointProcAddressingList.set(proci, nullptr);
+                            pointFieldDecomposerList.set(proci, nullptr);
+                        }
+                    }
+
+
+                    // If there is lagrangian data write it out
+                    forAll(lagrangianPositions, cloudI)
+                    {
+                        if (lagrangianPositions[cloudI].size())
+                        {
+                            lagrangianFieldDecomposer fieldDecomposer
                             (
                                 mesh,
                                 procMesh,
                                 faceProcAddressing,
                                 cellProcAddressing,
-                                boundaryProcAddressing
-                            )
-                        );
-                    }
-                    const fvFieldDecomposer& fieldDecomposer =
-                        fieldDecomposerList[proci];
-
-                    fieldDecomposer.decomposeFields(volScalarFields);
-                    fieldDecomposer.decomposeFields(volVectorFields);
-                    fieldDecomposer.decomposeFields(volSphericalTensorFields);
-                    fieldDecomposer.decomposeFields(volSymmTensorFields);
-                    fieldDecomposer.decomposeFields(volTensorFields);
-
-                    fieldDecomposer.decomposeFields(surfaceScalarFields);
-                    fieldDecomposer.decomposeFields(surfaceVectorFields);
-                    fieldDecomposer.decomposeFields
-                    (
-                        surfaceSphericalTensorFields
-                    );
-                    fieldDecomposer.decomposeFields(surfaceSymmTensorFields);
-                    fieldDecomposer.decomposeFields(surfaceTensorFields);
-
-                    if (times.size() == 1)
-                    {
-                        // Clear cached decomposer
-                        fieldDecomposerList.set(proci, nullptr);
-                    }
-                }
-
-                // Dimensioned fields
-                {
-                    if (!dimFieldDecomposerList.set(proci))
-                    {
-                        dimFieldDecomposerList.set
-                        (
-                            proci,
-                            new dimFieldDecomposer
-                            (
-                                mesh,
-                                procMesh,
-                                faceProcAddressing,
-                                cellProcAddressing
-                            )
-                        );
-                    }
-                    const dimFieldDecomposer& dimDecomposer =
-                        dimFieldDecomposerList[proci];
-
-                    dimDecomposer.decomposeFields(dimScalarFields);
-                    dimDecomposer.decomposeFields(dimVectorFields);
-                    dimDecomposer.decomposeFields(dimSphericalTensorFields);
-                    dimDecomposer.decomposeFields(dimSymmTensorFields);
-                    dimDecomposer.decomposeFields(dimTensorFields);
-
-                    if (times.size() == 1)
-                    {
-                        dimFieldDecomposerList.set(proci, nullptr);
-                    }
-                }
-
-
-                // Point fields
-                if
-                (
-                    pointScalarFields.size()
-                 || pointVectorFields.size()
-                 || pointSphericalTensorFields.size()
-                 || pointSymmTensorFields.size()
-                 || pointTensorFields.size()
-                )
-                {
-                    const labelIOList& pointProcAddressing = procAddressing
-                    (
-                        procMeshList,
-                        proci,
-                        "pointProcAddressing",
-                        pointProcAddressingList
-                    );
-
-                    const pointMesh& procPMesh = pointMesh::New(procMesh);
-
-                    if (!pointFieldDecomposerList.set(proci))
-                    {
-                        pointFieldDecomposerList.set
-                        (
-                            proci,
-                            new pointFieldDecomposer
-                            (
-                                pMesh,
-                                procPMesh,
-                                pointProcAddressing,
-                                boundaryProcAddressing
-                            )
-                        );
-                    }
-                    const pointFieldDecomposer& pointDecomposer =
-                        pointFieldDecomposerList[proci];
-
-                    pointDecomposer.decomposeFields(pointScalarFields);
-                    pointDecomposer.decomposeFields(pointVectorFields);
-                    pointDecomposer.decomposeFields(pointSphericalTensorFields);
-                    pointDecomposer.decomposeFields(pointSymmTensorFields);
-                    pointDecomposer.decomposeFields(pointTensorFields);
-
-
-                    if (times.size() == 1)
-                    {
-                        pointProcAddressingList.set(proci, nullptr);
-                        pointFieldDecomposerList.set(proci, nullptr);
-                    }
-                }
-
-
-                // If there is lagrangian data write it out
-                forAll(lagrangianPositions, cloudI)
-                {
-                    if (lagrangianPositions[cloudI].size())
-                    {
-                        lagrangianFieldDecomposer fieldDecomposer
-                        (
-                            mesh,
-                            procMesh,
-                            faceProcAddressing,
-                            cellProcAddressing,
-                            cloudDirs[cloudI],
-                            lagrangianPositions[cloudI],
-                            cellParticles[cloudI]
-                        );
-
-                        // Lagrangian fields
-                        {
-                            fieldDecomposer.decomposeFields
-                            (
                                 cloudDirs[cloudI],
-                                lagrangianLabelFields[cloudI]
-                            );
-                            fieldDecomposer.decomposeFieldFields
-                            (
-                                cloudDirs[cloudI],
-                                lagrangianLabelFieldFields[cloudI]
-                            );
-                            fieldDecomposer.decomposeFields
-                            (
-                                cloudDirs[cloudI],
-                                lagrangianScalarFields[cloudI]
-                            );
-                            fieldDecomposer.decomposeFieldFields
-                            (
-                                cloudDirs[cloudI],
-                                lagrangianScalarFieldFields[cloudI]
-                            );
-                            fieldDecomposer.decomposeFields
-                            (
-                                cloudDirs[cloudI],
-                                lagrangianVectorFields[cloudI]
-                            );
-                            fieldDecomposer.decomposeFieldFields
-                            (
-                                cloudDirs[cloudI],
-                                lagrangianVectorFieldFields[cloudI]
-                            );
-                            fieldDecomposer.decomposeFields
-                            (
-                                cloudDirs[cloudI],
-                                lagrangianSphericalTensorFields[cloudI]
-                            );
-                            fieldDecomposer.decomposeFieldFields
-                            (
-                                cloudDirs[cloudI],
-                                lagrangianSphericalTensorFieldFields[cloudI]
-                            );
-                            fieldDecomposer.decomposeFields
-                            (
-                                cloudDirs[cloudI],
-                                lagrangianSymmTensorFields[cloudI]
-                            );
-                            fieldDecomposer.decomposeFieldFields
-                            (
-                                cloudDirs[cloudI],
-                                lagrangianSymmTensorFieldFields[cloudI]
-                            );
-                            fieldDecomposer.decomposeFields
-                            (
-                                cloudDirs[cloudI],
-                                lagrangianTensorFields[cloudI]
-                            );
-                            fieldDecomposer.decomposeFieldFields
-                            (
-                                cloudDirs[cloudI],
-                                lagrangianTensorFieldFields[cloudI]
+                                lagrangianPositions[cloudI],
+                                cellParticles[cloudI]
                             );
+
+                            // Lagrangian fields
+                            {
+                                fieldDecomposer.decomposeFields
+                                (
+                                    cloudDirs[cloudI],
+                                    lagrangianLabelFields[cloudI]
+                                );
+                                fieldDecomposer.decomposeFieldFields
+                                (
+                                    cloudDirs[cloudI],
+                                    lagrangianLabelFieldFields[cloudI]
+                                );
+                                fieldDecomposer.decomposeFields
+                                (
+                                    cloudDirs[cloudI],
+                                    lagrangianScalarFields[cloudI]
+                                );
+                                fieldDecomposer.decomposeFieldFields
+                                (
+                                    cloudDirs[cloudI],
+                                    lagrangianScalarFieldFields[cloudI]
+                                );
+                                fieldDecomposer.decomposeFields
+                                (
+                                    cloudDirs[cloudI],
+                                    lagrangianVectorFields[cloudI]
+                                );
+                                fieldDecomposer.decomposeFieldFields
+                                (
+                                    cloudDirs[cloudI],
+                                    lagrangianVectorFieldFields[cloudI]
+                                );
+                                fieldDecomposer.decomposeFields
+                                (
+                                    cloudDirs[cloudI],
+                                    lagrangianSphericalTensorFields[cloudI]
+                                );
+                                fieldDecomposer.decomposeFieldFields
+                                (
+                                    cloudDirs[cloudI],
+                                    lagrangianSphericalTensorFieldFields[cloudI]
+                                );
+                                fieldDecomposer.decomposeFields
+                                (
+                                    cloudDirs[cloudI],
+                                    lagrangianSymmTensorFields[cloudI]
+                                );
+                                fieldDecomposer.decomposeFieldFields
+                                (
+                                    cloudDirs[cloudI],
+                                    lagrangianSymmTensorFieldFields[cloudI]
+                                );
+                                fieldDecomposer.decomposeFields
+                                (
+                                    cloudDirs[cloudI],
+                                    lagrangianTensorFields[cloudI]
+                                );
+                                fieldDecomposer.decomposeFieldFields
+                                (
+                                    cloudDirs[cloudI],
+                                    lagrangianTensorFieldFields[cloudI]
+                                );
+                            }
                         }
                     }
-                }
 
-                // Decompose the "uniform" directory in the time region
-                // directory
-                decomposeUniform(copyUniform, mesh, processorDb, regionDir);
+                    // Decompose the "uniform" directory in the time region
+                    // directory
+                    decomposeUniform(copyUniform, mesh, processorDb, regionDir);
 
-                // For the first region of a multi-region case additionally
-                // decompose the "uniform" directory in the time directory
-                if (regionNames.size() > 1 && regioni == 0)
-                {
-                    decomposeUniform(copyUniform, mesh, processorDb);
-                }
+                    // For the first region of a multi-region case additionally
+                    // decompose the "uniform" directory in the time directory
+                    if (regionNames.size() > 1 && regioni == 0)
+                    {
+                        decomposeUniform(copyUniform, mesh, processorDb);
+                    }
 
-                // We have cached all the constant mesh data for the current
-                // processor. This is only important if running with multiple
-                // times, otherwise it is just extra storage.
-                if (times.size() == 1)
-                {
-                    boundaryProcAddressingList.set(proci, nullptr);
-                    cellProcAddressingList.set(proci, nullptr);
-                    faceProcAddressingList.set(proci, nullptr);
-                    procMeshList.set(proci, nullptr);
-                    processorDbList.set(proci, nullptr);
+                    // We have cached all the constant mesh data for the current
+                    // processor. This is only important if running with
+                    // multiple times, otherwise it is just extra storage.
+                    if (times.size() == 1)
+                    {
+                        boundaryProcAddressingList.set(proci, nullptr);
+                        cellProcAddressingList.set(proci, nullptr);
+                        faceProcAddressingList.set(proci, nullptr);
+                        procMeshList.set(proci, nullptr);
+                        processorDbList.set(proci, nullptr);
+                    }
                 }
             }
         }
diff --git a/src/OpenFOAM/db/Time/timeSelector.C b/src/OpenFOAM/db/Time/timeSelector.C
index ecffc55dc..7e47c12a9 100644
--- a/src/OpenFOAM/db/Time/timeSelector.C
+++ b/src/OpenFOAM/db/Time/timeSelector.C
@@ -135,8 +135,12 @@ void Foam::timeSelector::addOptions
     argList::addBoolOption
     (
         "noZero",
-        "exclude the '0/' dir from the times list, "
-        "has precedence over the -withZero option"
+        string("exclude the '0/' dir from the times list")
+      + (
+            withZero
+          ? ", has precedence over the -withZero option"
+          : ""
+        )
     );
     argList::addBoolOption
     (
diff --git a/tutorials/incompressible/simpleFoam/motorBike/Allclean b/tutorials/incompressible/simpleFoam/motorBike/Allclean
index 68a1d17d7..93a0975c8 100755
--- a/tutorials/incompressible/simpleFoam/motorBike/Allclean
+++ b/tutorials/incompressible/simpleFoam/motorBike/Allclean
@@ -1,9 +1,10 @@
 #!/bin/sh
+cd ${0%/*} || exit 1    # Run from this directory
 
 # Source tutorial clean functions
 . $WM_PROJECT_DIR/bin/tools/CleanFunctions
 
-# remove surface and features
+# Remove surface and features
 rm -f constant/triSurface/motorBike.obj.gz > /dev/null 2>&1
 rm -rf constant/extendedFeatureEdgeMesh > /dev/null 2>&1
 rm -f constant/triSurface/motorBike.eMesh > /dev/null 2>&1
@@ -11,3 +12,5 @@ rm -f constant/triSurface/motorBike.eMesh > /dev/null 2>&1
 rm -rf 0 > /dev/null 2>&1
 
 cleanCase
+
+#------------------------------------------------------------------------------
diff --git a/tutorials/incompressible/simpleFoam/motorBike/Allrun b/tutorials/incompressible/simpleFoam/motorBike/Allrun
index 32e10a4ee..07069da13 100755
--- a/tutorials/incompressible/simpleFoam/motorBike/Allrun
+++ b/tutorials/incompressible/simpleFoam/motorBike/Allrun
@@ -4,22 +4,17 @@ cd ${0%/*} || exit 1    # Run from this directory
 # Source tutorial run functions
 . $WM_PROJECT_DIR/bin/tools/RunFunctions
 
-# copy motorbike surface from resources directory
+# Copy motorbike surface from resources directory
 cp $FOAM_TUTORIALS/resources/geometry/motorBike.obj.gz constant/triSurface/
 runApplication surfaceFeatureExtract
 
 runApplication blockMesh
 
-runApplication decomposePar
+[ ! -d 0 ] && cp -r 0.orig 0
+
+runApplication decomposePar -copyZero
 runParallel snappyHexMesh -overwrite
 
-#- For non-parallel running
-#cp -r 0.orig 0 > /dev/null 2>&1
-
-#- For parallel running
-ls -d processor* | xargs -I {} rm -rf ./{}/0
-ls -d processor* | xargs -I {} cp -r 0.orig ./{}/0
-
 runParallel patchSummary
 runParallel potentialFoam
 runParallel $(getApplication)