diff --git a/applications/utilities/parallelProcessing/decomposePar/Make/options b/applications/utilities/parallelProcessing/decomposePar/Make/options
index 7194eb1bce..5d5d67f989 100644
--- a/applications/utilities/parallelProcessing/decomposePar/Make/options
+++ b/applications/utilities/parallelProcessing/decomposePar/Make/options
@@ -3,7 +3,8 @@ EXE_INC = \
     -I$(LIB_SRC)/parallel/decompose/decompositionMethods/lnInclude \
     -I$(LIB_SRC)/finiteVolume/lnInclude \
     -I$(LIB_SRC)/lagrangian/basic/lnInclude \
-    -I$(LIB_SRC)/meshTools/lnInclude
+    -I$(LIB_SRC)/meshTools/lnInclude \
+    -I$(LIB_SRC)/regionModels/regionModel/lnInclude
 
 EXE_LIBS = \
     -lfiniteVolume \
@@ -11,4 +12,5 @@ EXE_LIBS = \
     -lgenericPatchFields \
     -ldecompositionMethods -L$(FOAM_LIBBIN)/dummy -lmetisDecomp -lscotchDecomp \
     -llagrangian \
-    -lmeshTools
+    -lmeshTools \
+    -lregionModels
diff --git a/applications/utilities/parallelProcessing/decomposePar/decomposePar.C b/applications/utilities/parallelProcessing/decomposePar/decomposePar.C
index 26d3813004..257c31df53 100644
--- a/applications/utilities/parallelProcessing/decomposePar/decomposePar.C
+++ b/applications/utilities/parallelProcessing/decomposePar/decomposePar.C
@@ -39,6 +39,10 @@ Usage
     \param -region regionName \n
     Decompose named region. Does not check for existence of processor*.
 
+    \param -allRegions \n
+    Decompose all regions in regionProperties. Does not check for
+    existence of processor*.
+
     \param -copyUniform \n
     Copy any \a uniform directories too.
 
@@ -82,6 +86,7 @@ Usage
 #include "tensorIOField.H"
 #include "tensorFieldIOField.H"
 #include "pointFields.H"
+#include "regionProperties.H"
 
 #include "readFields.H"
 #include "dimFieldDecomposer.H"
@@ -101,6 +106,11 @@ int main(int argc, char *argv[])
     argList::noParallel();
     #include "addRegionOption.H"
     argList::addBoolOption
