diff --git a/src/finiteVolume/fvMesh/fvMeshDistributors/cpuLoad/cpuLoad.C b/src/finiteVolume/fvMesh/fvMeshDistributors/cpuLoad/cpuLoad.C
index 249ddc5fe3..3c761d37d4 100644
--- a/src/finiteVolume/fvMesh/fvMeshDistributors/cpuLoad/cpuLoad.C
+++ b/src/finiteVolume/fvMesh/fvMeshDistributors/cpuLoad/cpuLoad.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2022 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2022-2024 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -107,6 +107,24 @@ Foam::optionalCpuLoad& Foam::optionalCpuLoad::New
 }
 
 
+Foam::optionalCpuLoad& Foam::optionalCpuLoad::New
+(
+    const polyMesh& mesh,
+    const word& name,
+    const bool loadBalancing
+)
+{
+    if (loadBalancing && isA<fvMesh>(mesh))
+    {
+        return New(refCast<const fvMesh>(mesh), name, loadBalancing);
+    }
+    else
+    {
+        return optionalCpuLoad::optionalCpuLoad_;
+    }
+}
+
+
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
 void Foam::cpuLoad::reset()
diff --git a/src/finiteVolume/fvMesh/fvMeshDistributors/cpuLoad/cpuLoad.H b/src/finiteVolume/fvMesh/fvMeshDistributors/cpuLoad/cpuLoad.H
index fcc815db46..140e5791a0 100644
--- a/src/finiteVolume/fvMesh/fvMeshDistributors/cpuLoad/cpuLoad.H
+++ b/src/finiteVolume/fvMesh/fvMeshDistributors/cpuLoad/cpuLoad.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2022 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2022-2024 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -77,6 +77,8 @@ public:
 
     // Selectors
 
+        //- Construct from fvMesh if loadBalancing is true
+        // otherwise return the dummy optionalCpuLoad
         static optionalCpuLoad& New
         (
             const fvMesh& mesh,
@@ -84,6 +86,15 @@ public:
             const bool loadBalancing
         );
 
+        //- Construct from polyMesh if it is an fvMesh and loadBalancing is true
+        // otherwise return the dummy optionalCpuLoad
+        static optionalCpuLoad& New
+        (
+            const polyMesh& mesh,
+            const word& name,
+            const bool loadBalancing
+        );
+
 
     //- Destructor
     virtual ~optionalCpuLoad()