+    (
+        "allRegions",
+        "operate on all regions in regionProperties"
+    );
+    argList::addBoolOption
     (
         "cellDist",
         "write cell distribution as a labelList - for use with 'manual' "
@@ -132,15 +142,7 @@ int main(int argc, char *argv[])
 
     #include "setRootCase.H"
 
-    word regionName = fvMesh::defaultRegion;
-    word regionDir = word::null;
-
-    if (args.optionReadIfPresent("region", regionName))
-    {
-        regionDir = regionName;
-        Info<< "Decomposing mesh " << regionName << nl << endl;
-    }
-
+    bool allRegions              = args.optionFound("allRegions");
     bool writeCellDist           = args.optionFound("cellDist");
     bool copyUniform             = args.optionFound("copyUniform");
     bool decomposeFieldsOnly     = args.optionFound("fields");
@@ -152,756 +154,659 @@ int main(int argc, char *argv[])
     // Allow override of time
     instantList times = timeSelector::selectIfPresent(runTime, args);
 
-    // determine the existing processor count directly
-    label nProcs = 0;
-    while
-    (
-        isDir
-        (
-            runTime.path()
-          / (word("processor") + name(nProcs))
-          / runTime.constant()
-          / regionDir
-          / polyMesh::meshSubDir
-        )
-    )
+
+    wordList regionNames;
+    wordList regionDirs;
+    if (allRegions)
     {
-        ++nProcs;
-    }
-
-    // get requested numberOfSubdomains
-    const label nDomains = readLabel
-    (
-        IOdictionary
-        (
-            IOobject
-            (
-                "decomposeParDict",
-                runTime.time().system(),
-                regionDir,          // use region if non-standard
-                runTime,
-                IOobject::MUST_READ_IF_MODIFIED,
-                IOobject::NO_WRITE,
-                false
-            )
-        ).lookup("numberOfSubdomains")
-    );
-
-    if (decomposeFieldsOnly)
-    {
-        // Sanity check on previously decomposed case
-        if (nProcs != nDomains)
+        Info<< "Decomposing all regions in regionProperties" << nl << endl;
+        regionProperties rp(runTime);
+        forAllConstIter(HashTable<wordList>, rp, iter)
         {
-            FatalErrorIn(args.executable())
-                << "Specified -fields, but the case was decomposed with "
-                << nProcs << " domains"
-                << nl
-                << "instead of " << nDomains
-                << " domains as specified in decomposeParDict"
-                << nl
-                << exit(FatalError);
-        }
-    }
-    else if (nProcs)
-    {
-        bool procDirsProblem = true;
-
-        if (ifRequiredDecomposition && nProcs == nDomains)
-        {
-            // we can reuse the decomposition
-            decomposeFieldsOnly = true;
-            procDirsProblem = false;
-            forceOverwrite = false;
-
-            Info<< "Using existing processor directories" << nl;
-        }
-
-        if (forceOverwrite)
-        {
-            Info<< "Removing " << nProcs
-                << " existing processor directories" << endl;
-
-            // remove existing processor dirs
-            // reverse order to avoid gaps if someone interrupts the process
-            for (label procI = nProcs-1; procI >= 0; --procI)
+            const wordList& regions = iter();
+            forAll(regions, i)
             {
-                fileName procDir
-                (
-                    runTime.path()/(word("processor") + name(procI))
-                );
-
-                rmDir(procDir);
-            }
-
-            procDirsProblem = false;
-        }
-
-        if (procDirsProblem)
-        {
-            FatalErrorIn(args.executable())
-                << "Case is already decomposed with " << nProcs
-                << " domains, use the -force option or manually" << nl
-                << "remove processor directories before decomposing. e.g.,"
-                << nl
-                << "    rm -rf " << runTime.path().c_str() << "/processor*"
-                << nl
-                << exit(FatalError);
-        }
-    }
-
-    Info<< "Create mesh" << endl;
-    domainDecomposition mesh
-    (
-        IOobject
-        (
-            regionName,
-            runTime.timeName(),
-            runTime
-        )
-    );
-
-    // Decompose the mesh
-    if (!decomposeFieldsOnly)
-    {
-        mesh.decomposeMesh();
-
-        mesh.writeDecomposition();
-
-        if (writeCellDist)
-        {
-            const labelList& procIds = mesh.cellToProc();
-
-            // Write the decomposition as labelList for use with 'manual'
-            // decomposition method.
-            labelIOList cellDecomposition
-            (
-                IOobject
-                (
-                    "cellDecomposition",
-                    mesh.facesInstance(),
-                    mesh,
-                    IOobject::NO_READ,
-                    IOobject::NO_WRITE,
-                    false
-                ),
-                procIds
-            );
-            cellDecomposition.write();
-
-            Info<< nl << "Wrote decomposition to "
-                << cellDecomposition.objectPath()
-                << " for use in manual decomposition." << endl;
-
-            // Write as volScalarField for postprocessing.
-            volScalarField cellDist
-            (
-                IOobject
-                (
-                    "cellDist",
-                    runTime.timeName(),
-                    mesh,
-                    IOobject::NO_READ,
-                    IOobject::AUTO_WRITE
-                ),
-                mesh,
-                dimensionedScalar("cellDist", dimless, 0),
-                zeroGradientFvPatchScalarField::typeName
-            );
-
-            forAll(procIds, celli)
-            {
-               cellDist[celli] = procIds[celli];
-            }
-
-            cellDist.write();
-
-            Info<< nl << "Wrote decomposition as volScalarField to "
-                << cellDist.name() << " for use in postprocessing."
-                << endl;
-        }
-    }
-
-
-
-    // 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)
-    {
-        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)
-        {
-            IOobjectList sprayObjs
-            (
-                mesh,
-                runTime.timeName(),
-                cloud::prefix/cloudDirs[i]
-            );
-
-            IOobject* positionsPtr = sprayObjs.lookup("positions");
-
-            if (positionsPtr)
-            {
-                // 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*>*>(NULL)
-                    )
-                );
-
-                label i = 0;
-
-                forAllIter
-                (
-                    Cloud<indexedParticle>,
-                    lagrangianPositions[cloudI],
-                    iter
-                )
+                if (findIndex(regionNames, regions[i]) == -1)
                 {
-                    iter().index() = i++;
-
-                    label celli = iter().cell();
-
-                    // Check
-                    if (celli < 0 || celli >= mesh.nCells())
-                    {
-                        FatalErrorIn(args.executable())
-                            << "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());
+                    regionNames.append(regions[i]);
                 }
-
-                // Read fields
-                // ~~~~~~~~~~~
-
-                IOobjectList lagrangianObjects
-                (
-                    mesh,
-                    runTime.timeName(),
-                    cloud::prefix/cloudDirs[cloudI]
-                );
-
-                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);
-
-
-        // Any uniform data to copy/link?
-        fileName uniformDir("uniform");
-
-        if (isDir(runTime.timePath()/uniformDir))
+        regionDirs = regionNames;
+    }
+    else
+    {
+        word regionName;
+        if (args.optionReadIfPresent("region", regionName))
         {
-            Info<< "Detected additional non-decomposed files in "
-                << runTime.timePath()/uniformDir
-                << endl;
+            regionNames = wordList(1, regionName);
+            regionDirs = regionNames;
         }
         else
         {
-            uniformDir.clear();
+            regionNames = wordList(1, fvMesh::defaultRegion);
+            regionDirs = wordList(1, word::null);
+        }
+    }
+
+
+
+    forAll(regionNames, regionI)
+    {
+        const word& regionName = regionNames[regionI];
+        const word& regionDir = regionDirs[regionI];
+
+        Info<< "\n\nDecomposing mesh " << regionName << nl << endl;
+
+
+        // determine the existing processor count directly
+        label nProcs = 0;
+        while
+        (
+            isDir
+            (
+                runTime.path()
+              / (word("processor") + name(nProcs))
+              / runTime.constant()
+              / regionDir
+              / polyMesh::meshSubDir
+            )
+        )
+        {
+            ++nProcs;
         }
 
-        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);
-
-            // remove files remnants that can cause horrible problems
-            // - mut and nut are used to mark the new turbulence models,
-            //   their existence prevents old models from being upgraded
-            {
-                fileName timeDir(processorDb.path()/processorDb.timeName());
-
-                rm(timeDir/"mut");
-                rm(timeDir/"nut");
-            }
-
-            // read the mesh
-            if (!procMeshList.set(procI))
-            {
-                procMeshList.set
-                (
-                    procI,
-                    new fvMesh
-                    (
-                        IOobject
-                        (
-                            regionName,
-                            processorDb.timeName(),
-                            processorDb
-                        )
-                    )
-                );
-            }
-            const fvMesh& procMesh = procMeshList[procI];
-
-
-            if (!faceProcAddressingList.set(procI))
-            {
-                faceProcAddressingList.set
-                (
-                    procI,
-                    new labelIOList
-                    (
-                        IOobject
-                        (
-                            "faceProcAddressing",
-                            procMesh.facesInstance(),
-                            procMesh.meshSubDir,
-                            procMesh,
-                            IOobject::MUST_READ,
-                            IOobject::NO_WRITE
-                        )
-                    )
-                );
-            }
-            const labelIOList& faceProcAddressing =
-                faceProcAddressingList[procI];
-
-
-            if (!cellProcAddressingList.set(procI))
-            {
-                cellProcAddressingList.set
-                (
-                    procI,
-                    new labelIOList
-                    (
-                        IOobject
-                        (
-                            "cellProcAddressing",
-                            procMesh.facesInstance(),
-                            procMesh.meshSubDir,
-                            procMesh,
-                            IOobject::MUST_READ,
-                            IOobject::NO_WRITE
-                        )
-                    )
-                );
-            }
-            const labelIOList& cellProcAddressing =
-                cellProcAddressingList[procI];
-
-
-            if (!boundaryProcAddressingList.set(procI))
-            {
-                boundaryProcAddressingList.set
-                (
-                    procI,
-                    new labelIOList
-                    (
-                        IOobject
-                        (
-                            "boundaryProcAddressing",
-                            procMesh.facesInstance(),
-                            procMesh.meshSubDir,
-                            procMesh,
-                            IOobject::MUST_READ,
-                            IOobject::NO_WRITE
-                        )
-                    )
-                );
-            }
-            const labelIOList& boundaryProcAddressing =
-                boundaryProcAddressingList[procI];
-
-
-            // 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, NULL);
-                }
-            }
-
-            // 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, NULL);
-                }
-            }
-
-
-            // Point fields
-            if
+        // get requested numberOfSubdomains
+        const label nDomains = readLabel
+        (
+            IOdictionary
             (
-                pointScalarFields.size()
-             || pointVectorFields.size()
-             || pointSphericalTensorFields.size()
-             || pointSymmTensorFields.size()
-             || pointTensorFields.size()
-            )
+                IOobject
+                (
+                    "decomposeParDict",
+                    runTime.time().system(),
+                    regionDir,          // use region if non-standard
+                    runTime,
+                    IOobject::MUST_READ_IF_MODIFIED,
+                    IOobject::NO_WRITE,
+                    false
+                )
+            ).lookup("numberOfSubdomains")
+        );
+
+        if (decomposeFieldsOnly)
+        {
+            // Sanity check on previously decomposed case
+            if (nProcs != nDomains)
             {
-                if (!pointProcAddressingList.set(procI))
+                FatalErrorIn(args.executable())
+                    << "Specified -fields, but the case was decomposed with "
+                    << nProcs << " domains"
+                    << nl
+                    << "instead of " << nDomains
+                    << " domains as specified in decomposeParDict"
+                    << nl
+                    << exit(FatalError);
+            }
+        }
+        else if (nProcs)
+        {
+            bool procDirsProblem = true;
+
+            if (ifRequiredDecomposition && nProcs == nDomains)
+            {
+                // we can reuse the decomposition
+                decomposeFieldsOnly = true;
+                procDirsProblem = false;
+                forceOverwrite = false;
+
+                Info<< "Using existing processor directories" << nl;
+            }
+
+            if (forceOverwrite)
+            {
+                Info<< "Removing " << nProcs
+                    << " existing processor directories" << endl;
+
+                // remove existing processor dirs
+                // reverse order to avoid gaps if someone interrupts the process
+                for (label procI = nProcs-1; procI >= 0; --procI)
                 {
-                    pointProcAddressingList.set
+                    fileName procDir
+                    (
+                        runTime.path()/(word("processor") + name(procI))
+                    );
+
+                    rmDir(procDir);
+                }
+
+                procDirsProblem = false;
+            }
+
+            if (procDirsProblem)
+            {
+                FatalErrorIn(args.executable())
+                    << "Case is already decomposed with " << nProcs
+                    << " domains, use the -force option or manually" << nl
+                    << "remove processor directories before decomposing. e.g.,"
+                    << nl
+                    << "    rm -rf " << runTime.path().c_str() << "/processor*"
+                    << nl
+                    << exit(FatalError);
+            }
+        }
+
+        Info<< "Create mesh" << endl;
+        domainDecomposition mesh
+        (
+            IOobject
+            (
+                regionName,
+                runTime.timeName(),
+                runTime
+            )
+        );
+
+        // Decompose the mesh
+        if (!decomposeFieldsOnly)
+        {
+            mesh.decomposeMesh();
+
+            mesh.writeDecomposition();
+
+            if (writeCellDist)
+            {
+                const labelList& procIds = mesh.cellToProc();
+
+                // Write the decomposition as labelList for use with 'manual'
+                // decomposition method.
+                labelIOList cellDecomposition
+                (
+                    IOobject
+                    (
+                        "cellDecomposition",
+                        mesh.facesInstance(),
+                        mesh,
+                        IOobject::NO_READ,
+                        IOobject::NO_WRITE,
+                        false
+                    ),
+                    procIds
+                );
+                cellDecomposition.write();
+
+                Info<< nl << "Wrote decomposition to "
+                    << cellDecomposition.objectPath()
+                    << " for use in manual decomposition." << endl;
+
+                // Write as volScalarField for postprocessing.
+                volScalarField cellDist
+                (
+                    IOobject
+                    (
+                        "cellDist",
+                        runTime.timeName(),
+                        mesh,
+                        IOobject::NO_READ,
+                        IOobject::AUTO_WRITE
+                    ),
+                    mesh,
+                    dimensionedScalar("cellDist", dimless, 0),
+                    zeroGradientFvPatchScalarField::typeName
+                );
+
+                forAll(procIds, celli)
+                {
+                   cellDist[celli] = procIds[celli];
+                }
+
+                cellDist.write();
+
+                Info<< nl << "Wrote decomposition as volScalarField to "
+                    << cellDist.name() << " for use in postprocessing."
+                    << endl;
+            }
+        }
+
+
+
+        // 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)
+        {
+            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)
+            {
+                IOobjectList sprayObjs
+                (
+                    mesh,
+                    runTime.timeName(),
+                    cloud::prefix/cloudDirs[i]
+                );
+
+                IOobject* positionsPtr = sprayObjs.lookup("positions");
+
+                if (positionsPtr)
+                {
+                    // 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*>*>(NULL)
+                        )
+                    );
+
+                    label i = 0;
+
+                    forAllIter
+                    (
+                        Cloud<indexedParticle>,
+                        lagrangianPositions[cloudI],
+                        iter
+                    )
+                    {
+                        iter().index() = i++;
+
+                        label celli = iter().cell();
+
+                        // Check
+                        if (celli < 0 || celli >= mesh.nCells())
+                        {
+                            FatalErrorIn(args.executable())
+                                << "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]
+                    );
+
+                    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);
+
+
+            // Any uniform data to copy/link?
+            fileName uniformDir("uniform");
+
+            if (isDir(runTime.timePath()/uniformDir))
+            {
+                Info<< "Detected additional non-decomposed files in "
+                    << runTime.timePath()/uniformDir
+                    << endl;
+            }
+            else
+            {
+                uniformDir.clear();
+            }
+
+            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);
+
+                // remove files remnants that can cause horrible problems
+                // - mut and nut are used to mark the new turbulence models,
+                //   their existence prevents old models from being upgraded
+                {
+                    fileName timeDir(processorDb.path()/processorDb.timeName());
+
+                    rm(timeDir/"mut");
+                    rm(timeDir/"nut");
+                }
+
+                // read the mesh
+                if (!procMeshList.set(procI))
+                {
+                    procMeshList.set
+                    (
+                        procI,
+                        new fvMesh
+                        (
+                            IOobject
+                            (
+                                regionName,
+                                processorDb.timeName(),
+                                processorDb
+                            )
+                        )
+                    );
+                }
+                const fvMesh& procMesh = procMeshList[procI];
+
+
+                if (!faceProcAddressingList.set(procI))
+                {
+                    faceProcAddressingList.set
                     (
                         procI,
                         new labelIOList
                         (
                             IOobject
                             (
-                                "pointProcAddressing",
+                                "faceProcAddressing",
                                 procMesh.facesInstance(),
                                 procMesh.meshSubDir,
                                 procMesh,
@@ -911,167 +816,321 @@ int main(int argc, char *argv[])
                         )
                     );
                 }
-                const labelIOList& pointProcAddressing =
-                    pointProcAddressingList[procI];
+                const labelIOList& faceProcAddressing =
+                    faceProcAddressingList[procI];
 
-                const pointMesh& procPMesh = pointMesh::New(procMesh);
 
-                if (!pointFieldDecomposerList.set(procI))
+                if (!cellProcAddressingList.set(procI))
                 {
-                    pointFieldDecomposerList.set
+                    cellProcAddressingList.set
                     (
                         procI,
-                        new pointFieldDecomposer
+                        new labelIOList
                         (
-                            pMesh,
-                            procPMesh,
-                            pointProcAddressing,
-                            boundaryProcAddressing
+                            IOobject
+                            (
+                                "cellProcAddressing",
+                                procMesh.facesInstance(),
+                                procMesh.meshSubDir,
+                                procMesh,
+                                IOobject::MUST_READ,
+                                IOobject::NO_WRITE
+                            )
                         )
                     );
                 }
-                const pointFieldDecomposer& pointDecomposer =
-                    pointFieldDecomposerList[procI];
-
-                pointDecomposer.decomposeFields(pointScalarFields);
-                pointDecomposer.decomposeFields(pointVectorFields);
-                pointDecomposer.decomposeFields(pointSphericalTensorFields);
-                pointDecomposer.decomposeFields(pointSymmTensorFields);
-                pointDecomposer.decomposeFields(pointTensorFields);
+                const labelIOList& cellProcAddressing =
+                    cellProcAddressingList[procI];
 
 
-                if (times.size() == 1)
+                if (!boundaryProcAddressingList.set(procI))
                 {
-                    pointProcAddressingList.set(procI, NULL);
-                    pointFieldDecomposerList.set(procI, NULL);
-                }
-            }
-
-
-            // If there is lagrangian data write it out
-            forAll(lagrangianPositions, cloudI)
-            {
-                if (lagrangianPositions[cloudI].size())
-                {
-                    lagrangianFieldDecomposer fieldDecomposer
+                    boundaryProcAddressingList.set
                     (
-                        mesh,
-                        procMesh,
-                        faceProcAddressing,
-                        cellProcAddressing,
-                        cloudDirs[cloudI],
-                        lagrangianPositions[cloudI],
-                        cellParticles[cloudI]
+                        procI,
+                        new labelIOList
+                        (
+                            IOobject
+                            (
+                                "boundaryProcAddressing",
+                                procMesh.facesInstance(),
+                                procMesh.meshSubDir,
+                                procMesh,
+                                IOobject::MUST_READ,
+                                IOobject::NO_WRITE
+                            )
+                        )
                     );
+                }
+                const labelIOList& boundaryProcAddressing =
+                    boundaryProcAddressingList[procI];
 
-                    // Lagrangian fields
+
+                // FV fields
+                {
+                    if (!fieldDecomposerList.set(procI))
                     {
-                        fieldDecomposer.decomposeFields
+                        fieldDecomposerList.set
                         (
-                            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]
+                            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);
 
-            // Any non-decomposed data to copy?
-            if (uniformDir.size())
-            {
-                const fileName timePath = processorDb.timePath();
-
-                if (copyUniform || mesh.distributed())
-                {
-                    cp
+                    fieldDecomposer.decomposeFields(surfaceScalarFields);
+                    fieldDecomposer.decomposeFields(surfaceVectorFields);
+                    fieldDecomposer.decomposeFields
                     (
-                        runTime.timePath()/uniformDir,
-                        timePath/uniformDir
+                        surfaceSphericalTensorFields
                     );
+                    fieldDecomposer.decomposeFields(surfaceSymmTensorFields);
+                    fieldDecomposer.decomposeFields(surfaceTensorFields);
+
+                    if (times.size() == 1)
+                    {
+                        // Clear cached decomposer
+                        fieldDecomposerList.set(procI, NULL);
+                    }
                 }
-                else
+
+                // Dimensioned fields
                 {
-                    // link with relative paths
-                    const string parentPath = string("..")/"..";
+                    if (!dimFieldDecomposerList.set(procI))
+                    {
+                        dimFieldDecomposerList.set
+                        (
+                            procI,
+                            new dimFieldDecomposer
+                            (
+                                mesh,
+                                procMesh,
+                                faceProcAddressing,
+                                cellProcAddressing
+                            )
+                        );
+                    }
+                    const dimFieldDecomposer& dimDecomposer =
+                        dimFieldDecomposerList[procI];
 
-                    fileName currentDir(cwd());
-                    chDir(timePath);
-                    ln
-                    (
-                        parentPath/runTime.timeName()/uniformDir,
-                        uniformDir
-                    );
-                    chDir(currentDir);
+                    dimDecomposer.decomposeFields(dimScalarFields);
+                    dimDecomposer.decomposeFields(dimVectorFields);
+                    dimDecomposer.decomposeFields(dimSphericalTensorFields);
+                    dimDecomposer.decomposeFields(dimSymmTensorFields);
+                    dimDecomposer.decomposeFields(dimTensorFields);
+
+                    if (times.size() == 1)
+                    {
+                        dimFieldDecomposerList.set(procI, NULL);
+                    }
+                }
+
+
+                // Point fields
+                if
+                (
+                    pointScalarFields.size()
+                 || pointVectorFields.size()
+                 || pointSphericalTensorFields.size()
+                 || pointSymmTensorFields.size()
+                 || pointTensorFields.size()
+                )
+                {
+                    if (!pointProcAddressingList.set(procI))
+                    {
+                        pointProcAddressingList.set
+                        (
+                            procI,
+                            new labelIOList
+                            (
+                                IOobject
+                                (
+                                    "pointProcAddressing",
+                                    procMesh.facesInstance(),
+                                    procMesh.meshSubDir,
+                                    procMesh,
+                                    IOobject::MUST_READ,
+                                    IOobject::NO_WRITE
+                                )
+                            )
+                        );
+                    }
+                    const labelIOList& pointProcAddressing =
+                        pointProcAddressingList[procI];
+
+                    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, NULL);
+                        pointFieldDecomposerList.set(procI, NULL);
+                    }
+                }
+
+
+                // 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]
+                            );
+                        }
+                    }
+                }
+
+
+                // Any non-decomposed data to copy?
+                if (uniformDir.size())
+                {
+                    const fileName timePath = processorDb.timePath();
+
+                    if (copyUniform || mesh.distributed())
+                    {
+                        cp
+                        (
+                            runTime.timePath()/uniformDir,
+                            timePath/uniformDir
+                        );
+                    }
+                    else
+                    {
+                        // link with relative paths
+                        const string parentPath = string("..")/"..";
+
+                        fileName currentDir(cwd());
+                        chDir(timePath);
+                        ln
+                        (
+                            parentPath/runTime.timeName()/uniformDir,
+                            uniformDir
+                        );
+                        chDir(currentDir);
+                    }
                 }
-            }
 
 
 
-            // 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, NULL);
-                cellProcAddressingList.set(procI, NULL);
-                faceProcAddressingList.set(procI, NULL);
-                procMeshList.set(procI, NULL);
-                processorDbList.set(procI, NULL);
+                // 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, NULL);
+                    cellProcAddressingList.set(procI, NULL);
+                    faceProcAddressingList.set(procI, NULL);
+                    procMeshList.set(procI, NULL);
+                    processorDbList.set(procI, NULL);
+                }
             }
         }
     }
diff --git a/applications/utilities/parallelProcessing/reconstructPar/Make/options b/applications/utilities/parallelProcessing/reconstructPar/Make/options
index fcfc86483d..e63099c8f5 100644
--- a/applications/utilities/parallelProcessing/reconstructPar/Make/options
+++ b/applications/utilities/parallelProcessing/reconstructPar/Make/options
@@ -1,11 +1,13 @@
 EXE_INC = \
     -I$(LIB_SRC)/finiteVolume/lnInclude \
     -I$(LIB_SRC)/lagrangian/basic/lnInclude \
-    -I$(LIB_SRC)/parallel/reconstruct/reconstruct/lnInclude
+    -I$(LIB_SRC)/parallel/reconstruct/reconstruct/lnInclude \
+    -I$(LIB_SRC)/regionModels/regionModel/lnInclude
 
 EXE_LIBS = \
     -lfiniteVolume \
     -lgenericPatchFields \
     -llagrangian \
     -lmeshTools \
-    -lreconstruct
+    -lreconstruct \
+    -lregionModels
diff --git a/applications/utilities/parallelProcessing/reconstructPar/reconstructPar.C b/applications/utilities/parallelProcessing/reconstructPar/reconstructPar.C
index 5c354531b7..09b169821d 100644
--- a/applications/utilities/parallelProcessing/reconstructPar/reconstructPar.C
+++ b/applications/utilities/parallelProcessing/reconstructPar/reconstructPar.C
@@ -25,7 +25,7 @@ Application
     reconstructPar
 
 Description
-    Reconstructs a mesh and fields of a case that is decomposed for parallel
+    Reconstructs fields of a case that is decomposed for parallel
     execution of OpenFOAM.
 
 \*---------------------------------------------------------------------------*/
@@ -36,6 +36,7 @@ Description
 #include "fvCFD.H"
 #include "IOobjectList.H"
 #include "processorMeshes.H"
+#include "regionProperties.H"
 #include "fvFieldReconstructor.H"
 #include "pointFieldReconstructor.H"
 #include "reconstructLagrangian.H"
@@ -44,11 +45,21 @@ Description
 
 int main(int argc, char *argv[])
 {
+    argList::addNote
+    (
+        "Reconstruct fields of a parallel case"
+    );
+
     // enable -constant ... if someone really wants it
     // enable -zeroTime to prevent accidentally trashing the initial fields
     timeSelector::addOptions(true, true);
     argList::noParallel();
 #   include "addRegionOption.H"
+    argList::addBoolOption
+    (
+        "allRegions",
+        "operate on all regions in regionProperties"
+    );
     argList::addOption
     (
         "fields",
@@ -101,7 +112,8 @@ int main(int argc, char *argv[])
     }
 
 
-    const bool newTimes = args.optionFound("newTimes");
+    const bool newTimes   = args.optionFound("newTimes");
+    const bool allRegions = args.optionFound("allRegions");
 
 
     // determine the processor count directly
@@ -159,414 +171,487 @@ int main(int argc, char *argv[])
     }
 
 
-
-#   include "createNamedMesh.H"
-    word regionDir = word::null;
-    if (regionName != fvMesh::defaultRegion)
-    {
-        regionDir = regionName;
-    }
-
     // Set all times on processor meshes equal to reconstructed mesh
     forAll(databases, procI)
     {
         databases[procI].setTime(runTime.timeName(), runTime.timeIndex());
     }
 
-    // Read all meshes and addressing to reconstructed mesh
-    processorMeshes procMeshes(databases, regionName);
 