diff --git a/src/fvMeshDistributors/loadBalancer/fvMeshDistributorsLoadBalancer.C b/src/fvMeshDistributors/loadBalancer/fvMeshDistributorsLoadBalancer.C
index 0d07d6ce87..01680982a8 100644
--- a/src/fvMeshDistributors/loadBalancer/fvMeshDistributorsLoadBalancer.C
+++ b/src/fvMeshDistributors/loadBalancer/fvMeshDistributorsLoadBalancer.C
@@ -85,12 +85,13 @@ bool Foam::fvMeshDistributors::loadBalancer::update()
     if
     (
         Pstream::nProcs() > 1
-     && mesh.time().timeIndex() > 1
+     && mesh.time().timeIndex() - mesh.time().startTimeIndex() > 1
      && timeIndex_ != mesh.time().timeIndex()
     )
     {
         timeIndex_ = mesh.time().timeIndex();
 
+        // Get the CPU time fer this processor which includes waiting time
         const scalar timeStepCpuTime = cpuTime_.cpuTimeIncrement();
 
         // CPU loads per cell
@@ -107,80 +108,125 @@ bool Foam::fvMeshDistributors::loadBalancer::update()
         {
             timeIndex_ = mesh.time().timeIndex();
 
-            scalar sumCpuLoad = 0;
+            scalarList procCpuLoads(cpuLoads.size());
 
+            label l = 0;
             forAllConstIter(HashTable<cpuLoad*>, cpuLoads, iter)
             {
-                sumCpuLoad += sum(iter()->primitiveField());
+                procCpuLoads[l++] = sum(iter()->primitiveField());
             }
 
-            const scalar cellCFDCpuTime = returnReduce
-            (
-                (timeStepCpuTime - sumCpuLoad)/mesh.nCells(),
-                minOp<scalar>()
-            );
+            List<scalarList> allProcCpuLoads(Pstream::nProcs());
+            allProcCpuLoads[Pstream::myProcNo()] = procCpuLoads;
+            Pstream::gatherList(allProcCpuLoads);
+            Pstream::scatterList(allProcCpuLoads);
 
-            // Total CPU time for this processor
-            const scalar processorCpuTime =
-                mesh.nCells()*cellCFDCpuTime + sumCpuLoad;
+            scalarList sumProcCpuLoads(procCpuLoads.size(), scalar(0));
+            scalarList maxProcCpuLoads(procCpuLoads.size(), scalar(0));
+            forAll(maxProcCpuLoads, l)
+            {
+                forAll(allProcCpuLoads, proci)
+                {
+                    sumProcCpuLoads[l] += allProcCpuLoads[proci][l];
+
+                    maxProcCpuLoads[l] =
+                        max(maxProcCpuLoads[l], allProcCpuLoads[proci][l]);
+                }
+            }
+
+            // Sum over loads of the maximum load CPU time per processor
+            const scalar sumMaxProcCpuLoad(sum(maxProcCpuLoads));
+
+            // Maximum number of cells per processor
+            const label maxNcells = returnReduce(mesh.nCells(), maxOp<label>());
+
+            // Maximum processor CPU time spent doing basic CFD
+            const scalar maxBaseCpuTime =
+                returnReduce(timeStepCpuTime, maxOp<scalar>())
+              - sumMaxProcCpuLoad;
+
+            const scalar cellBaseCpuTime = maxBaseCpuTime/maxNcells;
+
+            // Processor CPU time spent doing basic CFD, not waiting
+            const scalar baseCpuTime = mesh.nCells()*cellBaseCpuTime;
+
+            // Maximum total CPU time
+            const scalar maxProcCpuTime = maxBaseCpuTime + sumMaxProcCpuLoad;
+
+            // Total CPU time for this processor not waiting
+            const scalar procCpuTime = baseCpuTime + sum(procCpuLoads);
 
             // Average processor CPU time
             const scalar averageProcessorCpuTime =
-                returnReduce(processorCpuTime, sumOp<scalar>())
-               /Pstream::nProcs();
+                returnReduce(procCpuTime, sumOp<scalar>())/Pstream::nProcs();
 
-            Pout<< "imbalance "
-                << " " << sumCpuLoad
-                << " " << mesh.nCells()*cellCFDCpuTime
-                << " " << processorCpuTime
-                << " " << averageProcessorCpuTime << endl;
+            const scalar imbalance =
+                (maxProcCpuTime - averageProcessorCpuTime)
+               /averageProcessorCpuTime;
 
-            const scalar imbalance = returnReduce
-            (
-                mag(1 - processorCpuTime/averageProcessorCpuTime),
-                maxOp<scalar>()
-            );
+            Info<< nl << type() << nl;
 
-            scalarField weights;
-
-            if (multiConstraint_)
+            l = 0;
+            forAllConstIter(HashTable<cpuLoad*>, cpuLoads, iter)
             {
-                const int nWeights = cpuLoads.size() + 1;
-
-                weights.setSize(nWeights*mesh.nCells());
-
-                for (label i=0; i<mesh.nCells(); i++)
-                {
-                    weights[nWeights*i] = cellCFDCpuTime;
-                }
-
-                label loadi = 1;
-                forAllConstIter(HashTable<cpuLoad*>, cpuLoads, iter)
-                {
-                    const scalarField& cpuLoadField = iter()->primitiveField();
-
-                    forAll(cpuLoadField, i)
-                    {
-                        weights[nWeights*i + loadi] = cpuLoadField[i];
-                    }
-
-                    loadi++;
-                }
+                Info<< "    Imbalance of load " << iter()->name() << ": "
+                    << (
+                          maxProcCpuLoads[l]
+                        - sumProcCpuLoads[l]/Pstream::nProcs()
+                       )/averageProcessorCpuTime
+                    << endl;
             }
-            else
-            {
-                weights.setSize(mesh.nCells(), cellCFDCpuTime);
 
-                forAllConstIter(HashTable<cpuLoad*>, cpuLoads, iter)
-                {
-                    weights += iter()->primitiveField();
-                }
-            }
+            Info<< "    Imbalance of base load " << ": "
+                << (
+                      maxBaseCpuTime
+                    - mesh.globalData().nTotalCells()*cellBaseCpuTime
+                     /Pstream::nProcs()
+                   )/averageProcessorCpuTime
+                << endl;
+
+            Info<< "    Total imbalance " << imbalance << endl;
 
             if (imbalance > maxImbalance_)
             {
-                Info<< "Redistributing mesh with imbalance "
-                    << imbalance << endl;
+                Info<< "    Redistributing mesh" << endl;
+
+                scalarField weights;
+
+                if (multiConstraint_)
+                {
+                    const label nWeights = cpuLoads.size() + 1;
+
+                    weights.setSize(nWeights*mesh.nCells());
+
+                    for (label i=0; i<mesh.nCells(); i++)
+                    {
+                        weights[nWeights*i] = cellBaseCpuTime;
+                    }
+
+                    label l = 1;
+                    forAllConstIter(HashTable<cpuLoad*>, cpuLoads, iter)
+                    {
+                        const scalarField& cpuLoadField =
+                            iter()->primitiveField();
+
+                        forAll(cpuLoadField, i)
+                        {
+                            weights[nWeights*i + l] = cpuLoadField[i];
+                        }
+
+                        l++;
+                    }
+                }
+                else
+                {
+                    weights.setSize(mesh.nCells(), cellBaseCpuTime);
+
+                    forAllConstIter(HashTable<cpuLoad*>, cpuLoads, iter)
+                    {
+                        weights += iter()->primitiveField();
+                    }
+                }
 
                 // Create new decomposition distribution
                 const labelList distribution
@@ -191,6 +237,8 @@ bool Foam::fvMeshDistributors::loadBalancer::update()
                 distribute(distribution);
 
                 redistributed = true;
+
+                Info<< endl;
             }
         }
 
diff --git a/src/lagrangian/basic/Cloud/Cloud.C b/src/lagrangian/basic/Cloud/Cloud.C
index 2ef5080dfd..68f7869f06 100644
--- a/src/lagrangian/basic/Cloud/Cloud.C
+++ b/src/lagrangian/basic/Cloud/Cloud.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2023 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2024 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -35,6 +35,7 @@ License
 #include "OFstream.H"
 #include "wallPolyPatch.H"
 #include "nonConformalCyclicPolyPatch.H"
+#include "cpuLoad.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -301,6 +302,11 @@ void Foam::Cloud<ParticleType>::move
     List<IDLList<ParticleType>> sendParticles(Pstream::nProcs());
     List<DynamicList<label>> sendPatchIndices(Pstream::nProcs());
 
+    optionalCpuLoad& cloudCpuTime
+    (
+        optionalCpuLoad::New(pMesh_, name() + ":cpuLoad", cloud.cpuLoad())
+    );
+
     // While there are particles to transfer
     while (true)
     {
@@ -311,6 +317,11 @@ void Foam::Cloud<ParticleType>::move
             sendPatchIndices[proci].clear();
         }
 
+        if (cloud.cpuLoad())
+        {
+            cloudCpuTime.reset();
+        }
+
         // Loop over all particles
         forAllIter(typename Cloud<ParticleType>, *this, pIter)
         {
@@ -319,6 +330,11 @@ void Foam::Cloud<ParticleType>::move
             // Move the particle
             const bool keepParticle = p.move(cloud, td);
 
+            if (cloud.cpuLoad())
+            {
+                cloudCpuTime.cpuTimeIncrement(p.cell());
+            }
+
             // If the particle is to be kept
             if (keepParticle)
             {
@@ -724,7 +740,7 @@ void Foam::Cloud<ParticleType>::distribute(const polyDistributionMap& map)
     if (lostCount != 0)
     {
         WarningInFunction
-            << "Mesh-to-mesh mapping of cloud " << this->name()
+            << "Distribution of cloud " << this->name()
             << " lost " << lostCount << " particles" << endl;
     }
 }
diff --git a/src/lagrangian/basic/Cloud/Cloud.H b/src/lagrangian/basic/Cloud/Cloud.H
index 4b38855a6c..de4b365560 100644
--- a/src/lagrangian/basic/Cloud/Cloud.H
+++ b/src/lagrangian/basic/Cloud/Cloud.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2023 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2024 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -194,6 +194,13 @@ public:
                 return IDLList<ParticleType>::size();
             };
 
+            //- Return true to cache per-cell CPU load
+            //  Overridden in derived clouds, defaults to false
+            bool cpuLoad() const
+            {
+                return false;
+            }
+
 
             // Iterators
 
diff --git a/src/lagrangian/parcel/clouds/Templates/MomentumCloud/MomentumCloud.C b/src/lagrangian/parcel/clouds/Templates/MomentumCloud/MomentumCloud.C
index 48632444c3..9b241304ea 100644
--- a/src/lagrangian/parcel/clouds/Templates/MomentumCloud/MomentumCloud.C
+++ b/src/lagrangian/parcel/clouds/Templates/MomentumCloud/MomentumCloud.C
@@ -300,6 +300,7 @@ Foam::MomentumCloud<CloudType>::MomentumCloud
     (
         particleProperties_.subOrEmptyDict("subModels", true)
     ),
+    cpuLoad_(particleProperties_.lookupOrDefault("cpuLoad", false)),
     rndGen_(0),
     cellOccupancyPtr_(),
     cellLengthScale_(mag(cbrt(this->mesh().V()))),
@@ -411,6 +412,7 @@ Foam::MomentumCloud<CloudType>::MomentumCloud
     solution_(c.solution_),
     constProps_(c.constProps_),
     subModelProperties_(c.subModelProperties_),
+    cpuLoad_(c.cpuLoad_),
     rndGen_(c.rndGen_),
     cellOccupancyPtr_(nullptr),
     cellLengthScale_(c.cellLengthScale_),
@@ -500,6 +502,7 @@ Foam::MomentumCloud<CloudType>::MomentumCloud
     solution_(mesh),
     constProps_(),
     subModelProperties_(dictionary::null),
+    cpuLoad_(c.cpuLoad_),
     rndGen_(0),
     cellOccupancyPtr_(nullptr),
     cellLengthScale_(c.cellLengthScale_),
diff --git a/src/lagrangian/parcel/clouds/Templates/MomentumCloud/MomentumCloud.H b/src/lagrangian/parcel/clouds/Templates/MomentumCloud/MomentumCloud.H
index 6aeb46b26e..3a6b2e8080 100644
--- a/src/lagrangian/parcel/clouds/Templates/MomentumCloud/MomentumCloud.H
+++ b/src/lagrangian/parcel/clouds/Templates/MomentumCloud/MomentumCloud.H
@@ -155,6 +155,9 @@ protected:
         //- Sub-models dictionary
         const dictionary subModelProperties_;
 
+        //- Switch to enable per-cell CPU load caching for load-balancing
+        bool cpuLoad_;
+
         //- Random number generator - used by some injection routines
         mutable randomGenerator rndGen_;
 
@@ -531,6 +534,12 @@ public:
 
         // Cloud evolution functions
 
+            //- Return true to cache per-cell CPU load
+            bool cpuLoad() const
+            {
+                return cpuLoad_;
+            }
+
             //- Set parcel thermo properties
             void setParcelThermoProperties(parcelType& parcel);
 
diff --git a/src/lagrangian/parcel/submodels/Momentum/PatchInteractionModel/LocalInteraction/LocalInteraction.C b/src/lagrangian/parcel/submodels/Momentum/PatchInteractionModel/LocalInteraction/LocalInteraction.C
index b92f4a19fa..d15c91350b 100644
--- a/src/lagrangian/parcel/submodels/Momentum/PatchInteractionModel/LocalInteraction/LocalInteraction.C
+++ b/src/lagrangian/parcel/submodels/Momentum/PatchInteractionModel/LocalInteraction/LocalInteraction.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2024 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -318,6 +318,11 @@ bool Foam::LocalInteraction<CloudType>::correct
 {
     const label patchi = pp.index();
 
+    if (isA<processorPolyPatch>(pp))
+    {
+        return false;
+    }
+
     switch (patchInteractionTypes_[patchi])
     {
         case PatchInteractionModel<CloudType>::itNone:
diff --git a/src/thermophysicalModels/chemistryModel/chemistryModel/chemistryModel.C b/src/thermophysicalModels/chemistryModel/chemistryModel/chemistryModel.C
index b048c106ed..578b9dcadd 100644
--- a/src/thermophysicalModels/chemistryModel/chemistryModel/chemistryModel.C
+++ b/src/thermophysicalModels/chemistryModel/chemistryModel/chemistryModel.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2016-2023 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2016-2024 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -38,7 +38,7 @@ Foam::chemistryModel<ThermoType>::chemistryModel
 :
     odeChemistryModel(thermo),
     log_(this->lookupOrDefault("log", false)),
-    loadBalancing_(this->lookupOrDefault("loadBalancing", false)),
+    cpuLoad_(this->lookupOrDefault("cpuLoad", false)),
     jacobianType_
     (
         this->found("jacobian")
@@ -582,9 +582,9 @@ Foam::scalar Foam::chemistryModel<ThermoType>::solve
     const DeltaTType& deltaT
 )
 {
-    optionalCpuLoad& chemistryCpuTime
+    optionalCpuLoad& chemistryCpuLoad
     (
-        optionalCpuLoad::New(this->mesh(), "chemistryCpuTime", loadBalancing_)
+        optionalCpuLoad::New(this->mesh(), name() + ":cpuLoad", cpuLoad_)
     );
 
     // CPU time logging
@@ -617,7 +617,7 @@ Foam::scalar Foam::chemistryModel<ThermoType>::solve
     scalar deltaTMin = great;
 
     tabulation_.reset();
-    chemistryCpuTime.reset();
+    chemistryCpuLoad.reset();
 
     forAll(rho0vf, celli)
     {
@@ -763,9 +763,9 @@ Foam::scalar Foam::chemistryModel<ThermoType>::solve
             RR_[i][celli] = rho0*(Y_[i] - Y0[i])/deltaT[celli];
         }
 
-        if (loadBalancing_)
+        if (cpuLoad_)
         {
-            chemistryCpuTime.cpuTimeIncrement(celli);
+            chemistryCpuLoad.cpuTimeIncrement(celli);
         }
     }
 
diff --git a/src/thermophysicalModels/chemistryModel/chemistryModel/chemistryModel.H b/src/thermophysicalModels/chemistryModel/chemistryModel/chemistryModel.H
index 0094ebd27c..6e03f0bf2e 100644
--- a/src/thermophysicalModels/chemistryModel/chemistryModel/chemistryModel.H
+++ b/src/thermophysicalModels/chemistryModel/chemistryModel/chemistryModel.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2016-2023 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2016-2024 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -128,8 +128,8 @@ class chemistryModel
         //- Switch to select performance logging
         Switch log_;
 
-        //- Switch to enable loadBalancing performance logging
-        Switch loadBalancing_;
+        //- Switch to enable per-cell CPU load caching for load-balancing
+        Switch cpuLoad_;
 
         //- Type of the Jacobian to be calculated
         const jacobianType jacobianType_;
diff --git a/tutorials/incompressibleDenseParticleFluid/cyclone/0/U.air b/tutorials/incompressibleDenseParticleFluid/cyclone/0/U.air
index bbfdf3f280..a9be1b0d13 100644
--- a/tutorials/incompressibleDenseParticleFluid/cyclone/0/U.air
+++ b/tutorials/incompressibleDenseParticleFluid/cyclone/0/U.air
@@ -20,6 +20,8 @@ internalField   uniform (0 0 0);
 
 boundaryField
 {
+    #includeEtc "caseDicts/setConstraintTypes"
+
     inlet
     {
         type            fixedValue;
diff --git a/tutorials/incompressibleDenseParticleFluid/cyclone/0/k.air b/tutorials/incompressibleDenseParticleFluid/cyclone/0/k.air
index 33bab92b37..708972c357 100644
--- a/tutorials/incompressibleDenseParticleFluid/cyclone/0/k.air
+++ b/tutorials/incompressibleDenseParticleFluid/cyclone/0/k.air
@@ -19,6 +19,8 @@ internalField       uniform 1;
 
 boundaryField
 {
+    #includeEtc "caseDicts/setConstraintTypes"
+
     inlet
     {
         type            fixedValue;
diff --git a/tutorials/incompressibleDenseParticleFluid/cyclone/0/nut.air b/tutorials/incompressibleDenseParticleFluid/cyclone/0/nut.air
index b84d5f1a07..0d38241230 100644
--- a/tutorials/incompressibleDenseParticleFluid/cyclone/0/nut.air
+++ b/tutorials/incompressibleDenseParticleFluid/cyclone/0/nut.air
@@ -19,6 +19,8 @@ internalField       uniform 0;
 
 boundaryField
 {
+    #includeEtc "caseDicts/setConstraintTypes"
+
     inlet
     {
         type            calculated;
diff --git a/tutorials/incompressibleDenseParticleFluid/cyclone/0/p b/tutorials/incompressibleDenseParticleFluid/cyclone/0/p
index d4da51e1e7..f3d9af3b02 100644
--- a/tutorials/incompressibleDenseParticleFluid/cyclone/0/p
+++ b/tutorials/incompressibleDenseParticleFluid/cyclone/0/p
@@ -19,6 +19,8 @@ internalField   uniform 0;
 
 boundaryField
 {
+    #includeEtc "caseDicts/setConstraintTypes"
+
     inlet
     {
         type fixedFluxPressure;
diff --git a/tutorials/incompressibleDenseParticleFluid/cyclone/constant/cloudProperties b/tutorials/incompressibleDenseParticleFluid/cyclone/constant/cloudProperties
index a244b3badc..bec6874fd3 100644
--- a/tutorials/incompressibleDenseParticleFluid/cyclone/constant/cloudProperties
+++ b/tutorials/incompressibleDenseParticleFluid/cyclone/constant/cloudProperties
@@ -16,6 +16,8 @@ FoamFile
 
 type        MPPICCloud;
 
+cpuLoad     true;
+
 solution
 {
     coupled         true;
diff --git a/tutorials/incompressibleDenseParticleFluid/cyclone/constant/dynamicMeshDict b/tutorials/incompressibleDenseParticleFluid/cyclone/constant/dynamicMeshDict
new file mode 100644
index 0000000000..1757f79d30
--- /dev/null
+++ b/tutorials/incompressibleDenseParticleFluid/cyclone/constant/dynamicMeshDict
@@ -0,0 +1,27 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Version:  dev
+     \\/     M anipulation  |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    format      ascii;
+    class       dictionary;
+    object      dynamicMeshDict;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+distributor
+{
+    type            loadBalancer;
+
+    libs            ("libfvMeshDistributors.so");
+
+    multiConstraint true;
+    redistributionInterval  10;
+}
+
+
+// ************************************************************************* //
diff --git a/tutorials/incompressibleDenseParticleFluid/cyclone/system/blockMeshDict b/tutorials/incompressibleDenseParticleFluid/cyclone/system/blockMeshDict
index 602cc7e93d..cbad201f36 100644
--- a/tutorials/incompressibleDenseParticleFluid/cyclone/system/blockMeshDict
+++ b/tutorials/incompressibleDenseParticleFluid/cyclone/system/blockMeshDict
@@ -58,6 +58,12 @@ boundary
             (4 5 6 7)
         );
     }
+
+    internalFaces
+    {
+        type internal;
+        faces ();
+    }
 );
 
 // ************************************************************************* //
diff --git a/tutorials/incompressibleDenseParticleFluid/cyclone/system/controlDict b/tutorials/incompressibleDenseParticleFluid/cyclone/system/controlDict
index 6e132aec44..5e0c367069 100644
--- a/tutorials/incompressibleDenseParticleFluid/cyclone/system/controlDict
+++ b/tutorials/incompressibleDenseParticleFluid/cyclone/system/controlDict
@@ -18,7 +18,7 @@ application     foamRun;
 
 solver          incompressibleDenseParticleFluid;
 
-startFrom       latestTime;
+startFrom       startTime;
 
 startTime       0;
 
diff --git a/tutorials/incompressibleDenseParticleFluid/cyclone/system/decomposeParDict b/tutorials/incompressibleDenseParticleFluid/cyclone/system/decomposeParDict
index a39016e446..4fd552077a 100644
--- a/tutorials/incompressibleDenseParticleFluid/cyclone/system/decomposeParDict
+++ b/tutorials/incompressibleDenseParticleFluid/cyclone/system/decomposeParDict
@@ -16,11 +16,25 @@ FoamFile
 
 numberOfSubdomains 12;
 
-method          simple;
+decomposer      simple;
+distributor     zoltan;
+libs            ("libzoltanDecomp.so");
 
 simpleCoeffs
 {
-    n               (2 2 3);
+    n           (2 2 3);
 }
 
+hierarchicalCoeffs
+{
+    n           (2 2 3);
+    order       xyz;
+}
+
+zoltanCoeffs
+{
+    lb_method   rcb;
+}
+
+
 // ************************************************************************* //
diff --git a/tutorials/multicomponentFluid/counterFlowFlame2D_GRI/constant/chemistryProperties b/tutorials/multicomponentFluid/counterFlowFlame2D_GRI/constant/chemistryProperties
index 837b17eedd..92de006eee 100644
--- a/tutorials/multicomponentFluid/counterFlowFlame2D_GRI/constant/chemistryProperties
+++ b/tutorials/multicomponentFluid/counterFlowFlame2D_GRI/constant/chemistryProperties
@@ -21,7 +21,7 @@ chemistryType
 
 chemistry       on;
 
-loadBalancing   on;
+cpuLoad         on;
 
 initialChemicalTimeStep 1e-07;
 
diff --git a/tutorials/multicomponentFluid/counterFlowFlame2D_GRI/system/blockMeshDict b/tutorials/multicomponentFluid/counterFlowFlame2D_GRI/system/blockMeshDict
index 913cebe27f..9a64a747fb 100644
--- a/tutorials/multicomponentFluid/counterFlowFlame2D_GRI/system/blockMeshDict
+++ b/tutorials/multicomponentFluid/counterFlowFlame2D_GRI/system/blockMeshDict
@@ -69,7 +69,7 @@ boundary
         );
     }
 
-    internal
+    internalFaces
     {
         type internal;
         faces ();