-
-    // check face addressing for meshes that have been decomposed
-    // with a very old foam version
-#   include "checkFaceAddressingComp.H"
-
-    // Loop over all times
-    forAll(timeDirs, timeI)
+    wordList regionNames;
+    wordList regionDirs;
+    if (allRegions)
     {
-        if (newTimes)
+        Info<< "Reconstructing for all regions in regionProperties" << nl
+            << endl;
+        regionProperties rp(runTime);
+        forAllConstIter(HashTable<wordList>, rp, iter)
         {
-            // Compare on timeName, not value
-            bool foundTime = false;
-            forAll(masterTimeDirs, i)
+            const wordList& regions = iter();
+            forAll(regions, i)
             {
-                if (masterTimeDirs[i].name() == timeDirs[timeI].name())
+                if (findIndex(regionNames, regions[i]) == -1)
                 {
-                    foundTime = true;
-                    break;
+                    regionNames.append(regions[i]);
                 }
             }
-            if (foundTime)
+        }
+        regionDirs = regionNames;
+    }
+    else
+    {
+        word regionName;
+        if (args.optionReadIfPresent("region", regionName))
+        {
+            regionNames = wordList(1, regionName);
+            regionDirs = regionNames;
+        }
+        else
+        {
+            regionNames = wordList(1, fvMesh::defaultRegion);
+            regionDirs = wordList(1, word::null);
+        }
+    }
+
+
+    forAll(regionNames, regionI)
+    {
+        const word& regionName = regionNames[regionI];
+        const word& regionDir = regionDirs[regionI];
+
+        Info<< "\n\nReconstructing fields for mesh " << regionName << nl
+            << endl;
+
+        fvMesh mesh
+        (
+            IOobject
+            (
+                regionName,
+                runTime.timeName(),
+                runTime,
+                Foam::IOobject::MUST_READ
+            )
+        );
+
+
+        // Read all meshes and addressing to reconstructed mesh
+        processorMeshes procMeshes(databases, regionName);
+
+
+        // check face addressing for meshes that have been decomposed
+        // with a very old foam version
+#      include "checkFaceAddressingComp.H"
+
+        // Loop over all times
+        forAll(timeDirs, timeI)
+        {
+            if (newTimes)
             {
-                Info<< "Skipping time " << timeDirs[timeI].name()
-                    << endl << endl;
-                continue;
-            }
-        }
-
-
-        // Set time for global database
-        runTime.setTime(timeDirs[timeI], timeI);
-
-        Info<< "Time = " << runTime.timeName() << endl << endl;
-
-        // Set time for all databases
-        forAll(databases, procI)
-        {
-            databases[procI].setTime(timeDirs[timeI], timeI);
-        }
-
-        // Check if any new meshes need to be read.
-        fvMesh::readUpdateState meshStat = mesh.readUpdate();
-
-        fvMesh::readUpdateState procStat = procMeshes.readUpdate();
-
-        if (procStat == fvMesh::POINTS_MOVED)
-        {
-            // Reconstruct the points for moving mesh cases and write them out
-            procMeshes.reconstructPoints(mesh);
-        }
-        else if (meshStat != procStat)
-        {
-            WarningIn(args.executable())
-                << "readUpdate for the reconstructed mesh:" << meshStat << nl
-                << "readUpdate for the processor meshes  :" << procStat << nl
-                << "These should be equal or your addressing"
-                << " might be incorrect."
-                << " Please check your time directories for any "
-                << "mesh directories." << endl;
-        }
-
-
-        // Get list of objects from processor0 database
-        IOobjectList objects(procMeshes.meshes()[0], databases[0].timeName());
-
-        {
-            // If there are any FV fields, reconstruct them
-            Info<< "Reconstructing FV fields" << nl << endl;
-
-            fvFieldReconstructor fvReconstructor
-            (
-                mesh,
-                procMeshes.meshes(),
-                procMeshes.faceProcAddressing(),
-                procMeshes.cellProcAddressing(),
-                procMeshes.boundaryProcAddressing()
-            );
-
-            fvReconstructor.reconstructFvVolumeInternalFields<scalar>
-            (
-                objects,
-                selectedFields
-            );
-            fvReconstructor.reconstructFvVolumeInternalFields<vector>
-            (
-                objects,
-                selectedFields
-            );
-            fvReconstructor.reconstructFvVolumeInternalFields<sphericalTensor>
-            (
-                objects,
-                selectedFields
-            );
-            fvReconstructor.reconstructFvVolumeInternalFields<symmTensor>
-            (
-                objects,
-                selectedFields
-            );
-            fvReconstructor.reconstructFvVolumeInternalFields<tensor>
-            (
-                objects,
-                selectedFields
-            );
-
-            fvReconstructor.reconstructFvVolumeFields<scalar>
-            (
-                objects,
-                selectedFields
-            );
-            fvReconstructor.reconstructFvVolumeFields<vector>
-            (
-                objects,
-                selectedFields
-            );
-            fvReconstructor.reconstructFvVolumeFields<sphericalTensor>
-            (
-                objects,
-                selectedFields
-            );
-            fvReconstructor.reconstructFvVolumeFields<symmTensor>
-            (
-                objects,
-                selectedFields
-            );
-            fvReconstructor.reconstructFvVolumeFields<tensor>
-            (
-                objects,
-                selectedFields
-            );
-
-            fvReconstructor.reconstructFvSurfaceFields<scalar>
-            (
-                objects,
-                selectedFields
-            );
-            fvReconstructor.reconstructFvSurfaceFields<vector>
-            (
-                objects,
-                selectedFields
-            );
-            fvReconstructor.reconstructFvSurfaceFields<sphericalTensor>
-            (
-                objects,
-                selectedFields
-            );
-            fvReconstructor.reconstructFvSurfaceFields<symmTensor>
-            (
-                objects,
-                selectedFields
-            );
-            fvReconstructor.reconstructFvSurfaceFields<tensor>
-            (
-                objects,
-                selectedFields
-            );
-
-            if (fvReconstructor.nReconstructed() == 0)
-            {
-                Info<< "No FV fields" << nl << endl;
-            }
-        }
-
-        {
-            Info<< "Reconstructing point fields" << nl << endl;
-
-            const pointMesh& pMesh = pointMesh::New(mesh);
-            PtrList<pointMesh> pMeshes(procMeshes.meshes().size());
-
-            forAll(pMeshes, procI)
-            {
-                pMeshes.set(procI, new pointMesh(procMeshes.meshes()[procI]));
+                // Compare on timeName, not value
+                bool foundTime = false;
+                forAll(masterTimeDirs, i)
+                {
+                    if (masterTimeDirs[i].name() == timeDirs[timeI].name())
+                    {
+                        foundTime = true;
+                        break;
+                    }
+                }
+                if (foundTime)
+                {
+                    Info<< "Skipping time " << timeDirs[timeI].name()
+                        << endl << endl;
+                    continue;
+                }
             }
 
-            pointFieldReconstructor pointReconstructor
-            (
-                pMesh,
-                pMeshes,
-                procMeshes.pointProcAddressing(),
-                procMeshes.boundaryProcAddressing()
-            );
 
-            pointReconstructor.reconstructFields<scalar>
-            (
-                objects,
-                selectedFields
-            );
-            pointReconstructor.reconstructFields<vector>
-            (
-                objects,
-                selectedFields
-            );
-            pointReconstructor.reconstructFields<sphericalTensor>
-            (
-                objects,
-                selectedFields
-            );
-            pointReconstructor.reconstructFields<symmTensor>
-            (
-                objects,
-                selectedFields
-            );
-            pointReconstructor.reconstructFields<tensor>
-            (
-                objects,
-                selectedFields
-            );
+            // Set time for global database
+            runTime.setTime(timeDirs[timeI], timeI);
 
-            if (pointReconstructor.nReconstructed() == 0)
-            {
-                Info<< "No point fields" << nl << endl;
-            }
-        }
-
-
-        // If there are any clouds, reconstruct them.
-        // The problem is that a cloud of size zero will not get written so
-        // in pass 1 we determine the cloud names and per cloud name the
-        // fields. Note that the fields are stored as IOobjectList from
-        // the first processor that has them. They are in pass2 only used
-        // for name and type (scalar, vector etc).
-
-        if (!noLagrangian)
-        {
-            HashTable<IOobjectList> cloudObjects;
+            Info<< "Time = " << runTime.timeName() << endl << endl;
 
+            // Set time for all databases
             forAll(databases, procI)
             {
-                fileNameList cloudDirs
+                databases[procI].setTime(timeDirs[timeI], timeI);
+            }
+
+            // Check if any new meshes need to be read.
+            fvMesh::readUpdateState meshStat = mesh.readUpdate();
+
+            fvMesh::readUpdateState procStat = procMeshes.readUpdate();
+
+            if (procStat == fvMesh::POINTS_MOVED)
+            {
+                // Reconstruct the points for moving mesh cases and write
+                // them out
+                procMeshes.reconstructPoints(mesh);
+            }
+            else if (meshStat != procStat)
+            {
+                WarningIn(args.executable())
+                    << "readUpdate for the reconstructed mesh:"
+                    << meshStat << nl
+                    << "readUpdate for the processor meshes  :"
+                    << procStat << nl
+                    << "These should be equal or your addressing"
+                    << " might be incorrect."
+                    << " Please check your time directories for any "
+                    << "mesh directories." << endl;
+            }
+
+
+            // Get list of objects from processor0 database
+            IOobjectList objects
+            (
+                procMeshes.meshes()[0],
+                databases[0].timeName()
+            );
+
+            {
+                // If there are any FV fields, reconstruct them
+                Info<< "Reconstructing FV fields" << nl << endl;
+
+                fvFieldReconstructor fvReconstructor
                 (
-                    readDir
-                    (
-                        databases[procI].timePath() / regionDir / cloud::prefix,
-                        fileName::DIRECTORY
-                    )
+                    mesh,
+                    procMeshes.meshes(),
+                    procMeshes.faceProcAddressing(),
+                    procMeshes.cellProcAddressing(),
+                    procMeshes.boundaryProcAddressing()
                 );
 
-                forAll(cloudDirs, i)
+                fvReconstructor.reconstructFvVolumeInternalFields<scalar>
+                (
+                    objects,
+                    selectedFields
+                );
+                fvReconstructor.reconstructFvVolumeInternalFields<vector>
+                (
+                    objects,
+                    selectedFields
+                );
+                fvReconstructor.reconstructFvVolumeInternalFields
+                <sphericalTensor>
+                (
+                    objects,
+                    selectedFields
+                );
+                fvReconstructor.reconstructFvVolumeInternalFields<symmTensor>
+                (
+                    objects,
+                    selectedFields
+                );
+                fvReconstructor.reconstructFvVolumeInternalFields<tensor>
+                (
+                    objects,
+                    selectedFields
+                );
+
+                fvReconstructor.reconstructFvVolumeFields<scalar>
+                (
+                    objects,
+                    selectedFields
+                );
+                fvReconstructor.reconstructFvVolumeFields<vector>
+                (
+                    objects,
+                    selectedFields
+                );
+                fvReconstructor.reconstructFvVolumeFields<sphericalTensor>
+                (
+                    objects,
+                    selectedFields
+                );
+                fvReconstructor.reconstructFvVolumeFields<symmTensor>
+                (
+                    objects,
+                    selectedFields
+                );
+                fvReconstructor.reconstructFvVolumeFields<tensor>
+                (
+                    objects,
+                    selectedFields
+                );
+
+                fvReconstructor.reconstructFvSurfaceFields<scalar>
+                (
+                    objects,
+                    selectedFields
+                );
+                fvReconstructor.reconstructFvSurfaceFields<vector>
+                (
+                    objects,
+                    selectedFields
+                );
+                fvReconstructor.reconstructFvSurfaceFields<sphericalTensor>
+                (
+                    objects,
+                    selectedFields
+                );
+                fvReconstructor.reconstructFvSurfaceFields<symmTensor>
+                (
+                    objects,
+                    selectedFields
+                );
+                fvReconstructor.reconstructFvSurfaceFields<tensor>
+                (
+                    objects,
+                    selectedFields
+                );
+
+                if (fvReconstructor.nReconstructed() == 0)
                 {
-                    // Check if we already have cloud objects for this cloudname
-                    HashTable<IOobjectList>::const_iterator iter =
-                        cloudObjects.find(cloudDirs[i]);
+                    Info<< "No FV fields" << nl << endl;
+                }
+            }
 
-                    if (iter == cloudObjects.end())
-                    {
-                        // Do local scan for valid cloud objects
-                        IOobjectList sprayObjs
+            {
+                Info<< "Reconstructing point fields" << nl << endl;
+
+                const pointMesh& pMesh = pointMesh::New(mesh);
+                PtrList<pointMesh> pMeshes(procMeshes.meshes().size());
+
+                forAll(pMeshes, procI)
+                {
+                    pMeshes.set
+                    (
+                        procI,
+                        new pointMesh(procMeshes.meshes()[procI])
+                    );
+                }
+
+                pointFieldReconstructor pointReconstructor
+                (
+                    pMesh,
+                    pMeshes,
+                    procMeshes.pointProcAddressing(),
+                    procMeshes.boundaryProcAddressing()
+                );
+
+                pointReconstructor.reconstructFields<scalar>
+                (
+                    objects,
+                    selectedFields
+                );
+                pointReconstructor.reconstructFields<vector>
+                (
+                    objects,
+                    selectedFields
+                );
+                pointReconstructor.reconstructFields<sphericalTensor>
+                (
+                    objects,
+                    selectedFields
+                );
+                pointReconstructor.reconstructFields<symmTensor>
+                (
+                    objects,
+                    selectedFields
+                );
+                pointReconstructor.reconstructFields<tensor>
+                (
+                    objects,
+                    selectedFields
+                );
+
+                if (pointReconstructor.nReconstructed() == 0)
+                {
+                    Info<< "No point fields" << nl << endl;
+                }
+            }
+
+
+            // If there are any clouds, reconstruct them.
+            // The problem is that a cloud of size zero will not get written so
+            // in pass 1 we determine the cloud names and per cloud name the
+            // fields. Note that the fields are stored as IOobjectList from
+            // the first processor that has them. They are in pass2 only used
+            // for name and type (scalar, vector etc).
+
+            if (!noLagrangian)
+            {
+                HashTable<IOobjectList> cloudObjects;
+
+                forAll(databases, procI)
+                {
+                    fileNameList cloudDirs
+                    (
+                        readDir
                         (
-                            procMeshes.meshes()[procI],
-                            databases[procI].timeName(),
-                            cloud::prefix/cloudDirs[i]
-                        );
+                            databases[procI].timePath()
+                          / regionDir
+                          / cloud::prefix,
+                            fileName::DIRECTORY
+                        )
+                    );
 
-                        IOobject* positionsPtr = sprayObjs.lookup("positions");
+                    forAll(cloudDirs, i)
+                    {
+                        // Check if we already have cloud objects for this
+                        // cloudname
+                        HashTable<IOobjectList>::const_iterator iter =
+                            cloudObjects.find(cloudDirs[i]);
 
-                        if (positionsPtr)
+                        if (iter == cloudObjects.end())
                         {
-                            cloudObjects.insert(cloudDirs[i], sprayObjs);
+                            // Do local scan for valid cloud objects
+                            IOobjectList sprayObjs
+                            (
+                                procMeshes.meshes()[procI],
+                                databases[procI].timeName(),
+                                cloud::prefix/cloudDirs[i]
+                            );
+
+                            IOobject* positionsPtr = sprayObjs.lookup
+                            (
+                                "positions"
+                            );
+
+                            if (positionsPtr)
+                            {
+                                cloudObjects.insert(cloudDirs[i], sprayObjs);
+                            }
                         }
                     }
                 }
-            }
 
 
-            if (cloudObjects.size())
-            {
-                // Pass2: reconstruct the cloud
-                forAllConstIter(HashTable<IOobjectList>, cloudObjects, iter)
+                if (cloudObjects.size())
                 {
-                    const word cloudName = string::validate<word>(iter.key());
+                    // Pass2: reconstruct the cloud
+                    forAllConstIter(HashTable<IOobjectList>, cloudObjects, iter)
+                    {
+                        const word cloudName = string::validate<word>
+                        (
+                            iter.key()
+                        );
 
-                    // Objects (on arbitrary processor)
-                    const IOobjectList& sprayObjs = iter();
+                        // Objects (on arbitrary processor)
+                        const IOobjectList& sprayObjs = iter();
 
-                    Info<< "Reconstructing lagrangian fields for cloud "
-                        << cloudName << nl << endl;
+                        Info<< "Reconstructing lagrangian fields for cloud "
+                            << cloudName << nl << endl;
 
-                    reconstructLagrangianPositions
-                    (
-                        mesh,
-                        cloudName,
-                        procMeshes.meshes(),
-                        procMeshes.faceProcAddressing(),
-                        procMeshes.cellProcAddressing()
-                    );
-                    reconstructLagrangianFields<label>
-                    (
-                        cloudName,
-                        mesh,
-                        procMeshes.meshes(),
-                        sprayObjs,
-                        selectedLagrangianFields
-                    );
-                    reconstructLagrangianFieldFields<label>
-                    (
-                        cloudName,
-                        mesh,
-                        procMeshes.meshes(),
-                        sprayObjs,
-                        selectedLagrangianFields
-                    );
-                    reconstructLagrangianFields<scalar>
-                    (
-                        cloudName,
-                        mesh,
-                        procMeshes.meshes(),
-                        sprayObjs,
-                        selectedLagrangianFields
-                    );
-                    reconstructLagrangianFieldFields<scalar>
-                    (
-                        cloudName,
-                        mesh,
-                        procMeshes.meshes(),
-                        sprayObjs,
-                        selectedLagrangianFields
-                    );
-                    reconstructLagrangianFields<vector>
-                    (
-                        cloudName,
-                        mesh,
-                        procMeshes.meshes(),
-                        sprayObjs,
-                        selectedLagrangianFields
-                    );
-                    reconstructLagrangianFieldFields<vector>
-                    (
-                        cloudName,
-                        mesh,
-                        procMeshes.meshes(),
-                        sprayObjs,
-                        selectedLagrangianFields
-                    );
-                    reconstructLagrangianFields<sphericalTensor>
-                    (
-                        cloudName,
-                        mesh,
-                        procMeshes.meshes(),
-                        sprayObjs,
-                        selectedLagrangianFields
-                    );
-                    reconstructLagrangianFieldFields<sphericalTensor>
-                    (
-                        cloudName,
-                        mesh,
-                        procMeshes.meshes(),
-                        sprayObjs,
-                        selectedLagrangianFields
-                    );
-                    reconstructLagrangianFields<symmTensor>
-                    (
-                        cloudName,
-                        mesh,
-                        procMeshes.meshes(),
-                        sprayObjs,
-                        selectedLagrangianFields
-                    );
-                    reconstructLagrangianFieldFields<symmTensor>
-                    (
-                        cloudName,
-                        mesh,
-                        procMeshes.meshes(),
-                        sprayObjs,
-                        selectedLagrangianFields
-                    );
-                    reconstructLagrangianFields<tensor>
-                    (
-                        cloudName,
-                        mesh,
-                        procMeshes.meshes(),
-                        sprayObjs,
-                        selectedLagrangianFields
-                    );
-                    reconstructLagrangianFieldFields<tensor>
-                    (
-                        cloudName,
-                        mesh,
-                        procMeshes.meshes(),
-                        sprayObjs,
-                        selectedLagrangianFields
-                    );
+                        reconstructLagrangianPositions
+                        (
+                            mesh,
+                            cloudName,
+                            procMeshes.meshes(),
+                            procMeshes.faceProcAddressing(),
+                            procMeshes.cellProcAddressing()
+                        );
+                        reconstructLagrangianFields<label>
+                        (
+                            cloudName,
+                            mesh,
+                            procMeshes.meshes(),
+                            sprayObjs,
+                            selectedLagrangianFields
+                        );
+                        reconstructLagrangianFieldFields<label>
+                        (
+                            cloudName,
+                            mesh,
+                            procMeshes.meshes(),
+                            sprayObjs,
+                            selectedLagrangianFields
+                        );
+                        reconstructLagrangianFields<scalar>
+                        (
+                            cloudName,
+                            mesh,
+                            procMeshes.meshes(),
+                            sprayObjs,
+                            selectedLagrangianFields
+                        );
+                        reconstructLagrangianFieldFields<scalar>
+                        (
+                            cloudName,
+                            mesh,
+                            procMeshes.meshes(),
+                            sprayObjs,
+                            selectedLagrangianFields
+                        );
+                        reconstructLagrangianFields<vector>
+                        (
+                            cloudName,
+                            mesh,
+                            procMeshes.meshes(),
+                            sprayObjs,
+                            selectedLagrangianFields
+                        );
+                        reconstructLagrangianFieldFields<vector>
+                        (
+                            cloudName,
+                            mesh,
+                            procMeshes.meshes(),
+                            sprayObjs,
+                            selectedLagrangianFields
+                        );
+                        reconstructLagrangianFields<sphericalTensor>
+                        (
+                            cloudName,
+                            mesh,
+                            procMeshes.meshes(),
+                            sprayObjs,
+                            selectedLagrangianFields
+                        );
+                        reconstructLagrangianFieldFields<sphericalTensor>
+                        (
+                            cloudName,
+                            mesh,
+                            procMeshes.meshes(),
+                            sprayObjs,
+                            selectedLagrangianFields
+                        );
+                        reconstructLagrangianFields<symmTensor>
+                        (
+                            cloudName,
+                            mesh,
+                            procMeshes.meshes(),
+                            sprayObjs,
+                            selectedLagrangianFields
+                        );
+                        reconstructLagrangianFieldFields<symmTensor>
+                        (
+                            cloudName,
+                            mesh,
+                            procMeshes.meshes(),
+                            sprayObjs,
+                            selectedLagrangianFields
+                        );
+                        reconstructLagrangianFields<tensor>
+                        (
+                            cloudName,
+                            mesh,
+                            procMeshes.meshes(),
+                            sprayObjs,
+                            selectedLagrangianFields
+                        );
+                        reconstructLagrangianFieldFields<tensor>
+                        (
+                            cloudName,
+                            mesh,
+                            procMeshes.meshes(),
+                            sprayObjs,
+                            selectedLagrangianFields
+                        );
+                    }
+                }
+                else
+                {
+                    Info<< "No lagrangian fields" << nl << endl;
                 }
             }
-            else
-            {
-                Info<< "No lagrangian fields" << nl << endl;
-            }
         }
+    }
 
-        // If there are any "uniform" directories copy them from
-        // the master processor
-
+    // If there are any "uniform" directories copy them from
+    // the master processor
+    forAll(timeDirs, timeI)
+    {
         fileName uniformDir0 = databases[0].timePath()/"uniform";
         if (isDir(uniformDir0))
         {
diff --git a/applications/utilities/postProcessing/graphics/PV3Readers/PV3FoamReader/PV3FoamReader/PV3FoamReader_SM.xml b/applications/utilities/postProcessing/graphics/PV3Readers/PV3FoamReader/PV3FoamReader/PV3FoamReader_SM.xml
index 10873c3734..a798530ce8 100644
--- a/applications/utilities/postProcessing/graphics/PV3Readers/PV3FoamReader/PV3FoamReader/PV3FoamReader_SM.xml
+++ b/applications/utilities/postProcessing/graphics/PV3Readers/PV3FoamReader/PV3FoamReader/PV3FoamReader_SM.xml
@@ -107,7 +107,6 @@
       <BooleanDomain name="bool"/>
       <Documentation>
         Use vtkPolyhedron instead of decomposing polyhedra.
-        !!Actually uses vtkConvexPointSet until this is properly supported in VTK!!
       </Documentation>
     </IntVectorProperty>
 
@@ -154,6 +153,20 @@
       </Documentation>
     </IntVectorProperty>
 
+    <!-- Show Groups Only check-box -->
+    <IntVectorProperty
+      name="UiShowGroupsOnly"
+      command="SetShowGroupsOnly"
+      number_of_elements="1"
+      default_values="0"
+      is_internal="1"
+      animateable="0">
+      <BooleanDomain name="bool"/>
+      <Documentation>
+        Show groups only
+      </Documentation>
+    </IntVectorProperty>
+
     <!-- Force GUI update check box -->
     <IntVectorProperty
       name="UpdateGUI"
@@ -193,7 +206,8 @@
         </RequiredProperties>
       </ArraySelectionDomain>
       <Documentation>
-        This property contains a list of the mesh parts (patches, sets, zones).
+        This property contains a list of the mesh parts
+        (patches, groups, sets, zones).
       </Documentation>
     </StringVectorProperty>
 
@@ -281,6 +295,7 @@
     <Property name="UiZeroTime" show="0"/>
     <Property name="UiRefresh" show="0"/>
     <Property name="UiShowPatchNames" show="0"/>
+    <Property name="UiShowGroupsOnly" show="0"/>
     <Property name="UiIncludeSets" show="0"/>
     <Property name="UiIncludeZones" show="0"/>
   </Hints>
diff --git a/applications/utilities/postProcessing/graphics/PV3Readers/PV3FoamReader/PV3FoamReader/pqPV3FoamReaderPanel.cxx b/applications/utilities/postProcessing/graphics/PV3Readers/PV3FoamReader/PV3FoamReader/pqPV3FoamReaderPanel.cxx
index 66327dc6f5..babdd460c9 100644
--- a/applications/utilities/postProcessing/graphics/PV3Readers/PV3FoamReader/PV3FoamReader/pqPV3FoamReaderPanel.cxx
+++ b/applications/utilities/postProcessing/graphics/PV3Readers/PV3FoamReader/PV3FoamReader/pqPV3FoamReaderPanel.cxx
@@ -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) 2011-2012 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -109,7 +109,7 @@ pqPV3FoamReaderPanel::pqPV3FoamReaderPanel
 
     QFrame* hline1 = new QFrame(this);
     hline1->setFrameStyle(QFrame::HLine | QFrame::Sunken);
-    form->addWidget(hline1, 1, 0, 1, 2);
+    form->addWidget(hline1, 1, 0, 1, 3);
 
     // checkbox for caching mesh
     if ((prop = this->proxy()->GetProperty("UiCacheMesh")) != 0)
@@ -166,6 +166,34 @@ pqPV3FoamReaderPanel::pqPV3FoamReaderPanel
     }
 
 
+    // checkbox for Groups Only
+    if ((prop = this->proxy()->GetProperty("UiShowGroupsOnly")) != 0)
+    {
+        // immediate update on the Server Manager side
+        prop->SetImmediateUpdate(true);
+
+        ShowGroupsOnly_ = new QCheckBox("Groups Only");
+        ShowGroupsOnly_->setChecked
+        (
+            vtkSMIntVectorProperty::SafeDownCast(prop)->GetElement(0)
+        );
+        ShowGroupsOnly_->setToolTip
+        (
+            "Show patchGroups only."
+        );
+
+        // row/col 2, 2
+        form->addWidget(ShowGroupsOnly_, 2, 2, Qt::AlignLeft);
+        connect
+        (
+            ShowGroupsOnly_,
+            SIGNAL(stateChanged(int)),
+            this,
+            SLOT(ShowGroupsOnlyToggled())
+        );
+    }
+
+
     // checkbox for include sets
     if ((prop = this->proxy()->GetProperty("UiIncludeSets")) != 0)
     {
@@ -278,7 +306,7 @@ pqPV3FoamReaderPanel::pqPV3FoamReaderPanel
 
     QFrame* hline2 = new QFrame(this);
     hline2->setFrameStyle(QFrame::HLine | QFrame::Sunken);
-    form->addWidget(hline2, 5, 0, 1, 2);
+    form->addWidget(hline2, 5, 0, 1, 3);
 }
 
 
@@ -336,6 +364,22 @@ void pqPV3FoamReaderPanel::ShowPatchNamesToggled()
 }
 
 
+void pqPV3FoamReaderPanel::ShowGroupsOnlyToggled()
+{
+    vtkSMProperty* prop;
+
+    vtkSMIntVectorProperty::SafeDownCast
+    (
+        this->proxy()->GetProperty("UiShowGroupsOnly")
+    )->SetElement(0, ShowGroupsOnly_->isChecked());
+
+    if ((prop = this->proxy()->GetProperty("PartArrayStatus")) != 0)
+    {
+        this->proxy()->UpdatePropertyInformation(prop);
+    }
+}
+
+
 void pqPV3FoamReaderPanel::IncludeSetsToggled()
 {
     vtkSMProperty* prop;
diff --git a/applications/utilities/postProcessing/graphics/PV3Readers/PV3FoamReader/PV3FoamReader/pqPV3FoamReaderPanel.h b/applications/utilities/postProcessing/graphics/PV3Readers/PV3FoamReader/PV3FoamReader/pqPV3FoamReaderPanel.h
index f7b057ecc7..c4594c257e 100644
--- a/applications/utilities/postProcessing/graphics/PV3Readers/PV3FoamReader/PV3FoamReader/pqPV3FoamReaderPanel.h
+++ b/applications/utilities/postProcessing/graphics/PV3Readers/PV3FoamReader/PV3FoamReader/pqPV3FoamReaderPanel.h
@@ -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) 2011-2012 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -71,6 +71,9 @@ class pqPV3FoamReaderPanel
     //- Show Patch Names checkbox
     QCheckBox* ShowPatchNames_;
 
+    //- Show Groups Only checkbox
+    QCheckBox* ShowGroupsOnly_;
+
     //- IncludeSets checkbox
     QCheckBox* IncludeSets_;
 
@@ -90,6 +93,7 @@ protected slots:
     void ZeroTimeToggled();
     void RefreshPressed();
     void ShowPatchNamesToggled();
+    void ShowGroupsOnlyToggled();
     void IncludeSetsToggled();
     void IncludeZonesToggled();
     void InterpolateVolFieldsToggled();
diff --git a/applications/utilities/postProcessing/graphics/PV3Readers/PV3FoamReader/PV3FoamReader/vtkPV3FoamReader.cxx b/applications/utilities/postProcessing/graphics/PV3Readers/PV3FoamReader/PV3FoamReader/vtkPV3FoamReader.cxx
index a2671ddb9d..27c3f63fe5 100644
--- a/applications/utilities/postProcessing/graphics/PV3Readers/PV3FoamReader/PV3FoamReader/vtkPV3FoamReader.cxx
+++ b/applications/utilities/postProcessing/graphics/PV3Readers/PV3FoamReader/PV3FoamReader/vtkPV3FoamReader.cxx
@@ -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) 2011-2012 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -85,6 +85,7 @@ vtkPV3FoamReader::vtkPV3FoamReader()
     IncludeSets = 0;
     IncludeZones = 0;
     ShowPatchNames = 0;
+    ShowGroupsOnly = 0;
     InterpolateVolFields = 1;
 
     UpdateGUI = 0;
@@ -463,6 +464,19 @@ void vtkPV3FoamReader::SetShowPatchNames(int val)
 }
 
 
+void vtkPV3FoamReader::SetShowGroupsOnly(int val)
+{
+    if (ShowGroupsOnly != val)
+    {
+        ShowGroupsOnly = val;
+        if (foamData_)
+        {
+            foamData_->updateInfo();
+        }
+    }
+}
+
+
 void vtkPV3FoamReader::updatePatchNamesView(const bool show)
 {
     pqApplicationCore* appCore = pqApplicationCore::instance();
diff --git a/applications/utilities/postProcessing/graphics/PV3Readers/PV3FoamReader/PV3FoamReader/vtkPV3FoamReader.h b/applications/utilities/postProcessing/graphics/PV3Readers/PV3FoamReader/PV3FoamReader/vtkPV3FoamReader.h
index da31ba6231..aa4bec44b6 100644
--- a/applications/utilities/postProcessing/graphics/PV3Readers/PV3FoamReader/PV3FoamReader/vtkPV3FoamReader.h
+++ b/applications/utilities/postProcessing/graphics/PV3Readers/PV3FoamReader/PV3FoamReader/vtkPV3FoamReader.h
@@ -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) 2011-2012 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -121,6 +121,11 @@ public:
     virtual void SetShowPatchNames(int);
     vtkGetMacro(ShowPatchNames, int);
 
+    // Description:
+    // OpenFOAM display patchGroups
+    virtual void SetShowGroupsOnly(int);
+    vtkGetMacro(ShowGroupsOnly, int);
+
     // Description:
     // OpenFOAM volField interpolation
     vtkSetMacro(InterpolateVolFields, int);
@@ -231,6 +236,7 @@ private:
     int IncludeSets;
     int IncludeZones;
     int ShowPatchNames;
+    int ShowGroupsOnly;
     int InterpolateVolFields;
 
     //- Dummy variable/switch to invoke a reader update
diff --git a/applications/utilities/postProcessing/graphics/PV3Readers/PV3FoamReader/vtkPV3Foam/Make/files b/applications/utilities/postProcessing/graphics/PV3Readers/PV3FoamReader/vtkPV3Foam/Make/files
index e71b857bb2..685ea2e8a0 100644
--- a/applications/utilities/postProcessing/graphics/PV3Readers/PV3FoamReader/vtkPV3Foam/Make/files
+++ b/applications/utilities/postProcessing/graphics/PV3Readers/PV3FoamReader/vtkPV3Foam/Make/files
@@ -2,7 +2,6 @@ vtkPV3Foam.C
 vtkPV3FoamFields.C
 vtkPV3FoamMesh.C
 vtkPV3FoamMeshLagrangian.C
-vtkPV3FoamMeshPatch.C
 vtkPV3FoamMeshSet.C
 vtkPV3FoamMeshVolume.C
 vtkPV3FoamMeshZone.C
diff --git a/applications/utilities/postProcessing/graphics/PV3Readers/PV3FoamReader/vtkPV3Foam/vtkPV3Foam.H b/applications/utilities/postProcessing/graphics/PV3Readers/PV3FoamReader/vtkPV3Foam/vtkPV3Foam.H
index b4d031b7ec..397dc7ecc2 100644
--- a/applications/utilities/postProcessing/graphics/PV3Readers/PV3FoamReader/vtkPV3Foam/vtkPV3Foam.H
+++ b/applications/utilities/postProcessing/graphics/PV3Readers/PV3FoamReader/vtkPV3Foam/vtkPV3Foam.H
@@ -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) 2011-2012 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -33,7 +33,7 @@ SourceFiles
     vtkPV3FoamFields.C
     vtkPV3FoamMesh.C
     vtkPV3FoamMeshLagrangian.C
-    vtkPV3FoamMeshPatch.C
+    vtkPV3FoamTemplates.C
     vtkPV3FoamMeshSet.C
     vtkPV3FoamMeshVolume.C
     vtkPV3FoamMeshZone.C
@@ -443,7 +443,8 @@ class vtkPV3Foam
             );
 
             //- Add patch mesh
-            vtkPolyData* patchVTKMesh(const polyPatch&);
+            template<class PatchType>
+            vtkPolyData* patchVTKMesh(const word& name, const PatchType&);
 
             //- Add face zone mesh
             vtkPolyData* faceZoneVTKMesh
@@ -736,6 +737,12 @@ public:
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
+#ifdef NoRepository
+#   include "vtkPV3FoamTemplates.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
 #endif
 
 // ************************************************************************* //
diff --git a/applications/utilities/postProcessing/graphics/PV3Readers/PV3FoamReader/vtkPV3Foam/vtkPV3FoamMesh.C b/applications/utilities/postProcessing/graphics/PV3Readers/PV3FoamReader/vtkPV3Foam/vtkPV3FoamMesh.C
index c77216d858..b229da9479 100644
--- a/applications/utilities/postProcessing/graphics/PV3Readers/PV3FoamReader/vtkPV3Foam/vtkPV3FoamMesh.C
+++ b/applications/utilities/postProcessing/graphics/PV3Readers/PV3FoamReader/vtkPV3Foam/vtkPV3FoamMesh.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) 2011-2012 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -31,6 +31,7 @@ License
 #include "pointSet.H"
 #include "fvMeshSubset.H"
 #include "vtkPV3FoamReader.h"
+#include "uindirectPrimitivePatch.H"
 
 // VTK includes
 #include "vtkDataArraySelection.h"
@@ -171,21 +172,50 @@ void Foam::vtkPV3Foam::convertMeshPatches
 
     for (int partId = range.start(); partId < range.end(); ++partId)
     {
-        const word patchName = getPartName(partId);
-        const label  patchId = patches.findPatchID(patchName);
-
-        if (!partStatus_[partId] || patchId < 0)
+        if (!partStatus_[partId])
         {
             continue;
         }
 
+        const word patchName = getPartName(partId);
+
+        labelHashSet patchIds(patches.patchSet(List<wordRe>(1, patchName)));
+
         if (debug)
         {
-            Info<< "Creating VTK mesh for patch[" << patchId <<"] "
+            Info<< "Creating VTK mesh for patches [" << patchIds <<"] "
                 << patchName  << endl;
         }
 
-        vtkPolyData* vtkmesh = patchVTKMesh(patches[patchId]);
+        vtkPolyData* vtkmesh = NULL;
+        if (patchIds.size() == 1)
+        {
+            vtkmesh = patchVTKMesh(patchName, patches[patchIds.begin().key()]);
+        }
+        else
+        {
+            // Patch group. Collect patch faces.
+            label sz = 0;
+            forAllConstIter(labelHashSet, patchIds, iter)
+            {
+                sz += patches[iter.key()].size();
+            }
+            labelList meshFaceLabels(sz);
+            sz = 0;
+            forAllConstIter(labelHashSet, patchIds, iter)
+            {
+                const polyPatch& pp = patches[iter.key()];
+                forAll(pp, i)
+                {
+                    meshFaceLabels[sz++] = pp.start()+i;
+                }
+            }
+            UIndirectList<face> fcs(mesh.faces(), meshFaceLabels);
+            uindirectPrimitivePatch pp(fcs, mesh.points());
+
+            vtkmesh = patchVTKMesh(patchName, pp);
+        }
+
 
         if (vtkmesh)
         {
diff --git a/applications/utilities/postProcessing/graphics/PV3Readers/PV3FoamReader/vtkPV3Foam/vtkPV3FoamMeshPatch.C b/applications/utilities/postProcessing/graphics/PV3Readers/PV3FoamReader/vtkPV3Foam/vtkPV3FoamTemplates.C
similarity index 87%
rename from applications/utilities/postProcessing/graphics/PV3Readers/PV3FoamReader/vtkPV3Foam/vtkPV3FoamMeshPatch.C
rename to applications/utilities/postProcessing/graphics/PV3Readers/PV3FoamReader/vtkPV3Foam/vtkPV3FoamTemplates.C
index 29f64dc5af..605fb463ef 100644
--- a/applications/utilities/postProcessing/graphics/PV3Readers/PV3FoamReader/vtkPV3Foam/vtkPV3FoamMeshPatch.C
+++ b/applications/utilities/postProcessing/graphics/PV3Readers/PV3FoamReader/vtkPV3Foam/vtkPV3FoamTemplates.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) 2011-2012 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -37,13 +37,18 @@ License
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
-vtkPolyData* Foam::vtkPV3Foam::patchVTKMesh(const polyPatch& p)
+template<class PatchType>
+vtkPolyData* Foam::vtkPV3Foam::patchVTKMesh
+(
+    const word& name,
+    const PatchType& p
+)
 {
     vtkPolyData* vtkmesh = vtkPolyData::New();
 
     if (debug)
     {
-        Info<< "<beg> Foam::vtkPV3Foam::patchVTKMesh - " << p.name() << endl;
+        Info<< "<beg> Foam::vtkPV3Foam::patchVTKMesh - " << name << endl;
         printMemory();
     }
 
@@ -83,7 +88,7 @@ vtkPolyData* Foam::vtkPV3Foam::patchVTKMesh(const polyPatch& p)
 
     if (debug)
     {
-        Info<< "<end> Foam::vtkPV3Foam::patchVTKMesh - " << p.name() << endl;
+        Info<< "<end> Foam::vtkPV3Foam::patchVTKMesh - " << name << endl;
         printMemory();
     }
 
diff --git a/applications/utilities/postProcessing/graphics/PV3Readers/PV3FoamReader/vtkPV3Foam/vtkPV3FoamUpdateInfo.C b/applications/utilities/postProcessing/graphics/PV3Readers/PV3FoamReader/vtkPV3Foam/vtkPV3FoamUpdateInfo.C
index 642e5dbaae..fe7cdae8a9 100644
--- a/applications/utilities/postProcessing/graphics/PV3Readers/PV3FoamReader/vtkPV3Foam/vtkPV3FoamUpdateInfo.C
+++ b/applications/utilities/postProcessing/graphics/PV3Readers/PV3FoamReader/vtkPV3Foam/vtkPV3FoamUpdateInfo.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) 2011-2012 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -241,7 +241,6 @@ void Foam::vtkPV3Foam::updateInfoPatches
     {
         const polyBoundaryMesh& patches = meshPtr_->boundaryMesh();
         const HashTable<labelList, word>& groups = patches.groupPatchIDs();
-
         const wordList allPatchNames = patches.names();
 
         // Add patch groups
@@ -273,13 +272,19 @@ void Foam::vtkPV3Foam::updateInfoPatches
 
                 if (enabledEntriesSet.found(vtkGrpName))
                 {
-                    forAll(patchIDs, i)
+                    if (!reader_->GetShowGroupsOnly())
                     {
-                        const polyPatch& pp = patches[patchIDs[i]];
-                        string vtkPatchName = pp.name() + " - patch";
-                        enabledEntriesSet.insert(vtkPatchName);
+                        enabledEntriesSet.erase(vtkGrpName);
+                        forAll(patchIDs, i)
+                        {
+                            const polyPatch& pp = patches[patchIDs[i]];
+                            if (pp.size())
+                            {
+                                string vtkPatchName = pp.name() + " - patch";
+                                enabledEntriesSet.insert(vtkPatchName);
+                            }
+                        }
                     }
-                    enabledEntriesSet.erase(vtkGrpName);
                 }
             }
         }
@@ -288,19 +293,22 @@ void Foam::vtkPV3Foam::updateInfoPatches
         // Add patches
         // ~~~~~~~~~~~
 
-        forAll(patches, patchI)
+        if (!reader_->GetShowGroupsOnly())
         {
-            const polyPatch& pp = patches[patchI];
-
-            if (pp.size())
+            forAll(patches, patchI)
             {
-                // Add patch to GUI list
-                arraySelection->AddArray
-                (
-                    (pp.name() + " - patch").c_str()
-                );
+                const polyPatch& pp = patches[patchI];
 
-                ++nPatches;
+                if (pp.size())
+                {
+                    // Add patch to GUI list
+                    arraySelection->AddArray
+                    (
+                        (pp.name() + " - patch").c_str()
+                    );
+
+                    ++nPatches;
+                }
             }
         }
     }
@@ -356,6 +364,7 @@ void Foam::vtkPV3Foam::updateInfoPatches
 
                 wordList groupNames;
                 patchDict.readIfPresent("inGroups", groupNames);
+
                 forAll(groupNames, groupI)
                 {
                     HashTable<labelList, word>::iterator iter = groups.find
@@ -394,20 +403,25 @@ void Foam::vtkPV3Foam::updateInfoPatches
                 if (nFaces)
                 {
                     string vtkGrpName = groupName + " - group";
-
                     arraySelection->AddArray(vtkGrpName.c_str());
 
                     ++nPatches;
 
                     if (enabledEntriesSet.found(vtkGrpName))
                     {
-                        forAll(patchIDs, i)
+                        if (!reader_->GetShowGroupsOnly())
                         {
-                            string vtkPatchName =
-                                names[patchIDs[i]] + " - patch";
-                            enabledEntriesSet.insert(vtkPatchName);
+                            enabledEntriesSet.erase(vtkGrpName);
+                            forAll(patchIDs, i)
+                            {
+                                if (sizes[patchIDs[i]])
+                                {
+                                    string vtkPatchName =
+                                        names[patchIDs[i]] + " - patch";
+                                    enabledEntriesSet.insert(vtkPatchName);
+                                }
+                            }
                         }
-                        enabledEntriesSet.erase(vtkGrpName);
                     }
                 }
             }
@@ -416,17 +430,20 @@ void Foam::vtkPV3Foam::updateInfoPatches
             // Add (non-zero) patches to the list of mesh parts
             // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-            forAll(names, patchI)
+            if (!reader_->GetShowGroupsOnly())
             {
-                // Valid patch if nFace > 0 - add patch to GUI list
-                if (sizes[patchI])
+                forAll(names, patchI)
                 {
-                    arraySelection->AddArray
-                    (
-                        (names[patchI] + " - patch").c_str()
-                    );
+                    // Valid patch if nFace > 0 - add patch to GUI list
+                    if (sizes[patchI])
+                    {
+                        arraySelection->AddArray
+                        (
+                            (names[patchI] + " - patch").c_str()
+                        );
 
-                    ++nPatches;
+                        ++nPatches;
+                    }
                 }
             }
         }
diff --git a/etc/codeTemplates/dynamicCode/mixedFvPatchFieldTemplate.C b/etc/codeTemplates/dynamicCode/mixedFvPatchFieldTemplate.C
index ded11e8929..ab2f100f3e 100644
--- a/etc/codeTemplates/dynamicCode/mixedFvPatchFieldTemplate.C
+++ b/etc/codeTemplates/dynamicCode/mixedFvPatchFieldTemplate.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) 2011-2012 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -73,18 +73,18 @@ extern "C"
 makeRemovablePatchTypeField
 (
     fvPatch${FieldType},
-    ${typeName}FixedValueFvPatch${FieldType}
+    ${typeName}MixedValueFvPatch${FieldType}
 );
 
 
-const char* const ${typeName}FixedValueFvPatch${FieldType}::SHA1sum =
+const char* const ${typeName}MixedValueFvPatch${FieldType}::SHA1sum =
     "${SHA1sum}";
 
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
-${typeName}FixedValueFvPatch${FieldType}::
-${typeName}FixedValueFvPatch${FieldType}
+${typeName}MixedValueFvPatch${FieldType}::
+${typeName}MixedValueFvPatch${FieldType}
 (
     const fvPatch& p,
     const DimensionedField<${TemplateType}, volMesh>& iF
@@ -100,10 +100,10 @@ ${typeName}FixedValueFvPatch${FieldType}
 }
 
 
-${typeName}FixedValueFvPatch${FieldType}::
-${typeName}FixedValueFvPatch${FieldType}
+${typeName}MixedValueFvPatch${FieldType}::
+${typeName}MixedValueFvPatch${FieldType}
 (
-    const ${typeName}FixedValueFvPatch${FieldType}& ptf,
+    const ${typeName}MixedValueFvPatch${FieldType}& ptf,
     const fvPatch& p,
     const DimensionedField<${TemplateType}, volMesh>& iF,
     const fvPatchFieldMapper& mapper
@@ -119,8 +119,8 @@ ${typeName}FixedValueFvPatch${FieldType}
 }
 
 
-${typeName}FixedValueFvPatch${FieldType}::
-${typeName}FixedValueFvPatch${FieldType}
+${typeName}MixedValueFvPatch${FieldType}::
+${typeName}MixedValueFvPatch${FieldType}
 (
     const fvPatch& p,
     const DimensionedField<${TemplateType}, volMesh>& iF,
@@ -137,10 +137,10 @@ ${typeName}FixedValueFvPatch${FieldType}
 }
 
 
-${typeName}FixedValueFvPatch${FieldType}::
-${typeName}FixedValueFvPatch${FieldType}
+${typeName}MixedValueFvPatch${FieldType}::
+${typeName}MixedValueFvPatch${FieldType}
 (
-    const ${typeName}FixedValueFvPatch${FieldType}& ptf
+    const ${typeName}MixedValueFvPatch${FieldType}& ptf
 )
 :
     mixedFvPatchField<${TemplateType}>(ptf)
@@ -153,10 +153,10 @@ ${typeName}FixedValueFvPatch${FieldType}
 }
 
 
-${typeName}FixedValueFvPatch${FieldType}::
-${typeName}FixedValueFvPatch${FieldType}
+${typeName}MixedValueFvPatch${FieldType}::
+${typeName}MixedValueFvPatch${FieldType}
 (
-    const ${typeName}FixedValueFvPatch${FieldType}& ptf,
+    const ${typeName}MixedValueFvPatch${FieldType}& ptf,
     const DimensionedField<${TemplateType}, volMesh>& iF
 )
 :
@@ -172,8 +172,8 @@ ${typeName}FixedValueFvPatch${FieldType}
 
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
-${typeName}FixedValueFvPatch${FieldType}::
-~${typeName}FixedValueFvPatch${FieldType}()
+${typeName}MixedValueFvPatch${FieldType}::
+~${typeName}MixedValueFvPatch${FieldType}()
 {
     if (${verbose:-false})
     {
@@ -184,7 +184,7 @@ ${typeName}FixedValueFvPatch${FieldType}::
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
-void ${typeName}FixedValueFvPatch${FieldType}::updateCoeffs()
+void ${typeName}MixedValueFvPatch${FieldType}::updateCoeffs()
 {
     if (this->updated())
     {
diff --git a/etc/codeTemplates/dynamicCode/mixedFvPatchFieldTemplate.H b/etc/codeTemplates/dynamicCode/mixedFvPatchFieldTemplate.H
index 7c0b654618..06e1c9887c 100644
--- a/etc/codeTemplates/dynamicCode/mixedFvPatchFieldTemplate.H
+++ b/etc/codeTemplates/dynamicCode/mixedFvPatchFieldTemplate.H
@@ -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) 2011-2012 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -43,10 +43,10 @@ namespace Foam
 {
 
 /*---------------------------------------------------------------------------*\
-                         A templated FixedValueFvPatch
+                     A templated MixedValueFvPatchField
 \*---------------------------------------------------------------------------*/
 
-class ${typeName}FixedValueFvPatch${FieldType}
+class ${typeName}MixedValueFvPatch${FieldType}
 :
     public mixedFvPatchField<${TemplateType}>
 {
@@ -62,14 +62,14 @@ public:
     // Constructors
 
         //- Construct from patch and internal field
-        ${typeName}FixedValueFvPatch${FieldType}
+        ${typeName}MixedValueFvPatch${FieldType}
         (
             const fvPatch&,
             const DimensionedField<${TemplateType}, volMesh>&
         );
 
         //- Construct from patch, internal field and dictionary
-        ${typeName}FixedValueFvPatch${FieldType}
+        ${typeName}MixedValueFvPatch${FieldType}
         (
             const fvPatch&,
             const DimensionedField<${TemplateType}, volMesh>&,
@@ -77,18 +77,18 @@ public:
         );
 
         //- Construct by mapping a copy onto a new patch
-        ${typeName}FixedValueFvPatch${FieldType}
+        ${typeName}MixedValueFvPatch${FieldType}
         (
-            const ${typeName}FixedValueFvPatch${FieldType}&,
+            const ${typeName}MixedValueFvPatch${FieldType}&,
             const fvPatch&,
             const DimensionedField<${TemplateType}, volMesh>&,
             const fvPatchFieldMapper&
         );
 
         //- Construct as copy
-        ${typeName}FixedValueFvPatch${FieldType}
+        ${typeName}MixedValueFvPatch${FieldType}
         (
-            const ${typeName}FixedValueFvPatch${FieldType}&
+            const ${typeName}MixedValueFvPatch${FieldType}&
         );
 
         //- Construct and return a clone
@@ -96,14 +96,14 @@ public:
         {
             return tmp< fvPatch${FieldType} >
             (
-                new ${typeName}FixedValueFvPatch${FieldType}(*this)
+                new ${typeName}MixedValueFvPatch${FieldType}(*this)
             );
         }
 
         //- Construct as copy setting internal field reference
-        ${typeName}FixedValueFvPatch${FieldType}
+        ${typeName}MixedValueFvPatch${FieldType}
         (
-            const ${typeName}FixedValueFvPatch${FieldType}&,
+            const ${typeName}MixedValueFvPatch${FieldType}&,
             const DimensionedField<${TemplateType}, volMesh>&
         );
 
@@ -115,13 +115,13 @@ public:
         {
             return tmp< fvPatch${FieldType} >
             (
-                new ${typeName}FixedValueFvPatch${FieldType}(*this, iF)
+                new ${typeName}MixedValueFvPatch${FieldType}(*this, iF)
             );
         }
 
 
     //- Destructor
-    virtual ~${typeName}FixedValueFvPatch${FieldType}();
+    virtual ~${typeName}MixedValueFvPatch${FieldType}();
 
 
     // Member functions
diff --git a/etc/controlDict b/etc/controlDict
index f9998bcdd7..c4cf09edb2 100644
--- a/etc/controlDict
+++ b/etc/controlDict
@@ -989,7 +989,7 @@ DimensionSets
 
         // Set of units used for printing. Can be any basic or derived
         // but not scaled (only supported for dimensionedScalar, etc)
-        printUnits (kg m s K mol A Cd);
+        writeUnits (kg m s K mol A Cd);
     }
 }
 
diff --git a/src/OpenFOAM/db/dictionary/functionEntries/codeStream/codeStream.C b/src/OpenFOAM/db/dictionary/functionEntries/codeStream/codeStream.C
index de0b87d9ea..cfe9de3273 100644
--- a/src/OpenFOAM/db/dictionary/functionEntries/codeStream/codeStream.C
+++ b/src/OpenFOAM/db/dictionary/functionEntries/codeStream/codeStream.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) 2011-2012 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -104,11 +104,8 @@ Foam::functionEntries::codeStream::getFunction
 
     // codeName: codeStream + _<sha1>
     // codeDir : _<sha1>
-    dynamicCode dynCode
-    (
-        "codeStream" + context.sha1().str(true),
-        context.sha1().str(true)
-    );
+    std::string sha1Str(context.sha1().str(true));
+    dynamicCode dynCode("codeStream" + sha1Str, sha1Str);
 
     // Load library if not already loaded
     // Version information is encoded in the libPath (encoded with the SHA1)
diff --git a/src/OpenFOAM/db/dynamicLibrary/codedBase/codedBase.H b/src/OpenFOAM/db/dynamicLibrary/codedBase/codedBase.H
index 391c5267c0..a6bce15a25 100644
--- a/src/OpenFOAM/db/dynamicLibrary/codedBase/codedBase.H
+++ b/src/OpenFOAM/db/dynamicLibrary/codedBase/codedBase.H
@@ -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) 2011-2012 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -104,7 +104,7 @@ protected:
         virtual void prepare
         (
             dynamicCode&,
-            const dynamicCodeContext &
+            const dynamicCodeContext&
         ) const = 0;
 
         // Return a description (type + name) for the output
diff --git a/src/finiteVolume/fields/fvPatchFields/derived/codedMixed/codedMixedFvPatchField.H b/src/finiteVolume/fields/fvPatchFields/derived/codedMixed/codedMixedFvPatchField.H
index c631b20b86..3ab69cc81c 100644
--- a/src/finiteVolume/fields/fvPatchFields/derived/codedMixed/codedMixedFvPatchField.H
+++ b/src/finiteVolume/fields/fvPatchFields/derived/codedMixed/codedMixedFvPatchField.H
@@ -43,7 +43,9 @@ Description
 
         code
         #{
-            this->refValue() = min(10, 0.1*this->db().time().value());
+            this->refValue() =
+                vector(1, 0, 0)
+               *min(10, 0.1*this->db().time().value());
             this->refGrad() = vector::zero;
             this->valueFraction() = 1.0;
         #};
diff --git a/src/postProcessing/functionObjects/IO/writeDictionary/writeDictionary.C b/src/postProcessing/functionObjects/IO/writeDictionary/writeDictionary.C
index f10a84eece..c98ae3696b 100644
--- a/src/postProcessing/functionObjects/IO/writeDictionary/writeDictionary.C
+++ b/src/postProcessing/functionObjects/IO/writeDictionary/writeDictionary.C
@@ -26,6 +26,7 @@ License
 #include "writeDictionary.H"
 #include "dictionary.H"
 #include "Time.H"
+#include "HashSet.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
@@ -108,7 +109,9 @@ Foam::writeDictionary::~writeDictionary()
 
 void Foam::writeDictionary::read(const dictionary& dict)
 {
-    dict.lookup("dictNames") >> dictNames_;
+    wordList dictNames(dict.lookup("dictNames"));
+    HashSet<word> uniqueNames(dictNames);
+    dictNames_ = uniqueNames.toc();
 
     digests_.setSize(dictNames_.size(), SHA1Digest());
 
diff --git a/src/regionModels/regionModel/regionProperties/regionProperties.H b/src/regionModels/regionModel/regionProperties/regionProperties.H
index 796b0f6405..09ebbf66d5 100644
--- a/src/regionModels/regionModel/regionProperties/regionProperties.H
+++ b/src/regionModels/regionModel/regionProperties/regionProperties.H
@@ -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) 2011-2012 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -25,7 +25,11 @@ Class
     regionProperties
 
 Description
-    Simple class to hold region information for coupled region simulations
+    Simple class to hold region information for coupled region simulations.
+
+    Gives per physics ('fluid', 'solid') the names of the regions. There
+    is no assumption on this level that one region should only have one
+    set of physics.
 
 SourceFiles
     regionProperties.C
diff --git a/tutorials/heatTransfer/chtMultiRegionFoam/multiRegionHeater/Allrun b/tutorials/heatTransfer/chtMultiRegionFoam/multiRegionHeater/Allrun
index d6b2a5346d..64b8a22a12 100755
--- a/tutorials/heatTransfer/chtMultiRegionFoam/multiRegionHeater/Allrun
+++ b/tutorials/heatTransfer/chtMultiRegionFoam/multiRegionHeater/Allrun
@@ -31,27 +31,18 @@ done
 #runApplication `getApplication`
 
 # Decompose
-for i in bottomAir topAir heater leftSolid rightSolid
-do
-   decomposePar -region $i > log.decomposePar.$i 2>&1
-done
+runApplication decomposePar -allRegions
 
 # Run
 runParallel `getApplication` 4
 
 # Reconstruct
-for i in bottomAir topAir heater leftSolid rightSolid
-do
-   reconstructPar -region $i > log.reconstructPar.$i2 >&1
-done
+runApplication reconstructPar -allRegions
 
 
 echo
 echo "creating files for paraview post-processing"
 echo
-for i in bottomAir topAir heater leftSolid rightSolid
-do
-   paraFoam -touch -region $i
-done
+paraFoam -touchAll
 
 # ----------------------------------------------------------------- end-of-file
diff --git a/tutorials/heatTransfer/chtMultiRegionFoam/multiRegionLiquidHeater/Allrun b/tutorials/heatTransfer/chtMultiRegionFoam/multiRegionLiquidHeater/Allrun
index d30bb755dc..a1ef0bd9d6 100755
--- a/tutorials/heatTransfer/chtMultiRegionFoam/multiRegionLiquidHeater/Allrun
+++ b/tutorials/heatTransfer/chtMultiRegionFoam/multiRegionLiquidHeater/Allrun
@@ -31,19 +31,13 @@ done
 #runApplication chtMultiRegionFoam
 
 # Decompose
-for i in bottomWater topAir heater leftSolid rightSolid
-do
-   decomposePar -region $i > log.decomposePar.$i 2>&1
-done
+runApplication decomposePar -allRegions
 
 # Run
 runParallel `getApplication` 4
 
 # Reconstruct
-for i in bottomWater topAir heater leftSolid rightSolid
-do
-   reconstructPar -region $i > log.reconstructPar.$i 2>&1
-done
+runApplication reconstructPar -allRegions
 
 
 echo
diff --git a/tutorials/heatTransfer/chtMultiRegionFoam/snappyMultiRegionHeater/Allrun b/tutorials/heatTransfer/chtMultiRegionFoam/snappyMultiRegionHeater/Allrun
index 5f61c3380a..91f74227ac 100755
--- a/tutorials/heatTransfer/chtMultiRegionFoam/snappyMultiRegionHeater/Allrun
+++ b/tutorials/heatTransfer/chtMultiRegionFoam/snappyMultiRegionHeater/Allrun
@@ -36,27 +36,18 @@ runApplication `getApplication`
 
 
 ## Decompose
-#for i in bottomAir topAir heater leftSolid rightSolid
-#do
-#   decomposePar -region $i > log.decomposePar.$i 2>&1
-#done
+#runApplication decomposePar -allRegions
 #
 ## Run
 #runParallel `getApplication` 4
 #
 ## Reconstruct
-#for i in bottomAir topAir heater leftSolid rightSolid
-#do
-#   reconstructPar -region $i > log.reconstructPar.$i 2>&1
-#done
+#runApplication reconstructPar -allRegions
 
 
 echo
 echo "creating files for paraview post-processing"
 echo
-for i in bottomAir topAir heater leftSolid rightSolid
-do
-   paraFoam -touch -region $i
-done
+paraFoam -touchAll
 
 # ----------------------------------------------------------------- end-of-file
diff --git a/tutorials/heatTransfer/chtMultiRegionSimpleFoam/multiRegionHeater/Allrun b/tutorials/heatTransfer/chtMultiRegionSimpleFoam/multiRegionHeater/Allrun
index 953d19e839..4f27179ebc 100755
--- a/tutorials/heatTransfer/chtMultiRegionSimpleFoam/multiRegionHeater/Allrun
+++ b/tutorials/heatTransfer/chtMultiRegionSimpleFoam/multiRegionHeater/Allrun
@@ -31,19 +31,13 @@ done
 runApplication `getApplication`
 
 ## Decompose
-#for i in bottomAir topAir heater leftSolid rightSolid
-#do
-#   decomposePar -region $i > log.decomposePar.$i 2>&1
-#done
+#runApplication decomposePar -allRegions
 #
 ## Run
 #runParallel `getApplication` 4
 #
 ## Reconstruct
-#for i in bottomAir topAir heater leftSolid rightSolid
-#do
-#   reconstructPar -region $i > log.reconstructPar.$i 2>&1
-#done
+#runApplication reconstructPar -allRegions
 
 
 echo
diff --git a/tutorials/heatTransfer/chtMultiRegionSimpleFoam/multiRegionHeaterRadiation/Allrun b/tutorials/heatTransfer/chtMultiRegionSimpleFoam/multiRegionHeaterRadiation/Allrun
index a3801c1666..40b3687d50 100755
--- a/tutorials/heatTransfer/chtMultiRegionSimpleFoam/multiRegionHeaterRadiation/Allrun
+++ b/tutorials/heatTransfer/chtMultiRegionSimpleFoam/multiRegionHeaterRadiation/Allrun
@@ -44,10 +44,7 @@ runApplication `getApplication`
 
 ## Run in parallel
 ## Decompose
-#for i in bottomAir topAir heater leftSolid rightSolid
-#do
-#   decomposePar -region $i > log.decomposePar.$i 2>&1
-#done
+#runApplication decomposePar -allRegions
 #
 #for i in bottomAir topAir
 #do
@@ -63,10 +60,7 @@ runApplication `getApplication`
 #runParallel `getApplication` 4
 #
 ## Reconstruct
-#for i in bottomAir topAir heater leftSolid rightSolid
-#do
-#   reconstructPar -region $i > log.reconstructPar.$i 2>&1
-#done
+#runApplication reconstructPar -allRegions
 
 
 echo