diff --git a/applications/solvers/DNS/dnsFoam/createFields.H b/applications/solvers/DNS/dnsFoam/createFields.H
index 6c1bb42929..7584773636 100644
--- a/applications/solvers/DNS/dnsFoam/createFields.H
+++ b/applications/solvers/DNS/dnsFoam/createFields.H
@@ -1,29 +1,31 @@
-    Info<< "Reading field p\n" << endl;
-    volScalarField p
+Info<< "Reading field p\n" << endl;
+volScalarField p
+(
+    IOobject
     (
-        IOobject
-        (
-            "p",
-            runTime.timeName(),
-            mesh,
-            IOobject::MUST_READ,
-            IOobject::AUTO_WRITE
-        ),
-        mesh
-    );
+        "p",
+        runTime.timeName(),
+        mesh,
+        IOobject::MUST_READ,
+        IOobject::AUTO_WRITE
+    ),
+    mesh
+);
 
-    Info<< "Reading field U\n" << endl;
-    volVectorField U
+Info<< "Reading field U\n" << endl;
+volVectorField U
+(
+    IOobject
     (
-        IOobject
-        (
-            "U",
-            runTime.timeName(),
-            mesh,
-            IOobject::MUST_READ,
-            IOobject::AUTO_WRITE
-        ),
-        mesh
-    );
+        "U",
+        runTime.timeName(),
+        mesh,
+        IOobject::MUST_READ,
+        IOobject::AUTO_WRITE
+    ),
+    mesh
+);
 
-    #include "createPhi.H"
+#include "createPhi.H"
+
+mesh.setFluxRequired(p.name());
diff --git a/applications/solvers/combustion/PDRFoam/createFields.H b/applications/solvers/combustion/PDRFoam/createFields.H
index 2af6ecd53f..fb958b3b52 100644
--- a/applications/solvers/combustion/PDRFoam/createFields.H
+++ b/applications/solvers/combustion/PDRFoam/createFields.H
@@ -1,227 +1,229 @@
-    Info<< "Reading thermophysical properties\n" << endl;
+Info<< "Reading thermophysical properties\n" << endl;
 
-    autoPtr<psiuReactionThermo> pThermo
+autoPtr<psiuReactionThermo> pThermo
+(
+    psiuReactionThermo::New(mesh)
+);
+psiuReactionThermo& thermo = pThermo();
+thermo.validate(args.executable(), "ha", "ea");
+
+basicMultiComponentMixture& composition = thermo.composition();
+
+volScalarField rho
+(
+    IOobject
     (
-        psiuReactionThermo::New(mesh)
-    );
-    psiuReactionThermo& thermo = pThermo();
-    thermo.validate(args.executable(), "ha", "ea");
-
-    basicMultiComponentMixture& composition = thermo.composition();
-
-    volScalarField rho
-    (
-        IOobject
-        (
-            "rho",
-            runTime.timeName(),
-            mesh,
-            IOobject::NO_READ,
-            IOobject::AUTO_WRITE
-        ),
-        thermo.rho()
-    );
-
-    volScalarField& p = thermo.p();
-    const volScalarField& psi = thermo.psi();
-
-    volScalarField& b = composition.Y("b");
-    Info<< "min(b) = " << min(b).value() << endl;
-
-    Info<< "\nReading field U\n" << endl;
-    volVectorField U
-    (
-        IOobject
-        (
-            "U",
-            runTime.timeName(),
-            mesh,
-            IOobject::MUST_READ,
-            IOobject::AUTO_WRITE
-        ),
-        mesh
-    );
-
-    #include "compressibleCreatePhi.H"
-
-    Info<< "Creating turbulence model\n" << endl;
-    autoPtr<compressible::RASModel> turbulence
-    (
-        compressible::RASModel::New
-        (
-            rho,
-            U,
-            phi,
-            thermo
-        )
-    );
-
-
-    Info<< "Creating field dpdt\n" << endl;
-    volScalarField dpdt
-    (
-        IOobject
-        (
-            "dpdt",
-            runTime.timeName(),
-            mesh
-        ),
+        "rho",
+        runTime.timeName(),
         mesh,
-        dimensionedScalar("dpdt", p.dimensions()/dimTime, 0)
-    );
+        IOobject::NO_READ,
+        IOobject::AUTO_WRITE
+    ),
+    thermo.rho()
+);
 
-    Info<< "Creating field kinetic energy K\n" << endl;
-    volScalarField K("K", 0.5*magSqr(U));
+volScalarField& p = thermo.p();
+const volScalarField& psi = thermo.psi();
 
+volScalarField& b = composition.Y("b");
+Info<< "min(b) = " << min(b).value() << endl;
 
-    Info<< "Creating the unstrained laminar flame speed\n" << endl;
-    autoPtr<laminarFlameSpeed> unstrainedLaminarFlameSpeed
+Info<< "\nReading field U\n" << endl;
+volVectorField U
+(
+    IOobject
     (
-        laminarFlameSpeed::New(thermo)
-    );
+        "U",
+        runTime.timeName(),
+        mesh,
+        IOobject::MUST_READ,
+        IOobject::AUTO_WRITE
+    ),
+    mesh
+);
 
+#include "compressibleCreatePhi.H"
 
-    Info<< "Reading strained laminar flame speed field Su\n" << endl;
-    volScalarField Su
+mesh.setFluxRequired(p.name());
+
+Info<< "Creating turbulence model\n" << endl;
+autoPtr<compressible::RASModel> turbulence
+(
+    compressible::RASModel::New
     (
-        IOobject
-        (
-            "Su",
-            runTime.timeName(),
-            mesh,
-            IOobject::MUST_READ,
-            IOobject::AUTO_WRITE
-        ),
-        mesh
-    );
-
-    Info<< "Reading field betav\n" << endl;
-    volScalarField betav
-    (
-        IOobject
-        (
-            "betav",
-            mesh.facesInstance(),
-            mesh,
-            IOobject::MUST_READ,
-            IOobject::NO_WRITE
-        ),
-        mesh
-    );
-
-    Info<< "Reading field Lobs\n" << endl;
-    volScalarField Lobs
-    (
-        IOobject
-        (
-            "Lobs",
-            mesh.facesInstance(),
-            mesh,
-            IOobject::MUST_READ,
-            IOobject::NO_WRITE
-        ),
-        mesh
-    );
-
-    Info<< "Reading field CT\n" << endl;
-    volSymmTensorField CT
-    (
-        IOobject
-        (
-            "CT",
-            mesh.facesInstance(),
-            mesh,
-            IOobject::MUST_READ,
-            IOobject::NO_WRITE
-        ),
-        mesh
-    );
-
-    Info<< "Reading field Nv\n" << endl;
-    volScalarField Nv
-    (
-        IOobject
-        (
-            "Nv",
-            mesh.facesInstance(),
-            mesh,
-            IOobject::MUST_READ,
-            IOobject::NO_WRITE
-        ),
-        mesh
-    );
-
-    Info<< "Reading field nsv\n" << endl;
-    volSymmTensorField nsv
-    (
-        IOobject
-        (
-            "nsv",
-            mesh.facesInstance(),
-            mesh,
-            IOobject::MUST_READ,
-            IOobject::NO_WRITE
-        ),
-        mesh
-    );
-
-    IOdictionary PDRProperties
-    (
-        IOobject
-        (
-            "PDRProperties",
-            runTime.constant(),
-            mesh,
-            IOobject::MUST_READ_IF_MODIFIED,
-            IOobject::NO_WRITE
-        )
-    );
-
-    //- Create the drag model
-    autoPtr<PDRDragModel> drag = PDRDragModel::New
-    (
-        PDRProperties,
-        turbulence,
         rho,
         U,
-        phi
-    );
+        phi,
+        thermo
+    )
+);
 
-    //- Create the flame-wrinkling model
-    autoPtr<XiModel> flameWrinkling = XiModel::New
+
+Info<< "Creating field dpdt\n" << endl;
+volScalarField dpdt
+(
+    IOobject
     (
-        PDRProperties,
-        thermo,
-        turbulence,
-        Su,
-        rho,
-        b,
-        phi
-    );
+        "dpdt",
+        runTime.timeName(),
+        mesh
+    ),
+    mesh,
+    dimensionedScalar("dpdt", p.dimensions()/dimTime, 0)
+);
 
-    Info<< "Calculating turbulent flame speed field St\n" << endl;
-    volScalarField St
+Info<< "Creating field kinetic energy K\n" << endl;
+volScalarField K("K", 0.5*magSqr(U));
+
+
+Info<< "Creating the unstrained laminar flame speed\n" << endl;
+autoPtr<laminarFlameSpeed> unstrainedLaminarFlameSpeed
+(
+    laminarFlameSpeed::New(thermo)
+);
+
+
+Info<< "Reading strained laminar flame speed field Su\n" << endl;
+volScalarField Su
+(
+    IOobject
     (
-        IOobject
-        (
-            "St",
-            runTime.timeName(),
-            mesh,
-            IOobject::NO_READ,
-            IOobject::AUTO_WRITE
-        ),
-        flameWrinkling->Xi()*Su
-    );
+        "Su",
+        runTime.timeName(),
+        mesh,
+        IOobject::MUST_READ,
+        IOobject::AUTO_WRITE
+    ),
+    mesh
+);
+
+Info<< "Reading field betav\n" << endl;
+volScalarField betav
+(
+    IOobject
+    (
+        "betav",
+        mesh.facesInstance(),
+        mesh,
+        IOobject::MUST_READ,
+        IOobject::NO_WRITE
+    ),
+    mesh
+);
+
+Info<< "Reading field Lobs\n" << endl;
+volScalarField Lobs
+(
+    IOobject
+    (
+        "Lobs",
+        mesh.facesInstance(),
+        mesh,
+        IOobject::MUST_READ,
+        IOobject::NO_WRITE
+    ),
+    mesh
+);
+
+Info<< "Reading field CT\n" << endl;
+volSymmTensorField CT
+(
+    IOobject
+    (
+        "CT",
+        mesh.facesInstance(),
+        mesh,
+        IOobject::MUST_READ,
+        IOobject::NO_WRITE
+    ),
+    mesh
+);
+
+Info<< "Reading field Nv\n" << endl;
+volScalarField Nv
+(
+    IOobject
+    (
+        "Nv",
+        mesh.facesInstance(),
+        mesh,
+        IOobject::MUST_READ,
+        IOobject::NO_WRITE
+    ),
+    mesh
+);
+
+Info<< "Reading field nsv\n" << endl;
+volSymmTensorField nsv
+(
+    IOobject
+    (
+        "nsv",
+        mesh.facesInstance(),
+        mesh,
+        IOobject::MUST_READ,
+        IOobject::NO_WRITE
+    ),
+    mesh
+);
+
+IOdictionary PDRProperties
+(
+    IOobject
+    (
+        "PDRProperties",
+        runTime.constant(),
+        mesh,
+        IOobject::MUST_READ_IF_MODIFIED,
+        IOobject::NO_WRITE
+    )
+);
+
+//- Create the drag model
+autoPtr<PDRDragModel> drag = PDRDragModel::New
+(
+    PDRProperties,
+    turbulence,
+    rho,
+    U,
+    phi
+);
+
+//- Create the flame-wrinkling model
+autoPtr<XiModel> flameWrinkling = XiModel::New
+(
+    PDRProperties,
+    thermo,
+    turbulence,
+    Su,
+    rho,
+    b,
+    phi
+);
+
+Info<< "Calculating turbulent flame speed field St\n" << endl;
+volScalarField St
+(
+    IOobject
+    (
+        "St",
+        runTime.timeName(),
+        mesh,
+        IOobject::NO_READ,
+        IOobject::AUTO_WRITE
+    ),
+    flameWrinkling->Xi()*Su
+);
 
 
-    multivariateSurfaceInterpolationScheme<scalar>::fieldTable fields;
+multivariateSurfaceInterpolationScheme<scalar>::fieldTable fields;
 
-    if (composition.contains("ft"))
-    {
-        fields.add(composition.Y("ft"));
-    }
+if (composition.contains("ft"))
+{
+    fields.add(composition.Y("ft"));
+}
 
-    fields.add(b);
-    fields.add(thermo.he());
-    fields.add(thermo.heu());
-    flameWrinkling->addXi(fields);
+fields.add(b);
+fields.add(thermo.he());
+fields.add(thermo.heu());
+flameWrinkling->addXi(fields);
diff --git a/applications/solvers/combustion/XiFoam/createFields.H b/applications/solvers/combustion/XiFoam/createFields.H
index 17103885e5..fa573b9b77 100644
--- a/applications/solvers/combustion/XiFoam/createFields.H
+++ b/applications/solvers/combustion/XiFoam/createFields.H
@@ -1,140 +1,141 @@
-    Info<< "Reading thermophysical properties\n" << endl;
+Info<< "Reading thermophysical properties\n" << endl;
 
-    autoPtr<psiuReactionThermo> pThermo
+autoPtr<psiuReactionThermo> pThermo
+(
+    psiuReactionThermo::New(mesh)
+);
+psiuReactionThermo& thermo = pThermo();
+thermo.validate(args.executable(), "ha", "ea");
+
+basicMultiComponentMixture& composition = thermo.composition();
+
+volScalarField rho
+(
+    IOobject
     (
-        psiuReactionThermo::New(mesh)
-    );
-    psiuReactionThermo& thermo = pThermo();
-    thermo.validate(args.executable(), "ha", "ea");
-
-    basicMultiComponentMixture& composition = thermo.composition();
-
-    volScalarField rho
-    (
-        IOobject
-        (
-            "rho",
-            runTime.timeName(),
-            mesh,
-            IOobject::NO_READ,
-            IOobject::AUTO_WRITE
-        ),
-        thermo.rho()
-    );
-
-    volScalarField& p = thermo.p();
-    const volScalarField& psi = thermo.psi();
-
-    volScalarField& b = composition.Y("b");
-    Info<< "min(b) = " << min(b).value() << endl;
-
-
-    Info<< "\nReading field U\n" << endl;
-    volVectorField U
-    (
-        IOobject
-        (
-            "U",
-            runTime.timeName(),
-            mesh,
-            IOobject::MUST_READ,
-            IOobject::AUTO_WRITE
-        ),
-        mesh
-    );
-
-    #include "compressibleCreatePhi.H"
-
-
-    Info<< "Creating turbulence model\n" << endl;
-    autoPtr<compressible::turbulenceModel> turbulence
-    (
-        compressible::turbulenceModel::New
-        (
-            rho,
-            U,
-            phi,
-            thermo
-        )
-    );
-
-    Info<< "Creating field dpdt\n" << endl;
-    volScalarField dpdt
-    (
-        IOobject
-        (
-            "dpdt",
-            runTime.timeName(),
-            mesh
-        ),
+        "rho",
+        runTime.timeName(),
         mesh,
-        dimensionedScalar("dpdt", p.dimensions()/dimTime, 0)
-    );
+        IOobject::NO_READ,
+        IOobject::AUTO_WRITE
+    ),
+    thermo.rho()
+);
 
-    Info<< "Creating field kinetic energy K\n" << endl;
-    volScalarField K("K", 0.5*magSqr(U));
+volScalarField& p = thermo.p();
+const volScalarField& psi = thermo.psi();
 
-    Info<< "Creating field Xi\n" << endl;
-    volScalarField Xi
+volScalarField& b = composition.Y("b");
+Info<< "min(b) = " << min(b).value() << endl;
+
+
+Info<< "\nReading field U\n" << endl;
+volVectorField U
+(
+    IOobject
     (
-        IOobject
-        (
-            "Xi",
-            runTime.timeName(),
-            mesh,
-            IOobject::MUST_READ,
-            IOobject::AUTO_WRITE
-        ),
+        "U",
+        runTime.timeName(),
+        mesh,
+        IOobject::MUST_READ,
+        IOobject::AUTO_WRITE
+    ),
+    mesh
+);
+
+#include "compressibleCreatePhi.H"
+
+mesh.setFluxRequired(p.name());
+
+Info<< "Creating turbulence model\n" << endl;
+autoPtr<compressible::turbulenceModel> turbulence
+(
+    compressible::turbulenceModel::New
+    (
+        rho,
+        U,
+        phi,
+        thermo
+    )
+);
+
+Info<< "Creating field dpdt\n" << endl;
+volScalarField dpdt
+(
+    IOobject
+    (
+        "dpdt",
+        runTime.timeName(),
         mesh
-    );
+    ),
+    mesh,
+    dimensionedScalar("dpdt", p.dimensions()/dimTime, 0)
+);
 
+Info<< "Creating field kinetic energy K\n" << endl;
+volScalarField K("K", 0.5*magSqr(U));
 
-    Info<< "Creating the unstrained laminar flame speed\n" << endl;
-    autoPtr<laminarFlameSpeed> unstrainedLaminarFlameSpeed
+Info<< "Creating field Xi\n" << endl;
+volScalarField Xi
+(
+    IOobject
     (
-        laminarFlameSpeed::New(thermo)
-    );
+        "Xi",
+        runTime.timeName(),
+        mesh,
+        IOobject::MUST_READ,
+        IOobject::AUTO_WRITE
+    ),
+    mesh
+);
 
 
-    Info<< "Reading strained laminar flame speed field Su\n" << endl;
-    volScalarField Su
+Info<< "Creating the unstrained laminar flame speed\n" << endl;
+autoPtr<laminarFlameSpeed> unstrainedLaminarFlameSpeed
+(
+    laminarFlameSpeed::New(thermo)
+);
+
+
+Info<< "Reading strained laminar flame speed field Su\n" << endl;
+volScalarField Su
+(
+    IOobject
     (
-        IOobject
-        (
-            "Su",
-            runTime.timeName(),
-            mesh,
-            IOobject::MUST_READ,
-            IOobject::AUTO_WRITE
-        ),
-        mesh
-    );
+        "Su",
+        runTime.timeName(),
+        mesh,
+        IOobject::MUST_READ,
+        IOobject::AUTO_WRITE
+    ),
+    mesh
+);
 
-    dimensionedScalar SuMin = 0.01*Su.average();
-    dimensionedScalar SuMax = 4*Su.average();
+dimensionedScalar SuMin = 0.01*Su.average();
+dimensionedScalar SuMax = 4*Su.average();
 
-    Info<< "Calculating turbulent flame speed field St\n" << endl;
-    volScalarField St
+Info<< "Calculating turbulent flame speed field St\n" << endl;
+volScalarField St
+(
+    IOobject
     (
-        IOobject
-        (
-            "St",
-            runTime.timeName(),
-            mesh,
-            IOobject::NO_READ,
-            IOobject::AUTO_WRITE
-        ),
-        Xi*Su
-    );
+        "St",
+        runTime.timeName(),
+        mesh,
+        IOobject::NO_READ,
+        IOobject::AUTO_WRITE
+    ),
+    Xi*Su
+);
 
 
-    multivariateSurfaceInterpolationScheme<scalar>::fieldTable fields;
+multivariateSurfaceInterpolationScheme<scalar>::fieldTable fields;
 
-    if (composition.contains("ft"))
-    {
-        fields.add(composition.Y("ft"));
-    }
+if (composition.contains("ft"))
+{
+    fields.add(composition.Y("ft"));
+}
 
-    fields.add(b);
-    fields.add(thermo.he());
-    fields.add(thermo.heu());
+fields.add(b);
+fields.add(thermo.he());
+fields.add(thermo.heu());
diff --git a/applications/solvers/combustion/fireFoam/createFields.H b/applications/solvers/combustion/fireFoam/createFields.H
index 72b5e0869b..c5fcc21c90 100644
--- a/applications/solvers/combustion/fireFoam/createFields.H
+++ b/applications/solvers/combustion/fireFoam/createFields.H
@@ -1,148 +1,150 @@
-    Info<< "Creating combustion model\n" << endl;
+Info<< "Creating combustion model\n" << endl;
 
-    autoPtr<combustionModels::psiCombustionModel> combustion
+autoPtr<combustionModels::psiCombustionModel> combustion
+(
+    combustionModels::psiCombustionModel::New
     (
-        combustionModels::psiCombustionModel::New
-        (
-            mesh
-        )
-    );
-
-    Info<< "Reading thermophysical properties\n" << endl;
-
-    psiReactionThermo& thermo = combustion->thermo();
-    thermo.validate(args.executable(), "h", "e");
-
-    SLGThermo slgThermo(mesh, thermo);
-
-    basicMultiComponentMixture& composition = thermo.composition();
-    PtrList<volScalarField>& Y = composition.Y();
-
-    const word inertSpecie(thermo.lookup("inertSpecie"));
-
-    Info<< "Creating field rho\n" << endl;
-    volScalarField rho
-    (
-        IOobject
-        (
-            "rho",
-            runTime.timeName(),
-            mesh,
-            IOobject::NO_READ,
-            IOobject::AUTO_WRITE
-        ),
-        thermo.rho()
-    );
-
-    volScalarField& p = thermo.p();
-    const volScalarField& T = thermo.T();
-    const volScalarField& psi = thermo.psi();
-
-    Info<< "\nReading field U\n" << endl;
-    volVectorField U
-    (
-        IOobject
-        (
-            "U",
-            runTime.timeName(),
-            mesh,
-            IOobject::MUST_READ,
-            IOobject::AUTO_WRITE
-        ),
         mesh
-    );
+    )
+);
 
-    #include "compressibleCreatePhi.H"
+Info<< "Reading thermophysical properties\n" << endl;
 
-    Info<< "Creating turbulence model\n" << endl;
-    autoPtr<compressible::turbulenceModel> turbulence
+psiReactionThermo& thermo = combustion->thermo();
+thermo.validate(args.executable(), "h", "e");
+
+SLGThermo slgThermo(mesh, thermo);
+
+basicMultiComponentMixture& composition = thermo.composition();
+PtrList<volScalarField>& Y = composition.Y();
+
+const word inertSpecie(thermo.lookup("inertSpecie"));
+
+Info<< "Creating field rho\n" << endl;
+volScalarField rho
+(
+    IOobject
     (
-        compressible::turbulenceModel::New
-        (
-            rho,
-            U,
-            phi,
-            thermo
-        )
-    );
-
-    // Set the turbulence into the combustion model
-    combustion->setTurbulence(turbulence());
-
-    volScalarField dQ
-    (
-        IOobject
-        (
-            "dQ",
-            runTime.timeName(),
-            mesh,
-            IOobject::NO_READ,
-            IOobject::AUTO_WRITE
-        ),
+        "rho",
+        runTime.timeName(),
         mesh,
-        dimensionedScalar("dQ", dimEnergy/dimTime, 0.0)
-    );
+        IOobject::NO_READ,
+        IOobject::AUTO_WRITE
+    ),
+    thermo.rho()
+);
 
+volScalarField& p = thermo.p();
+const volScalarField& T = thermo.T();
+const volScalarField& psi = thermo.psi();
 
-    Info<< "Creating field dpdt\n" << endl;
-    volScalarField dpdt
+Info<< "\nReading field U\n" << endl;
+volVectorField U
+(
+    IOobject
     (
-        IOobject
-        (
-            "dpdt",
-            runTime.timeName(),
-            mesh
-        ),
+        "U",
+        runTime.timeName(),
         mesh,
-        dimensionedScalar("dpdt", p.dimensions()/dimTime, 0)
-    );
+        IOobject::MUST_READ,
+        IOobject::AUTO_WRITE
+    ),
+    mesh
+);
 
-    Info<< "Creating field kinetic energy K\n" << endl;
-    volScalarField K("K", 0.5*magSqr(U));
+#include "compressibleCreatePhi.H"
 
-
-    #include "readGravitationalAcceleration.H"
-    #include "readhRef.H"
-    #include "gh.H"
-
-
-    volScalarField p_rgh
+Info<< "Creating turbulence model\n" << endl;
+autoPtr<compressible::turbulenceModel> turbulence
+(
+    compressible::turbulenceModel::New
     (
-        IOobject
-        (
-            "p_rgh",
-            runTime.timeName(),
-            mesh,
-            IOobject::MUST_READ,
-            IOobject::AUTO_WRITE
-        ),
+        rho,
+        U,
+        phi,
+        thermo
+    )
+);
+
+// Set the turbulence into the combustion model
+combustion->setTurbulence(turbulence());
+
+volScalarField dQ
+(
+    IOobject
+    (
+        "dQ",
+        runTime.timeName(),
+        mesh,
+        IOobject::NO_READ,
+        IOobject::AUTO_WRITE
+    ),
+    mesh,
+    dimensionedScalar("dQ", dimEnergy/dimTime, 0.0)
+);
+
+
+Info<< "Creating field dpdt\n" << endl;
+volScalarField dpdt
+(
+    IOobject
+    (
+        "dpdt",
+        runTime.timeName(),
         mesh
-    );
+    ),
+    mesh,
+    dimensionedScalar("dpdt", p.dimensions()/dimTime, 0)
+);
 
-    // Force p_rgh to be consistent with p
-    p_rgh = p - rho*gh;
+Info<< "Creating field kinetic energy K\n" << endl;
+volScalarField K("K", 0.5*magSqr(U));
 
-    multivariateSurfaceInterpolationScheme<scalar>::fieldTable fields;
 
-    forAll(Y, i)
-    {
-        fields.add(Y[i]);
-    }
-    fields.add(thermo.he());
+#include "readGravitationalAcceleration.H"
+#include "readhRef.H"
+#include "gh.H"
 
-    IOdictionary additionalControlsDict
+
+volScalarField p_rgh
+(
+    IOobject
     (
-        IOobject
-        (
-            "additionalControls",
-            runTime.constant(),
-            mesh,
-            IOobject::MUST_READ_IF_MODIFIED,
-            IOobject::NO_WRITE
-        )
-    );
+        "p_rgh",
+        runTime.timeName(),
+        mesh,
+        IOobject::MUST_READ,
+        IOobject::AUTO_WRITE
+    ),
+    mesh
+);
 
-    Switch solvePrimaryRegion
+// Force p_rgh to be consistent with p
+p_rgh = p - rho*gh;
+
+mesh.setFluxRequired(p_rgh.name());
+
+multivariateSurfaceInterpolationScheme<scalar>::fieldTable fields;
+
+forAll(Y, i)
+{
+    fields.add(Y[i]);
+}
+fields.add(thermo.he());
+
+IOdictionary additionalControlsDict
+(
+    IOobject
     (
-        additionalControlsDict.lookup("solvePrimaryRegion")
-    );
+        "additionalControls",
+        runTime.constant(),
+        mesh,
+        IOobject::MUST_READ_IF_MODIFIED,
+        IOobject::NO_WRITE
+    )
+);
+
+Switch solvePrimaryRegion
+(
+    additionalControlsDict.lookup("solvePrimaryRegion")
+);
diff --git a/applications/solvers/combustion/reactingFoam/createFields.H b/applications/solvers/combustion/reactingFoam/createFields.H
index 32bdd372ee..19c115a8f2 100644
--- a/applications/solvers/combustion/reactingFoam/createFields.H
+++ b/applications/solvers/combustion/reactingFoam/createFields.H
@@ -45,6 +45,8 @@ const volScalarField& T = thermo.T();
 
 #include "compressibleCreatePhi.H"
 
+mesh.setFluxRequired(p.name());
+
 Info << "Creating turbulence model.\n" << nl;
 autoPtr<compressible::turbulenceModel> turbulence
 (
diff --git a/applications/solvers/combustion/reactingFoam/rhoReactingBuoyantFoam/createFields.H b/applications/solvers/combustion/reactingFoam/rhoReactingBuoyantFoam/createFields.H
index 5298950425..9caa9effab 100644
--- a/applications/solvers/combustion/reactingFoam/rhoReactingBuoyantFoam/createFields.H
+++ b/applications/solvers/combustion/reactingFoam/rhoReactingBuoyantFoam/createFields.H
@@ -46,6 +46,7 @@ const volScalarField& T = thermo.T();
 
 #include "compressibleCreatePhi.H"
 
+mesh.setFluxRequired(p.name());
 
 Info << "Creating turbulence model.\n" << nl;
 autoPtr<compressible::turbulenceModel> turbulence
diff --git a/applications/solvers/combustion/reactingFoam/rhoReactingFoam/createFields.H b/applications/solvers/combustion/reactingFoam/rhoReactingFoam/createFields.H
index e99639e189..32dc5f0483 100644
--- a/applications/solvers/combustion/reactingFoam/rhoReactingFoam/createFields.H
+++ b/applications/solvers/combustion/reactingFoam/rhoReactingFoam/createFields.H
@@ -43,9 +43,10 @@ volScalarField& p = thermo.p();
 const volScalarField& psi = thermo.psi();
 const volScalarField& T = thermo.T();
 
-
 #include "compressibleCreatePhi.H"
 
+mesh.setFluxRequired(p.name());
+
 
 Info << "Creating turbulence model.\n" << nl;
 autoPtr<compressible::turbulenceModel> turbulence
diff --git a/applications/solvers/compressible/rhoPimpleFoam/createFields.H b/applications/solvers/compressible/rhoPimpleFoam/createFields.H
index fc82f631d0..0e214011de 100644
--- a/applications/solvers/compressible/rhoPimpleFoam/createFields.H
+++ b/applications/solvers/compressible/rhoPimpleFoam/createFields.H
@@ -1,90 +1,92 @@
-    Info<< "Reading thermophysical properties\n" << endl;
+Info<< "Reading thermophysical properties\n" << endl;
 
-    autoPtr<psiThermo> pThermo
+autoPtr<psiThermo> pThermo
+(
+    psiThermo::New(mesh)
+);
+psiThermo& thermo = pThermo();
+thermo.validate(args.executable(), "h", "e");
+
+volScalarField& p = thermo.p();
+const volScalarField& psi = thermo.psi();
+
+volScalarField rho
+(
+    IOobject
     (
-        psiThermo::New(mesh)
-    );
-    psiThermo& thermo = pThermo();
-    thermo.validate(args.executable(), "h", "e");
-
-    volScalarField& p = thermo.p();
-    const volScalarField& psi = thermo.psi();
-
-    volScalarField rho
-    (
-        IOobject
-        (
-            "rho",
-            runTime.timeName(),
-            mesh,
-            IOobject::READ_IF_PRESENT,
-            IOobject::AUTO_WRITE
-        ),
-        thermo.rho()
-    );
-
-    Info<< "Reading field U\n" << endl;
-    volVectorField U
-    (
-        IOobject
-        (
-            "U",
-            runTime.timeName(),
-            mesh,
-            IOobject::MUST_READ,
-            IOobject::AUTO_WRITE
-        ),
-        mesh
-    );
-
-    #include "compressibleCreatePhi.H"
-
-    dimensionedScalar rhoMax
-    (
-        dimensionedScalar::lookupOrDefault
-        (
-            "rhoMax",
-            pimple.dict(),
-            GREAT,
-            dimDensity
-        )
-    );
-
-    dimensionedScalar rhoMin
-    (
-        dimensionedScalar::lookupOrDefault
-        (
-            "rhoMin",
-            pimple.dict(),
-            0,
-            dimDensity
-        )
-    );
-
-    Info<< "Creating turbulence model\n" << endl;
-    autoPtr<compressible::turbulenceModel> turbulence
-    (
-        compressible::turbulenceModel::New
-        (
-            rho,
-            U,
-            phi,
-            thermo
-        )
-    );
-
-    Info<< "Creating field dpdt\n" << endl;
-    volScalarField dpdt
-    (
-        IOobject
-        (
-            "dpdt",
-            runTime.timeName(),
-            mesh
-        ),
+        "rho",
+        runTime.timeName(),
         mesh,
-        dimensionedScalar("dpdt", p.dimensions()/dimTime, 0)
-    );
+        IOobject::READ_IF_PRESENT,
+        IOobject::AUTO_WRITE
+    ),
+    thermo.rho()
+);
 
-    Info<< "Creating field kinetic energy K\n" << endl;
-    volScalarField K("K", 0.5*magSqr(U));
+Info<< "Reading field U\n" << endl;
+volVectorField U
+(
+    IOobject
+    (
+        "U",
+        runTime.timeName(),
+        mesh,
+        IOobject::MUST_READ,
+        IOobject::AUTO_WRITE
+    ),
+    mesh
+);
+
+#include "compressibleCreatePhi.H"
+
+dimensionedScalar rhoMax
+(
+    dimensionedScalar::lookupOrDefault
+    (
+        "rhoMax",
+        pimple.dict(),
+        GREAT,
+        dimDensity
+    )
+);
+
+dimensionedScalar rhoMin
+(
+    dimensionedScalar::lookupOrDefault
+    (
+        "rhoMin",
+        pimple.dict(),
+        0,
+        dimDensity
+    )
+);
+
+Info<< "Creating turbulence model\n" << endl;
+autoPtr<compressible::turbulenceModel> turbulence
+(
+    compressible::turbulenceModel::New
+    (
+        rho,
+        U,
+        phi,
+        thermo
+    )
+);
+
+mesh.setFluxRequired(p.name());
+
+Info<< "Creating field dpdt\n" << endl;
+volScalarField dpdt
+(
+    IOobject
+    (
+        "dpdt",
+        runTime.timeName(),
+        mesh
+    ),
+    mesh,
+    dimensionedScalar("dpdt", p.dimensions()/dimTime, 0)
+);
+
+Info<< "Creating field kinetic energy K\n" << endl;
+volScalarField K("K", 0.5*magSqr(U));
diff --git a/applications/solvers/compressible/rhoSimpleFoam/createFields.H b/applications/solvers/compressible/rhoSimpleFoam/createFields.H
index fd303612c6..2d89e2b566 100644
--- a/applications/solvers/compressible/rhoSimpleFoam/createFields.H
+++ b/applications/solvers/compressible/rhoSimpleFoam/createFields.H
@@ -1,81 +1,83 @@
-    Info<< "Reading thermophysical properties\n" << endl;
+Info<< "Reading thermophysical properties\n" << endl;
 
-    autoPtr<psiThermo> pThermo
+autoPtr<psiThermo> pThermo
+(
+    psiThermo::New(mesh)
+);
+psiThermo& thermo = pThermo();
+thermo.validate(args.executable(), "h", "e");
+
+volScalarField rho
+(
+    IOobject
     (
-        psiThermo::New(mesh)
-    );
-    psiThermo& thermo = pThermo();
-    thermo.validate(args.executable(), "h", "e");
+        "rho",
+        runTime.timeName(),
+        mesh,
+        IOobject::READ_IF_PRESENT,
+        IOobject::AUTO_WRITE
+    ),
+    thermo.rho()
+);
 
-    volScalarField rho
+volScalarField& p = thermo.p();
+const volScalarField& psi = thermo.psi();
+
+Info<< "Reading field U\n" << endl;
+volVectorField U
+(
+    IOobject
     (
-        IOobject
-        (
-            "rho",
-            runTime.timeName(),
-            mesh,
-            IOobject::READ_IF_PRESENT,
-            IOobject::AUTO_WRITE
-        ),
-        thermo.rho()
-    );
+        "U",
+        runTime.timeName(),
+        mesh,
+        IOobject::MUST_READ,
+        IOobject::AUTO_WRITE
+    ),
+    mesh
+);
 
-    volScalarField& p = thermo.p();
-    const volScalarField& psi = thermo.psi();
+#include "compressibleCreatePhi.H"
 
-    Info<< "Reading field U\n" << endl;
-    volVectorField U
+
+label pRefCell = 0;
+scalar pRefValue = 0.0;
+setRefCell(p, simple.dict(), pRefCell, pRefValue);
+
+mesh.setFluxRequired(p.name());
+
+dimensionedScalar rhoMax
+(
+    dimensionedScalar::lookupOrDefault
     (
-        IOobject
-        (
-            "U",
-            runTime.timeName(),
-            mesh,
-            IOobject::MUST_READ,
-            IOobject::AUTO_WRITE
-        ),
-        mesh
-    );
+        "rhoMax",
+        simple.dict(),
+        GREAT,
+        dimDensity
+    )
+);
 
-    #include "compressibleCreatePhi.H"
-
-
-    label pRefCell = 0;
-    scalar pRefValue = 0.0;
-    setRefCell(p, simple.dict(), pRefCell, pRefValue);
-
-    dimensionedScalar rhoMax
+dimensionedScalar rhoMin
+(
+    dimensionedScalar::lookupOrDefault
     (
-        dimensionedScalar::lookupOrDefault
-        (
-            "rhoMax",
-            simple.dict(),
-            GREAT,
-            dimDensity
-        )
-    );
+        "rhoMin",
+        simple.dict(),
+        0,
+        dimDensity
+    )
+);
 
-    dimensionedScalar rhoMin
+Info<< "Creating turbulence model\n" << endl;
+autoPtr<compressible::RASModel> turbulence
+(
+    compressible::RASModel::New
     (
-        dimensionedScalar::lookupOrDefault
-        (
-            "rhoMin",
-            simple.dict(),
-            0,
-            dimDensity
-        )
-    );
+        rho,
+        U,
+        phi,
+        thermo
+    )
+);
 
-    Info<< "Creating turbulence model\n" << endl;
-    autoPtr<compressible::RASModel> turbulence
-    (
-        compressible::RASModel::New
-        (
-            rho,
-            U,
-            phi,
-            thermo
-        )
-    );
-
-    dimensionedScalar initialMass = fvc::domainIntegrate(rho);
+dimensionedScalar initialMass = fvc::domainIntegrate(rho);
diff --git a/applications/solvers/compressible/rhoSimpleFoam/rhoPorousSimpleFoam/createFields.H b/applications/solvers/compressible/rhoSimpleFoam/rhoPorousSimpleFoam/createFields.H
index ced5e478bf..3ce8270b5e 100644
--- a/applications/solvers/compressible/rhoSimpleFoam/rhoPorousSimpleFoam/createFields.H
+++ b/applications/solvers/compressible/rhoSimpleFoam/rhoPorousSimpleFoam/createFields.H
@@ -1,80 +1,82 @@
-    Info<< "Reading thermophysical properties\n" << endl;
+Info<< "Reading thermophysical properties\n" << endl;
 
-    autoPtr<rhoThermo> pThermo
+autoPtr<rhoThermo> pThermo
+(
+    rhoThermo::New(mesh)
+);
+rhoThermo& thermo = pThermo();
+thermo.validate(args.executable(), "h", "e");
+
+volScalarField rho
+(
+    IOobject
     (
-        rhoThermo::New(mesh)
-    );
-    rhoThermo& thermo = pThermo();
-    thermo.validate(args.executable(), "h", "e");
+        "rho",
+        runTime.timeName(),
+        mesh,
+        IOobject::READ_IF_PRESENT,
+        IOobject::AUTO_WRITE
+    ),
+    thermo.rho()
+);
 
-    volScalarField rho
+volScalarField& p = thermo.p();
+
+Info<< "Reading field U\n" << endl;
+volVectorField U
+(
+    IOobject
     (
-        IOobject
-        (
-            "rho",
-            runTime.timeName(),
-            mesh,
-            IOobject::READ_IF_PRESENT,
-            IOobject::AUTO_WRITE
-        ),
-        thermo.rho()
-    );
+        "U",
+        runTime.timeName(),
+        mesh,
+        IOobject::MUST_READ,
+        IOobject::AUTO_WRITE
+    ),
+    mesh
+);
 
-    volScalarField& p = thermo.p();
+#include "compressibleCreatePhi.H"
 
-    Info<< "Reading field U\n" << endl;
-    volVectorField U
+
+label pRefCell = 0;
+scalar pRefValue = 0.0;
+setRefCell(p, simple.dict(), pRefCell, pRefValue);
+
+mesh.setFluxRequired(p.name());
+
+dimensionedScalar rhoMax
+(
+    dimensionedScalar::lookupOrDefault
     (
-        IOobject
-        (
-            "U",
-            runTime.timeName(),
-            mesh,
-            IOobject::MUST_READ,
-            IOobject::AUTO_WRITE
-        ),
-        mesh
-    );
+        "rhoMax",
+        simple.dict(),
+        GREAT,
+        dimDensity
+    )
+);
 
-    #include "compressibleCreatePhi.H"
-
-
-    label pRefCell = 0;
-    scalar pRefValue = 0.0;
-    setRefCell(p, simple.dict(), pRefCell, pRefValue);
-
-    dimensionedScalar rhoMax
+dimensionedScalar rhoMin
+(
+    dimensionedScalar::lookupOrDefault
     (
-        dimensionedScalar::lookupOrDefault
-        (
-            "rhoMax",
-            simple.dict(),
-            GREAT,
-            dimDensity
-        )
-    );
+        "rhoMin",
+        simple.dict(),
+        0,
+        dimDensity
+    )
+);
 
-    dimensionedScalar rhoMin
+Info<< "Creating turbulence model\n" << endl;
+autoPtr<compressible::RASModel> turbulence
+(
+    compressible::RASModel::New
     (
-        dimensionedScalar::lookupOrDefault
-        (
-            "rhoMin",
-            simple.dict(),
-            0,
-            dimDensity
-        )
-    );
+        rho,
+        U,
+        phi,
+        thermo
+    )
+);
 
-    Info<< "Creating turbulence model\n" << endl;
-    autoPtr<compressible::RASModel> turbulence
-    (
-        compressible::RASModel::New
-        (
-            rho,
-            U,
-            phi,
-            thermo
-        )
-    );
-
-    dimensionedScalar initialMass = fvc::domainIntegrate(rho);
+dimensionedScalar initialMass = fvc::domainIntegrate(rho);
diff --git a/applications/solvers/compressible/sonicFoam/createFields.H b/applications/solvers/compressible/sonicFoam/createFields.H
index c3421369e7..ad4b4a3019 100644
--- a/applications/solvers/compressible/sonicFoam/createFields.H
+++ b/applications/solvers/compressible/sonicFoam/createFields.H
@@ -1,55 +1,56 @@
-    Info<< "Reading thermophysical properties\n" << endl;
+Info<< "Reading thermophysical properties\n" << endl;
 
-    autoPtr<psiThermo> pThermo
+autoPtr<psiThermo> pThermo
+(
+    psiThermo::New(mesh)
+);
+psiThermo& thermo = pThermo();
+thermo.validate(args.executable(), "e");
+
+volScalarField& p = thermo.p();
+volScalarField& e = thermo.he();
+const volScalarField& psi = thermo.psi();
+
+volScalarField rho
+(
+    IOobject
     (
-        psiThermo::New(mesh)
-    );
-    psiThermo& thermo = pThermo();
-    thermo.validate(args.executable(), "e");
-
-    volScalarField& p = thermo.p();
-    volScalarField& e = thermo.he();
-    const volScalarField& psi = thermo.psi();
-
-    volScalarField rho
-    (
-        IOobject
-        (
-            "rho",
-            runTime.timeName(),
-            mesh
-        ),
-        thermo.rho()
-    );
-
-    Info<< "Reading field U\n" << endl;
-    volVectorField U
-    (
-        IOobject
-        (
-            "U",
-            runTime.timeName(),
-            mesh,
-            IOobject::MUST_READ,
-            IOobject::AUTO_WRITE
-        ),
+        "rho",
+        runTime.timeName(),
         mesh
-    );
+    ),
+    thermo.rho()
+);
 
-    #include "compressibleCreatePhi.H"
-
-
-    Info<< "Creating turbulence model\n" << endl;
-    autoPtr<compressible::turbulenceModel> turbulence
+Info<< "Reading field U\n" << endl;
+volVectorField U
+(
+    IOobject
     (
-        compressible::turbulenceModel::New
-        (
-            rho,
-            U,
-            phi,
-            thermo
-        )
-    );
+        "U",
+        runTime.timeName(),
+        mesh,
+        IOobject::MUST_READ,
+        IOobject::AUTO_WRITE
+    ),
+    mesh
+);
 
-    Info<< "Creating field kinetic energy K\n" << endl;
-    volScalarField K("K", 0.5*magSqr(U));
+#include "compressibleCreatePhi.H"
+
+mesh.setFluxRequired(p.name());
+
+Info<< "Creating turbulence model\n" << endl;
+autoPtr<compressible::turbulenceModel> turbulence
+(
+    compressible::turbulenceModel::New
+    (
+        rho,
+        U,
+        phi,
+        thermo
+    )
+);
+
+Info<< "Creating field kinetic energy K\n" << endl;
+volScalarField K("K", 0.5*magSqr(U));
diff --git a/applications/solvers/compressible/sonicFoam/sonicLiquidFoam/createFields.H b/applications/solvers/compressible/sonicFoam/sonicLiquidFoam/createFields.H
index 1268cbb7b0..54f26a90c0 100644
--- a/applications/solvers/compressible/sonicFoam/sonicLiquidFoam/createFields.H
+++ b/applications/solvers/compressible/sonicFoam/sonicLiquidFoam/createFields.H
@@ -1,44 +1,46 @@
-    Info<< "Reading field p\n" << endl;
-    volScalarField p
+Info<< "Reading field p\n" << endl;
+volScalarField p
+(
+    IOobject
     (
-        IOobject
-        (
-            "p",
-            runTime.timeName(),
-            mesh,
-            IOobject::MUST_READ,
-            IOobject::AUTO_WRITE
-        ),
-        mesh
-    );
+        "p",
+        runTime.timeName(),
+        mesh,
+        IOobject::MUST_READ,
+        IOobject::AUTO_WRITE
+    ),
+    mesh
+);
 
 
-    Info<< "Reading field U\n" << endl;
-    volVectorField U
+Info<< "Reading field U\n" << endl;
+volVectorField U
+(
+    IOobject
     (
-        IOobject
-        (
-            "U",
-            runTime.timeName(),
-            mesh,
-            IOobject::MUST_READ,
-            IOobject::AUTO_WRITE
-        ),
-        mesh
-    );
+        "U",
+        runTime.timeName(),
+        mesh,
+        IOobject::MUST_READ,
+        IOobject::AUTO_WRITE
+    ),
+    mesh
+);
 
-    volScalarField rho
+volScalarField rho
+(
+    IOobject
     (
-        IOobject
-        (
-            "rho",
-            runTime.timeName(),
-            mesh,
-            IOobject::NO_READ,
-            IOobject::AUTO_WRITE
-        ),
-        rhoO + psi*p
-    );
+        "rho",
+        runTime.timeName(),
+        mesh,
+        IOobject::NO_READ,
+        IOobject::AUTO_WRITE
+    ),
+    rhoO + psi*p
+);
 
 
-    #include "compressibleCreatePhi.H"
+#include "compressibleCreatePhi.H"
+
+mesh.setFluxRequired(p.name());
diff --git a/applications/solvers/electromagnetics/mhdFoam/createFields.H b/applications/solvers/electromagnetics/mhdFoam/createFields.H
index a514f11416..528bcd1b54 100644
--- a/applications/solvers/electromagnetics/mhdFoam/createFields.H
+++ b/applications/solvers/electromagnetics/mhdFoam/createFields.H
@@ -1,107 +1,110 @@
-    Info<< "Reading transportProperties\n" << endl;
+Info<< "Reading transportProperties\n" << endl;
 
-    IOdictionary transportProperties
+IOdictionary transportProperties
+(
+    IOobject
     (
-        IOobject
-        (
-            "transportProperties",
-            runTime.constant(),
-            mesh,
-            IOobject::MUST_READ_IF_MODIFIED,
-            IOobject::NO_WRITE
-        )
-    );
+        "transportProperties",
+        runTime.constant(),
+        mesh,
+        IOobject::MUST_READ_IF_MODIFIED,
+        IOobject::NO_WRITE
+    )
+);
 
-    dimensionedScalar rho
+dimensionedScalar rho
+(
+    transportProperties.lookup("rho")
+);
+
+dimensionedScalar nu
+(
+    transportProperties.lookup("nu")
+);
+
+dimensionedScalar mu
+(
+    transportProperties.lookup("mu")
+);
+
+dimensionedScalar sigma
+(
+    transportProperties.lookup("sigma")
+);
+
+Info<< "Reading field p\n" << endl;
+volScalarField p
+(
+    IOobject
     (
-        transportProperties.lookup("rho")
-    );
+        "p",
+        runTime.timeName(),
+        mesh,
+        IOobject::MUST_READ,
+        IOobject::AUTO_WRITE
+    ),
+    mesh
+);
 
-    dimensionedScalar nu
+
+Info<< "Reading field U\n" << endl;
+volVectorField U
+(
+    IOobject
     (
-        transportProperties.lookup("nu")
-    );
+        "U",
+        runTime.timeName(),
+        mesh,
+        IOobject::MUST_READ,
+        IOobject::AUTO_WRITE
+    ),
+    mesh
+);
 
-    dimensionedScalar mu
+#include "createPhi.H"
+
+Info<< "Reading field pB\n" << endl;
+volScalarField pB
+(
+    IOobject
     (
-        transportProperties.lookup("mu")
-    );
+        "pB",
+        runTime.timeName(),
+        mesh,
+        IOobject::MUST_READ,
+        IOobject::AUTO_WRITE
+    ),
+    mesh
+);
 
-    dimensionedScalar sigma
+
+Info<< "Reading field B\n" << endl;
+volVectorField B
+(
+    IOobject
     (
-        transportProperties.lookup("sigma")
-    );
-
-    Info<< "Reading field p\n" << endl;
-    volScalarField p
-    (
-        IOobject
-        (
-            "p",
-            runTime.timeName(),
-            mesh,
-            IOobject::MUST_READ,
-            IOobject::AUTO_WRITE
-        ),
-        mesh
-    );
+        "B",
+        runTime.timeName(),
+        mesh,
+        IOobject::MUST_READ,
+        IOobject::AUTO_WRITE
+    ),
+    mesh
+);
 
 
-    Info<< "Reading field U\n" << endl;
-    volVectorField U
-    (
-        IOobject
-        (
-            "U",
-            runTime.timeName(),
-            mesh,
-            IOobject::MUST_READ,
-            IOobject::AUTO_WRITE
-        ),
-        mesh
-    );
+#include "createPhiB.H"
 
-    #include "createPhi.H"
+dimensionedScalar DB = 1.0/(mu*sigma);
+DB.name() = "DB";
 
-    Info<< "Reading field pB\n" << endl;
-    volScalarField pB
-    (
-        IOobject
-        (
-            "pB",
-            runTime.timeName(),
-            mesh,
-            IOobject::MUST_READ,
-            IOobject::AUTO_WRITE
-        ),
-        mesh
-    );
+dimensionedScalar DBU = 1.0/(2.0*mu*rho);
+DBU.name() = "DBU";
 
 
-    Info<< "Reading field B\n" << endl;
-    volVectorField B
-    (
-        IOobject
-        (
-            "B",
-            runTime.timeName(),
-            mesh,
-            IOobject::MUST_READ,
-            IOobject::AUTO_WRITE
-        ),
-        mesh
-    );
+label pRefCell = 0;
+scalar pRefValue = 0.0;
+setRefCell(p, piso.dict(), pRefCell, pRefValue);
 
-
-    #include "createPhiB.H"
-
-    dimensionedScalar DB = 1.0/(mu*sigma);
-    DB.name() = "DB";
-
-    dimensionedScalar DBU = 1.0/(2.0*mu*rho);
-    DBU.name() = "DBU";
-
-
-    label pRefCell = 0;
-    scalar pRefValue = 0.0;
-    setRefCell(p, piso.dict(), pRefCell, pRefValue);
+mesh.setFluxRequired(p.name());
+mesh.setFluxRequired(pB.name());
diff --git a/applications/solvers/heatTransfer/buoyantBoussinesqPimpleFoam/createFields.H b/applications/solvers/heatTransfer/buoyantBoussinesqPimpleFoam/createFields.H
index 0f554ef78d..f98c472e11 100644
--- a/applications/solvers/heatTransfer/buoyantBoussinesqPimpleFoam/createFields.H
+++ b/applications/solvers/heatTransfer/buoyantBoussinesqPimpleFoam/createFields.H
@@ -1,120 +1,122 @@
-    Info<< "Reading thermophysical properties\n" << endl;
+Info<< "Reading thermophysical properties\n" << endl;
 
-    Info<< "Reading field T\n" << endl;
-    volScalarField T
+Info<< "Reading field T\n" << endl;
+volScalarField T
+(
+    IOobject
     (
-        IOobject
-        (
-            "T",
-            runTime.timeName(),
-            mesh,
-            IOobject::MUST_READ,
-            IOobject::AUTO_WRITE
-        ),
+        "T",
+        runTime.timeName(),
+        mesh,
+        IOobject::MUST_READ,
+        IOobject::AUTO_WRITE
+    ),
+    mesh
+);
+
+Info<< "Reading field p_rgh\n" << endl;
+volScalarField p_rgh
+(
+    IOobject
+    (
+        "p_rgh",
+        runTime.timeName(),
+        mesh,
+        IOobject::MUST_READ,
+        IOobject::AUTO_WRITE
+    ),
+    mesh
+);
+
+Info<< "Reading field U\n" << endl;
+volVectorField U
+(
+    IOobject
+    (
+        "U",
+        runTime.timeName(),
+        mesh,
+        IOobject::MUST_READ,
+        IOobject::AUTO_WRITE
+    ),
+    mesh
+);
+
+#include "createPhi.H"
+
+#include "readTransportProperties.H"
+
+Info<< "Creating turbulence model\n" << endl;
+autoPtr<incompressible::RASModel> turbulence
+(
+    incompressible::RASModel::New(U, phi, laminarTransport)
+);
+
+// Kinematic density for buoyancy force
+volScalarField rhok
+(
+    IOobject
+    (
+        "rhok",
+        runTime.timeName(),
         mesh
-    );
+    ),
+    1.0 - beta*(T - TRef)
+);
 
-    Info<< "Reading field p_rgh\n" << endl;
-    volScalarField p_rgh
+// kinematic turbulent thermal thermal conductivity m2/s
+Info<< "Reading field alphat\n" << endl;
+volScalarField alphat
+(
+    IOobject
     (
-        IOobject
-        (
-            "p_rgh",
-            runTime.timeName(),
-            mesh,
-            IOobject::MUST_READ,
-            IOobject::AUTO_WRITE
-        ),
-        mesh
-    );
+        "alphat",
+        runTime.timeName(),
+        mesh,
+        IOobject::MUST_READ,
+        IOobject::AUTO_WRITE
+    ),
+    mesh
+);
 
-    Info<< "Reading field U\n" << endl;
-    volVectorField U
+
+#include "readGravitationalAcceleration.H"
+#include "readhRef.H"
+#include "gh.H"
+
+
+volScalarField p
+(
+    IOobject
     (
-        IOobject
-        (
-            "U",
-            runTime.timeName(),
-            mesh,
-            IOobject::MUST_READ,
-            IOobject::AUTO_WRITE
-        ),
-        mesh
-    );
+        "p",
+        runTime.timeName(),
+        mesh,
+        IOobject::NO_READ,
+        IOobject::AUTO_WRITE
+    ),
+    p_rgh + rhok*gh
+);
 
-    #include "createPhi.H"
+label pRefCell = 0;
+scalar pRefValue = 0.0;
+setRefCell
+(
+    p,
+    p_rgh,
+    pimple.dict(),
+    pRefCell,
+    pRefValue
+);
 
-    #include "readTransportProperties.H"
-
-    Info<< "Creating turbulence model\n" << endl;
-    autoPtr<incompressible::RASModel> turbulence
+if (p_rgh.needReference())
+{
+    p += dimensionedScalar
     (
-        incompressible::RASModel::New(U, phi, laminarTransport)
+        "p",
+        p.dimensions(),
+        pRefValue - getRefCellValue(p, pRefCell)
     );
+}
 
-    // Kinematic density for buoyancy force
-    volScalarField rhok
-    (
-        IOobject
-        (
-            "rhok",
-            runTime.timeName(),
-            mesh
-        ),
-        1.0 - beta*(T - TRef)
-    );
-
-    // kinematic turbulent thermal thermal conductivity m2/s
-    Info<< "Reading field alphat\n" << endl;
-    volScalarField alphat
-    (
-        IOobject
-        (
-            "alphat",
-            runTime.timeName(),
-            mesh,
-            IOobject::MUST_READ,
-            IOobject::AUTO_WRITE
-        ),
-        mesh
-    );
-
-
-    #include "readGravitationalAcceleration.H"
-    #include "readhRef.H"
-    #include "gh.H"
-
-
-    volScalarField p
-    (
-        IOobject
-        (
-            "p",
-            runTime.timeName(),
-            mesh,
-            IOobject::NO_READ,
-            IOobject::AUTO_WRITE
-        ),
-        p_rgh + rhok*gh
-    );
-
-    label pRefCell = 0;
-    scalar pRefValue = 0.0;
-    setRefCell
-    (
-        p,
-        p_rgh,
-        pimple.dict(),
-        pRefCell,
-        pRefValue
-    );
-
-    if (p_rgh.needReference())
-    {
-        p += dimensionedScalar
-        (
-            "p",
-            p.dimensions(),
-            pRefValue - getRefCellValue(p, pRefCell)
-        );
-    }
+mesh.setFluxRequired(p_rgh.name());
diff --git a/applications/solvers/heatTransfer/buoyantBoussinesqSimpleFoam/createFields.H b/applications/solvers/heatTransfer/buoyantBoussinesqSimpleFoam/createFields.H
index c54cebc9f4..17306f7d46 100644
--- a/applications/solvers/heatTransfer/buoyantBoussinesqSimpleFoam/createFields.H
+++ b/applications/solvers/heatTransfer/buoyantBoussinesqSimpleFoam/createFields.H
@@ -1,120 +1,122 @@
-    Info<< "Reading thermophysical properties\n" << endl;
+Info<< "Reading thermophysical properties\n" << endl;
 
-    Info<< "Reading field T\n" << endl;
-    volScalarField T
+Info<< "Reading field T\n" << endl;
+volScalarField T
+(
+    IOobject
     (
-        IOobject
-        (
-            "T",
-            runTime.timeName(),
-            mesh,
-            IOobject::MUST_READ,
-            IOobject::AUTO_WRITE
-        ),
+        "T",
+        runTime.timeName(),
+        mesh,
+        IOobject::MUST_READ,
+        IOobject::AUTO_WRITE
+    ),
+    mesh
+);
+
+Info<< "Reading field p_rgh\n" << endl;
+volScalarField p_rgh
+(
+    IOobject
+    (
+        "p_rgh",
+        runTime.timeName(),
+        mesh,
+        IOobject::MUST_READ,
+        IOobject::AUTO_WRITE
+    ),
+    mesh
+);
+
+Info<< "Reading field U\n" << endl;
+volVectorField U
+(
+    IOobject
+    (
+        "U",
+        runTime.timeName(),
+        mesh,
+        IOobject::MUST_READ,
+        IOobject::AUTO_WRITE
+    ),
+    mesh
+);
+
+#include "createPhi.H"
+
+#include "readTransportProperties.H"
+
+Info<< "Creating turbulence model\n" << endl;
+autoPtr<incompressible::RASModel> turbulence
+(
+    incompressible::RASModel::New(U, phi, laminarTransport)
+);
+
+// Kinematic density for buoyancy force
+volScalarField rhok
+(
+    IOobject
+    (
+        "rhok",
+        runTime.timeName(),
         mesh
-    );
+    ),
+    1.0 - beta*(T - TRef)
+);
 
-    Info<< "Reading field p_rgh\n" << endl;
-    volScalarField p_rgh
+// kinematic turbulent thermal thermal conductivity m2/s
+Info<< "Reading field alphat\n" << endl;
+volScalarField alphat
+(
+    IOobject
     (
-        IOobject
-        (
-            "p_rgh",
-            runTime.timeName(),
-            mesh,
-            IOobject::MUST_READ,
-            IOobject::AUTO_WRITE
-        ),
-        mesh
-    );
+        "alphat",
+        runTime.timeName(),
+        mesh,
+        IOobject::MUST_READ,
+        IOobject::AUTO_WRITE
+    ),
+    mesh
+);
 
-    Info<< "Reading field U\n" << endl;
-    volVectorField U
+
+#include "readGravitationalAcceleration.H"
+#include "readhRef.H"
+#include "gh.H"
+
+
+volScalarField p
+(
+    IOobject
     (
-        IOobject
-        (
-            "U",
-            runTime.timeName(),
-            mesh,
-            IOobject::MUST_READ,
-            IOobject::AUTO_WRITE
-        ),
-        mesh
-    );
+        "p",
+        runTime.timeName(),
+        mesh,
+        IOobject::NO_READ,
+        IOobject::AUTO_WRITE
+    ),
+    p_rgh + rhok*gh
+);
 
-    #include "createPhi.H"
+label pRefCell = 0;
+scalar pRefValue = 0.0;
+setRefCell
+(
+    p,
+    p_rgh,
+    simple.dict(),
+    pRefCell,
+    pRefValue
+);
 
-    #include "readTransportProperties.H"
-
-    Info<< "Creating turbulence model\n" << endl;
-    autoPtr<incompressible::RASModel> turbulence
+if (p_rgh.needReference())
+{
+    p += dimensionedScalar
     (
-        incompressible::RASModel::New(U, phi, laminarTransport)
+        "p",
+        p.dimensions(),
+        pRefValue - getRefCellValue(p, pRefCell)
     );
+}
 
-    // Kinematic density for buoyancy force
-    volScalarField rhok
-    (
-        IOobject
-        (
-            "rhok",
-            runTime.timeName(),
-            mesh
-        ),
-        1.0 - beta*(T - TRef)
-    );
-
-    // kinematic turbulent thermal thermal conductivity m2/s
-    Info<< "Reading field alphat\n" << endl;
-    volScalarField alphat
-    (
-        IOobject
-        (
-            "alphat",
-            runTime.timeName(),
-            mesh,
-            IOobject::MUST_READ,
-            IOobject::AUTO_WRITE
-        ),
-        mesh
-    );
-
-
-    #include "readGravitationalAcceleration.H"
-    #include "readhRef.H"
-    #include "gh.H"
-
-
-    volScalarField p
-    (
-        IOobject
-        (
-            "p",
-            runTime.timeName(),
-            mesh,
-            IOobject::NO_READ,
-            IOobject::AUTO_WRITE
-        ),
-        p_rgh + rhok*gh
-    );
-
-    label pRefCell = 0;
-    scalar pRefValue = 0.0;
-    setRefCell
-    (
-        p,
-        p_rgh,
-        simple.dict(),
-        pRefCell,
-        pRefValue
-    );
-
-    if (p_rgh.needReference())
-    {
-        p += dimensionedScalar
-        (
-            "p",
-            p.dimensions(),
-            pRefValue - getRefCellValue(p, pRefCell)
-        );
-    }
+mesh.setFluxRequired(p_rgh.name());
diff --git a/applications/solvers/heatTransfer/buoyantPimpleFoam/createFields.H b/applications/solvers/heatTransfer/buoyantPimpleFoam/createFields.H
index eaa078c6ad..977fb1542a 100644
--- a/applications/solvers/heatTransfer/buoyantPimpleFoam/createFields.H
+++ b/applications/solvers/heatTransfer/buoyantPimpleFoam/createFields.H
@@ -1,88 +1,90 @@
-    Info<< "Reading thermophysical properties\n" << endl;
+Info<< "Reading thermophysical properties\n" << endl;
 
-    autoPtr<rhoThermo> pThermo(rhoThermo::New(mesh));
-    rhoThermo& thermo = pThermo();
-    thermo.validate(args.executable(), "h", "e");
+autoPtr<rhoThermo> pThermo(rhoThermo::New(mesh));
+rhoThermo& thermo = pThermo();
+thermo.validate(args.executable(), "h", "e");
 
-    volScalarField rho
+volScalarField rho
+(
+    IOobject
     (
-        IOobject
-        (
-            "rho",
-            runTime.timeName(),
-            mesh,
-            IOobject::NO_READ,
-            IOobject::NO_WRITE
-        ),
-        thermo.rho()
-    );
-
-    volScalarField& p = thermo.p();
-    const volScalarField& psi = thermo.psi();
-
-
-    Info<< "Reading field U\n" << endl;
-    volVectorField U
-    (
-        IOobject
-        (
-            "U",
-            runTime.timeName(),
-            mesh,
-            IOobject::MUST_READ,
-            IOobject::AUTO_WRITE
-        ),
-        mesh
-    );
-
-    #include "compressibleCreatePhi.H"
-
-
-    Info<< "Creating turbulence model\n" << endl;
-    autoPtr<compressible::turbulenceModel> turbulence
-    (
-        compressible::turbulenceModel::New
-        (
-            rho,
-            U,
-            phi,
-            thermo
-        )
-    );
-
-    Info<< "Calculating field g.h\n" << endl;
-    volScalarField gh("gh", g & mesh.C());
-    surfaceScalarField ghf("ghf", g & mesh.Cf());
-
-    Info<< "Reading field p_rgh\n" << endl;
-    volScalarField p_rgh
-    (
-        IOobject
-        (
-            "p_rgh",
-            runTime.timeName(),
-            mesh,
-            IOobject::MUST_READ,
-            IOobject::AUTO_WRITE
-        ),
-        mesh
-    );
-
-    // Force p_rgh to be consistent with p
-    p_rgh = p - rho*gh;
-
-    Info<< "Creating field dpdt\n" << endl;
-    volScalarField dpdt
-    (
-        IOobject
-        (
-            "dpdt",
-            runTime.timeName(),
-            mesh
-        ),
+        "rho",
+        runTime.timeName(),
         mesh,
-        dimensionedScalar("dpdt", p.dimensions()/dimTime, 0)
-    );
+        IOobject::NO_READ,
+        IOobject::NO_WRITE
+    ),
+    thermo.rho()
+);
 
-    Info<< "Creating field kinetic energy K\n" << endl;
-    volScalarField K("K", 0.5*magSqr(U));
+volScalarField& p = thermo.p();
+const volScalarField& psi = thermo.psi();
+
+
+Info<< "Reading field U\n" << endl;
+volVectorField U
+(
+    IOobject
+    (
+        "U",
+        runTime.timeName(),
+        mesh,
+        IOobject::MUST_READ,
+        IOobject::AUTO_WRITE
+    ),
+    mesh
+);
+
+#include "compressibleCreatePhi.H"
+
+
+Info<< "Creating turbulence model\n" << endl;
+autoPtr<compressible::turbulenceModel> turbulence
+(
+    compressible::turbulenceModel::New
+    (
+        rho,
+        U,
+        phi,
+        thermo
+    )
+);
+
+Info<< "Calculating field g.h\n" << endl;
+volScalarField gh("gh", g & mesh.C());
+surfaceScalarField ghf("ghf", g & mesh.Cf());
+
+Info<< "Reading field p_rgh\n" << endl;
+volScalarField p_rgh
+(
+    IOobject
+    (
+        "p_rgh",
+        runTime.timeName(),
+        mesh,
+        IOobject::MUST_READ,
+        IOobject::AUTO_WRITE
+    ),
+    mesh
+);
+
+// Force p_rgh to be consistent with p
+p_rgh = p - rho*gh;
+
+mesh.setFluxRequired(p_rgh.name());
+
+Info<< "Creating field dpdt\n" << endl;
+volScalarField dpdt
+(
+    IOobject
+    (
+        "dpdt",
+        runTime.timeName(),
+        mesh
+    ),
+    mesh,
+    dimensionedScalar("dpdt", p.dimensions()/dimTime, 0)
+);
+
+Info<< "Creating field kinetic energy K\n" << endl;
+volScalarField K("K", 0.5*magSqr(U));
diff --git a/applications/solvers/heatTransfer/buoyantSimpleFoam/createFields.H b/applications/solvers/heatTransfer/buoyantSimpleFoam/createFields.H
index f60eb1481c..5b07f643b1 100644
--- a/applications/solvers/heatTransfer/buoyantSimpleFoam/createFields.H
+++ b/applications/solvers/heatTransfer/buoyantSimpleFoam/createFields.H
@@ -1,86 +1,87 @@
-    Info<< "Reading thermophysical properties\n" << endl;
+Info<< "Reading thermophysical properties\n" << endl;
 
-    autoPtr<rhoThermo> pThermo(rhoThermo::New(mesh));
-    rhoThermo& thermo = pThermo();
-    thermo.validate(args.executable(), "h", "e");
+autoPtr<rhoThermo> pThermo(rhoThermo::New(mesh));
+rhoThermo& thermo = pThermo();
+thermo.validate(args.executable(), "h", "e");
 
-    volScalarField rho
+volScalarField rho
+(
+    IOobject
     (
-        IOobject
-        (
-            "rho",
-            runTime.timeName(),
-            mesh,
-            IOobject::NO_READ,
-            IOobject::NO_WRITE
-        ),
-        thermo.rho()
-    );
+        "rho",
+        runTime.timeName(),
+        mesh,
+        IOobject::NO_READ,
+        IOobject::NO_WRITE
+    ),
+    thermo.rho()
+);
 
-    volScalarField& p = thermo.p();
-    const volScalarField& psi = thermo.psi();
+volScalarField& p = thermo.p();
+const volScalarField& psi = thermo.psi();
 
-    Info<< "Reading field U\n" << endl;
-    volVectorField U
+Info<< "Reading field U\n" << endl;
+volVectorField U
+(
+    IOobject
     (
-        IOobject
-        (
-            "U",
-            runTime.timeName(),
-            mesh,
-            IOobject::MUST_READ,
-            IOobject::AUTO_WRITE
-        ),
-        mesh
-    );
+        "U",
+        runTime.timeName(),
+        mesh,
+        IOobject::MUST_READ,
+        IOobject::AUTO_WRITE
+    ),
+    mesh
+);
 
-    #include "compressibleCreatePhi.H"
+#include "compressibleCreatePhi.H"
 
-    Info<< "Creating turbulence model\n" << endl;
-    autoPtr<compressible::RASModel> turbulence
+Info<< "Creating turbulence model\n" << endl;
+autoPtr<compressible::RASModel> turbulence
+(
+    compressible::RASModel::New
     (
-        compressible::RASModel::New
-        (
-            rho,
-            U,
-            phi,
-            thermo
-        )
-    );
+        rho,
+        U,
+        phi,
+        thermo
+    )
+);
 
 
-    Info<< "Calculating field g.h\n" << endl;
-    volScalarField gh("gh", g & mesh.C());
-    surfaceScalarField ghf("ghf", g & mesh.Cf());
+Info<< "Calculating field g.h\n" << endl;
+volScalarField gh("gh", g & mesh.C());
+surfaceScalarField ghf("ghf", g & mesh.Cf());
 
-    Info<< "Reading field p_rgh\n" << endl;
-    volScalarField p_rgh
+Info<< "Reading field p_rgh\n" << endl;
+volScalarField p_rgh
+(
+    IOobject
     (
-        IOobject
-        (
-            "p_rgh",
-            runTime.timeName(),
-            mesh,
-            IOobject::MUST_READ,
-            IOobject::AUTO_WRITE
-        ),
-        mesh
-    );
+        "p_rgh",
+        runTime.timeName(),
+        mesh,
+        IOobject::MUST_READ,
+        IOobject::AUTO_WRITE
+    ),
+    mesh
+);
 
-    // Force p_rgh to be consistent with p
-    p_rgh = p - rho*gh;
+// Force p_rgh to be consistent with p
+p_rgh = p - rho*gh;
 
+label pRefCell = 0;
+scalar pRefValue = 0.0;
+setRefCell
+(
+    p,
+    p_rgh,
+    simple.dict(),
+    pRefCell,
+    pRefValue
+);
 
-    label pRefCell = 0;
-    scalar pRefValue = 0.0;
-    setRefCell
-    (
-        p,
-        p_rgh,
-        simple.dict(),
-        pRefCell,
-        pRefValue
-    );
+mesh.setFluxRequired(p_rgh.name());
 
-    dimensionedScalar initialMass = fvc::domainIntegrate(rho);
-    dimensionedScalar totalVolume = sum(mesh.V());
+dimensionedScalar initialMass = fvc::domainIntegrate(rho);
+dimensionedScalar totalVolume = sum(mesh.V());
diff --git a/applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/fluid/createFluidFields.H b/applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/fluid/createFluidFields.H
index f41f8f97e3..bd7452ae9e 100644
--- a/applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/fluid/createFluidFields.H
+++ b/applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/fluid/createFluidFields.H
@@ -1,222 +1,224 @@
-    // Initialise fluid field pointer lists
-    PtrList<rhoThermo> thermoFluid(fluidRegions.size());
-    PtrList<volScalarField> rhoFluid(fluidRegions.size());
-    PtrList<volVectorField> UFluid(fluidRegions.size());
-    PtrList<surfaceScalarField> phiFluid(fluidRegions.size());
-    PtrList<uniformDimensionedVectorField> gFluid(fluidRegions.size());
-    PtrList<compressible::turbulenceModel> turbulence(fluidRegions.size());
-    PtrList<volScalarField> p_rghFluid(fluidRegions.size());
-    PtrList<volScalarField> ghFluid(fluidRegions.size());
-    PtrList<surfaceScalarField> ghfFluid(fluidRegions.size());
-    PtrList<radiation::radiationModel> radiation(fluidRegions.size());
+// Initialise fluid field pointer lists
+PtrList<rhoThermo> thermoFluid(fluidRegions.size());
+PtrList<volScalarField> rhoFluid(fluidRegions.size());
+PtrList<volVectorField> UFluid(fluidRegions.size());
+PtrList<surfaceScalarField> phiFluid(fluidRegions.size());
+PtrList<uniformDimensionedVectorField> gFluid(fluidRegions.size());
+PtrList<compressible::turbulenceModel> turbulence(fluidRegions.size());
+PtrList<volScalarField> p_rghFluid(fluidRegions.size());
+PtrList<volScalarField> ghFluid(fluidRegions.size());
+PtrList<surfaceScalarField> ghfFluid(fluidRegions.size());
+PtrList<radiation::radiationModel> radiation(fluidRegions.size());
 
-    List<scalar> initialMassFluid(fluidRegions.size());
-    List<label> pRefCellFluid(fluidRegions.size(), 0);
-    List<scalar> pRefValueFluid(fluidRegions.size(), 0.0);
-    List<bool> frozenFlowFluid(fluidRegions.size(), false);
+List<scalar> initialMassFluid(fluidRegions.size());
+List<label> pRefCellFluid(fluidRegions.size(), 0);
+List<scalar> pRefValueFluid(fluidRegions.size(), 0.0);
+List<bool> frozenFlowFluid(fluidRegions.size(), false);
 
-    PtrList<dimensionedScalar> rhoMax(fluidRegions.size());
-    PtrList<dimensionedScalar> rhoMin(fluidRegions.size());
+PtrList<dimensionedScalar> rhoMax(fluidRegions.size());
+PtrList<dimensionedScalar> rhoMin(fluidRegions.size());
 
-    PtrList<IOMRFZoneList> MRFfluid(fluidRegions.size());
-    PtrList<fv::IOoptionList> fluidFvOptions(fluidRegions.size());
+PtrList<IOMRFZoneList> MRFfluid(fluidRegions.size());
+PtrList<fv::IOoptionList> fluidFvOptions(fluidRegions.size());
 
-    // Populate fluid field pointer lists
-    forAll(fluidRegions, i)
-    {
-        Info<< "*** Reading fluid mesh thermophysical properties for region "
-            << fluidRegions[i].name() << nl << endl;
+// Populate fluid field pointer lists
+forAll(fluidRegions, i)
+{
+    Info<< "*** Reading fluid mesh thermophysical properties for region "
+        << fluidRegions[i].name() << nl << endl;
 
-        Info<< "    Adding to thermoFluid\n" << endl;
+    Info<< "    Adding to thermoFluid\n" << endl;
 
-        thermoFluid.set
+    thermoFluid.set
+    (
+        i,
+        rhoThermo::New(fluidRegions[i]).ptr()
+    );
+
+    Info<< "    Adding to rhoFluid\n" << endl;
+    rhoFluid.set
+    (
+        i,
+        new volScalarField
         (
-            i,
-            rhoThermo::New(fluidRegions[i]).ptr()
-        );
-
-        Info<< "    Adding to rhoFluid\n" << endl;
-        rhoFluid.set
-        (
-            i,
-            new volScalarField
+            IOobject
             (
-                IOobject
-                (
-                    "rho",
-                    runTime.timeName(),
-                    fluidRegions[i],
-                    IOobject::NO_READ,
-                    IOobject::AUTO_WRITE
-                ),
-                thermoFluid[i].rho()
+                "rho",
+                runTime.timeName(),
+                fluidRegions[i],
+                IOobject::NO_READ,
+                IOobject::AUTO_WRITE
+            ),
+            thermoFluid[i].rho()
+        )
+    );
+
+    Info<< "    Adding to UFluid\n" << endl;
+    UFluid.set
+    (
+        i,
+        new volVectorField
+        (
+            IOobject
+            (
+                "U",
+                runTime.timeName(),
+                fluidRegions[i],
+                IOobject::MUST_READ,
+                IOobject::AUTO_WRITE
+            ),
+            fluidRegions[i]
+        )
+    );
+
+    Info<< "    Adding to phiFluid\n" << endl;
+    phiFluid.set
+    (
+        i,
+        new surfaceScalarField
+        (
+            IOobject
+            (
+                "phi",
+                runTime.timeName(),
+                fluidRegions[i],
+                IOobject::READ_IF_PRESENT,
+                IOobject::AUTO_WRITE
+            ),
+            linearInterpolate(rhoFluid[i]*UFluid[i])
+                & fluidRegions[i].Sf()
+        )
+    );
+
+    Info<< "    Adding to gFluid\n" << endl;
+    gFluid.set
+    (
+        i,
+        new uniformDimensionedVectorField
+        (
+            IOobject
+            (
+                "g",
+                runTime.constant(),
+                fluidRegions[i],
+                IOobject::MUST_READ,
+                IOobject::NO_WRITE
             )
-        );
+        )
+    );
 
-        Info<< "    Adding to UFluid\n" << endl;
-        UFluid.set
+    Info<< "    Adding to turbulence\n" << endl;
+    turbulence.set
+    (
+        i,
+        compressible::turbulenceModel::New
         (
-            i,
-            new volVectorField
+            rhoFluid[i],
+            UFluid[i],
+            phiFluid[i],
+            thermoFluid[i]
+        ).ptr()
+    );
+
+    Info<< "    Adding to ghFluid\n" << endl;
+    ghFluid.set
+    (
+        i,
+        new volScalarField("gh", gFluid[i] & fluidRegions[i].C())
+    );
+
+    Info<< "    Adding to ghfFluid\n" << endl;
+    ghfFluid.set
+    (
+        i,
+        new surfaceScalarField("ghf", gFluid[i] & fluidRegions[i].Cf())
+    );
+
+    p_rghFluid.set
+    (
+        i,
+        new volScalarField
+        (
+            IOobject
             (
-                IOobject
-                (
-                    "U",
-                    runTime.timeName(),
-                    fluidRegions[i],
-                    IOobject::MUST_READ,
-                    IOobject::AUTO_WRITE
-                ),
-                fluidRegions[i]
+                "p_rgh",
+                runTime.timeName(),
+                fluidRegions[i],
+                IOobject::MUST_READ,
+                IOobject::AUTO_WRITE
+            ),
+            fluidRegions[i]
+        )
+    );
+
+    // Force p_rgh to be consistent with p
+    p_rghFluid[i] = thermoFluid[i].p() - rhoFluid[i]*ghFluid[i];
+
+    fluidRegions[i].setFluxRequired(p_rghFluid[i].name());
+
+    radiation.set
+    (
+        i,
+        radiation::radiationModel::New(thermoFluid[i].T())
+    );
+
+    initialMassFluid[i] = fvc::domainIntegrate(rhoFluid[i]).value();
+
+    const dictionary& simpleDict =
+        fluidRegions[i].solutionDict().subDict("SIMPLE");
+
+    setRefCell
+    (
+        thermoFluid[i].p(),
+        p_rghFluid[i],
+        simpleDict,
+        pRefCellFluid[i],
+        pRefValueFluid[i]
+    );
+
+    simpleDict.readIfPresent("frozenFlow", frozenFlowFluid[i]);
+
+    rhoMax.set
+    (
+        i,
+        new dimensionedScalar
+        (
+            dimensionedScalar::lookupOrDefault
+            (
+                "rhoMax",
+                simpleDict,
+                GREAT,
+                dimDensity
             )
-        );
+        )
+    );
 
-        Info<< "    Adding to phiFluid\n" << endl;
-        phiFluid.set
+    rhoMin.set
+    (
+        i,
+        new dimensionedScalar
         (
-            i,
-            new surfaceScalarField
+            dimensionedScalar::lookupOrDefault
             (
-                IOobject
-                (
-                    "phi",
-                    runTime.timeName(),
-                    fluidRegions[i],
-                    IOobject::READ_IF_PRESENT,
-                    IOobject::AUTO_WRITE
-                ),
-                linearInterpolate(rhoFluid[i]*UFluid[i])
-                    & fluidRegions[i].Sf()
+                "rhoMin",
+                simpleDict,
+                0,
+                dimDensity
             )
-        );
+        )
+    );
 
-        Info<< "    Adding to gFluid\n" << endl;
-        gFluid.set
-        (
-            i,
-            new uniformDimensionedVectorField
-            (
-                IOobject
-                (
-                    "g",
-                    runTime.constant(),
-                    fluidRegions[i],
-                    IOobject::MUST_READ,
-                    IOobject::NO_WRITE
-                )
-            )
-        );
+    Info<< "    Adding MRF\n" << endl;
+    MRFfluid.set
+    (
+        i,
+        new IOMRFZoneList(fluidRegions[i])
+    );
 
-        Info<< "    Adding to turbulence\n" << endl;
-        turbulence.set
-        (
-            i,
-            compressible::turbulenceModel::New
-            (
-                rhoFluid[i],
-                UFluid[i],
-                phiFluid[i],
-                thermoFluid[i]
-            ).ptr()
-        );
-
-        Info<< "    Adding to ghFluid\n" << endl;
-        ghFluid.set
-        (
-            i,
-            new volScalarField("gh", gFluid[i] & fluidRegions[i].C())
-        );
-
-        Info<< "    Adding to ghfFluid\n" << endl;
-        ghfFluid.set
-        (
-            i,
-            new surfaceScalarField("ghf", gFluid[i] & fluidRegions[i].Cf())
-        );
-
-        p_rghFluid.set
-        (
-            i,
-            new volScalarField
-            (
-                IOobject
-                (
-                    "p_rgh",
-                    runTime.timeName(),
-                    fluidRegions[i],
-                    IOobject::MUST_READ,
-                    IOobject::AUTO_WRITE
-                ),
-                fluidRegions[i]
-            )
-        );
-
-        // Force p_rgh to be consistent with p
-        p_rghFluid[i] = thermoFluid[i].p() - rhoFluid[i]*ghFluid[i];
-
-        radiation.set
-        (
-            i,
-            radiation::radiationModel::New(thermoFluid[i].T())
-        );
-
-        initialMassFluid[i] = fvc::domainIntegrate(rhoFluid[i]).value();
-
-        const dictionary& simpleDict =
-            fluidRegions[i].solutionDict().subDict("SIMPLE");
-
-        setRefCell
-        (
-            thermoFluid[i].p(),
-            p_rghFluid[i],
-            simpleDict,
-            pRefCellFluid[i],
-            pRefValueFluid[i]
-        );
-
-        simpleDict.readIfPresent("frozenFlow", frozenFlowFluid[i]);
-
-        rhoMax.set
-        (
-            i,
-            new dimensionedScalar
-            (
-                dimensionedScalar::lookupOrDefault
-                (
-                    "rhoMax",
-                    simpleDict,
-                    GREAT,
-                    dimDensity
-                )
-            )
-        );
-
-        rhoMin.set
-        (
-            i,
-            new dimensionedScalar
-            (
-                dimensionedScalar::lookupOrDefault
-                (
-                    "rhoMin",
-                    simpleDict,
-                    0,
-                    dimDensity
-                )
-            )
-        );
-
-        Info<< "    Adding MRF\n" << endl;
-        MRFfluid.set
-        (
-            i,
-            new IOMRFZoneList(fluidRegions[i])
-        );
-
-        Info<< "    Adding fvOptions\n" << endl;
-        fluidFvOptions.set
-        (
-            i,
-            new fv::IOoptionList(fluidRegions[i])
-        );
-    }
+    Info<< "    Adding fvOptions\n" << endl;
+    fluidFvOptions.set
+    (
+        i,
+        new fv::IOoptionList(fluidRegions[i])
+    );
+}
diff --git a/applications/solvers/heatTransfer/chtMultiRegionFoam/fluid/createFluidFields.H b/applications/solvers/heatTransfer/chtMultiRegionFoam/fluid/createFluidFields.H
index 1d51cb6228..2e66546483 100644
--- a/applications/solvers/heatTransfer/chtMultiRegionFoam/fluid/createFluidFields.H
+++ b/applications/solvers/heatTransfer/chtMultiRegionFoam/fluid/createFluidFields.H
@@ -1,212 +1,214 @@
-    // Initialise fluid field pointer lists
-    PtrList<rhoThermo> thermoFluid(fluidRegions.size());
-    PtrList<volScalarField> rhoFluid(fluidRegions.size());
-    PtrList<volVectorField> UFluid(fluidRegions.size());
-    PtrList<surfaceScalarField> phiFluid(fluidRegions.size());
-    PtrList<uniformDimensionedVectorField> gFluid(fluidRegions.size());
-    PtrList<compressible::turbulenceModel> turbulence(fluidRegions.size());
-    PtrList<volScalarField> p_rghFluid(fluidRegions.size());
-    PtrList<volScalarField> ghFluid(fluidRegions.size());
-    PtrList<surfaceScalarField> ghfFluid(fluidRegions.size());
-    PtrList<radiation::radiationModel> radiation(fluidRegions.size());
-    PtrList<volScalarField> KFluid(fluidRegions.size());
-    PtrList<volScalarField> dpdtFluid(fluidRegions.size());
+// Initialise fluid field pointer lists
+PtrList<rhoThermo> thermoFluid(fluidRegions.size());
+PtrList<volScalarField> rhoFluid(fluidRegions.size());
+PtrList<volVectorField> UFluid(fluidRegions.size());
+PtrList<surfaceScalarField> phiFluid(fluidRegions.size());
+PtrList<uniformDimensionedVectorField> gFluid(fluidRegions.size());
+PtrList<compressible::turbulenceModel> turbulence(fluidRegions.size());
+PtrList<volScalarField> p_rghFluid(fluidRegions.size());
+PtrList<volScalarField> ghFluid(fluidRegions.size());
+PtrList<surfaceScalarField> ghfFluid(fluidRegions.size());
+PtrList<radiation::radiationModel> radiation(fluidRegions.size());
+PtrList<volScalarField> KFluid(fluidRegions.size());
+PtrList<volScalarField> dpdtFluid(fluidRegions.size());
 
-    List<scalar> initialMassFluid(fluidRegions.size());
-    List<bool> frozenFlowFluid(fluidRegions.size(), false);
+List<scalar> initialMassFluid(fluidRegions.size());
+List<bool> frozenFlowFluid(fluidRegions.size(), false);
 
-    PtrList<IOMRFZoneList> MRFfluid(fluidRegions.size());
-    PtrList<fv::IOoptionList> fluidFvOptions(fluidRegions.size());
+PtrList<IOMRFZoneList> MRFfluid(fluidRegions.size());
+PtrList<fv::IOoptionList> fluidFvOptions(fluidRegions.size());
 
-    // Populate fluid field pointer lists
-    forAll(fluidRegions, i)
-    {
-        Info<< "*** Reading fluid mesh thermophysical properties for region "
-            << fluidRegions[i].name() << nl << endl;
+// Populate fluid field pointer lists
+forAll(fluidRegions, i)
+{
+    Info<< "*** Reading fluid mesh thermophysical properties for region "
+        << fluidRegions[i].name() << nl << endl;
 
-        Info<< "    Adding to thermoFluid\n" << endl;
+    Info<< "    Adding to thermoFluid\n" << endl;
 
-        thermoFluid.set
+    thermoFluid.set
+    (
+        i,
+        rhoThermo::New(fluidRegions[i]).ptr()
+    );
+
+    Info<< "    Adding to rhoFluid\n" << endl;
+    rhoFluid.set
+    (
+        i,
+        new volScalarField
         (
-            i,
-            rhoThermo::New(fluidRegions[i]).ptr()
-        );
-
-        Info<< "    Adding to rhoFluid\n" << endl;
-        rhoFluid.set
-        (
-            i,
-            new volScalarField
+            IOobject
             (
-                IOobject
-                (
-                    "rho",
-                    runTime.timeName(),
-                    fluidRegions[i],
-                    IOobject::NO_READ,
-                    IOobject::AUTO_WRITE
-                ),
-                thermoFluid[i].rho()
-            )
-        );
-
-        Info<< "    Adding to UFluid\n" << endl;
-        UFluid.set
-        (
-            i,
-            new volVectorField
-            (
-                IOobject
-                (
-                    "U",
-                    runTime.timeName(),
-                    fluidRegions[i],
-                    IOobject::MUST_READ,
-                    IOobject::AUTO_WRITE
-                ),
-                fluidRegions[i]
-            )
-        );
-
-        Info<< "    Adding to phiFluid\n" << endl;
-        phiFluid.set
-        (
-            i,
-            new surfaceScalarField
-            (
-                IOobject
-                (
-                    "phi",
-                    runTime.timeName(),
-                    fluidRegions[i],
-                    IOobject::READ_IF_PRESENT,
-                    IOobject::AUTO_WRITE
-                ),
-                linearInterpolate(rhoFluid[i]*UFluid[i])
-                    & fluidRegions[i].Sf()
-            )
-        );
-
-        Info<< "    Adding to gFluid\n" << endl;
-        gFluid.set
-        (
-            i,
-            new uniformDimensionedVectorField
-            (
-                IOobject
-                (
-                    "g",
-                    runTime.constant(),
-                    fluidRegions[i],
-                    IOobject::MUST_READ,
-                    IOobject::NO_WRITE
-                )
-            )
-        );
-
-        Info<< "    Adding to turbulence\n" << endl;
-        turbulence.set
-        (
-            i,
-            compressible::turbulenceModel::New
-            (
-                rhoFluid[i],
-                UFluid[i],
-                phiFluid[i],
-                thermoFluid[i]
-            ).ptr()
-        );
-
-        Info<< "    Adding to ghFluid\n" << endl;
-        ghFluid.set
-        (
-            i,
-            new volScalarField("gh", gFluid[i] & fluidRegions[i].C())
-        );
-
-        Info<< "    Adding to ghfFluid\n" << endl;
-        ghfFluid.set
-        (
-            i,
-            new surfaceScalarField("ghf", gFluid[i] & fluidRegions[i].Cf())
-        );
-
-        p_rghFluid.set
-        (
-            i,
-            new volScalarField
-            (
-                IOobject
-                (
-                    "p_rgh",
-                    runTime.timeName(),
-                    fluidRegions[i],
-                    IOobject::MUST_READ,
-                    IOobject::AUTO_WRITE
-                ),
-                fluidRegions[i]
-            )
-        );
-
-        // Force p_rgh to be consistent with p
-        p_rghFluid[i] = thermoFluid[i].p() - rhoFluid[i]*ghFluid[i];
-
-        radiation.set
-        (
-            i,
-            radiation::radiationModel::New(thermoFluid[i].T())
-        );
-
-        initialMassFluid[i] = fvc::domainIntegrate(rhoFluid[i]).value();
-
-        Info<< "    Adding to KFluid\n" << endl;
-        KFluid.set
-        (
-            i,
-            new volScalarField
-            (
-                "K",
-                0.5*magSqr(UFluid[i])
-            )
-        );
-
-        Info<< "    Adding to dpdtFluid\n" << endl;
-        dpdtFluid.set
-        (
-            i,
-            new volScalarField
-            (
-                IOobject
-                (
-                    "dpdt",
-                    runTime.timeName(),
-                    fluidRegions[i]
-                ),
+                "rho",
+                runTime.timeName(),
                 fluidRegions[i],
-                dimensionedScalar
-                (
-                    "dpdt",
-                    thermoFluid[i].p().dimensions()/dimTime,
-                    0
-                )
+                IOobject::NO_READ,
+                IOobject::AUTO_WRITE
+            ),
+            thermoFluid[i].rho()
+        )
+    );
+
+    Info<< "    Adding to UFluid\n" << endl;
+    UFluid.set
+    (
+        i,
+        new volVectorField
+        (
+            IOobject
+            (
+                "U",
+                runTime.timeName(),
+                fluidRegions[i],
+                IOobject::MUST_READ,
+                IOobject::AUTO_WRITE
+            ),
+            fluidRegions[i]
+        )
+    );
+
+    Info<< "    Adding to phiFluid\n" << endl;
+    phiFluid.set
+    (
+        i,
+        new surfaceScalarField
+        (
+            IOobject
+            (
+                "phi",
+                runTime.timeName(),
+                fluidRegions[i],
+                IOobject::READ_IF_PRESENT,
+                IOobject::AUTO_WRITE
+            ),
+            linearInterpolate(rhoFluid[i]*UFluid[i])
+                & fluidRegions[i].Sf()
+        )
+    );
+
+    Info<< "    Adding to gFluid\n" << endl;
+    gFluid.set
+    (
+        i,
+        new uniformDimensionedVectorField
+        (
+            IOobject
+            (
+                "g",
+                runTime.constant(),
+                fluidRegions[i],
+                IOobject::MUST_READ,
+                IOobject::NO_WRITE
             )
-        );
+        )
+    );
 
-        const dictionary& pimpleDict =
-            fluidRegions[i].solutionDict().subDict("PIMPLE");
-        pimpleDict.readIfPresent("frozenFlow", frozenFlowFluid[i]);
-
-        Info<< "    Adding MRF\n" << endl;
-        MRFfluid.set
+    Info<< "    Adding to turbulence\n" << endl;
+    turbulence.set
+    (
+        i,
+        compressible::turbulenceModel::New
         (
-            i,
-            new IOMRFZoneList(fluidRegions[i])
-        );
+            rhoFluid[i],
+            UFluid[i],
+            phiFluid[i],
+            thermoFluid[i]
+        ).ptr()
+    );
 
-        Info<< "    Adding fvOptions\n" << endl;
-        fluidFvOptions.set
+    Info<< "    Adding to ghFluid\n" << endl;
+    ghFluid.set
+    (
+        i,
+        new volScalarField("gh", gFluid[i] & fluidRegions[i].C())
+    );
+
+    Info<< "    Adding to ghfFluid\n" << endl;
+    ghfFluid.set
+    (
+        i,
+        new surfaceScalarField("ghf", gFluid[i] & fluidRegions[i].Cf())
+    );
+
+    p_rghFluid.set
+    (
+        i,
+        new volScalarField
         (
-            i,
-            new fv::IOoptionList(fluidRegions[i])
-        );
-    }
+            IOobject
+            (
+                "p_rgh",
+                runTime.timeName(),
+                fluidRegions[i],
+                IOobject::MUST_READ,
+                IOobject::AUTO_WRITE
+            ),
+            fluidRegions[i]
+        )
+    );
+
+    // Force p_rgh to be consistent with p
+    p_rghFluid[i] = thermoFluid[i].p() - rhoFluid[i]*ghFluid[i];
+
+    fluidRegions[i].setFluxRequired(p_rghFluid[i].name());
+
+    radiation.set
+    (
+        i,
+        radiation::radiationModel::New(thermoFluid[i].T())
+    );
+
+    initialMassFluid[i] = fvc::domainIntegrate(rhoFluid[i]).value();
+
+    Info<< "    Adding to KFluid\n" << endl;
+    KFluid.set
+    (
+        i,
+        new volScalarField
+        (
+            "K",
+            0.5*magSqr(UFluid[i])
+        )
+    );
+
+    Info<< "    Adding to dpdtFluid\n" << endl;
+    dpdtFluid.set
+    (
+        i,
+        new volScalarField
+        (
+            IOobject
+            (
+                "dpdt",
+                runTime.timeName(),
+                fluidRegions[i]
+            ),
+            fluidRegions[i],
+            dimensionedScalar
+            (
+                "dpdt",
+                thermoFluid[i].p().dimensions()/dimTime,
+                0
+            )
+        )
+    );
+
+    const dictionary& pimpleDict =
+        fluidRegions[i].solutionDict().subDict("PIMPLE");
+    pimpleDict.readIfPresent("frozenFlow", frozenFlowFluid[i]);
+
+    Info<< "    Adding MRF\n" << endl;
+    MRFfluid.set
+    (
+        i,
+        new IOMRFZoneList(fluidRegions[i])
+    );
+
+    Info<< "    Adding fvOptions\n" << endl;
+    fluidFvOptions.set
+    (
+        i,
+        new fv::IOoptionList(fluidRegions[i])
+    );
+}
diff --git a/applications/solvers/incompressible/pimpleFoam/pimpleDyMFoam/createFields.H b/applications/solvers/incompressible/pimpleFoam/pimpleDyMFoam/createFields.H
deleted file mode 100644
index 3ab37cd443..0000000000
--- a/applications/solvers/incompressible/pimpleFoam/pimpleDyMFoam/createFields.H
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "../createFields.H"
-mesh.setFluxRequired("pcorr");
diff --git a/applications/solvers/lagrangian/DPMFoam/createFields.H b/applications/solvers/lagrangian/DPMFoam/createFields.H
index 97b6287804..9e34895a73 100644
--- a/applications/solvers/lagrangian/DPMFoam/createFields.H
+++ b/applications/solvers/lagrangian/DPMFoam/createFields.H
@@ -1,164 +1,165 @@
-    word continuousPhaseName
-    (
-        IOdictionary
-        (
-            IOobject
-            (
-                "transportProperties",
-                runTime.constant(),
-                mesh,
-                IOobject::MUST_READ
-            )
-        ).lookup("continuousPhaseName")
-    );
-
-    Info<< "Reading field U\n" << endl;
-    volVectorField Uc
+word continuousPhaseName
+(
+    IOdictionary
     (
         IOobject
         (
-            IOobject::groupName("U", continuousPhaseName),
-            runTime.timeName(),
+            "transportProperties",
+            runTime.constant(),
             mesh,
-            IOobject::MUST_READ,
-            IOobject::AUTO_WRITE
-        ),
-        mesh
-    );
-
-    Info<< "Reading field p\n" << endl;
-    volScalarField p
-    (
-        IOobject
-        (
-            "p",
-            runTime.timeName(),
-            mesh,
-            IOobject::MUST_READ,
-            IOobject::AUTO_WRITE
-        ),
-        mesh
-    );
-
-
-    Info<< "Reading/calculating continuous-phase face flux field phic\n"
-        << endl;
-
-    surfaceScalarField phic
-    (
-        IOobject
-        (
-            IOobject::groupName("phi", continuousPhaseName),
-            runTime.timeName(),
-            mesh,
-            IOobject::READ_IF_PRESENT,
-            IOobject::AUTO_WRITE
-        ),
-        linearInterpolate(Uc) & mesh.Sf()
-    );
-
-    label pRefCell = 0;
-    scalar pRefValue = 0.0;
-    setRefCell(p, pimple.dict(), pRefCell, pRefValue);
-
-    Info<< "Creating turbulence model\n" << endl;
-
-    singlePhaseTransportModel continuousPhaseTransport(Uc, phic);
-
-    dimensionedScalar rhocValue
-    (
-        IOobject::groupName("rho", continuousPhaseName),
-        dimDensity,
-        continuousPhaseTransport.lookup
-        (
-            IOobject::groupName("rho", continuousPhaseName)
+            IOobject::MUST_READ
         )
-    );
+    ).lookup("continuousPhaseName")
+);
 
-    volScalarField rhoc
+Info<< "Reading field U\n" << endl;
+volVectorField Uc
+(
+    IOobject
     (
-        IOobject
-        (
-            rhocValue.name(),
-            runTime.timeName(),
-            mesh,
-            IOobject::NO_READ,
-            IOobject::AUTO_WRITE
-        ),
+        IOobject::groupName("U", continuousPhaseName),
+        runTime.timeName(),
         mesh,
-        rhocValue
-    );
+        IOobject::MUST_READ,
+        IOobject::AUTO_WRITE
+    ),
+    mesh
+);
 
-    volScalarField muc
+Info<< "Reading field p\n" << endl;
+volScalarField p
+(
+    IOobject
     (
-        IOobject
-        (
-            IOobject::groupName("mu", continuousPhaseName),
-            runTime.timeName(),
-            mesh,
-            IOobject::NO_READ,
-            IOobject::AUTO_WRITE
-        ),
-        rhoc*continuousPhaseTransport.nu()
-    );
-
-    Info << "Creating field alphac\n" << endl;
-    // alphac must be constructed before the cloud
-    // so that the drag-models can find it
-    volScalarField alphac
-    (
-        IOobject
-        (
-            IOobject::groupName("alpha", continuousPhaseName),
-            runTime.timeName(),
-            mesh,
-            IOobject::READ_IF_PRESENT,
-            IOobject::AUTO_WRITE
-        ),
+        "p",
+        runTime.timeName(),
         mesh,
-        dimensionedScalar("0", dimless, 0)
-    );
+        IOobject::MUST_READ,
+        IOobject::AUTO_WRITE
+    ),
+    mesh
+);
 
-    word kinematicCloudName("kinematicCloud");
-    args.optionReadIfPresent("cloudName", kinematicCloudName);
 
-    Info<< "Constructing kinematicCloud " << kinematicCloudName << endl;
-    basicKinematicTypeCloud kinematicCloud
+Info<< "Reading/calculating continuous-phase face flux field phic\n"
+    << endl;
+
+surfaceScalarField phic
+(
+    IOobject
     (
-        kinematicCloudName,
-        rhoc,
+        IOobject::groupName("phi", continuousPhaseName),
+        runTime.timeName(),
+        mesh,
+        IOobject::READ_IF_PRESENT,
+        IOobject::AUTO_WRITE
+    ),
+    linearInterpolate(Uc) & mesh.Sf()
+);
+
+label pRefCell = 0;
+scalar pRefValue = 0.0;
+setRefCell(p, pimple.dict(), pRefCell, pRefValue);
+mesh.setFluxRequired(p.name());
+
+Info<< "Creating turbulence model\n" << endl;
+
+singlePhaseTransportModel continuousPhaseTransport(Uc, phic);
+
+dimensionedScalar rhocValue
+(
+    IOobject::groupName("rho", continuousPhaseName),
+    dimDensity,
+    continuousPhaseTransport.lookup
+    (
+        IOobject::groupName("rho", continuousPhaseName)
+    )
+);
+
+volScalarField rhoc
+(
+    IOobject
+    (
+        rhocValue.name(),
+        runTime.timeName(),
+        mesh,
+        IOobject::NO_READ,
+        IOobject::AUTO_WRITE
+    ),
+    mesh,
+    rhocValue
+);
+
+volScalarField muc
+(
+    IOobject
+    (
+        IOobject::groupName("mu", continuousPhaseName),
+        runTime.timeName(),
+        mesh,
+        IOobject::NO_READ,
+        IOobject::AUTO_WRITE
+    ),
+    rhoc*continuousPhaseTransport.nu()
+);
+
+Info << "Creating field alphac\n" << endl;
+// alphac must be constructed before the cloud
+// so that the drag-models can find it
+volScalarField alphac
+(
+    IOobject
+    (
+        IOobject::groupName("alpha", continuousPhaseName),
+        runTime.timeName(),
+        mesh,
+        IOobject::READ_IF_PRESENT,
+        IOobject::AUTO_WRITE
+    ),
+    mesh,
+    dimensionedScalar("0", dimless, 0)
+);
+
+word kinematicCloudName("kinematicCloud");
+args.optionReadIfPresent("cloudName", kinematicCloudName);
+
+Info<< "Constructing kinematicCloud " << kinematicCloudName << endl;
+basicKinematicTypeCloud kinematicCloud
+(
+    kinematicCloudName,
+    rhoc,
+    Uc,
+    muc,
+    g
+);
+
+// Particle fraction upper limit
+scalar alphacMin
+(
+    1.0
+  - readScalar
+    (
+        kinematicCloud.particleProperties().subDict("constantProperties")
+       .lookup("alphaMax")
+    )
+);
+
+// Update alphac from the particle locations
+alphac = max(1.0 - kinematicCloud.theta(), alphacMin);
+alphac.correctBoundaryConditions();
+
+surfaceScalarField alphacf("alphacf", fvc::interpolate(alphac));
+surfaceScalarField alphaPhic("alphaPhic", alphacf*phic);
+
+autoPtr<PhaseIncompressibleTurbulenceModel<singlePhaseTransportModel> >
+continuousPhaseTurbulence
+(
+    PhaseIncompressibleTurbulenceModel<singlePhaseTransportModel>::New
+    (
+        alphac,
         Uc,
-        muc,
-        g
-    );
-
-    // Particle fraction upper limit
-    scalar alphacMin
-    (
-        1.0
-      - readScalar
-        (
-            kinematicCloud.particleProperties().subDict("constantProperties")
-           .lookup("alphaMax")
-        )
-    );
-
-    // Update alphac from the particle locations
-    alphac = max(1.0 - kinematicCloud.theta(), alphacMin);
-    alphac.correctBoundaryConditions();
-
-    surfaceScalarField alphacf("alphacf", fvc::interpolate(alphac));
-    surfaceScalarField alphaPhic("alphaPhic", alphacf*phic);
-
-    autoPtr<PhaseIncompressibleTurbulenceModel<singlePhaseTransportModel> >
-    continuousPhaseTurbulence
-    (
-        PhaseIncompressibleTurbulenceModel<singlePhaseTransportModel>::New
-        (
-            alphac,
-            Uc,
-            alphaPhic,
-            phic,
-            continuousPhaseTransport
-        )
-    );
+        alphaPhic,
+        phic,
+        continuousPhaseTransport
+    )
+);
diff --git a/applications/solvers/lagrangian/coalChemistryFoam/createFields.H b/applications/solvers/lagrangian/coalChemistryFoam/createFields.H
index 52d736458c..cb41f9a407 100644
--- a/applications/solvers/lagrangian/coalChemistryFoam/createFields.H
+++ b/applications/solvers/lagrangian/coalChemistryFoam/createFields.H
@@ -1,141 +1,143 @@
-    Info<< "Creating combustion model\n" << endl;
+Info<< "Creating combustion model\n" << endl;
 
-    autoPtr<combustionModels::psiCombustionModel> combustion
+autoPtr<combustionModels::psiCombustionModel> combustion
+(
+    combustionModels::psiCombustionModel::New(mesh)
+);
+
+psiReactionThermo& thermo = combustion->thermo();
+thermo.validate(args.executable(), "h", "e");
+
+SLGThermo slgThermo(mesh, thermo);
+
+basicSpecieMixture& composition = thermo.composition();
+PtrList<volScalarField>& Y = composition.Y();
+
+const word inertSpecie(thermo.lookup("inertSpecie"));
+
+if (!composition.contains(inertSpecie))
+{
+    FatalErrorIn(args.executable())
+        << "Specified inert specie '" << inertSpecie << "' not found in "
+        << "species list. Available species:" << composition.species()
+        << exit(FatalError);
+}
+
+volScalarField& p = thermo.p();
+const volScalarField& T = thermo.T();
+const volScalarField& psi = thermo.psi();
+
+multivariateSurfaceInterpolationScheme<scalar>::fieldTable fields;
+
+forAll(Y, i)
+{
+    fields.add(Y[i]);
+}
+fields.add(thermo.he());
+
+volScalarField rho
+(
+    IOobject
     (
-        combustionModels::psiCombustionModel::New(mesh)
-    );
-
-    psiReactionThermo& thermo = combustion->thermo();
-    thermo.validate(args.executable(), "h", "e");
-
-    SLGThermo slgThermo(mesh, thermo);
-
-    basicSpecieMixture& composition = thermo.composition();
-    PtrList<volScalarField>& Y = composition.Y();
-
-    const word inertSpecie(thermo.lookup("inertSpecie"));
-
-    if (!composition.contains(inertSpecie))
-    {
-        FatalErrorIn(args.executable())
-            << "Specified inert specie '" << inertSpecie << "' not found in "
-            << "species list. Available species:" << composition.species()
-            << exit(FatalError);
-    }
-
-    volScalarField& p = thermo.p();
-    const volScalarField& T = thermo.T();
-    const volScalarField& psi = thermo.psi();
-
-    multivariateSurfaceInterpolationScheme<scalar>::fieldTable fields;
-
-    forAll(Y, i)
-    {
-        fields.add(Y[i]);
-    }
-    fields.add(thermo.he());
-
-    volScalarField rho
-    (
-        IOobject
-        (
-            "rho",
-            runTime.timeName(),
-            mesh,
-            IOobject::NO_READ,
-            IOobject::AUTO_WRITE
-        ),
-        thermo.rho()
-    );
-
-    // lagrangian effective density field - used externally (optional)
-    volScalarField rhoEffLagrangian
-    (
-        IOobject
-        (
-            "rhoEffLagrangian",
-            runTime.timeName(),
-            mesh,
-            IOobject::NO_READ,
-            IOobject::AUTO_WRITE
-        ),
+        "rho",
+        runTime.timeName(),
         mesh,
-        dimensionedScalar("zero", dimDensity, 0.0)
-    );
+        IOobject::NO_READ,
+        IOobject::AUTO_WRITE
+    ),
+    thermo.rho()
+);
 
-    // dynamic pressure field - used externally (optional)
-    volScalarField pDyn
+// lagrangian effective density field - used externally (optional)
+volScalarField rhoEffLagrangian
+(
+    IOobject
     (
-        IOobject
-        (
-            "pDyn",
-            runTime.timeName(),
-            mesh,
-            IOobject::NO_READ,
-            IOobject::AUTO_WRITE
-        ),
+        "rhoEffLagrangian",
+        runTime.timeName(),
         mesh,
-        dimensionedScalar("zero", dimPressure, 0.0)
-    );
+        IOobject::NO_READ,
+        IOobject::AUTO_WRITE
+    ),
+    mesh,
+    dimensionedScalar("zero", dimDensity, 0.0)
+);
 
-
-    Info<< "\nReading field U\n" << endl;
-    volVectorField U
+// dynamic pressure field - used externally (optional)
+volScalarField pDyn
+(
+    IOobject
     (
-        IOobject
-        (
-            "U",
-            runTime.timeName(),
-            mesh,
-            IOobject::MUST_READ,
-            IOobject::AUTO_WRITE
-        ),
+        "pDyn",
+        runTime.timeName(),
+        mesh,
+        IOobject::NO_READ,
+        IOobject::AUTO_WRITE
+    ),
+    mesh,
+    dimensionedScalar("zero", dimPressure, 0.0)
+);
+
+
+Info<< "\nReading field U\n" << endl;
+volVectorField U
+(
+    IOobject
+    (
+        "U",
+        runTime.timeName(),
+        mesh,
+        IOobject::MUST_READ,
+        IOobject::AUTO_WRITE
+    ),
+    mesh
+);
+
+#include "compressibleCreatePhi.H"
+
+mesh.setFluxRequired(p.name());
+
+Info<< "Creating turbulence model\n" << endl;
+autoPtr<compressible::turbulenceModel> turbulence
+(
+    compressible::turbulenceModel::New
+    (
+        rho,
+        U,
+        phi,
+        thermo
+    )
+);
+
+// Set the turbulence into the combustion model
+combustion->setTurbulence(turbulence());
+
+Info<< "Creating field dpdt\n" << endl;
+volScalarField dpdt
+(
+    IOobject
+    (
+        "dpdt",
+        runTime.timeName(),
         mesh
-    );
+    ),
+    mesh,
+    dimensionedScalar("dpdt", p.dimensions()/dimTime, 0)
+);
 
-    #include "compressibleCreatePhi.H"
+Info<< "Creating field kinetic energy K\n" << endl;
+volScalarField K("K", 0.5*magSqr(U));
 
-    Info<< "Creating turbulence model\n" << endl;
-    autoPtr<compressible::turbulenceModel> turbulence
+volScalarField dQ
+(
+    IOobject
     (
-        compressible::turbulenceModel::New
-        (
-            rho,
-            U,
-            phi,
-            thermo
-        )
-    );
-
-    // Set the turbulence into the combustion model
-    combustion->setTurbulence(turbulence());
-
-    Info<< "Creating field dpdt\n" << endl;
-    volScalarField dpdt
-    (
-        IOobject
-        (
-            "dpdt",
-            runTime.timeName(),
-            mesh
-        ),
+        "dQ",
+        runTime.timeName(),
         mesh,
-        dimensionedScalar("dpdt", p.dimensions()/dimTime, 0)
-    );
-
-    Info<< "Creating field kinetic energy K\n" << endl;
-    volScalarField K("K", 0.5*magSqr(U));
-
-    volScalarField dQ
-    (
-        IOobject
-        (
-            "dQ",
-            runTime.timeName(),
-            mesh,
-            IOobject::NO_READ,
-            IOobject::AUTO_WRITE
-        ),
-        mesh,
-        dimensionedScalar("dQ", dimEnergy/dimTime, 0.0)
-    );
+        IOobject::NO_READ,
+        IOobject::AUTO_WRITE
+    ),
+    mesh,
+    dimensionedScalar("dQ", dimEnergy/dimTime, 0.0)
+);
diff --git a/applications/solvers/lagrangian/reactingParcelFilmFoam/createFields.H b/applications/solvers/lagrangian/reactingParcelFilmFoam/createFields.H
index 847c67bcf2..63d8b8b05c 100644
--- a/applications/solvers/lagrangian/reactingParcelFilmFoam/createFields.H
+++ b/applications/solvers/lagrangian/reactingParcelFilmFoam/createFields.H
@@ -1,142 +1,144 @@
-    Info<< "Creating combustion model\n" << endl;
+Info<< "Creating combustion model\n" << endl;
 
-    autoPtr<combustionModels::psiCombustionModel> combustion
+autoPtr<combustionModels::psiCombustionModel> combustion
+(
+    combustionModels::psiCombustionModel::New(mesh)
+);
+
+psiReactionThermo& thermo = combustion->thermo();
+thermo.validate(args.executable(), "h", "e");
+
+SLGThermo slgThermo(mesh, thermo);
+
+basicSpecieMixture& composition = thermo.composition();
+PtrList<volScalarField>& Y = composition.Y();
+
+const word inertSpecie(thermo.lookup("inertSpecie"));
+
+Info<< "Creating field rho\n" << endl;
+volScalarField rho
+(
+    IOobject
     (
-        combustionModels::psiCombustionModel::New(mesh)
-    );
-
-    psiReactionThermo& thermo = combustion->thermo();
-    thermo.validate(args.executable(), "h", "e");
-
-    SLGThermo slgThermo(mesh, thermo);
-
-    basicSpecieMixture& composition = thermo.composition();
-    PtrList<volScalarField>& Y = composition.Y();
-
-    const word inertSpecie(thermo.lookup("inertSpecie"));
-
-    Info<< "Creating field rho\n" << endl;
-    volScalarField rho
-    (
-        IOobject
-        (
-            "rho",
-            runTime.timeName(),
-            mesh,
-            IOobject::NO_READ,
-            IOobject::AUTO_WRITE
-        ),
-        thermo.rho()
-    );
-
-    volScalarField& p = thermo.p();
-    const volScalarField& T = thermo.T();
-    const volScalarField& psi = thermo.psi();
-
-    Info<< "\nReading field U\n" << endl;
-    volVectorField U
-    (
-        IOobject
-        (
-            "U",
-            runTime.timeName(),
-            mesh,
-            IOobject::MUST_READ,
-            IOobject::AUTO_WRITE
-        ),
-        mesh
-    );
-
-    #include "compressibleCreatePhi.H"
-
-    Info<< "Creating turbulence model\n" << endl;
-    autoPtr<compressible::turbulenceModel> turbulence
-    (
-        compressible::turbulenceModel::New
-        (
-            rho,
-            U,
-            phi,
-            thermo
-        )
-    );
-
-    // Set the turbulence into the combustion model
-    combustion->setTurbulence(turbulence());
-
-    Info<< "Creating field dpdt\n" << endl;
-    volScalarField dpdt
-    (
-        IOobject
-        (
-            "dpdt",
-            runTime.timeName(),
-            mesh
-        ),
+        "rho",
+        runTime.timeName(),
         mesh,
-        dimensionedScalar("dpdt", p.dimensions()/dimTime, 0)
-    );
+        IOobject::NO_READ,
+        IOobject::AUTO_WRITE
+    ),
+    thermo.rho()
+);
 
-    Info<< "Creating field kinetic energy K\n" << endl;
-    volScalarField K("K", 0.5*magSqr(U));
+volScalarField& p = thermo.p();
+const volScalarField& T = thermo.T();
+const volScalarField& psi = thermo.psi();
 
-
-    #include "readGravitationalAcceleration.H"
-    #include "readhRef.H"
-    #include "gh.H"
-
-
-    volScalarField p_rgh
+Info<< "\nReading field U\n" << endl;
+volVectorField U
+(
+    IOobject
     (
-        IOobject
-        (
-            "p_rgh",
-            runTime.timeName(),
-            mesh,
-            IOobject::MUST_READ,
-            IOobject::AUTO_WRITE
-        ),
-        mesh
-    );
-
-    // Force p_rgh to be consistent with p
-    p_rgh = p - rho*gh;
-
-    multivariateSurfaceInterpolationScheme<scalar>::fieldTable fields;
-
-    forAll(Y, i)
-    {
-        fields.add(Y[i]);
-    }
-    fields.add(thermo.he());
-
-    IOdictionary additionalControlsDict
-    (
-        IOobject
-        (
-            "additionalControls",
-            runTime.constant(),
-            mesh,
-            IOobject::MUST_READ_IF_MODIFIED,
-            IOobject::NO_WRITE
-        )
-    );
-
-    Switch solvePrimaryRegion
-    (
-        additionalControlsDict.lookup("solvePrimaryRegion")
-    );
-
-    volScalarField dQ
-    (
-        IOobject
-        (
-            "dQ",
-            runTime.timeName(),
-            mesh,
-            IOobject::NO_READ,
-            IOobject::AUTO_WRITE
-        ),
+        "U",
+        runTime.timeName(),
         mesh,
-        dimensionedScalar("dQ", dimEnergy/dimTime, 0.0)
-    );
+        IOobject::MUST_READ,
+        IOobject::AUTO_WRITE
+    ),
+    mesh
+);
+
+#include "compressibleCreatePhi.H"
+
+Info<< "Creating turbulence model\n" << endl;
+autoPtr<compressible::turbulenceModel> turbulence
+(
+    compressible::turbulenceModel::New
+    (
+        rho,
+        U,
+        phi,
+        thermo
+    )
+);
+
+// Set the turbulence into the combustion model
+combustion->setTurbulence(turbulence());
+
+Info<< "Creating field dpdt\n" << endl;
+volScalarField dpdt
+(
+    IOobject
+    (
+        "dpdt",
+        runTime.timeName(),
+        mesh
+    ),
+    mesh,
+    dimensionedScalar("dpdt", p.dimensions()/dimTime, 0)
+);
+
+Info<< "Creating field kinetic energy K\n" << endl;
+volScalarField K("K", 0.5*magSqr(U));
+
+
+#include "readGravitationalAcceleration.H"
+#include "readhRef.H"
+#include "gh.H"
+
+
+volScalarField p_rgh
+(
+    IOobject
+    (
+        "p_rgh",
+        runTime.timeName(),
+        mesh,
+        IOobject::MUST_READ,
+        IOobject::AUTO_WRITE
+    ),
+    mesh
+);
+
+// Force p_rgh to be consistent with p
+p_rgh = p - rho*gh;
+
+mesh.setFluxRequired(p_rgh.name());
+
+multivariateSurfaceInterpolationScheme<scalar>::fieldTable fields;
+
+forAll(Y, i)
+{
+    fields.add(Y[i]);
+}
+fields.add(thermo.he());
+
+IOdictionary additionalControlsDict
+(
+    IOobject
+    (
+        "additionalControls",
+        runTime.constant(),
+        mesh,
+        IOobject::MUST_READ_IF_MODIFIED,
+        IOobject::NO_WRITE
+    )
+);
+
+Switch solvePrimaryRegion
+(
+    additionalControlsDict.lookup("solvePrimaryRegion")
+);
+
+volScalarField dQ
+(
+    IOobject
+    (
+        "dQ",
+        runTime.timeName(),
+        mesh,
+        IOobject::NO_READ,
+        IOobject::AUTO_WRITE
+    ),
+    mesh,
+    dimensionedScalar("dQ", dimEnergy/dimTime, 0.0)
+);
diff --git a/applications/solvers/lagrangian/reactingParcelFoam/createFields.H b/applications/solvers/lagrangian/reactingParcelFoam/createFields.H
index 4cb020cdfa..43c3d45e32 100644
--- a/applications/solvers/lagrangian/reactingParcelFoam/createFields.H
+++ b/applications/solvers/lagrangian/reactingParcelFoam/createFields.H
@@ -1,133 +1,135 @@
-    Info<< "Creating combustion model\n" << endl;
+Info<< "Creating combustion model\n" << endl;
 
-    autoPtr<combustionModels::rhoCombustionModel> combustion
+autoPtr<combustionModels::rhoCombustionModel> combustion
+(
+    combustionModels::rhoCombustionModel::New(mesh)
+);
+
+rhoReactionThermo& thermo = combustion->thermo();
+thermo.validate(args.executable(), "h", "e");
+
+SLGThermo slgThermo(mesh, thermo);
+
+basicSpecieMixture& composition = thermo.composition();
+PtrList<volScalarField>& Y = composition.Y();
+
+const word inertSpecie(thermo.lookup("inertSpecie"));
+
+if (!composition.contains(inertSpecie))
+{
+    FatalErrorIn(args.executable())
+        << "Specified inert specie '" << inertSpecie << "' not found in "
+        << "species list. Available species:" << composition.species()
+        << exit(FatalError);
+}
+
+volScalarField& p = thermo.p();
+const volScalarField& T = thermo.T();
+const volScalarField& psi = thermo.psi();
+
+volScalarField rho
+(
+    IOobject
     (
-        combustionModels::rhoCombustionModel::New(mesh)
-    );
+        "rho",
+        runTime.timeName(),
+        mesh,
+        IOobject::NO_READ,
+        IOobject::AUTO_WRITE
+    ),
+    thermo.rho()
+);
 
-    rhoReactionThermo& thermo = combustion->thermo();
-    thermo.validate(args.executable(), "h", "e");
-
-    SLGThermo slgThermo(mesh, thermo);
-
-    basicSpecieMixture& composition = thermo.composition();
-    PtrList<volScalarField>& Y = composition.Y();
-
-    const word inertSpecie(thermo.lookup("inertSpecie"));
-
-    if (!composition.contains(inertSpecie))
-    {
-        FatalErrorIn(args.executable())
-            << "Specified inert specie '" << inertSpecie << "' not found in "
-            << "species list. Available species:" << composition.species()
-            << exit(FatalError);
-    }
-
-    volScalarField& p = thermo.p();
-    const volScalarField& T = thermo.T();
-    const volScalarField& psi = thermo.psi();
-
-    volScalarField rho
+Info<< "\nReading field U\n" << endl;
+volVectorField U
+(
+    IOobject
     (
-        IOobject
-        (
-            "rho",
-            runTime.timeName(),
-            mesh,
-            IOobject::NO_READ,
-            IOobject::AUTO_WRITE
-        ),
-        thermo.rho()
-    );
+        "U",
+        runTime.timeName(),
+        mesh,
+        IOobject::MUST_READ,
+        IOobject::AUTO_WRITE
+    ),
+    mesh
+);
 
-    Info<< "\nReading field U\n" << endl;
-    volVectorField U
+#include "compressibleCreatePhi.H"
+
+mesh.setFluxRequired(p.name());
+
+dimensionedScalar rhoMax
+(
+    dimensionedScalar::lookupOrDefault
     (
-        IOobject
-        (
-            "U",
-            runTime.timeName(),
-            mesh,
-            IOobject::MUST_READ,
-            IOobject::AUTO_WRITE
-        ),
+        "rhoMax",
+        pimple.dict(),
+        GREAT,
+        dimDensity
+    )
+);
+
+dimensionedScalar rhoMin
+(
+    dimensionedScalar::lookupOrDefault
+    (
+        "rhoMin",
+        pimple.dict(),
+        0,
+        dimDensity
+    )
+);
+
+Info<< "Creating turbulence model\n" << endl;
+autoPtr<compressible::turbulenceModel> turbulence
+(
+    compressible::turbulenceModel::New
+    (
+        rho,
+        U,
+        phi,
+        thermo
+    )
+);
+
+// Set the turbulence into the combustion model
+combustion->setTurbulence(turbulence());
+
+Info<< "Creating field dpdt\n" << endl;
+volScalarField dpdt
+(
+    IOobject
+    (
+        "dpdt",
+        runTime.timeName(),
         mesh
-    );
+    ),
+    mesh,
+    dimensionedScalar("dpdt", p.dimensions()/dimTime, 0)
+);
 
-    #include "compressibleCreatePhi.H"
+Info<< "Creating field kinetic energy K\n" << endl;
+volScalarField K("K", 0.5*magSqr(U));
 
-    dimensionedScalar rhoMax
+Info<< "Creating multi-variate interpolation scheme\n" << endl;
+multivariateSurfaceInterpolationScheme<scalar>::fieldTable fields;
+
+forAll(Y, i)
+{
+    fields.add(Y[i]);
+}
+fields.add(thermo.he());
+
+volScalarField dQ
+(
+    IOobject
     (
-        dimensionedScalar::lookupOrDefault
-        (
-            "rhoMax",
-            pimple.dict(),
-            GREAT,
-            dimDensity
-        )
-    );
-
-    dimensionedScalar rhoMin
-    (
-        dimensionedScalar::lookupOrDefault
-        (
-            "rhoMin",
-            pimple.dict(),
-            0,
-            dimDensity
-        )
-    );
-
-    Info<< "Creating turbulence model\n" << endl;
-    autoPtr<compressible::turbulenceModel> turbulence
-    (
-        compressible::turbulenceModel::New
-        (
-            rho,
-            U,
-            phi,
-            thermo
-        )
-    );
-
-    // Set the turbulence into the combustion model
-    combustion->setTurbulence(turbulence());
-
-    Info<< "Creating field dpdt\n" << endl;
-    volScalarField dpdt
-    (
-        IOobject
-        (
-            "dpdt",
-            runTime.timeName(),
-            mesh
-        ),
+        "dQ",
+        runTime.timeName(),
         mesh,
-        dimensionedScalar("dpdt", p.dimensions()/dimTime, 0)
-    );
-
-    Info<< "Creating field kinetic energy K\n" << endl;
-    volScalarField K("K", 0.5*magSqr(U));
-
-    Info<< "Creating multi-variate interpolation scheme\n" << endl;
-    multivariateSurfaceInterpolationScheme<scalar>::fieldTable fields;
-
-    forAll(Y, i)
-    {
-        fields.add(Y[i]);
-    }
-    fields.add(thermo.he());
-
-    volScalarField dQ
-    (
-        IOobject
-        (
-            "dQ",
-            runTime.timeName(),
-            mesh,
-            IOobject::NO_READ,
-            IOobject::AUTO_WRITE
-        ),
-        mesh,
-        dimensionedScalar("dQ", dimEnergy/dimTime, 0.0)
-    );
+        IOobject::NO_READ,
+        IOobject::AUTO_WRITE
+    ),
+    mesh,
+    dimensionedScalar("dQ", dimEnergy/dimTime, 0.0)
+);
diff --git a/applications/solvers/lagrangian/reactingParcelFoam/simpleReactingParcelFoam/createFields.H b/applications/solvers/lagrangian/reactingParcelFoam/simpleReactingParcelFoam/createFields.H
index 541833ad10..7e79f9fb7d 100644
--- a/applications/solvers/lagrangian/reactingParcelFoam/simpleReactingParcelFoam/createFields.H
+++ b/applications/solvers/lagrangian/reactingParcelFoam/simpleReactingParcelFoam/createFields.H
@@ -1,118 +1,119 @@
-    Info<< "Creating combustion model\n" << endl;
+Info<< "Creating combustion model\n" << endl;
 
-    autoPtr<combustionModels::rhoCombustionModel> combustion
+autoPtr<combustionModels::rhoCombustionModel> combustion
+(
+    combustionModels::rhoCombustionModel::New(mesh)
+);
+
+rhoReactionThermo& thermo = combustion->thermo();
+thermo.validate(args.executable(), "h", "e");
+
+SLGThermo slgThermo(mesh, thermo);
+
+basicSpecieMixture& composition = thermo.composition();
+PtrList<volScalarField>& Y = composition.Y();
+
+const word inertSpecie(thermo.lookup("inertSpecie"));
+
+if (!composition.contains(inertSpecie))
+{
+    FatalErrorIn(args.executable())
+        << "Specified inert specie '" << inertSpecie << "' not found in "
+        << "species list. Available species:" << composition.species()
+        << exit(FatalError);
+}
+
+volScalarField& p = thermo.p();
+const volScalarField& T = thermo.T();
+const volScalarField& psi = thermo.psi();
+
+volScalarField rho
+(
+    IOobject
     (
-        combustionModels::rhoCombustionModel::New(mesh)
-    );
-
-    rhoReactionThermo& thermo = combustion->thermo();
-    thermo.validate(args.executable(), "h", "e");
-
-    SLGThermo slgThermo(mesh, thermo);
-
-    basicSpecieMixture& composition = thermo.composition();
-    PtrList<volScalarField>& Y = composition.Y();
-
-    const word inertSpecie(thermo.lookup("inertSpecie"));
-
-    if (!composition.contains(inertSpecie))
-    {
-        FatalErrorIn(args.executable())
-            << "Specified inert specie '" << inertSpecie << "' not found in "
-            << "species list. Available species:" << composition.species()
-            << exit(FatalError);
-    }
-
-    volScalarField& p = thermo.p();
-    const volScalarField& T = thermo.T();
-    const volScalarField& psi = thermo.psi();
-
-    volScalarField rho
-    (
-        IOobject
-        (
-            "rho",
-            runTime.timeName(),
-            mesh,
-            IOobject::NO_READ,
-            IOobject::AUTO_WRITE
-        ),
-        thermo.rho()
-    );
-
-    Info<< "\nReading field U\n" << endl;
-    volVectorField U
-    (
-        IOobject
-        (
-            "U",
-            runTime.timeName(),
-            mesh,
-            IOobject::MUST_READ,
-            IOobject::AUTO_WRITE
-        ),
-        mesh
-    );
-
-    #include "compressibleCreatePhi.H"
-
-
-    dimensionedScalar rhoMax
-    (
-        dimensionedScalar::lookupOrDefault
-        (
-            "rhoMax",
-            simple.dict(),
-            GREAT,
-            dimDensity
-        )
-    );
-
-    dimensionedScalar rhoMin
-    (
-        dimensionedScalar::lookupOrDefault
-        (
-            "rhoMin",
-            simple.dict(),
-            0,
-            dimDensity
-        )
-    );
-
-    Info<< "Creating turbulence model\n" << endl;
-    autoPtr<compressible::turbulenceModel> turbulence
-    (
-        compressible::turbulenceModel::New
-        (
-            rho,
-            U,
-            phi,
-            thermo
-        )
-    );
-
-    // Set the turbulence into the combustion model
-    combustion->setTurbulence(turbulence());
-
-    Info<< "Creating multi-variate interpolation scheme\n" << endl;
-    multivariateSurfaceInterpolationScheme<scalar>::fieldTable fields;
-
-    forAll(Y, i)
-    {
-        fields.add(Y[i]);
-    }
-    fields.add(thermo.he());
-
-    volScalarField dQ
-    (
-        IOobject
-        (
-            "dQ",
-            runTime.timeName(),
-            mesh,
-            IOobject::NO_READ,
-            IOobject::AUTO_WRITE
-        ),
+        "rho",
+        runTime.timeName(),
         mesh,
-        dimensionedScalar("dQ", dimEnergy/dimTime, 0.0)
-    );
+        IOobject::NO_READ,
+        IOobject::AUTO_WRITE
+    ),
+    thermo.rho()
+);
+
+Info<< "\nReading field U\n" << endl;
+volVectorField U
+(
+    IOobject
+    (
+        "U",
+        runTime.timeName(),
+        mesh,
+        IOobject::MUST_READ,
+        IOobject::AUTO_WRITE
+    ),
+    mesh
+);
+
+#include "compressibleCreatePhi.H"
+
+mesh.setFluxRequired(p.name());
+
+dimensionedScalar rhoMax
+(
+    dimensionedScalar::lookupOrDefault
+    (
+        "rhoMax",
+        simple.dict(),
+        GREAT,
+        dimDensity
+    )
+);
+
+dimensionedScalar rhoMin
+(
+    dimensionedScalar::lookupOrDefault
+    (
+        "rhoMin",
+        simple.dict(),
+        0,
+        dimDensity
+    )
+);
+
+Info<< "Creating turbulence model\n" << endl;
+autoPtr<compressible::turbulenceModel> turbulence
+(
+    compressible::turbulenceModel::New
+    (
+        rho,
+        U,
+        phi,
+        thermo
+    )
+);
+
+// Set the turbulence into the combustion model
+combustion->setTurbulence(turbulence());
+
+Info<< "Creating multi-variate interpolation scheme\n" << endl;
+multivariateSurfaceInterpolationScheme<scalar>::fieldTable fields;
+
+forAll(Y, i)
+{
+    fields.add(Y[i]);
+}
+fields.add(thermo.he());
+
+volScalarField dQ
+(
+    IOobject
+    (
+        "dQ",
+        runTime.timeName(),
+        mesh,
+        IOobject::NO_READ,
+        IOobject::AUTO_WRITE
+    ),
+    mesh,
+    dimensionedScalar("dQ", dimEnergy/dimTime, 0.0)
+);
diff --git a/applications/solvers/lagrangian/sprayFoam/createFields.H b/applications/solvers/lagrangian/sprayFoam/createFields.H
index 0ad541a3fa..721c3f8319 100644
--- a/applications/solvers/lagrangian/sprayFoam/createFields.H
+++ b/applications/solvers/lagrangian/sprayFoam/createFields.H
@@ -1,131 +1,133 @@
-    Info<< "Creating combustion model\n" << endl;
+Info<< "Creating combustion model\n" << endl;
 
-    autoPtr<combustionModels::psiCombustionModel> combustion
+autoPtr<combustionModels::psiCombustionModel> combustion
+(
+    combustionModels::psiCombustionModel::New(mesh)
+);
+
+psiReactionThermo& thermo = combustion->thermo();
+thermo.validate(args.executable(), "h", "e");
+
+SLGThermo slgThermo(mesh, thermo);
+
+basicSpecieMixture& composition = thermo.composition();
+PtrList<volScalarField>& Y = composition.Y();
+
+const word inertSpecie(thermo.lookup("inertSpecie"));
+
+if (!composition.contains(inertSpecie))
+{
+    FatalErrorIn(args.executable())
+        << "Specified inert specie '" << inertSpecie << "' not found in "
+        << "species list. Available species:" << composition.species()
+        << exit(FatalError);
+}
+
+volScalarField& p = thermo.p();
+const volScalarField& T = thermo.T();
+const volScalarField& psi = thermo.psi();
+
+volScalarField rho
+(
+    IOobject
     (
-        combustionModels::psiCombustionModel::New(mesh)
-    );
+        "rho",
+        runTime.timeName(),
+        mesh,
+        IOobject::READ_IF_PRESENT,
+        IOobject::AUTO_WRITE
+    ),
+    thermo.rho()
+);
 
-    psiReactionThermo& thermo = combustion->thermo();
-    thermo.validate(args.executable(), "h", "e");
-
-    SLGThermo slgThermo(mesh, thermo);
-
-    basicSpecieMixture& composition = thermo.composition();
-    PtrList<volScalarField>& Y = composition.Y();
-
-    const word inertSpecie(thermo.lookup("inertSpecie"));
-
-    if (!composition.contains(inertSpecie))
-    {
-        FatalErrorIn(args.executable())
-            << "Specified inert specie '" << inertSpecie << "' not found in "
-            << "species list. Available species:" << composition.species()
-            << exit(FatalError);
-    }
-
-    volScalarField& p = thermo.p();
-    const volScalarField& T = thermo.T();
-    const volScalarField& psi = thermo.psi();
-
-    volScalarField rho
+Info<< "\nReading field U\n" << endl;
+volVectorField U
+(
+    IOobject
     (
-        IOobject
-        (
-            "rho",
-            runTime.timeName(),
-            mesh,
-            IOobject::READ_IF_PRESENT,
-            IOobject::AUTO_WRITE
-        ),
-        thermo.rho()
-    );
+        "U",
+        runTime.timeName(),
+        mesh,
+        IOobject::MUST_READ,
+        IOobject::AUTO_WRITE
+    ),
+    mesh
+);
 
-    Info<< "\nReading field U\n" << endl;
-    volVectorField U
+#include "compressibleCreatePhi.H"
+
+mesh.setFluxRequired(p.name());
+
+dimensionedScalar rhoMax
+(
+    dimensionedScalar::lookupOrDefault
     (
-        IOobject
-        (
-            "U",
-            runTime.timeName(),
-            mesh,
-            IOobject::MUST_READ,
-            IOobject::AUTO_WRITE
-        ),
+        "rhoMax",
+        pimple.dict(),
+        GREAT,
+        dimDensity
+    )
+);
+
+dimensionedScalar rhoMin
+(
+    dimensionedScalar::lookupOrDefault
+    (
+        "rhoMin",
+        pimple.dict(),
+        0,
+        dimDensity
+    )
+);
+
+Info<< "Creating turbulence model\n" << endl;
+autoPtr<compressible::turbulenceModel> turbulence
+(
+    compressible::turbulenceModel::New
+    (
+        rho,
+        U,
+        phi,
+        thermo
+    )
+);
+
+// Set the turbulence into the combustion model
+combustion->setTurbulence(turbulence());
+
+Info<< "Creating field dpdt\n" << endl;
+volScalarField dpdt
+(
+    IOobject
+    (
+        "dpdt",
+        runTime.timeName(),
         mesh
-    );
+    ),
+    mesh,
+    dimensionedScalar("dpdt", p.dimensions()/dimTime, 0)
+);
 
-    #include "compressibleCreatePhi.H"
+Info<< "Creating field kinetic energy K\n" << endl;
+volScalarField K("K", 0.5*magSqr(U));
+multivariateSurfaceInterpolationScheme<scalar>::fieldTable fields;
 
-    dimensionedScalar rhoMax
+forAll(Y, i)
+{
+    fields.add(Y[i]);
+}
+fields.add(thermo.he());
+
+volScalarField dQ
+(
+    IOobject
     (
-        dimensionedScalar::lookupOrDefault
-        (
-            "rhoMax",
-            pimple.dict(),
-            GREAT,
-            dimDensity
-        )
-    );
-
-    dimensionedScalar rhoMin
-    (
-        dimensionedScalar::lookupOrDefault
-        (
-            "rhoMin",
-            pimple.dict(),
-            0,
-            dimDensity
-        )
-    );
-
-    Info<< "Creating turbulence model\n" << endl;
-    autoPtr<compressible::turbulenceModel> turbulence
-    (
-        compressible::turbulenceModel::New
-        (
-            rho,
-            U,
-            phi,
-            thermo
-        )
-    );
-
-    // Set the turbulence into the combustion model
-    combustion->setTurbulence(turbulence());
-
-    Info<< "Creating field dpdt\n" << endl;
-    volScalarField dpdt
-    (
-        IOobject
-        (
-            "dpdt",
-            runTime.timeName(),
-            mesh
-        ),
+        "dQ",
+        runTime.timeName(),
         mesh,
-        dimensionedScalar("dpdt", p.dimensions()/dimTime, 0)
-    );
-
-    Info<< "Creating field kinetic energy K\n" << endl;
-    volScalarField K("K", 0.5*magSqr(U));
-    multivariateSurfaceInterpolationScheme<scalar>::fieldTable fields;
-
-    forAll(Y, i)
-    {
-        fields.add(Y[i]);
-    }
-    fields.add(thermo.he());
-
-    volScalarField dQ
-    (
-        IOobject
-        (
-            "dQ",
-            runTime.timeName(),
-            mesh,
-            IOobject::NO_READ,
-            IOobject::AUTO_WRITE
-        ),
-        mesh,
-        dimensionedScalar("dQ", dimEnergy/dimTime, 0.0)
-    );
+        IOobject::NO_READ,
+        IOobject::AUTO_WRITE
+    ),
+    mesh,
+    dimensionedScalar("dQ", dimEnergy/dimTime, 0.0)
+);
diff --git a/applications/solvers/multiphase/cavitatingFoam/cavitatingDyMFoam/correctPhi.H b/applications/solvers/multiphase/cavitatingFoam/cavitatingDyMFoam/correctPhi.H
index c31b07ecc6..62f83226bc 100644
--- a/applications/solvers/multiphase/cavitatingFoam/cavitatingDyMFoam/correctPhi.H
+++ b/applications/solvers/multiphase/cavitatingFoam/cavitatingDyMFoam/correctPhi.H
@@ -19,6 +19,8 @@ correctUphiBCs(U, phi);
     surfaceScalarField rhof(fvc::interpolate(rho, "div(phi,rho)"));
     dimensionedScalar rAUf("rAUf", dimTime, 1.0);
 
+    mesh.setFluxRequired(pcorr.name());
+
     while (pimple.correctNonOrthogonal())
     {
         fvScalarMatrix pcorrEqn
diff --git a/applications/solvers/multiphase/cavitatingFoam/createFields.H b/applications/solvers/multiphase/cavitatingFoam/createFields.H
index 3c28de16c5..f124d8972c 100644
--- a/applications/solvers/multiphase/cavitatingFoam/createFields.H
+++ b/applications/solvers/multiphase/cavitatingFoam/createFields.H
@@ -1,89 +1,94 @@
-    Info<< "Reading field p\n" << endl;
-    volScalarField p
+Info<< "Reading field p\n" << endl;
+volScalarField p
+(
+    IOobject
     (
-        IOobject
-        (
-            "p",
-            runTime.timeName(),
-            mesh,
-            IOobject::MUST_READ,
-            IOobject::AUTO_WRITE
-        ),
-        mesh
+        "p",
+        runTime.timeName(),
+        mesh,
+        IOobject::MUST_READ,
+        IOobject::AUTO_WRITE
+    ),
+    mesh
+);
+
+volScalarField rho
+(
+    IOobject
+    (
+        "rho",
+        runTime.timeName(),
+        mesh,
+        IOobject::MUST_READ,
+        IOobject::AUTO_WRITE
+    ),
+    mesh
+);
+
+Info<< "Reading field U\n" << endl;
+volVectorField U
+(
+    IOobject
+    (
+        "U",
+        runTime.timeName(),
+        mesh,
+        IOobject::MUST_READ,
+        IOobject::AUTO_WRITE
+    ),
+    mesh
+);
+
+#include "createPhi.H"
+
+mesh.setFluxRequired(p.name());
+
+// Mass flux (corrected by rhoEqn.H)
+surfaceScalarField rhoPhi
+(
+    IOobject
+    (
+        "rhoPhi",
+        runTime.timeName(),
+        mesh,
+        IOobject::NO_READ,
+        IOobject::NO_WRITE
+    ),
+    fvc::interpolate(rho)*phi
+);
+
+Info<< "Reading transportProperties\n" << endl;
+
+incompressibleTwoPhaseMixture mixture(U, phi);
+
+volScalarField& alphav(mixture.alpha1());
+alphav.oldTime();
+
+volScalarField& alphal(mixture.alpha2());
+
+Info<< "Creating compressibilityModel\n" << endl;
+autoPtr<barotropicCompressibilityModel> psiModel =
+    barotropicCompressibilityModel::New
+    (
+        thermodynamicProperties,
+        alphav
     );
 
-    volScalarField rho
-    (
-        IOobject
-        (
-            "rho",
-            runTime.timeName(),
-            mesh,
-            IOobject::MUST_READ,
-            IOobject::AUTO_WRITE
-        ),
-        mesh
-    );
+const volScalarField& psi = psiModel->psi();
 
-    Info<< "Reading field U\n" << endl;
-    volVectorField U
-    (
-        IOobject
-        (
-            "U",
-            runTime.timeName(),
-            mesh,
-            IOobject::MUST_READ,
-            IOobject::AUTO_WRITE
-        ),
-        mesh
-    );
+rho == max
+(
+    psi*p
+  + alphal*rhol0
+  + ((alphav*psiv + alphal*psil) - psi)*pSat,
+    rhoMin
+);
 
-    #include "createPhi.H"
+mesh.setFluxRequired(p.name());
+mesh.setFluxRequired(rho.name());
 
-    // Mass flux (corrected by rhoEqn.H)
-    surfaceScalarField rhoPhi
-    (
-        IOobject
-        (
-            "rhoPhi",
-            runTime.timeName(),
-            mesh,
-            IOobject::NO_READ,
-            IOobject::NO_WRITE
-        ),
-        fvc::interpolate(rho)*phi
-    );
-
-    Info<< "Reading transportProperties\n" << endl;
-
-    incompressibleTwoPhaseMixture mixture(U, phi);
-
-    volScalarField& alphav(mixture.alpha1());
-    alphav.oldTime();
-
-    volScalarField& alphal(mixture.alpha2());
-
-    Info<< "Creating compressibilityModel\n" << endl;
-    autoPtr<barotropicCompressibilityModel> psiModel =
-        barotropicCompressibilityModel::New
-        (
-            thermodynamicProperties,
-            alphav
-        );
-
-    const volScalarField& psi = psiModel->psi();
-
-    rho == max
-    (
-        psi*p
-      + alphal*rhol0
-      + ((alphav*psiv + alphal*psil) - psi)*pSat,
-        rhoMin
-    );
-
-    // Create incompressible turbulence model
-    autoPtr<incompressible::turbulenceModel> turbulence
-    (
-        incompressible::turbulenceModel::New(U, phi, mixture)
-    );
+// Create incompressible turbulence model
+autoPtr<incompressible::turbulenceModel> turbulence
+(
+    incompressible::turbulenceModel::New(U, phi, mixture)
+);
diff --git a/applications/solvers/multiphase/compressibleInterFoam/createFields.H b/applications/solvers/multiphase/compressibleInterFoam/createFields.H
index fecec7a80d..181160c510 100644
--- a/applications/solvers/multiphase/compressibleInterFoam/createFields.H
+++ b/applications/solvers/multiphase/compressibleInterFoam/createFields.H
@@ -1,104 +1,106 @@
-    Info<< "Reading field p_rgh\n" << endl;
-    volScalarField p_rgh
+Info<< "Reading field p_rgh\n" << endl;
+volScalarField p_rgh
+(
+    IOobject
     (
-        IOobject
-        (
-            "p_rgh",
-            runTime.timeName(),
-            mesh,
-            IOobject::MUST_READ,
-            IOobject::AUTO_WRITE
-        ),
-        mesh
-    );
+        "p_rgh",
+        runTime.timeName(),
+        mesh,
+        IOobject::MUST_READ,
+        IOobject::AUTO_WRITE
+    ),
+    mesh
+);
 
-    Info<< "Reading field U\n" << endl;
-    volVectorField U
+Info<< "Reading field U\n" << endl;
+volVectorField U
+(
+    IOobject
     (
-        IOobject
-        (
-            "U",
-            runTime.timeName(),
-            mesh,
-            IOobject::MUST_READ,
-            IOobject::AUTO_WRITE
-        ),
-        mesh
-    );
+        "U",
+        runTime.timeName(),
+        mesh,
+        IOobject::MUST_READ,
+        IOobject::AUTO_WRITE
+    ),
+    mesh
+);
 
-    #include "createPhi.H"
+#include "createPhi.H"
 
-    Info<< "Constructing twoPhaseMixtureThermo\n" << endl;
-    twoPhaseMixtureThermo mixture(mesh);
+Info<< "Constructing twoPhaseMixtureThermo\n" << endl;
+twoPhaseMixtureThermo mixture(mesh);
 
-    volScalarField& alpha1(mixture.alpha1());
-    volScalarField& alpha2(mixture.alpha2());
+volScalarField& alpha1(mixture.alpha1());
+volScalarField& alpha2(mixture.alpha2());
 
-    Info<< "Reading thermophysical properties\n" << endl;
+Info<< "Reading thermophysical properties\n" << endl;
 
-    volScalarField& p = mixture.p();
-    volScalarField& T = mixture.T();
-    volScalarField& rho1 = mixture.thermo1().rho();
-    const volScalarField& psi1 = mixture.thermo1().psi();
-    volScalarField& rho2 = mixture.thermo2().rho();
-    const volScalarField& psi2 = mixture.thermo2().psi();
+volScalarField& p = mixture.p();
+volScalarField& T = mixture.T();
+volScalarField& rho1 = mixture.thermo1().rho();
+const volScalarField& psi1 = mixture.thermo1().psi();
+volScalarField& rho2 = mixture.thermo2().rho();
+const volScalarField& psi2 = mixture.thermo2().psi();
 
-    volScalarField rho
+volScalarField rho
+(
+    IOobject
     (
-        IOobject
-        (
-            "rho",
-            runTime.timeName(),
-            mesh,
-            IOobject::READ_IF_PRESENT,
-            IOobject::AUTO_WRITE
-        ),
-        alpha1*rho1 + alpha2*rho2
-    );
+        "rho",
+        runTime.timeName(),
+        mesh,
+        IOobject::READ_IF_PRESENT,
+        IOobject::AUTO_WRITE
+    ),
+    alpha1*rho1 + alpha2*rho2
+);
 
 
-    dimensionedScalar pMin
+dimensionedScalar pMin
+(
+    "pMin",
+    dimPressure,
+    mixture.lookup("pMin")
+);
+
+mesh.setFluxRequired(p_rgh.name());
+
+
+#include "readGravitationalAcceleration.H"
+#include "readhRef.H"
+#include "gh.H"
+
+
+// Mass flux
+// Initialisation does not matter because rhoPhi is reset after the
+// alpha1 solution before it is used in the U equation.
+surfaceScalarField rhoPhi
+(
+    IOobject
     (
-        "pMin",
-        dimPressure,
-        mixture.lookup("pMin")
-    );
+        "rhoPhi",
+        runTime.timeName(),
+        mesh,
+        IOobject::NO_READ,
+        IOobject::NO_WRITE
+    ),
+    fvc::interpolate(rho)*phi
+);
 
+volScalarField dgdt
+(
+    pos(alpha2)*fvc::div(phi)/max(alpha2, scalar(0.0001))
+);
 
-    #include "readGravitationalAcceleration.H"
-    #include "readhRef.H"
-    #include "gh.H"
+// Construct interface from alpha1 distribution
+interfaceProperties interface(alpha1, U, mixture);
 
+// Construct compressible turbulence model
+autoPtr<compressible::turbulenceModel> turbulence
+(
+    compressible::turbulenceModel::New(rho, U, rhoPhi, mixture)
+);
 
-    // Mass flux
-    // Initialisation does not matter because rhoPhi is reset after the
-    // alpha1 solution before it is used in the U equation.
-    surfaceScalarField rhoPhi
-    (
-        IOobject
-        (
-            "rhoPhi",
-            runTime.timeName(),
-            mesh,
-            IOobject::NO_READ,
-            IOobject::NO_WRITE
-        ),
-        fvc::interpolate(rho)*phi
-    );
-
-    volScalarField dgdt
-    (
-        pos(alpha2)*fvc::div(phi)/max(alpha2, scalar(0.0001))
-    );
-
-    // Construct interface from alpha1 distribution
-    interfaceProperties interface(alpha1, U, mixture);
-
-    // Construct compressible turbulence model
-    autoPtr<compressible::turbulenceModel> turbulence
-    (
-        compressible::turbulenceModel::New(rho, U, rhoPhi, mixture)
-    );
-
-    Info<< "Creating field kinetic energy K\n" << endl;
-    volScalarField K("K", 0.5*magSqr(U));
+Info<< "Creating field kinetic energy K\n" << endl;
+volScalarField K("K", 0.5*magSqr(U));
diff --git a/applications/solvers/multiphase/compressibleMultiphaseInterFoam/createFields.H b/applications/solvers/multiphase/compressibleMultiphaseInterFoam/createFields.H
index d281df81e9..ce0faac571 100644
--- a/applications/solvers/multiphase/compressibleMultiphaseInterFoam/createFields.H
+++ b/applications/solvers/multiphase/compressibleMultiphaseInterFoam/createFields.H
@@ -1,70 +1,72 @@
-    Info<< "Reading field p_rgh\n" << endl;
-    volScalarField p_rgh
+Info<< "Reading field p_rgh\n" << endl;
+volScalarField p_rgh
+(
+    IOobject
     (
-        IOobject
-        (
-            "p_rgh",
-            runTime.timeName(),
-            mesh,
-            IOobject::MUST_READ,
-            IOobject::AUTO_WRITE
-        ),
-        mesh
-    );
+        "p_rgh",
+        runTime.timeName(),
+        mesh,
+        IOobject::MUST_READ,
+        IOobject::AUTO_WRITE
+    ),
+    mesh
+);
 
-    Info<< "Reading field U\n" << endl;
-    volVectorField U
+Info<< "Reading field U\n" << endl;
+volVectorField U
+(
+    IOobject
     (
-        IOobject
-        (
-            "U",
-            runTime.timeName(),
-            mesh,
-            IOobject::MUST_READ,
-            IOobject::AUTO_WRITE
-        ),
-        mesh
-    );
+        "U",
+        runTime.timeName(),
+        mesh,
+        IOobject::MUST_READ,
+        IOobject::AUTO_WRITE
+    ),
+    mesh
+);
 
-    #include "createPhi.H"
+#include "createPhi.H"
 
-    Info<< "Constructing multiphaseMixtureThermo\n" << endl;
-    multiphaseMixtureThermo mixture(U, phi);
+Info<< "Constructing multiphaseMixtureThermo\n" << endl;
+multiphaseMixtureThermo mixture(U, phi);
 
-    volScalarField& p = mixture.p();
-    volScalarField& T = mixture.T();
+volScalarField& p = mixture.p();
+volScalarField& T = mixture.T();
 
-    volScalarField rho
+volScalarField rho
+(
+    IOobject
     (
-        IOobject
-        (
-            "rho",
-            runTime.timeName(),
-            mesh,
-            IOobject::READ_IF_PRESENT
-        ),
-        mixture.rho()
-    );
+        "rho",
+        runTime.timeName(),
+        mesh,
+        IOobject::READ_IF_PRESENT
+    ),
+    mixture.rho()
+);
 
-    dimensionedScalar pMin(mixture.lookup("pMin"));
+dimensionedScalar pMin(mixture.lookup("pMin"));
+
+mesh.setFluxRequired(p_rgh.name());
 
 
-    #include "readGravitationalAcceleration.H"
-    #include "readhRef.H"
-    #include "gh.H"
+#include "readGravitationalAcceleration.H"
+#include "readhRef.H"
+#include "gh.H"
 
 
-    // Construct compressible turbulence model
-    autoPtr<compressible::turbulenceModel> turbulence
+// Construct compressible turbulence model
+autoPtr<compressible::turbulenceModel> turbulence
+(
+    compressible::turbulenceModel::New
     (
-        compressible::turbulenceModel::New
-        (
-            rho,
-            U,
-            mixture.rhoPhi(),
-            mixture
-        )
-    );
+        rho,
+        U,
+        mixture.rhoPhi(),
+        mixture
+    )
+);
 
-    Info<< "Creating field kinetic energy K\n" << endl;
-    volScalarField K("K", 0.5*magSqr(U));
+Info<< "Creating field kinetic energy K\n" << endl;
+volScalarField K("K", 0.5*magSqr(U));
diff --git a/applications/solvers/multiphase/driftFluxFoam/createFields.H b/applications/solvers/multiphase/driftFluxFoam/createFields.H
index 988aba07b9..d2e8d1d93e 100644
--- a/applications/solvers/multiphase/driftFluxFoam/createFields.H
+++ b/applications/solvers/multiphase/driftFluxFoam/createFields.H
@@ -1,136 +1,138 @@
-    Info<< "Reading field p_rgh\n" << endl;
-    volScalarField p_rgh
+Info<< "Reading field p_rgh\n" << endl;
+volScalarField p_rgh
+(
+    IOobject
     (
-        IOobject
-        (
-            "p_rgh",
-            runTime.timeName(),
-            mesh,
-            IOobject::MUST_READ,
-            IOobject::AUTO_WRITE
-        ),
-        mesh
-    );
+        "p_rgh",
+        runTime.timeName(),
+        mesh,
+        IOobject::MUST_READ,
+        IOobject::AUTO_WRITE
+    ),
+    mesh
+);
 
-    Info<< "Reading field U\n" << endl;
-    volVectorField U
+Info<< "Reading field U\n" << endl;
+volVectorField U
+(
+    IOobject
     (
-        IOobject
-        (
-            "U",
-            runTime.timeName(),
-            mesh,
-            IOobject::MUST_READ,
-            IOobject::AUTO_WRITE
-        ),
-        mesh
-    );
+        "U",
+        runTime.timeName(),
+        mesh,
+        IOobject::MUST_READ,
+        IOobject::AUTO_WRITE
+    ),
+    mesh
+);
 
-    #include "createPhi.H"
+#include "createPhi.H"
 
 
-    Info<< "Reading incompressibleTwoPhaseInteractingMixture\n" << endl;
-    incompressibleTwoPhaseInteractingMixture mixture(U, phi);
+Info<< "Reading incompressibleTwoPhaseInteractingMixture\n" << endl;
+incompressibleTwoPhaseInteractingMixture mixture(U, phi);
 
-    volScalarField& alpha1(mixture.alpha1());
-    volScalarField& alpha2(mixture.alpha2());
+volScalarField& alpha1(mixture.alpha1());
+volScalarField& alpha2(mixture.alpha2());
 
-    const dimensionedScalar& rho1 = mixture.rhod();
-    const dimensionedScalar& rho2 = mixture.rhoc();
+const dimensionedScalar& rho1 = mixture.rhod();
+const dimensionedScalar& rho2 = mixture.rhoc();
 
-    // Mixture density
-    volScalarField rho
+// Mixture density
+volScalarField rho
+(
+    IOobject
     (
-        IOobject
-        (
-            "rho",
-            runTime.timeName(),
-            mesh,
-            IOobject::NO_READ,
-            IOobject::NO_WRITE
-        ),
-        mixture.rho()
-    );
+        "rho",
+        runTime.timeName(),
+        mesh,
+        IOobject::NO_READ,
+        IOobject::NO_WRITE
+    ),
+    mixture.rho()
+);
 
-    // Mass flux
-    surfaceScalarField rhoPhi
+// Mass flux
+surfaceScalarField rhoPhi
+(
+    IOobject
     (
-        IOobject
-        (
-            "rhoPhi",
-            runTime.timeName(),
-            mesh,
-            IOobject::NO_READ,
-            IOobject::NO_WRITE
-        ),
-        fvc::interpolate(rho)*phi
-    );
+        "rhoPhi",
+        runTime.timeName(),
+        mesh,
+        IOobject::NO_READ,
+        IOobject::NO_WRITE
+    ),
+    fvc::interpolate(rho)*phi
+);
 
 
-    // Relative Velocity
-    autoPtr<relativeVelocityModel> UdmModelPtr
+// Relative Velocity
+autoPtr<relativeVelocityModel> UdmModelPtr
+(
+    relativeVelocityModel::New
     (
-        relativeVelocityModel::New
-        (
-            mixture,
-            mixture
-        )
-    );
+        mixture,
+        mixture
+    )
+);
 
-    relativeVelocityModel& UdmModel(UdmModelPtr());
+relativeVelocityModel& UdmModel(UdmModelPtr());
 
 
-    // Construct compressible turbulence model
-    autoPtr
-    <
-        CompressibleTurbulenceModel<incompressibleTwoPhaseInteractingMixture>
-    > turbulence
+// Construct compressible turbulence model
+autoPtr
+<
+    CompressibleTurbulenceModel<incompressibleTwoPhaseInteractingMixture>
+> turbulence
+(
+    CompressibleTurbulenceModel<incompressibleTwoPhaseInteractingMixture>
+    ::New(rho, U, rhoPhi, mixture)
+);
+
+
+#include "readGravitationalAcceleration.H"
+#include "readhRef.H"
+#include "gh.H"
+
+
+volScalarField p
+(
+    IOobject
     (
-        CompressibleTurbulenceModel<incompressibleTwoPhaseInteractingMixture>
-        ::New(rho, U, rhoPhi, mixture)
-    );
+        "p",
+        runTime.timeName(),
+        mesh,
+        IOobject::NO_READ,
+        IOobject::AUTO_WRITE
+    ),
+    p_rgh + rho*gh
+);
 
+label pRefCell = 0;
+scalar pRefValue = 0.0;
+setRefCell
+(
+    p,
+    p_rgh,
+    pimple.dict(),
+    pRefCell,
+    pRefValue
+);
 
-    #include "readGravitationalAcceleration.H"
-    #include "readhRef.H"
-    #include "gh.H"
-
-
-    volScalarField p
+if (p_rgh.needReference())
+{
+    p += dimensionedScalar
     (
-        IOobject
-        (
-            "p",
-            runTime.timeName(),
-            mesh,
-            IOobject::NO_READ,
-            IOobject::AUTO_WRITE
-        ),
-        p_rgh + rho*gh
+        "p",
+        p.dimensions(),
+        pRefValue - getRefCellValue(p, pRefCell)
     );
+    p_rgh = p - rho*gh;
+}
 
-    label pRefCell = 0;
-    scalar pRefValue = 0.0;
-    setRefCell
-    (
-        p,
-        p_rgh,
-        pimple.dict(),
-        pRefCell,
-        pRefValue
-    );
+mesh.setFluxRequired(p_rgh.name());
+mesh.setFluxRequired(alpha1.name());
 
-    if (p_rgh.needReference())
-    {
-        p += dimensionedScalar
-        (
-            "p",
-            p.dimensions(),
-            pRefValue - getRefCellValue(p, pRefCell)
-        );
-        p_rgh = p - rho*gh;
-    }
-
-
-    // MULES Correction
-    tmp<surfaceScalarField> tphiAlphaCorr0;
+// MULES Correction
+tmp<surfaceScalarField> tphiAlphaCorr0;
diff --git a/applications/solvers/multiphase/interFoam/createFields.H b/applications/solvers/multiphase/interFoam/createFields.H
index 58960256b1..fc682190ce 100644
--- a/applications/solvers/multiphase/interFoam/createFields.H
+++ b/applications/solvers/multiphase/interFoam/createFields.H
@@ -1,135 +1,138 @@
-    Info<< "Reading field p_rgh\n" << endl;
-    volScalarField p_rgh
+Info<< "Reading field p_rgh\n" << endl;
+volScalarField p_rgh
+(
+    IOobject
     (
-        IOobject
-        (
-            "p_rgh",
-            runTime.timeName(),
-            mesh,
-            IOobject::MUST_READ,
-            IOobject::AUTO_WRITE
-        ),
-        mesh
-    );
+        "p_rgh",
+        runTime.timeName(),
+        mesh,
+        IOobject::MUST_READ,
+        IOobject::AUTO_WRITE
+    ),
+    mesh
+);
 
-    Info<< "Reading field U\n" << endl;
-    volVectorField U
+Info<< "Reading field U\n" << endl;
+volVectorField U
+(
+    IOobject
     (
-        IOobject
-        (
-            "U",
-            runTime.timeName(),
-            mesh,
-            IOobject::MUST_READ,
-            IOobject::AUTO_WRITE
-        ),
-        mesh
-    );
+        "U",
+        runTime.timeName(),
+        mesh,
+        IOobject::MUST_READ,
+        IOobject::AUTO_WRITE
+    ),
+    mesh
+);
 
-    #include "createPhi.H"
+#include "createPhi.H"
 
 
-    Info<< "Reading transportProperties\n" << endl;
-    immiscibleIncompressibleTwoPhaseMixture mixture(U, phi);
+Info<< "Reading transportProperties\n" << endl;
+immiscibleIncompressibleTwoPhaseMixture mixture(U, phi);
 
-    volScalarField& alpha1(mixture.alpha1());
-    volScalarField& alpha2(mixture.alpha2());
+volScalarField& alpha1(mixture.alpha1());
+volScalarField& alpha2(mixture.alpha2());
 
-    const dimensionedScalar& rho1 = mixture.rho1();
-    const dimensionedScalar& rho2 = mixture.rho2();
+const dimensionedScalar& rho1 = mixture.rho1();
+const dimensionedScalar& rho2 = mixture.rho2();
 
 
-    // Need to store rho for ddt(rho, U)
-    volScalarField rho
+// Need to store rho for ddt(rho, U)
+volScalarField rho
+(
+    IOobject
     (
-        IOobject
-        (
-            "rho",
-            runTime.timeName(),
-            mesh,
-            IOobject::READ_IF_PRESENT
-        ),
-        alpha1*rho1 + alpha2*rho2,
-        alpha1.boundaryField().types()
-    );
-    rho.oldTime();
+        "rho",
+        runTime.timeName(),
+        mesh,
+        IOobject::READ_IF_PRESENT
+    ),
+    alpha1*rho1 + alpha2*rho2,
+    alpha1.boundaryField().types()
+);
+rho.oldTime();
 
 
-    // Mass flux
-    surfaceScalarField rhoPhi
+// Mass flux
+surfaceScalarField rhoPhi
+(
+    IOobject
     (
-        IOobject
-        (
-            "rhoPhi",
-            runTime.timeName(),
-            mesh,
-            IOobject::NO_READ,
-            IOobject::NO_WRITE
-        ),
-        fvc::interpolate(rho)*phi
-    );
+        "rhoPhi",
+        runTime.timeName(),
+        mesh,
+        IOobject::NO_READ,
+        IOobject::NO_WRITE
+    ),
+    fvc::interpolate(rho)*phi
+);
 
 
-    // Construct incompressible turbulence model
-    autoPtr<incompressible::turbulenceModel> turbulence
+// Construct incompressible turbulence model
+autoPtr<incompressible::turbulenceModel> turbulence
+(
+    incompressible::turbulenceModel::New(U, phi, mixture)
+);
+
+
+#include "readGravitationalAcceleration.H"
+#include "readhRef.H"
+#include "gh.H"
+
+
+volScalarField p
+(
+    IOobject
     (
-        incompressible::turbulenceModel::New(U, phi, mixture)
-    );
+        "p",
+        runTime.timeName(),
+        mesh,
+        IOobject::NO_READ,
+        IOobject::AUTO_WRITE
+    ),
+    p_rgh + rho*gh
+);
 
+label pRefCell = 0;
+scalar pRefValue = 0.0;
+setRefCell
+(
+    p,
+    p_rgh,
+    pimple.dict(),
+    pRefCell,
+    pRefValue
+);
 
-    #include "readGravitationalAcceleration.H"
-    #include "readhRef.H"
-    #include "gh.H"
-
-
-    volScalarField p
+if (p_rgh.needReference())
+{
+    p += dimensionedScalar
     (
-        IOobject
-        (
-            "p",
-            runTime.timeName(),
-            mesh,
-            IOobject::NO_READ,
-            IOobject::AUTO_WRITE
-        ),
-        p_rgh + rho*gh
+        "p",
+        p.dimensions(),
+        pRefValue - getRefCellValue(p, pRefCell)
     );
+    p_rgh = p - rho*gh;
+}
 
-    label pRefCell = 0;
-    scalar pRefValue = 0.0;
-    setRefCell
+mesh.setFluxRequired(p_rgh.name());
+mesh.setFluxRequired(alpha1.name());
+
+// MULES flux from previous time-step
+surfaceScalarField phiAlpha
+(
+    IOobject
     (
-        p,
-        p_rgh,
-        pimple.dict(),
-        pRefCell,
-        pRefValue
-    );
+        "phiAlpha",
+        runTime.timeName(),
+        mesh,
+        IOobject::READ_IF_PRESENT,
+        IOobject::AUTO_WRITE
+    ),
+    phi*fvc::interpolate(alpha1)
+);
 
-    if (p_rgh.needReference())
-    {
-        p += dimensionedScalar
-        (
-            "p",
-            p.dimensions(),
-            pRefValue - getRefCellValue(p, pRefCell)
-        );
-        p_rgh = p - rho*gh;
-    }
-
-    // MULES flux from previous time-step
-    surfaceScalarField phiAlpha
-    (
-        IOobject
-        (
-            "phiAlpha",
-            runTime.timeName(),
-            mesh,
-            IOobject::READ_IF_PRESENT,
-            IOobject::AUTO_WRITE
-        ),
-        phi*fvc::interpolate(alpha1)
-    );
-
-    // MULES Correction
-    tmp<surfaceScalarField> tphiAlphaCorr0;
+// MULES Correction
+tmp<surfaceScalarField> tphiAlphaCorr0;
diff --git a/applications/solvers/multiphase/interFoam/interMixingFoam/createFields.H b/applications/solvers/multiphase/interFoam/interMixingFoam/createFields.H
index 21fde57907..1a0ae893c2 100644
--- a/applications/solvers/multiphase/interFoam/interMixingFoam/createFields.H
+++ b/applications/solvers/multiphase/interFoam/interMixingFoam/createFields.H
@@ -1,119 +1,122 @@
-    Info<< "Reading field p_rgh\n" << endl;
-    volScalarField p_rgh
+Info<< "Reading field p_rgh\n" << endl;
+volScalarField p_rgh
+(
+    IOobject
     (
-        IOobject
-        (
-            "p_rgh",
-            runTime.timeName(),
-            mesh,
-            IOobject::MUST_READ,
-            IOobject::AUTO_WRITE
-        ),
-        mesh
-    );
+        "p_rgh",
+        runTime.timeName(),
+        mesh,
+        IOobject::MUST_READ,
+        IOobject::AUTO_WRITE
+    ),
+    mesh
+);
 
-    Info<< "Reading field U\n" << endl;
-    volVectorField U
+Info<< "Reading field U\n" << endl;
+volVectorField U
+(
+    IOobject
     (
-        IOobject
-        (
-            "U",
-            runTime.timeName(),
-            mesh,
-            IOobject::MUST_READ,
-            IOobject::AUTO_WRITE
-        ),
-        mesh
-    );
+        "U",
+        runTime.timeName(),
+        mesh,
+        IOobject::MUST_READ,
+        IOobject::AUTO_WRITE
+    ),
+    mesh
+);
 
-    #include "createPhi.H"
+#include "createPhi.H"
 
-    immiscibleIncompressibleThreePhaseMixture mixture(U, phi);
+immiscibleIncompressibleThreePhaseMixture mixture(U, phi);
 
-    volScalarField& alpha1(mixture.alpha1());
-    volScalarField& alpha2(mixture.alpha2());
-    volScalarField& alpha3(mixture.alpha3());
+volScalarField& alpha1(mixture.alpha1());
+volScalarField& alpha2(mixture.alpha2());
+volScalarField& alpha3(mixture.alpha3());
 
-    const dimensionedScalar& rho1 = mixture.rho1();
-    const dimensionedScalar& rho2 = mixture.rho2();
-    const dimensionedScalar& rho3 = mixture.rho3();
+const dimensionedScalar& rho1 = mixture.rho1();
+const dimensionedScalar& rho2 = mixture.rho2();
+const dimensionedScalar& rho3 = mixture.rho3();
 
-    dimensionedScalar D23(mixture.lookup("D23"));
+dimensionedScalar D23(mixture.lookup("D23"));
 
-    // Need to store rho for ddt(rho, U)
-    volScalarField rho
+// Need to store rho for ddt(rho, U)
+volScalarField rho
+(
+    IOobject
     (
-        IOobject
-        (
-            "rho",
-            runTime.timeName(),
-            mesh,
-            IOobject::READ_IF_PRESENT
-        ),
-        alpha1*rho1 + alpha2*rho2 + alpha3*rho3,
-        alpha1.boundaryField().types()
-    );
-    rho.oldTime();
+        "rho",
+        runTime.timeName(),
+        mesh,
+        IOobject::READ_IF_PRESENT
+    ),
+    alpha1*rho1 + alpha2*rho2 + alpha3*rho3,
+    alpha1.boundaryField().types()
+);
+rho.oldTime();
 
 
-    // Mass flux
-    // Initialisation does not matter because rhoPhi is reset after the
-    // alpha solution before it is used in the U equation.
-    surfaceScalarField rhoPhi
+// Mass flux
+// Initialisation does not matter because rhoPhi is reset after the
+// alpha solution before it is used in the U equation.
+surfaceScalarField rhoPhi
+(
+    IOobject
     (
-        IOobject
-        (
-            "rhoPhi",
-            runTime.timeName(),
-            mesh,
-            IOobject::NO_READ,
-            IOobject::NO_WRITE
-        ),
-        rho1*phi
-    );
+        "rhoPhi",
+        runTime.timeName(),
+        mesh,
+        IOobject::NO_READ,
+        IOobject::NO_WRITE
+    ),
+    rho1*phi
+);
 
 
-    // Construct incompressible turbulence model
-    autoPtr<incompressible::turbulenceModel> turbulence
+// Construct incompressible turbulence model
+autoPtr<incompressible::turbulenceModel> turbulence
+(
+    incompressible::turbulenceModel::New(U, phi, mixture)
+);
+
+#include "readGravitationalAcceleration.H"
+#include "readhRef.H"
+#include "gh.H"
+
+volScalarField p
+(
+    IOobject
     (
-        incompressible::turbulenceModel::New(U, phi, mixture)
-    );
+        "p",
+        runTime.timeName(),
+        mesh,
+        IOobject::NO_READ,
+        IOobject::AUTO_WRITE
+    ),
+    p_rgh + rho*gh
+);
 
-    #include "readGravitationalAcceleration.H"
-    #include "readhRef.H"
-    #include "gh.H"
+label pRefCell = 0;
+scalar pRefValue = 0.0;
+setRefCell
+(
+    p,
+    p_rgh,
+    pimple.dict(),
+    pRefCell,
+    pRefValue
+);
 
-    volScalarField p
+if (p_rgh.needReference())
+{
+    p += dimensionedScalar
     (
-        IOobject
-        (
-            "p",
-            runTime.timeName(),
-            mesh,
-            IOobject::NO_READ,
-            IOobject::AUTO_WRITE
-        ),
-        p_rgh + rho*gh
+        "p",
+        p.dimensions(),
+        pRefValue - getRefCellValue(p, pRefCell)
     );
+    p_rgh = p - rho*gh;
+}
 
-    label pRefCell = 0;
-    scalar pRefValue = 0.0;
-    setRefCell
-    (
-        p,
-        p_rgh,
-        pimple.dict(),
-        pRefCell,
-        pRefValue
-    );
-
-    if (p_rgh.needReference())
-    {
-        p += dimensionedScalar
-        (
-            "p",
-            p.dimensions(),
-            pRefValue - getRefCellValue(p, pRefCell)
-        );
-        p_rgh = p - rho*gh;
-    }
+mesh.setFluxRequired(p_rgh.name());
+mesh.setFluxRequired(alpha2.name());
diff --git a/applications/solvers/multiphase/interPhaseChangeFoam/createFields.H b/applications/solvers/multiphase/interPhaseChangeFoam/createFields.H
index abebd61f17..dc0491bd03 100644
--- a/applications/solvers/multiphase/interPhaseChangeFoam/createFields.H
+++ b/applications/solvers/multiphase/interPhaseChangeFoam/createFields.H
@@ -1,108 +1,111 @@
-    Info<< "Reading field p_rgh\n" << endl;
-    volScalarField p_rgh
+Info<< "Reading field p_rgh\n" << endl;
+volScalarField p_rgh
+(
+    IOobject
     (
-        IOobject
-        (
-            "p_rgh",
-            runTime.timeName(),
-            mesh,
-            IOobject::MUST_READ,
-            IOobject::AUTO_WRITE
-        ),
-        mesh
-    );
+        "p_rgh",
+        runTime.timeName(),
+        mesh,
+        IOobject::MUST_READ,
+        IOobject::AUTO_WRITE
+    ),
+    mesh
+);
 
-    Info<< "Reading field U\n" << endl;
-    volVectorField U
+Info<< "Reading field U\n" << endl;
+volVectorField U
+(
+    IOobject
     (
-        IOobject
-        (
-            "U",
-            runTime.timeName(),
-            mesh,
-            IOobject::MUST_READ,
-            IOobject::AUTO_WRITE
-        ),
-        mesh
-    );
+        "U",
+        runTime.timeName(),
+        mesh,
+        IOobject::MUST_READ,
+        IOobject::AUTO_WRITE
+    ),
+    mesh
+);
 
-    #include "createPhi.H"
+#include "createPhi.H"
 
 
-    Info<< "Creating phaseChangeTwoPhaseMixture\n" << endl;
-    autoPtr<phaseChangeTwoPhaseMixture> mixture =
-        phaseChangeTwoPhaseMixture::New(U, phi);
+Info<< "Creating phaseChangeTwoPhaseMixture\n" << endl;
+autoPtr<phaseChangeTwoPhaseMixture> mixture =
+    phaseChangeTwoPhaseMixture::New(U, phi);
 
-    volScalarField& alpha1(mixture->alpha1());
-    volScalarField& alpha2(mixture->alpha2());
+volScalarField& alpha1(mixture->alpha1());
+volScalarField& alpha2(mixture->alpha2());
 
-    const dimensionedScalar& rho1 = mixture->rho1();
-    const dimensionedScalar& rho2 = mixture->rho2();
-    const dimensionedScalar& pSat = mixture->pSat();
+const dimensionedScalar& rho1 = mixture->rho1();
+const dimensionedScalar& rho2 = mixture->rho2();
+const dimensionedScalar& pSat = mixture->pSat();
 
 
-    // Need to store rho for ddt(rho, U)
-    volScalarField rho
+// Need to store rho for ddt(rho, U)
+volScalarField rho
+(
+    IOobject
     (
-        IOobject
-        (
-            "rho",
-            runTime.timeName(),
-            mesh,
-            IOobject::READ_IF_PRESENT
-        ),
-        alpha1*rho1 + alpha2*rho2,
-        alpha1.boundaryField().types()
-    );
-    rho.oldTime();
+        "rho",
+        runTime.timeName(),
+        mesh,
+        IOobject::READ_IF_PRESENT
+    ),
+    alpha1*rho1 + alpha2*rho2,
+    alpha1.boundaryField().types()
+);
+rho.oldTime();
 
 
-    // Construct interface from alpha1 distribution
-    interfaceProperties interface(alpha1, U, mixture());
+// Construct interface from alpha1 distribution
+interfaceProperties interface(alpha1, U, mixture());
 
-    // Construct incompressible turbulence model
-    autoPtr<incompressible::turbulenceModel> turbulence
+// Construct incompressible turbulence model
+autoPtr<incompressible::turbulenceModel> turbulence
+(
+    incompressible::turbulenceModel::New(U, phi, mixture())
+);
+
+
+#include "readGravitationalAcceleration.H"
+#include "readhRef.H"
+#include "gh.H"
+
+
+volScalarField p
+(
+    IOobject
     (
-        incompressible::turbulenceModel::New(U, phi, mixture())
-    );
+        "p",
+        runTime.timeName(),
+        mesh,
+        IOobject::NO_READ,
+        IOobject::AUTO_WRITE
+    ),
+    p_rgh + rho*gh
+);
 
+label pRefCell = 0;
+scalar pRefValue = 0.0;
+setRefCell
+(
+    p,
+    p_rgh,
+    pimple.dict(),
+    pRefCell,
+    pRefValue
+);
 
-    #include "readGravitationalAcceleration.H"
-    #include "readhRef.H"
-    #include "gh.H"
-
-
-    volScalarField p
+if (p_rgh.needReference())
+{
+    p += dimensionedScalar
     (
-        IOobject
-        (
-            "p",
-            runTime.timeName(),
-            mesh,
-            IOobject::NO_READ,
-            IOobject::AUTO_WRITE
-        ),
-        p_rgh + rho*gh
+        "p",
+        p.dimensions(),
+        pRefValue - getRefCellValue(p, pRefCell)
     );
+    p_rgh = p - rho*gh;
+}
 
-    label pRefCell = 0;
-    scalar pRefValue = 0.0;
-    setRefCell
-    (
-        p,
-        p_rgh,
-        pimple.dict(),
-        pRefCell,
-        pRefValue
-    );
-
-    if (p_rgh.needReference())
-    {
-        p += dimensionedScalar
-        (
-            "p",
-            p.dimensions(),
-            pRefValue - getRefCellValue(p, pRefCell)
-        );
-        p_rgh = p - rho*gh;
-    }
+mesh.setFluxRequired(p_rgh.name());
+mesh.setFluxRequired(alpha1.name());
diff --git a/applications/solvers/multiphase/multiphaseEulerFoam/createFields.H b/applications/solvers/multiphase/multiphaseEulerFoam/createFields.H
index 249673a9b2..0747583599 100644
--- a/applications/solvers/multiphase/multiphaseEulerFoam/createFields.H
+++ b/applications/solvers/multiphase/multiphaseEulerFoam/createFields.H
@@ -1,115 +1,116 @@
-    Info<< "Reading field p_rgh\n" << endl;
-    volScalarField p_rgh
+Info<< "Reading field p_rgh\n" << endl;
+volScalarField p_rgh
+(
+    IOobject
     (
-        IOobject
-        (
-            "p_rgh",
-            runTime.timeName(),
-            mesh,
-            IOobject::MUST_READ,
-            IOobject::AUTO_WRITE
-        ),
-        mesh
-    );
-
-    volVectorField U
-    (
-        IOobject
-        (
-            "U",
-            runTime.timeName(),
-            mesh,
-            IOobject::NO_READ,
-            IOobject::AUTO_WRITE
-        ),
+        "p_rgh",
+        runTime.timeName(),
         mesh,
-        dimensionedVector("U", dimVelocity, vector::zero)
-    );
+        IOobject::MUST_READ,
+        IOobject::AUTO_WRITE
+    ),
+    mesh
+);
 
-    surfaceScalarField phi
+volVectorField U
+(
+    IOobject
     (
-        IOobject
-        (
-            "phi",
-            runTime.timeName(),
-            mesh,
-            IOobject::NO_READ,
-            IOobject::AUTO_WRITE
-        ),
+        "U",
+        runTime.timeName(),
         mesh,
-        dimensionedScalar("phi", dimArea*dimVelocity, 0)
-    );
+        IOobject::NO_READ,
+        IOobject::AUTO_WRITE
+    ),
+    mesh,
+    dimensionedVector("U", dimVelocity, vector::zero)
+);
 
-    multiphaseSystem fluid(U, phi);
-
-    forAllIter(PtrDictionary<phaseModel>, fluid.phases(), iter)
-    {
-        phaseModel& phase = iter();
-        const volScalarField& alpha = phase;
-
-        U += alpha*phase.U();
-        phi += fvc::interpolate(alpha)*phase.phi();
-    }
-
-    scalar slamDampCoeff
+surfaceScalarField phi
+(
+    IOobject
     (
-        fluid.lookupOrDefault<scalar>("slamDampCoeff", 1)
-    );
+        "phi",
+        runTime.timeName(),
+        mesh,
+        IOobject::NO_READ,
+        IOobject::AUTO_WRITE
+    ),
+    mesh,
+    dimensionedScalar("phi", dimArea*dimVelocity, 0)
+);
 
-    dimensionedScalar maxSlamVelocity
+multiphaseSystem fluid(U, phi);
+
+forAllIter(PtrDictionary<phaseModel>, fluid.phases(), iter)
+{
+    phaseModel& phase = iter();
+    const volScalarField& alpha = phase;
+
+    U += alpha*phase.U();
+    phi += fvc::interpolate(alpha)*phase.phi();
+}
+
+scalar slamDampCoeff
+(
+    fluid.lookupOrDefault<scalar>("slamDampCoeff", 1)
+);
+
+dimensionedScalar maxSlamVelocity
+(
+    "maxSlamVelocity",
+    dimVelocity,
+    fluid.lookupOrDefault<scalar>("maxSlamVelocity", GREAT)
+);
+
+
+volScalarField rho
+(
+    IOobject
     (
-        "maxSlamVelocity",
-        dimVelocity,
-        fluid.lookupOrDefault<scalar>("maxSlamVelocity", GREAT)
-    );
+        "rho",
+        runTime.timeName(),
+        mesh,
+        IOobject::NO_READ,
+        IOobject::AUTO_WRITE
+    ),
+    fluid.rho()
+);
 
 
-    volScalarField rho
+// Construct incompressible turbulence model
+autoPtr<incompressible::turbulenceModel> turbulence
+(
+    incompressible::turbulenceModel::New(U, phi, fluid)
+);
+
+
+#include "readGravitationalAcceleration.H"
+#include "readhRef.H"
+#include "gh.H"
+
+
+volScalarField p
+(
+    IOobject
     (
-        IOobject
-        (
-            "rho",
-            runTime.timeName(),
-            mesh,
-            IOobject::NO_READ,
-            IOobject::AUTO_WRITE
-        ),
-        fluid.rho()
-    );
+        "p",
+        runTime.timeName(),
+        mesh,
+        IOobject::NO_READ,
+        IOobject::AUTO_WRITE
+    ),
+    p_rgh + rho*gh
+);
 
-
-    // Construct incompressible turbulence model
-    autoPtr<incompressible::turbulenceModel> turbulence
-    (
-        incompressible::turbulenceModel::New(U, phi, fluid)
-    );
-
-
-    #include "readGravitationalAcceleration.H"
-    #include "readhRef.H"
-    #include "gh.H"
-
-
-    volScalarField p
-    (
-        IOobject
-        (
-            "p",
-            runTime.timeName(),
-            mesh,
-            IOobject::NO_READ,
-            IOobject::AUTO_WRITE
-        ),
-        p_rgh + rho*gh
-    );
-
-    label pRefCell = 0;
-    scalar pRefValue = 0.0;
-    setRefCell
-    (
-        p,
-        p_rgh,
-        pimple.dict(),
-        pRefCell,
-        pRefValue
-    );
+label pRefCell = 0;
+scalar pRefValue = 0.0;
+setRefCell
+(
+    p,
+    p_rgh,
+    pimple.dict(),
+    pRefCell,
+    pRefValue
+);
+mesh.setFluxRequired(p_rgh.name());
diff --git a/applications/solvers/multiphase/multiphaseInterFoam/createFields.H b/applications/solvers/multiphase/multiphaseInterFoam/createFields.H
index 17253bf0a9..2aca07af74 100644
--- a/applications/solvers/multiphase/multiphaseInterFoam/createFields.H
+++ b/applications/solvers/multiphase/multiphaseInterFoam/createFields.H
@@ -1,93 +1,95 @@
-    Info<< "Reading field p_rgh\n" << endl;
-    volScalarField p_rgh
+Info<< "Reading field p_rgh\n" << endl;
+volScalarField p_rgh
+(
+    IOobject
     (
-        IOobject
-        (
-            "p_rgh",
-            runTime.timeName(),
-            mesh,
-            IOobject::MUST_READ,
-            IOobject::AUTO_WRITE
-        ),
-        mesh
-    );
+        "p_rgh",
+        runTime.timeName(),
+        mesh,
+        IOobject::MUST_READ,
+        IOobject::AUTO_WRITE
+    ),
+    mesh
+);
 
-    Info<< "Reading field U\n" << endl;
-    volVectorField U
+Info<< "Reading field U\n" << endl;
+volVectorField U
+(
+    IOobject
     (
-        IOobject
-        (
-            "U",
-            runTime.timeName(),
-            mesh,
-            IOobject::MUST_READ,
-            IOobject::AUTO_WRITE
-        ),
-        mesh
-    );
+        "U",
+        runTime.timeName(),
+        mesh,
+        IOobject::MUST_READ,
+        IOobject::AUTO_WRITE
+    ),
+    mesh
+);
 
-    #include "createPhi.H"
+#include "createPhi.H"
 
-    multiphaseMixture mixture(U, phi);
+multiphaseMixture mixture(U, phi);
 
-    // Need to store rho for ddt(rho, U)
-    volScalarField rho
+// Need to store rho for ddt(rho, U)
+volScalarField rho
+(
+    IOobject
     (
-        IOobject
-        (
-            "rho",
-            runTime.timeName(),
-            mesh,
-            IOobject::READ_IF_PRESENT
-        ),
-        mixture.rho()
-    );
-    rho.oldTime();
+        "rho",
+        runTime.timeName(),
+        mesh,
+        IOobject::READ_IF_PRESENT
+    ),
+    mixture.rho()
+);
+rho.oldTime();
 
-    const surfaceScalarField& rhoPhi(mixture.rhoPhi());
+const surfaceScalarField& rhoPhi(mixture.rhoPhi());
 
-    // Construct incompressible turbulence model
-    autoPtr<incompressible::turbulenceModel> turbulence
+// Construct incompressible turbulence model
+autoPtr<incompressible::turbulenceModel> turbulence
+(
+    incompressible::turbulenceModel::New(U, phi, mixture)
+);
+
+
+#include "readGravitationalAcceleration.H"
+#include "readhRef.H"
+#include "gh.H"
+
+
+volScalarField p
+(
+    IOobject
     (
-        incompressible::turbulenceModel::New(U, phi, mixture)
-    );
+        "p",
+        runTime.timeName(),
+        mesh,
+        IOobject::NO_READ,
+        IOobject::AUTO_WRITE
+    ),
+    p_rgh + rho*gh
+);
 
+label pRefCell = 0;
+scalar pRefValue = 0.0;
+setRefCell
+(
+    p,
+    p_rgh,
+    pimple.dict(),
+    pRefCell,
+    pRefValue
+);
 
-    #include "readGravitationalAcceleration.H"
-    #include "readhRef.H"
-    #include "gh.H"
-
-
-    volScalarField p
+if (p_rgh.needReference())
+{
+    p += dimensionedScalar
     (
-        IOobject
-        (
-            "p",
-            runTime.timeName(),
-            mesh,
-            IOobject::NO_READ,
-            IOobject::AUTO_WRITE
-        ),
-        p_rgh + rho*gh
+        "p",
+        p.dimensions(),
+        pRefValue - getRefCellValue(p, pRefCell)
     );
+}
 
-    label pRefCell = 0;
-    scalar pRefValue = 0.0;
-    setRefCell
-    (
-        p,
-        p_rgh,
-        pimple.dict(),
-        pRefCell,
-        pRefValue
-    );
-
-    if (p_rgh.needReference())
-    {
-        p += dimensionedScalar
-        (
-            "p",
-            p.dimensions(),
-            pRefValue - getRefCellValue(p, pRefCell)
-        );
-    }
+mesh.setFluxRequired(p_rgh.name());
diff --git a/applications/solvers/multiphase/potentialFreeSurfaceFoam/createFields.H b/applications/solvers/multiphase/potentialFreeSurfaceFoam/createFields.H
index 9e1c7aa9ad..40ba336dad 100644
--- a/applications/solvers/multiphase/potentialFreeSurfaceFoam/createFields.H
+++ b/applications/solvers/multiphase/potentialFreeSurfaceFoam/createFields.H
@@ -1,76 +1,77 @@
-    Info<< "Reading field p (kinematic)\n" << endl;
-    volScalarField p
+Info<< "Reading field p (kinematic)\n" << endl;
+volScalarField p
+(
+    IOobject
     (
-        IOobject
-        (
-            "p",
-            runTime.timeName(),
-            mesh,
-            IOobject::MUST_READ,
-            IOobject::AUTO_WRITE
-        ),
-        mesh
-    );
-
-    Info<< "Reading field U\n" << endl;
-    volVectorField U
-    (
-        IOobject
-        (
-            "U",
-            runTime.timeName(),
-            mesh,
-            IOobject::MUST_READ,
-            IOobject::AUTO_WRITE
-        ),
-        mesh
-    );
-
-    #include "createPhi.H"
-
-    singlePhaseTransportModel laminarTransport(U, phi);
-
-    autoPtr<incompressible::turbulenceModel> turbulence
-    (
-        incompressible::turbulenceModel::New(U, phi, laminarTransport)
-    );
-
-    #include "readGravitationalAcceleration.H"
-
-    Info<< "Creating field zeta\n" << endl;
-    volVectorField zeta
-    (
-        IOobject
-        (
-            "zeta",
-            runTime.timeName(),
-            mesh,
-            IOobject::READ_IF_PRESENT,
-            IOobject::AUTO_WRITE
-        ),
+        "p",
+        runTime.timeName(),
         mesh,
-        dimensionedVector("zero", dimLength, vector::zero)
-    );
+        IOobject::MUST_READ,
+        IOobject::AUTO_WRITE
+    ),
+    mesh
+);
 
-    Info<< "Creating field p_gh\n" << endl;
-    volScalarField p_gh
+Info<< "Reading field U\n" << endl;
+volVectorField U
+(
+    IOobject
     (
-        IOobject
-        (
-            "p_gh",
-            runTime.timeName(),
-            mesh,
-            IOobject::MUST_READ,
-            IOobject::AUTO_WRITE
-        ),
-        mesh
-    );
+        "U",
+        runTime.timeName(),
+        mesh,
+        IOobject::MUST_READ,
+        IOobject::AUTO_WRITE
+    ),
+    mesh
+);
 
-    // Force p_gh to be consistent with p
-    // Height is made relative to field 'refLevel'
-    p_gh =  p - (g & mesh.C());
+#include "createPhi.H"
+
+singlePhaseTransportModel laminarTransport(U, phi);
+
+autoPtr<incompressible::turbulenceModel> turbulence
+(
+    incompressible::turbulenceModel::New(U, phi, laminarTransport)
+);
+
+#include "readGravitationalAcceleration.H"
+
+Info<< "Creating field zeta\n" << endl;
+volVectorField zeta
+(
+    IOobject
+    (
+        "zeta",
+        runTime.timeName(),
+        mesh,
+        IOobject::READ_IF_PRESENT,
+        IOobject::AUTO_WRITE
+    ),
+    mesh,
+    dimensionedVector("zero", dimLength, vector::zero)
+);
+
+Info<< "Creating field p_gh\n" << endl;
+volScalarField p_gh
+(
+    IOobject
+    (
+        "p_gh",
+        runTime.timeName(),
+        mesh,
+        IOobject::MUST_READ,
+        IOobject::AUTO_WRITE
+    ),
+    mesh
+);
+
+// Force p_gh to be consistent with p
+// Height is made relative to field 'refLevel'
+p_gh =  p - (g & mesh.C());
 
 
-    label p_ghRefCell = 0;
-    scalar p_ghRefValue = 0.0;
-    setRefCell(p_gh, pimple.dict(), p_ghRefCell, p_ghRefValue);
+label p_ghRefCell = 0;
+scalar p_ghRefValue = 0.0;
+setRefCell(p_gh, pimple.dict(), p_ghRefCell, p_ghRefValue);
+mesh.setFluxRequired(p_gh.name());
diff --git a/applications/solvers/multiphase/reactingTwoPhaseEulerFoam/createFields.H b/applications/solvers/multiphase/reactingTwoPhaseEulerFoam/createFields.H
index 85bb8be45e..c1f7a130a7 100644
--- a/applications/solvers/multiphase/reactingTwoPhaseEulerFoam/createFields.H
+++ b/applications/solvers/multiphase/reactingTwoPhaseEulerFoam/createFields.H
@@ -1,76 +1,78 @@
-    #include "readGravitationalAcceleration.H"
-    #include "readhRef.H"
+#include "readGravitationalAcceleration.H"
+#include "readhRef.H"
 
-    Info<< "Creating phaseSystem\n" << endl;
+Info<< "Creating phaseSystem\n" << endl;
 
-    autoPtr<twoPhaseSystem> fluidPtr
+autoPtr<twoPhaseSystem> fluidPtr
+(
+    twoPhaseSystem::New(mesh)
+);
+twoPhaseSystem& fluid = fluidPtr();
+
+phaseModel& phase1 = fluid.phase1();
+phaseModel& phase2 = fluid.phase2();
+
+volScalarField& alpha1 = phase1;
+volScalarField& alpha2 = phase2;
+
+volVectorField& U1 = phase1.U();
+surfaceScalarField& phi1 = phase1.phi();
+surfaceScalarField& alphaPhi1 = phase1.alphaPhi();
+surfaceScalarField& alphaRhoPhi1 = phase1.alphaRhoPhi();
+
+volVectorField& U2 = phase2.U();
+surfaceScalarField& phi2 = phase2.phi();
+surfaceScalarField& alphaPhi2 = phase2.alphaPhi();
+surfaceScalarField& alphaRhoPhi2 = phase2.alphaRhoPhi();
+
+surfaceScalarField& phi = fluid.phi();
+
+dimensionedScalar pMin
+(
+    "pMin",
+    dimPressure,
+    fluid.lookup("pMin")
+);
+
+#include "gh.H"
+
+rhoThermo& thermo1 = phase1.thermo();
+rhoThermo& thermo2 = phase2.thermo();
+
+volScalarField& p = thermo1.p();
+
+volScalarField& rho1 = thermo1.rho();
+const volScalarField& psi1 = thermo1.psi();
+
+volScalarField& rho2 = thermo2.rho();
+const volScalarField& psi2 = thermo2.psi();
+
+Info<< "Reading field p_rgh\n" << endl;
+volScalarField p_rgh
+(
+    IOobject
     (
-        twoPhaseSystem::New(mesh)
-    );
-    twoPhaseSystem& fluid = fluidPtr();
+        "p_rgh",
+        runTime.timeName(),
+        mesh,
+        IOobject::MUST_READ,
+        IOobject::AUTO_WRITE
+    ),
+    mesh
+);
 
-    phaseModel& phase1 = fluid.phase1();
-    phaseModel& phase2 = fluid.phase2();
+label pRefCell = 0;
+scalar pRefValue = 0.0;
+setRefCell
+(
+    p,
+    p_rgh,
+    pimple.dict(),
+    pRefCell,
+    pRefValue
+);
+mesh.setFluxRequired(p_rgh.name());
+mesh.setFluxRequired(alpha1.name());
 
-    volScalarField& alpha1 = phase1;
-    volScalarField& alpha2 = phase2;
-
-    volVectorField& U1 = phase1.U();
-    surfaceScalarField& phi1 = phase1.phi();
-    surfaceScalarField& alphaPhi1 = phase1.alphaPhi();
-    surfaceScalarField& alphaRhoPhi1 = phase1.alphaRhoPhi();
-
-    volVectorField& U2 = phase2.U();
-    surfaceScalarField& phi2 = phase2.phi();
-    surfaceScalarField& alphaPhi2 = phase2.alphaPhi();
-    surfaceScalarField& alphaRhoPhi2 = phase2.alphaRhoPhi();
-
-    surfaceScalarField& phi = fluid.phi();
-
-    dimensionedScalar pMin
-    (
-        "pMin",
-        dimPressure,
-        fluid.lookup("pMin")
-    );
-
-    #include "gh.H"
-
-    rhoThermo& thermo1 = phase1.thermo();
-    rhoThermo& thermo2 = phase2.thermo();
-
-    volScalarField& p = thermo1.p();
-
-    volScalarField& rho1 = thermo1.rho();
-    const volScalarField& psi1 = thermo1.psi();
-
-    volScalarField& rho2 = thermo2.rho();
-    const volScalarField& psi2 = thermo2.psi();
-
-    Info<< "Reading field p_rgh\n" << endl;
-    volScalarField p_rgh
-    (
-        IOobject
-        (
-            "p_rgh",
-            runTime.timeName(),
-            mesh,
-            IOobject::MUST_READ,
-            IOobject::AUTO_WRITE
-        ),
-        mesh
-    );
-
-    label pRefCell = 0;
-    scalar pRefValue = 0.0;
-    setRefCell
-    (
-        p,
-        p_rgh,
-        pimple.dict(),
-        pRefCell,
-        pRefValue
-    );
-
-    const IOMRFZoneList& MRF = fluid.MRF();
-    fv::IOoptionList& fvOptions = fluid.fvOptions();
+const IOMRFZoneList& MRF = fluid.MRF();
+fv::IOoptionList& fvOptions = fluid.fvOptions();
diff --git a/applications/solvers/multiphase/twoLiquidMixingFoam/createFields.H b/applications/solvers/multiphase/twoLiquidMixingFoam/createFields.H
index 1a01871985..9fc3bcbbbe 100644
--- a/applications/solvers/multiphase/twoLiquidMixingFoam/createFields.H
+++ b/applications/solvers/multiphase/twoLiquidMixingFoam/createFields.H
@@ -1,111 +1,114 @@
-    Info<< "Reading field p_rgh\n" << endl;
-    volScalarField p_rgh
+Info<< "Reading field p_rgh\n" << endl;
+volScalarField p_rgh
+(
+    IOobject
     (
-        IOobject
-        (
-            "p_rgh",
-            runTime.timeName(),
-            mesh,
-            IOobject::MUST_READ,
-            IOobject::AUTO_WRITE
-        ),
-        mesh
-    );
+        "p_rgh",
+        runTime.timeName(),
+        mesh,
+        IOobject::MUST_READ,
+        IOobject::AUTO_WRITE
+    ),
+    mesh
+);
 
-    Info<< "Reading field U\n" << endl;
-    volVectorField U
+Info<< "Reading field U\n" << endl;
+volVectorField U
+(
+    IOobject
     (
-        IOobject
-        (
-            "U",
-            runTime.timeName(),
-            mesh,
-            IOobject::MUST_READ,
-            IOobject::AUTO_WRITE
-        ),
-        mesh
-    );
+        "U",
+        runTime.timeName(),
+        mesh,
+        IOobject::MUST_READ,
+        IOobject::AUTO_WRITE
+    ),
+    mesh
+);
 
-    #include "createPhi.H"
+#include "createPhi.H"
 
-    Info<< "Reading transportProperties\n" << endl;
-    incompressibleTwoPhaseMixture mixture(U, phi);
+Info<< "Reading transportProperties\n" << endl;
+incompressibleTwoPhaseMixture mixture(U, phi);
 
-    volScalarField& alpha1(mixture.alpha1());
-    volScalarField& alpha2(mixture.alpha2());
+volScalarField& alpha1(mixture.alpha1());
+volScalarField& alpha2(mixture.alpha2());
 
-    const dimensionedScalar& rho1 = mixture.rho1();
-    const dimensionedScalar& rho2 = mixture.rho2();
+const dimensionedScalar& rho1 = mixture.rho1();
+const dimensionedScalar& rho2 = mixture.rho2();
 
-    dimensionedScalar Dab(mixture.lookup("Dab"));
+dimensionedScalar Dab(mixture.lookup("Dab"));
 
-    // Read the reciprocal of the turbulent Schmidt number
-    dimensionedScalar alphatab(mixture.lookup("alphatab"));
+// Read the reciprocal of the turbulent Schmidt number
+dimensionedScalar alphatab(mixture.lookup("alphatab"));
 
-    // Need to store rho for ddt(rho, U)
-    volScalarField rho("rho", alpha1*rho1 + alpha2*rho2);
-    rho.oldTime();
+// Need to store rho for ddt(rho, U)
+volScalarField rho("rho", alpha1*rho1 + alpha2*rho2);
+rho.oldTime();
 
 
-    // Mass flux
-    // Initialisation does not matter because rhoPhi is reset after the
-    // alpha1 solution before it is used in the U equation.
-    surfaceScalarField rhoPhi
+// Mass flux
+// Initialisation does not matter because rhoPhi is reset after the
+// alpha1 solution before it is used in the U equation.
+surfaceScalarField rhoPhi
+(
+    IOobject
     (
-        IOobject
-        (
-            "rhoPhi",
-            runTime.timeName(),
-            mesh,
-            IOobject::NO_READ,
-            IOobject::NO_WRITE
-        ),
-        rho1*phi
-    );
+        "rhoPhi",
+        runTime.timeName(),
+        mesh,
+        IOobject::NO_READ,
+        IOobject::NO_WRITE
+    ),
+    rho1*phi
+);
 
-    // Construct incompressible turbulence model
-    autoPtr<incompressible::turbulenceModel> turbulence
+// Construct incompressible turbulence model
+autoPtr<incompressible::turbulenceModel> turbulence
+(
+    incompressible::turbulenceModel::New(U, phi, mixture)
+);
+
+
+#include "readGravitationalAcceleration.H"
+#include "readhRef.H"
+#include "gh.H"
+
+
+volScalarField p
+(
+    IOobject
     (
-        incompressible::turbulenceModel::New(U, phi, mixture)
-    );
+        "p",
+        runTime.timeName(),
+        mesh,
+        IOobject::NO_READ,
+        IOobject::AUTO_WRITE
+    ),
+    p_rgh + rho*gh
+);
 
+label pRefCell = 0;
+scalar pRefValue = 0.0;
+setRefCell
+(
+    p,
+    p_rgh,
+    pimple.dict(),
+    pRefCell,
+    pRefValue
+);
 
-    #include "readGravitationalAcceleration.H"
-    #include "readhRef.H"
-    #include "gh.H"
-
-
-    volScalarField p
+if (p_rgh.needReference())
+{
+    p += dimensionedScalar
     (
-        IOobject
-        (
-            "p",
-            runTime.timeName(),
-            mesh,
-            IOobject::NO_READ,
-            IOobject::AUTO_WRITE
-        ),
-        p_rgh + rho*gh
+        "p",
+        p.dimensions(),
+        pRefValue - getRefCellValue(p, pRefCell)
     );
+    p_rgh = p - rho*gh;
+}
 
-    label pRefCell = 0;
-    scalar pRefValue = 0.0;
-    setRefCell
-    (
-        p,
-        p_rgh,
-        pimple.dict(),
-        pRefCell,
-        pRefValue
-    );
-
-    if (p_rgh.needReference())
-    {
-        p += dimensionedScalar
-        (
-            "p",
-            p.dimensions(),
-            pRefValue - getRefCellValue(p, pRefCell)
-        );
-        p_rgh = p - rho*gh;
-    }
+mesh.setFluxRequired(p_rgh.name());
+mesh.setFluxRequired(alpha1.name());
diff --git a/applications/solvers/multiphase/twoPhaseEulerFoam/createFields.H b/applications/solvers/multiphase/twoPhaseEulerFoam/createFields.H
index a882a58249..f76f904fb4 100644
--- a/applications/solvers/multiphase/twoPhaseEulerFoam/createFields.H
+++ b/applications/solvers/multiphase/twoPhaseEulerFoam/createFields.H
@@ -1,100 +1,102 @@
-    #include "readGravitationalAcceleration.H"
-    #include "readhRef.H"
+#include "readGravitationalAcceleration.H"
+#include "readhRef.H"
 
-    Info<< "Creating twoPhaseSystem\n" << endl;
+Info<< "Creating twoPhaseSystem\n" << endl;
 
-    twoPhaseSystem fluid(mesh, g);
+twoPhaseSystem fluid(mesh, g);
 
-    phaseModel& phase1 = fluid.phase1();
-    phaseModel& phase2 = fluid.phase2();
+phaseModel& phase1 = fluid.phase1();
+phaseModel& phase2 = fluid.phase2();
 
-    volScalarField& alpha1 = phase1;
-    volScalarField& alpha2 = phase2;
+volScalarField& alpha1 = phase1;
+volScalarField& alpha2 = phase2;
 
-    volVectorField& U1 = phase1.U();
-    surfaceScalarField& phi1 = phase1.phi();
-    surfaceScalarField& alphaPhi1 = phase1.alphaPhi();
-    surfaceScalarField& alphaRhoPhi1 = phase1.alphaRhoPhi();
+volVectorField& U1 = phase1.U();
+surfaceScalarField& phi1 = phase1.phi();
+surfaceScalarField& alphaPhi1 = phase1.alphaPhi();
+surfaceScalarField& alphaRhoPhi1 = phase1.alphaRhoPhi();
 
-    volVectorField& U2 = phase2.U();
-    surfaceScalarField& phi2 = phase2.phi();
-    surfaceScalarField& alphaPhi2 = phase2.alphaPhi();
-    surfaceScalarField& alphaRhoPhi2 = phase2.alphaRhoPhi();
+volVectorField& U2 = phase2.U();
+surfaceScalarField& phi2 = phase2.phi();
+surfaceScalarField& alphaPhi2 = phase2.alphaPhi();
+surfaceScalarField& alphaRhoPhi2 = phase2.alphaRhoPhi();
 
-    surfaceScalarField& phi = fluid.phi();
+surfaceScalarField& phi = fluid.phi();
 
-    dimensionedScalar pMin
+dimensionedScalar pMin
+(
+    "pMin",
+    dimPressure,
+    fluid.lookup("pMin")
+);
+
+#include "gh.H"
+
+rhoThermo& thermo1 = phase1.thermo();
+rhoThermo& thermo2 = phase2.thermo();
+
+volScalarField& p = thermo1.p();
+
+volScalarField& rho1 = thermo1.rho();
+const volScalarField& psi1 = thermo1.psi();
+
+volScalarField& rho2 = thermo2.rho();
+const volScalarField& psi2 = thermo2.psi();
+
+Info<< "Reading field p_rgh\n" << endl;
+volScalarField p_rgh
+(
+    IOobject
     (
-        "pMin",
-        dimPressure,
-        fluid.lookup("pMin")
-    );
-
-    #include "gh.H"
-
-    rhoThermo& thermo1 = phase1.thermo();
-    rhoThermo& thermo2 = phase2.thermo();
-
-    volScalarField& p = thermo1.p();
-
-    volScalarField& rho1 = thermo1.rho();
-    const volScalarField& psi1 = thermo1.psi();
-
-    volScalarField& rho2 = thermo2.rho();
-    const volScalarField& psi2 = thermo2.psi();
-
-    Info<< "Reading field p_rgh\n" << endl;
-    volScalarField p_rgh
-    (
-        IOobject
-        (
-            "p_rgh",
-            runTime.timeName(),
-            mesh,
-            IOobject::MUST_READ,
-            IOobject::AUTO_WRITE
-        ),
-        mesh
-    );
-
-    volVectorField U
-    (
-        IOobject
-        (
-            "U",
-            runTime.timeName(),
-            mesh,
-            IOobject::NO_READ,
-            IOobject::AUTO_WRITE
-        ),
-        fluid.U()
-    );
-
-    label pRefCell = 0;
-    scalar pRefValue = 0.0;
-    setRefCell
-    (
-        p,
-        p_rgh,
-        pimple.dict(),
-        pRefCell,
-        pRefValue
-    );
-
-    Info<< "Creating field dpdt\n" << endl;
-    volScalarField dpdt
-    (
-        IOobject
-        (
-            "dpdt",
-            runTime.timeName(),
-            mesh
-        ),
+        "p_rgh",
+        runTime.timeName(),
         mesh,
-        dimensionedScalar("dpdt", p.dimensions()/dimTime, 0)
-    );
+        IOobject::MUST_READ,
+        IOobject::AUTO_WRITE
+    ),
+    mesh
+);
+
+volVectorField U
+(
+    IOobject
+    (
+        "U",
+        runTime.timeName(),
+        mesh,
+        IOobject::NO_READ,
+        IOobject::AUTO_WRITE
+    ),
+    fluid.U()
+);
+
+label pRefCell = 0;
+scalar pRefValue = 0.0;
+setRefCell
+(
+    p,
+    p_rgh,
+    pimple.dict(),
+    pRefCell,
+    pRefValue
+);
+mesh.setFluxRequired(p_rgh.name());
+mesh.setFluxRequired(alpha1.name());
+
+Info<< "Creating field dpdt\n" << endl;
+volScalarField dpdt
+(
+    IOobject
+    (
+        "dpdt",
+        runTime.timeName(),
+        mesh
+    ),
+    mesh,
+    dimensionedScalar("dpdt", p.dimensions()/dimTime, 0)
+);
 
 
-    Info<< "Creating field kinetic energy K\n" << endl;
-    volScalarField K1(IOobject::groupName("K", phase1.name()), 0.5*magSqr(U1));
-    volScalarField K2(IOobject::groupName("K", phase2.name()), 0.5*magSqr(U2));
+Info<< "Creating field kinetic energy K\n" << endl;
+volScalarField K1(IOobject::groupName("K", phase1.name()), 0.5*magSqr(U1));
+volScalarField K2(IOobject::groupName("K", phase2.name()), 0.5*magSqr(U2));
diff --git a/applications/solvers/stressAnalysis/solidDisplacementFoam/createFields.H b/applications/solvers/stressAnalysis/solidDisplacementFoam/createFields.H
index ff3cd1450d..004cda1732 100644
--- a/applications/solvers/stressAnalysis/solidDisplacementFoam/createFields.H
+++ b/applications/solvers/stressAnalysis/solidDisplacementFoam/createFields.H
@@ -72,3 +72,5 @@ else
 {
     divSigmaExp -= fvc::div((2*mu + lambda)*fvc::grad(D), "div(sigmaD)");
 }
+
+mesh.setFluxRequired(D.name());
diff --git a/src/finiteVolume/cfdTools/general/CorrectPhi/CorrectPhi.C b/src/finiteVolume/cfdTools/general/CorrectPhi/CorrectPhi.C
index eaa8cf5edc..c6cdff20c5 100644
--- a/src/finiteVolume/cfdTools/general/CorrectPhi/CorrectPhi.C
+++ b/src/finiteVolume/cfdTools/general/CorrectPhi/CorrectPhi.C
@@ -89,6 +89,8 @@ void Foam::CorrectPhi
         fvc::makeAbsolute(phi, U);
     }
 
+    mesh.setFluxRequired(pcorr.name());
+
     while (pimple.correctNonOrthogonal())
     {
         // Solve for pcorr such that the divergence of the corrected flux
@@ -156,6 +158,8 @@ void Foam::CorrectPhi
         pcorrTypes
     );
 
+    mesh.setFluxRequired(pcorr.name());
+
     while (pimple.correctNonOrthogonal())
     {
         // Solve for pcorr such that the divergence of the corrected flux
diff --git a/src/finiteVolume/finiteVolume/fvSchemes/fvSchemes.C b/src/finiteVolume/finiteVolume/fvSchemes/fvSchemes.C
index c0ed1db010..57695c0465 100644
--- a/src/finiteVolume/finiteVolume/fvSchemes/fvSchemes.C
+++ b/src/finiteVolume/finiteVolume/fvSchemes/fvSchemes.C
@@ -558,7 +558,7 @@ Foam::ITstream& Foam::fvSchemes::laplacianScheme(const word& name) const
 }
 
 
-void Foam::fvSchemes::setFluxRequired(const word& name)
+void Foam::fvSchemes::setFluxRequired(const word& name) const
 {
     if (debug)
     {
diff --git a/src/finiteVolume/finiteVolume/fvSchemes/fvSchemes.H b/src/finiteVolume/finiteVolume/fvSchemes/fvSchemes.H
index bf3099929b..839ae4e724 100644
--- a/src/finiteVolume/finiteVolume/fvSchemes/fvSchemes.H
+++ b/src/finiteVolume/finiteVolume/fvSchemes/fvSchemes.H
@@ -75,7 +75,7 @@ class fvSchemes
         dictionary laplacianSchemes_;
         ITstream defaultLaplacianScheme_;
 
-        dictionary fluxRequired_;
+        mutable dictionary fluxRequired_;
         bool defaultFluxRequired_;
 
         //- Steady-state run indicator
@@ -130,7 +130,7 @@ public:
 
             ITstream& laplacianScheme(const word& name) const;
 
-            void setFluxRequired(const word& name);
+            void setFluxRequired(const word& name) const;
 
             bool fluxRequired(const word& name) const;
 
diff --git a/src/lagrangian/intermediate/submodels/MPPIC/PackingModels/Implicit/Implicit.C b/src/lagrangian/intermediate/submodels/MPPIC/PackingModels/Implicit/Implicit.C
index a159ed375f..31b72c3cf6 100644
--- a/src/lagrangian/intermediate/submodels/MPPIC/PackingModels/Implicit/Implicit.C
+++ b/src/lagrangian/intermediate/submodels/MPPIC/PackingModels/Implicit/Implicit.C
@@ -29,7 +29,7 @@ License
 #include "fvmDiv.H"
 #include "fvmLaplacian.H"
 #include "fvcReconstruct.H"
-#include "volPointInterpolation.H"                                              
+#include "volPointInterpolation.H"
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
@@ -89,7 +89,7 @@ void Foam::PackingModels::Implicit<CloudType>::cacheFields(const bool store)
     PackingModel<CloudType>::cacheFields(store);
 
     if (store)
-    { 
+    {
         const fvMesh& mesh = this->owner().mesh();
         const dimensionedScalar deltaT = this->owner().db().time().deltaT();
         const word& cloudName = this->owner().name();
@@ -108,6 +108,7 @@ void Foam::PackingModels::Implicit<CloudType>::cacheFields(const bool store)
                 cloudName + ":uSqrAverage"
             );
 
+        mesh.setFluxRequired(alpha_.name());
 
         // Property fields
         // ~~~~~~~~~~~~~~~
@@ -140,7 +141,7 @@ void Foam::PackingModels::Implicit<CloudType>::cacheFields(const bool store)
         //Info << "     rho: " << rho.internalField() << endl;
         //Info << endl;
 
-        
+
         // Stress field
         // ~~~~~~~~~~~~
 
diff --git a/src/regionModels/surfaceFilmModels/kinematicSingleLayer/kinematicSingleLayer.C b/src/regionModels/surfaceFilmModels/kinematicSingleLayer/kinematicSingleLayer.C
index 2faa91982c..d743ff1de0 100644
--- a/src/regionModels/surfaceFilmModels/kinematicSingleLayer/kinematicSingleLayer.C
+++ b/src/regionModels/surfaceFilmModels/kinematicSingleLayer/kinematicSingleLayer.C
@@ -383,7 +383,8 @@ void kinematicSingleLayer::solveThickness
         "deltaCoeff",
         fvc::interpolate(delta_)*deltarUAf*rhof*fvc::interpolate(pp)
     );
-//    constrainFilmField(ddrhorUAppf, 0.0);
+
+    regionMesh().setFluxRequired(delta_.name());
 
     for (int nonOrth=0; nonOrth<=nNonOrthCorr_; nonOrth++)
     {
diff --git a/tutorials/Alltest b/tutorials/Alltest
index 21c89a979a..f287c4926f 100755
--- a/tutorials/Alltest
+++ b/tutorials/Alltest
@@ -106,7 +106,6 @@ divSchemes
 laplacianSchemes { default Gauss linear corrected; }
 interpolationSchemes { default linear; }
 snGradSchemes { default corrected; }
-fluxRequired { default yes; }
 EOF
 }
 
@@ -140,7 +139,6 @@ FV_SCHEMES=\
     laplacianScheme \
     interpolationScheme \
     snGradScheme \
-    fluxRequired \
 "
 SCHEMES_FILE="FvSchemes"
 SCHEMES_TEMP="FvSchemes.temp"
diff --git a/tutorials/DNS/dnsFoam/boxTurb16/system/fvSchemes b/tutorials/DNS/dnsFoam/boxTurb16/system/fvSchemes
index a1802e439b..fcde7de79f 100644
--- a/tutorials/DNS/dnsFoam/boxTurb16/system/fvSchemes
+++ b/tutorials/DNS/dnsFoam/boxTurb16/system/fvSchemes
@@ -46,11 +46,5 @@ snGradSchemes
     default         corrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p               ;
-}
-
 
 // ************************************************************************* //
diff --git a/tutorials/basic/laplacianFoam/flange/system/fvSchemes b/tutorials/basic/laplacianFoam/flange/system/fvSchemes
index 212c29c8a6..fe2e5854ec 100644
--- a/tutorials/basic/laplacianFoam/flange/system/fvSchemes
+++ b/tutorials/basic/laplacianFoam/flange/system/fvSchemes
@@ -47,11 +47,5 @@ snGradSchemes
     default         corrected;
 }
 
-fluxRequired
-{
-    default         no;
-    T               ;
-}
-
 
 // ************************************************************************* //
diff --git a/tutorials/basic/scalarTransportFoam/pitzDaily/system/fvSchemes b/tutorials/basic/scalarTransportFoam/pitzDaily/system/fvSchemes
index 7070ad800d..e9c860c19d 100644
--- a/tutorials/basic/scalarTransportFoam/pitzDaily/system/fvSchemes
+++ b/tutorials/basic/scalarTransportFoam/pitzDaily/system/fvSchemes
@@ -47,11 +47,5 @@ snGradSchemes
     default         corrected;
 }
 
-fluxRequired
-{
-    default         no;
-    T               ;
-}
-
 
 // ************************************************************************* //
diff --git a/tutorials/combustion/PDRFoam/flamePropagationWithObstacles/system/fvSchemes b/tutorials/combustion/PDRFoam/flamePropagationWithObstacles/system/fvSchemes
index 979d0d7dc9..654bdb3d19 100644
--- a/tutorials/combustion/PDRFoam/flamePropagationWithObstacles/system/fvSchemes
+++ b/tutorials/combustion/PDRFoam/flamePropagationWithObstacles/system/fvSchemes
@@ -69,10 +69,4 @@ snGradSchemes
     default         limited corrected 0.333;
 }
 
-fluxRequired
-{
-    default         no;
-    p;
-}
-
 // ************************************************************************* //
diff --git a/tutorials/combustion/XiFoam/ras/moriyoshiHomogeneous/system/fvSchemes b/tutorials/combustion/XiFoam/ras/moriyoshiHomogeneous/system/fvSchemes
index d790a62798..f5476baa16 100644
--- a/tutorials/combustion/XiFoam/ras/moriyoshiHomogeneous/system/fvSchemes
+++ b/tutorials/combustion/XiFoam/ras/moriyoshiHomogeneous/system/fvSchemes
@@ -67,11 +67,5 @@ snGradSchemes
     default         corrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p               ;
-}
-
 
 // ************************************************************************* //
diff --git a/tutorials/combustion/chemFoam/gri/system/fvSchemes b/tutorials/combustion/chemFoam/gri/system/fvSchemes
index d491cdcee7..0bd096859e 100644
--- a/tutorials/combustion/chemFoam/gri/system/fvSchemes
+++ b/tutorials/combustion/chemFoam/gri/system/fvSchemes
@@ -29,8 +29,4 @@ divSchemes
 laplacianSchemes
 {}
 
-fluxRequired
-{}
-
-
 // ************************************************************************* //
diff --git a/tutorials/combustion/chemFoam/h2/system/fvSchemes b/tutorials/combustion/chemFoam/h2/system/fvSchemes
index fe89c288c6..b19e2dd0b1 100644
--- a/tutorials/combustion/chemFoam/h2/system/fvSchemes
+++ b/tutorials/combustion/chemFoam/h2/system/fvSchemes
@@ -32,9 +32,5 @@ laplacianSchemes
 {
 }
 
-fluxRequired
-{
-}
-
 
 // ************************************************************************* //
diff --git a/tutorials/combustion/chemFoam/ic8h18/system/fvSchemes b/tutorials/combustion/chemFoam/ic8h18/system/fvSchemes
index d491cdcee7..0bd096859e 100644
--- a/tutorials/combustion/chemFoam/ic8h18/system/fvSchemes
+++ b/tutorials/combustion/chemFoam/ic8h18/system/fvSchemes
@@ -29,8 +29,4 @@ divSchemes
 laplacianSchemes
 {}
 
-fluxRequired
-{}
-
-
 // ************************************************************************* //
diff --git a/tutorials/combustion/engineFoam/kivaTest/system/fvSchemes b/tutorials/combustion/engineFoam/kivaTest/system/fvSchemes
index 87efa40d7e..1e0ebc519b 100644
--- a/tutorials/combustion/engineFoam/kivaTest/system/fvSchemes
+++ b/tutorials/combustion/engineFoam/kivaTest/system/fvSchemes
@@ -71,11 +71,5 @@ snGradSchemes
     default         limited corrected 0.5;
 }
 
-fluxRequired
-{
-    default         no;
-    p               ;
-}
-
 
 // ************************************************************************* //
diff --git a/tutorials/combustion/fireFoam/les/flameSpreadWaterSuppressionPanel/system/filmRegion/fvSchemes b/tutorials/combustion/fireFoam/les/flameSpreadWaterSuppressionPanel/system/filmRegion/fvSchemes
index 1af5787d81..a6a35f420f 100644
--- a/tutorials/combustion/fireFoam/les/flameSpreadWaterSuppressionPanel/system/filmRegion/fvSchemes
+++ b/tutorials/combustion/fireFoam/les/flameSpreadWaterSuppressionPanel/system/filmRegion/fvSchemes
@@ -43,11 +43,5 @@ snGradSchemes
     default uncorrected;
 }
 
-fluxRequired
-{
-    default no;
-    deltaf;
-}
-
 
 // ************************************************************************* //
diff --git a/tutorials/combustion/fireFoam/les/flameSpreadWaterSuppressionPanel/system/fvSchemes b/tutorials/combustion/fireFoam/les/flameSpreadWaterSuppressionPanel/system/fvSchemes
index 1173de15cf..282be76457 100644
--- a/tutorials/combustion/fireFoam/les/flameSpreadWaterSuppressionPanel/system/fvSchemes
+++ b/tutorials/combustion/fireFoam/les/flameSpreadWaterSuppressionPanel/system/fvSchemes
@@ -64,11 +64,5 @@ snGradSchemes
     default         corrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p_rgh;
-}
-
 
 // ************************************************************************* //
diff --git a/tutorials/combustion/fireFoam/les/flameSpreadWaterSuppressionPanel/system/pyrolysisRegion/fvSchemes b/tutorials/combustion/fireFoam/les/flameSpreadWaterSuppressionPanel/system/pyrolysisRegion/fvSchemes
index 7ba1c2cc9d..c974c1091b 100644
--- a/tutorials/combustion/fireFoam/les/flameSpreadWaterSuppressionPanel/system/pyrolysisRegion/fvSchemes
+++ b/tutorials/combustion/fireFoam/les/flameSpreadWaterSuppressionPanel/system/pyrolysisRegion/fvSchemes
@@ -46,9 +46,5 @@ snGradSchemes
     default        uncorrected;
 }
 
-fluxRequired
-{
-    default         no;
-}
 
 // ************************************************************************* //
diff --git a/tutorials/combustion/fireFoam/les/oppositeBurningPanels/system/fvSchemes b/tutorials/combustion/fireFoam/les/oppositeBurningPanels/system/fvSchemes
index 0ca1dcaa67..f28d6fcd16 100644
--- a/tutorials/combustion/fireFoam/les/oppositeBurningPanels/system/fvSchemes
+++ b/tutorials/combustion/fireFoam/les/oppositeBurningPanels/system/fvSchemes
@@ -59,12 +59,4 @@ snGradSchemes
     default         corrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p_rgh;
-    phiMesh;
-}
-
-
 // ************************************************************************* //
diff --git a/tutorials/combustion/fireFoam/les/oppositeBurningPanels/system/panelRegion/fvSchemes b/tutorials/combustion/fireFoam/les/oppositeBurningPanels/system/panelRegion/fvSchemes
index 405227e503..1a0a8dfb06 100644
--- a/tutorials/combustion/fireFoam/les/oppositeBurningPanels/system/panelRegion/fvSchemes
+++ b/tutorials/combustion/fireFoam/les/oppositeBurningPanels/system/panelRegion/fvSchemes
@@ -46,9 +46,5 @@ snGradSchemes
     default        corrected;
 }
 
-fluxRequired
-{
-    default         no;
-}
 
 // ************************************************************************* //
diff --git a/tutorials/combustion/fireFoam/les/smallPoolFire2D/system/fvSchemes b/tutorials/combustion/fireFoam/les/smallPoolFire2D/system/fvSchemes
index 406f98c2aa..01608aaaa1 100644
--- a/tutorials/combustion/fireFoam/les/smallPoolFire2D/system/fvSchemes
+++ b/tutorials/combustion/fireFoam/les/smallPoolFire2D/system/fvSchemes
@@ -61,11 +61,5 @@ snGradSchemes
     default         corrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p_rgh;
-}
-
 
 // ************************************************************************* //
diff --git a/tutorials/combustion/fireFoam/les/smallPoolFire3D/system/fvSchemes b/tutorials/combustion/fireFoam/les/smallPoolFire3D/system/fvSchemes
index fbb43d9b9c..a713ce9d93 100644
--- a/tutorials/combustion/fireFoam/les/smallPoolFire3D/system/fvSchemes
+++ b/tutorials/combustion/fireFoam/les/smallPoolFire3D/system/fvSchemes
@@ -59,11 +59,5 @@ snGradSchemes
     default         corrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p_rgh;
-}
-
 
 // ************************************************************************* //
diff --git a/tutorials/combustion/reactingFoam/ras/counterFlowFlame2D/system/fvSchemes b/tutorials/combustion/reactingFoam/ras/counterFlowFlame2D/system/fvSchemes
index 48b4e3fff9..9208e7ca8f 100644
--- a/tutorials/combustion/reactingFoam/ras/counterFlowFlame2D/system/fvSchemes
+++ b/tutorials/combustion/reactingFoam/ras/counterFlowFlame2D/system/fvSchemes
@@ -53,11 +53,5 @@ snGradSchemes
     default         orthogonal;
 }
 
-fluxRequired
-{
-    default         no;
-    p;
-}
-
 
 // ************************************************************************* //
diff --git a/tutorials/combustion/reactingFoam/ras/counterFlowFlame2DLTS/system/fvSchemes b/tutorials/combustion/reactingFoam/ras/counterFlowFlame2DLTS/system/fvSchemes
index edeed781b1..4eac5336f5 100644
--- a/tutorials/combustion/reactingFoam/ras/counterFlowFlame2DLTS/system/fvSchemes
+++ b/tutorials/combustion/reactingFoam/ras/counterFlowFlame2DLTS/system/fvSchemes
@@ -53,11 +53,5 @@ snGradSchemes
     default         orthogonal;
 }
 
-fluxRequired
-{
-    default         no;
-    p;
-}
-
 
 // ************************************************************************* //
diff --git a/tutorials/compressible/rhoPimpleDyMFoam/annularThermalMixer/system/fvSchemes b/tutorials/compressible/rhoPimpleDyMFoam/annularThermalMixer/system/fvSchemes
index 1cd4e17a52..da7424d0e2 100644
--- a/tutorials/compressible/rhoPimpleDyMFoam/annularThermalMixer/system/fvSchemes
+++ b/tutorials/compressible/rhoPimpleDyMFoam/annularThermalMixer/system/fvSchemes
@@ -53,12 +53,4 @@ snGradSchemes
     default         corrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p               ;
-    pcorr           ;
-}
-
-
 // ************************************************************************* //
diff --git a/tutorials/compressible/rhoPimpleFoam/les/pitzDaily/system/fvSchemes b/tutorials/compressible/rhoPimpleFoam/les/pitzDaily/system/fvSchemes
index 36d3193afd..60b6961604 100644
--- a/tutorials/compressible/rhoPimpleFoam/les/pitzDaily/system/fvSchemes
+++ b/tutorials/compressible/rhoPimpleFoam/les/pitzDaily/system/fvSchemes
@@ -54,11 +54,5 @@ snGradSchemes
     default         corrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p               ;
-}
-
 
 // ************************************************************************* //
diff --git a/tutorials/compressible/rhoPimpleFoam/ras/angledDuct/system/fvSchemes b/tutorials/compressible/rhoPimpleFoam/ras/angledDuct/system/fvSchemes
index dce2ee09ff..359d6ad3e1 100644
--- a/tutorials/compressible/rhoPimpleFoam/ras/angledDuct/system/fvSchemes
+++ b/tutorials/compressible/rhoPimpleFoam/ras/angledDuct/system/fvSchemes
@@ -57,11 +57,5 @@ snGradSchemes
     default         corrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p               ;
-}
-
 
 // ************************************************************************* //
diff --git a/tutorials/compressible/rhoPimpleFoam/ras/angledDuctLTS/system/fvSchemes b/tutorials/compressible/rhoPimpleFoam/ras/angledDuctLTS/system/fvSchemes
index 8d1dad976f..a1fefe7b4b 100644
--- a/tutorials/compressible/rhoPimpleFoam/ras/angledDuctLTS/system/fvSchemes
+++ b/tutorials/compressible/rhoPimpleFoam/ras/angledDuctLTS/system/fvSchemes
@@ -57,11 +57,5 @@ snGradSchemes
     default         corrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p               ;
-}
-
 
 // ************************************************************************* //
diff --git a/tutorials/compressible/rhoPimpleFoam/ras/cavity/system/fvSchemes b/tutorials/compressible/rhoPimpleFoam/ras/cavity/system/fvSchemes
index c2728910fe..748560d7c2 100644
--- a/tutorials/compressible/rhoPimpleFoam/ras/cavity/system/fvSchemes
+++ b/tutorials/compressible/rhoPimpleFoam/ras/cavity/system/fvSchemes
@@ -57,12 +57,6 @@ snGradSchemes
     default         orthogonal;
 }
 
-fluxRequired
-{
-    default         no;
-    p               ;
-}
-
 wallDist
 {
     method meshWave;
diff --git a/tutorials/compressible/rhoPimpleFoam/ras/mixerVessel2D/system/fvSchemes b/tutorials/compressible/rhoPimpleFoam/ras/mixerVessel2D/system/fvSchemes
index ddea2bbda0..71bcc6b81f 100644
--- a/tutorials/compressible/rhoPimpleFoam/ras/mixerVessel2D/system/fvSchemes
+++ b/tutorials/compressible/rhoPimpleFoam/ras/mixerVessel2D/system/fvSchemes
@@ -51,11 +51,5 @@ snGradSchemes
     default         corrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p               ;
-}
-
 
 // ************************************************************************* //
diff --git a/tutorials/compressible/rhoPorousSimpleFoam/angledDuctExplicit/system/fvSchemes b/tutorials/compressible/rhoPorousSimpleFoam/angledDuctExplicit/system/fvSchemes
index 232bd728b0..890b5f5632 100644
--- a/tutorials/compressible/rhoPorousSimpleFoam/angledDuctExplicit/system/fvSchemes
+++ b/tutorials/compressible/rhoPorousSimpleFoam/angledDuctExplicit/system/fvSchemes
@@ -50,11 +50,5 @@ snGradSchemes
     default         corrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p               ;
-}
-
 
 // ************************************************************************* //
diff --git a/tutorials/compressible/rhoPorousSimpleFoam/angledDuctImplicit/system/fvSchemes b/tutorials/compressible/rhoPorousSimpleFoam/angledDuctImplicit/system/fvSchemes
index 232bd728b0..890b5f5632 100644
--- a/tutorials/compressible/rhoPorousSimpleFoam/angledDuctImplicit/system/fvSchemes
+++ b/tutorials/compressible/rhoPorousSimpleFoam/angledDuctImplicit/system/fvSchemes
@@ -50,11 +50,5 @@ snGradSchemes
     default         corrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p               ;
-}
-
 
 // ************************************************************************* //
diff --git a/tutorials/compressible/rhoSimpleFoam/angledDuctExplicitFixedCoeff/system/fvSchemes b/tutorials/compressible/rhoSimpleFoam/angledDuctExplicitFixedCoeff/system/fvSchemes
index 7c3213ef9b..b23305abb6 100644
--- a/tutorials/compressible/rhoSimpleFoam/angledDuctExplicitFixedCoeff/system/fvSchemes
+++ b/tutorials/compressible/rhoSimpleFoam/angledDuctExplicitFixedCoeff/system/fvSchemes
@@ -52,11 +52,5 @@ snGradSchemes
     default         corrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p               ;
-}
-
 
 // ************************************************************************* //
diff --git a/tutorials/compressible/rhoSimpleFoam/squareBend/system/fvSchemes b/tutorials/compressible/rhoSimpleFoam/squareBend/system/fvSchemes
index 665b390b98..ac63c55d11 100644
--- a/tutorials/compressible/rhoSimpleFoam/squareBend/system/fvSchemes
+++ b/tutorials/compressible/rhoSimpleFoam/squareBend/system/fvSchemes
@@ -55,11 +55,5 @@ snGradSchemes
     default         corrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p;
-    pCorr;
-}
 
 // ************************************************************************* //
diff --git a/tutorials/compressible/sonicDyMFoam/movingCone/system/fvSchemes b/tutorials/compressible/sonicDyMFoam/movingCone/system/fvSchemes
index 3a23ea6bb7..823e92a106 100644
--- a/tutorials/compressible/sonicDyMFoam/movingCone/system/fvSchemes
+++ b/tutorials/compressible/sonicDyMFoam/movingCone/system/fvSchemes
@@ -55,12 +55,4 @@ snGradSchemes
     default         corrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p               ;
-    pcorr           ;
-}
-
-
 // ************************************************************************* //
diff --git a/tutorials/compressible/sonicFoam/laminar/forwardStep/system/fvSchemes b/tutorials/compressible/sonicFoam/laminar/forwardStep/system/fvSchemes
index 0b421e801c..fb2db00392 100644
--- a/tutorials/compressible/sonicFoam/laminar/forwardStep/system/fvSchemes
+++ b/tutorials/compressible/sonicFoam/laminar/forwardStep/system/fvSchemes
@@ -52,11 +52,5 @@ snGradSchemes
     default         corrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p               ;
-}
-
 
 // ************************************************************************* //
diff --git a/tutorials/compressible/sonicFoam/laminar/shockTube/system/fvSchemes b/tutorials/compressible/sonicFoam/laminar/shockTube/system/fvSchemes
index 85d4f97a6c..43433e562d 100644
--- a/tutorials/compressible/sonicFoam/laminar/shockTube/system/fvSchemes
+++ b/tutorials/compressible/sonicFoam/laminar/shockTube/system/fvSchemes
@@ -51,11 +51,5 @@ snGradSchemes
     default         orthogonal;
 }
 
-fluxRequired
-{
-    default         no;
-    p               ;
-}
-
 
 // ************************************************************************* //
diff --git a/tutorials/compressible/sonicFoam/ras/nacaAirfoil/system/fvSchemes b/tutorials/compressible/sonicFoam/ras/nacaAirfoil/system/fvSchemes
index e43f10e9b9..68acc29cb7 100644
--- a/tutorials/compressible/sonicFoam/ras/nacaAirfoil/system/fvSchemes
+++ b/tutorials/compressible/sonicFoam/ras/nacaAirfoil/system/fvSchemes
@@ -53,11 +53,5 @@ snGradSchemes
     default         corrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p;
-}
-
 
 // ************************************************************************* //
diff --git a/tutorials/compressible/sonicFoam/ras/prism/system/fvSchemes b/tutorials/compressible/sonicFoam/ras/prism/system/fvSchemes
index 6519c5e77c..cf64fe7144 100644
--- a/tutorials/compressible/sonicFoam/ras/prism/system/fvSchemes
+++ b/tutorials/compressible/sonicFoam/ras/prism/system/fvSchemes
@@ -53,11 +53,5 @@ snGradSchemes
     default         corrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p;
-}
-
 
 // ************************************************************************* //
diff --git a/tutorials/compressible/sonicLiquidFoam/decompressionTank/system/fvSchemes b/tutorials/compressible/sonicLiquidFoam/decompressionTank/system/fvSchemes
index 0e2f9b22f7..85de5505e1 100644
--- a/tutorials/compressible/sonicLiquidFoam/decompressionTank/system/fvSchemes
+++ b/tutorials/compressible/sonicLiquidFoam/decompressionTank/system/fvSchemes
@@ -47,11 +47,5 @@ snGradSchemes
     default         corrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p               ;
-}
-
 
 // ************************************************************************* //
diff --git a/tutorials/discreteMethods/dsmcFoam/freeSpacePeriodic/system/fvSchemes b/tutorials/discreteMethods/dsmcFoam/freeSpacePeriodic/system/fvSchemes
index 2e5c55b28b..f2b1c3d1e5 100644
--- a/tutorials/discreteMethods/dsmcFoam/freeSpacePeriodic/system/fvSchemes
+++ b/tutorials/discreteMethods/dsmcFoam/freeSpacePeriodic/system/fvSchemes
@@ -45,10 +45,4 @@ snGradSchemes
     default         none;
 }
 
-fluxRequired
-{
-    default         no;
-}
-
-
 // ************************************************************************* //
diff --git a/tutorials/discreteMethods/dsmcFoam/freeSpaceStream/system/fvSchemes b/tutorials/discreteMethods/dsmcFoam/freeSpaceStream/system/fvSchemes
index 2e5c55b28b..f2b1c3d1e5 100644
--- a/tutorials/discreteMethods/dsmcFoam/freeSpaceStream/system/fvSchemes
+++ b/tutorials/discreteMethods/dsmcFoam/freeSpaceStream/system/fvSchemes
@@ -45,10 +45,4 @@ snGradSchemes
     default         none;
 }
 
-fluxRequired
-{
-    default         no;
-}
-
-
 // ************************************************************************* //
diff --git a/tutorials/discreteMethods/dsmcFoam/supersonicCorner/system/fvSchemes b/tutorials/discreteMethods/dsmcFoam/supersonicCorner/system/fvSchemes
index 2e5c55b28b..f2b1c3d1e5 100644
--- a/tutorials/discreteMethods/dsmcFoam/supersonicCorner/system/fvSchemes
+++ b/tutorials/discreteMethods/dsmcFoam/supersonicCorner/system/fvSchemes
@@ -45,10 +45,4 @@ snGradSchemes
     default         none;
 }
 
-fluxRequired
-{
-    default         no;
-}
-
-
 // ************************************************************************* //
diff --git a/tutorials/discreteMethods/dsmcFoam/wedge15Ma5/system/fvSchemes b/tutorials/discreteMethods/dsmcFoam/wedge15Ma5/system/fvSchemes
index 2e5c55b28b..f2b1c3d1e5 100644
--- a/tutorials/discreteMethods/dsmcFoam/wedge15Ma5/system/fvSchemes
+++ b/tutorials/discreteMethods/dsmcFoam/wedge15Ma5/system/fvSchemes
@@ -45,10 +45,4 @@ snGradSchemes
     default         none;
 }
 
-fluxRequired
-{
-    default         no;
-}
-
-
 // ************************************************************************* //
diff --git a/tutorials/discreteMethods/molecularDynamics/mdEquilibrationFoam/periodicCubeArgon/system/fvSchemes b/tutorials/discreteMethods/molecularDynamics/mdEquilibrationFoam/periodicCubeArgon/system/fvSchemes
index 2e5c55b28b..f2b1c3d1e5 100644
--- a/tutorials/discreteMethods/molecularDynamics/mdEquilibrationFoam/periodicCubeArgon/system/fvSchemes
+++ b/tutorials/discreteMethods/molecularDynamics/mdEquilibrationFoam/periodicCubeArgon/system/fvSchemes
@@ -45,10 +45,4 @@ snGradSchemes
     default         none;
 }
 
-fluxRequired
-{
-    default         no;
-}
-
-
 // ************************************************************************* //
diff --git a/tutorials/discreteMethods/molecularDynamics/mdEquilibrationFoam/periodicCubeWater/system/fvSchemes b/tutorials/discreteMethods/molecularDynamics/mdEquilibrationFoam/periodicCubeWater/system/fvSchemes
index 2e5c55b28b..f2b1c3d1e5 100644
--- a/tutorials/discreteMethods/molecularDynamics/mdEquilibrationFoam/periodicCubeWater/system/fvSchemes
+++ b/tutorials/discreteMethods/molecularDynamics/mdEquilibrationFoam/periodicCubeWater/system/fvSchemes
@@ -45,10 +45,4 @@ snGradSchemes
     default         none;
 }
 
-fluxRequired
-{
-    default         no;
-}
-
-
 // ************************************************************************* //
diff --git a/tutorials/discreteMethods/molecularDynamics/mdFoam/nanoNozzle/system/fvSchemes b/tutorials/discreteMethods/molecularDynamics/mdFoam/nanoNozzle/system/fvSchemes
index 2e5c55b28b..f2b1c3d1e5 100644
--- a/tutorials/discreteMethods/molecularDynamics/mdFoam/nanoNozzle/system/fvSchemes
+++ b/tutorials/discreteMethods/molecularDynamics/mdFoam/nanoNozzle/system/fvSchemes
@@ -45,10 +45,4 @@ snGradSchemes
     default         none;
 }
 
-fluxRequired
-{
-    default         no;
-}
-
-
 // ************************************************************************* //
diff --git a/tutorials/electromagnetics/electrostaticFoam/chargedWire/system/fvSchemes b/tutorials/electromagnetics/electrostaticFoam/chargedWire/system/fvSchemes
index 7e4087cf14..181294c4b9 100644
--- a/tutorials/electromagnetics/electrostaticFoam/chargedWire/system/fvSchemes
+++ b/tutorials/electromagnetics/electrostaticFoam/chargedWire/system/fvSchemes
@@ -47,11 +47,5 @@ snGradSchemes
     default         corrected;
 }
 
-fluxRequired
-{
-    default         no;
-    phi             ;
-}
-
 
 // ************************************************************************* //
diff --git a/tutorials/electromagnetics/mhdFoam/hartmann/system/fvSchemes b/tutorials/electromagnetics/mhdFoam/hartmann/system/fvSchemes
index 26477dec7e..5332e1f62f 100644
--- a/tutorials/electromagnetics/mhdFoam/hartmann/system/fvSchemes
+++ b/tutorials/electromagnetics/mhdFoam/hartmann/system/fvSchemes
@@ -49,12 +49,4 @@ snGradSchemes
     default         corrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p               ;
-    pB              ;
-}
-
-
 // ************************************************************************* //
diff --git a/tutorials/heatTransfer/buoyantBoussinesqPimpleFoam/hotRoom/system/fvSchemes b/tutorials/heatTransfer/buoyantBoussinesqPimpleFoam/hotRoom/system/fvSchemes
index 9052cd188f..c81e72a231 100644
--- a/tutorials/heatTransfer/buoyantBoussinesqPimpleFoam/hotRoom/system/fvSchemes
+++ b/tutorials/heatTransfer/buoyantBoussinesqPimpleFoam/hotRoom/system/fvSchemes
@@ -53,11 +53,5 @@ snGradSchemes
     default         uncorrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p_rgh;
-}
-
 
 // ************************************************************************* //
diff --git a/tutorials/heatTransfer/buoyantBoussinesqSimpleFoam/hotRoom/system/fvSchemes b/tutorials/heatTransfer/buoyantBoussinesqSimpleFoam/hotRoom/system/fvSchemes
index cbc48629e5..5314cd6d6c 100644
--- a/tutorials/heatTransfer/buoyantBoussinesqSimpleFoam/hotRoom/system/fvSchemes
+++ b/tutorials/heatTransfer/buoyantBoussinesqSimpleFoam/hotRoom/system/fvSchemes
@@ -51,11 +51,5 @@ snGradSchemes
     default         corrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p_rgh           ;
-}
-
 
 // ************************************************************************* //
diff --git a/tutorials/heatTransfer/buoyantBoussinesqSimpleFoam/iglooWithFridges/system/fvSchemes b/tutorials/heatTransfer/buoyantBoussinesqSimpleFoam/iglooWithFridges/system/fvSchemes
index b64a3959f5..3d8c60dc1f 100644
--- a/tutorials/heatTransfer/buoyantBoussinesqSimpleFoam/iglooWithFridges/system/fvSchemes
+++ b/tutorials/heatTransfer/buoyantBoussinesqSimpleFoam/iglooWithFridges/system/fvSchemes
@@ -53,11 +53,5 @@ snGradSchemes
     default         limited corrected 0.333;
 }
 
-fluxRequired
-{
-    default         no;
-    p_rgh           ;
-}
-
 
 // ************************************************************************* //
diff --git a/tutorials/heatTransfer/buoyantPimpleFoam/hotRoom/system/fvSchemes b/tutorials/heatTransfer/buoyantPimpleFoam/hotRoom/system/fvSchemes
index d156cf98bb..994a06ef44 100644
--- a/tutorials/heatTransfer/buoyantPimpleFoam/hotRoom/system/fvSchemes
+++ b/tutorials/heatTransfer/buoyantPimpleFoam/hotRoom/system/fvSchemes
@@ -55,11 +55,5 @@ snGradSchemes
     default         corrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p_rgh;
-}
-
 
 // ************************************************************************* //
diff --git a/tutorials/heatTransfer/buoyantSimpleFoam/buoyantCavity/system/fvSchemes b/tutorials/heatTransfer/buoyantSimpleFoam/buoyantCavity/system/fvSchemes
index d2738ff36b..0b96d46074 100644
--- a/tutorials/heatTransfer/buoyantSimpleFoam/buoyantCavity/system/fvSchemes
+++ b/tutorials/heatTransfer/buoyantSimpleFoam/buoyantCavity/system/fvSchemes
@@ -52,12 +52,6 @@ snGradSchemes
     default         orthogonal;
 }
 
-fluxRequired
-{
-    default         no;
-    p_rgh;
-}
-
 wallDist
 {
     method meshWave;
diff --git a/tutorials/heatTransfer/buoyantSimpleFoam/circuitBoardCooling/system/fvSchemes b/tutorials/heatTransfer/buoyantSimpleFoam/circuitBoardCooling/system/fvSchemes
index 0c8ae95a6d..7e71c2ea5f 100644
--- a/tutorials/heatTransfer/buoyantSimpleFoam/circuitBoardCooling/system/fvSchemes
+++ b/tutorials/heatTransfer/buoyantSimpleFoam/circuitBoardCooling/system/fvSchemes
@@ -57,11 +57,5 @@ snGradSchemes
     default         uncorrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p_rgh;
-}
-
 
 // ************************************************************************* //
diff --git a/tutorials/heatTransfer/buoyantSimpleFoam/externalCoupledCavity/system/fvSchemes b/tutorials/heatTransfer/buoyantSimpleFoam/externalCoupledCavity/system/fvSchemes
index d2738ff36b..0b96d46074 100644
--- a/tutorials/heatTransfer/buoyantSimpleFoam/externalCoupledCavity/system/fvSchemes
+++ b/tutorials/heatTransfer/buoyantSimpleFoam/externalCoupledCavity/system/fvSchemes
@@ -52,12 +52,6 @@ snGradSchemes
     default         orthogonal;
 }
 
-fluxRequired
-{
-    default         no;
-    p_rgh;
-}
-
 wallDist
 {
     method meshWave;
diff --git a/tutorials/heatTransfer/buoyantSimpleFoam/hotRadiationRoom/system/fvSchemes b/tutorials/heatTransfer/buoyantSimpleFoam/hotRadiationRoom/system/fvSchemes
index 293a173b11..96b831bc89 100644
--- a/tutorials/heatTransfer/buoyantSimpleFoam/hotRadiationRoom/system/fvSchemes
+++ b/tutorials/heatTransfer/buoyantSimpleFoam/hotRadiationRoom/system/fvSchemes
@@ -51,11 +51,5 @@ snGradSchemes
     default         corrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p_rgh;
-}
-
 
 // ************************************************************************* //
diff --git a/tutorials/heatTransfer/buoyantSimpleFoam/hotRadiationRoomFvDOM/system/fvSchemes b/tutorials/heatTransfer/buoyantSimpleFoam/hotRadiationRoomFvDOM/system/fvSchemes
index 1abd80550c..54466bf0d1 100644
--- a/tutorials/heatTransfer/buoyantSimpleFoam/hotRadiationRoomFvDOM/system/fvSchemes
+++ b/tutorials/heatTransfer/buoyantSimpleFoam/hotRadiationRoomFvDOM/system/fvSchemes
@@ -52,11 +52,5 @@ snGradSchemes
     default         corrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p_rgh;
-}
-
 
 // ************************************************************************* //
diff --git a/tutorials/heatTransfer/chtMultiRegionFoam/multiRegionHeater/system/bottomWater/fvSchemes b/tutorials/heatTransfer/chtMultiRegionFoam/multiRegionHeater/system/bottomWater/fvSchemes
index 1278f2856a..8f2303576a 100644
--- a/tutorials/heatTransfer/chtMultiRegionFoam/multiRegionHeater/system/bottomWater/fvSchemes
+++ b/tutorials/heatTransfer/chtMultiRegionFoam/multiRegionHeater/system/bottomWater/fvSchemes
@@ -53,10 +53,4 @@ snGradSchemes
     default         corrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p_rgh;
-}
-
 // ************************************************************************* //
diff --git a/tutorials/heatTransfer/chtMultiRegionFoam/multiRegionHeater/system/fvSchemes b/tutorials/heatTransfer/chtMultiRegionFoam/multiRegionHeater/system/fvSchemes
index e7d321e959..a61bdb780e 100644
--- a/tutorials/heatTransfer/chtMultiRegionFoam/multiRegionHeater/system/fvSchemes
+++ b/tutorials/heatTransfer/chtMultiRegionFoam/multiRegionHeater/system/fvSchemes
@@ -38,9 +38,5 @@ snGradSchemes
 {
 }
 
-fluxRequired
-{
-}
-
 
 // ************************************************************************* //
diff --git a/tutorials/heatTransfer/chtMultiRegionFoam/multiRegionHeater/system/heater/fvSchemes b/tutorials/heatTransfer/chtMultiRegionFoam/multiRegionHeater/system/heater/fvSchemes
index d1227f9fad..0f84921410 100644
--- a/tutorials/heatTransfer/chtMultiRegionFoam/multiRegionHeater/system/heater/fvSchemes
+++ b/tutorials/heatTransfer/chtMultiRegionFoam/multiRegionHeater/system/heater/fvSchemes
@@ -45,9 +45,5 @@ snGradSchemes
     default         corrected;
 }
 
-fluxRequired
-{
-    default         no;
-}
 
 // ************************************************************************* //
diff --git a/tutorials/heatTransfer/chtMultiRegionFoam/snappyMultiRegionHeater/system/bottomAir/fvSchemes b/tutorials/heatTransfer/chtMultiRegionFoam/snappyMultiRegionHeater/system/bottomAir/fvSchemes
index 867b0a2e97..4e566a5ec1 100644
--- a/tutorials/heatTransfer/chtMultiRegionFoam/snappyMultiRegionHeater/system/bottomAir/fvSchemes
+++ b/tutorials/heatTransfer/chtMultiRegionFoam/snappyMultiRegionHeater/system/bottomAir/fvSchemes
@@ -53,10 +53,4 @@ snGradSchemes
     default         corrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p_rgh;
-}
-
 // ************************************************************************* //
diff --git a/tutorials/heatTransfer/chtMultiRegionFoam/snappyMultiRegionHeater/system/fvSchemes b/tutorials/heatTransfer/chtMultiRegionFoam/snappyMultiRegionHeater/system/fvSchemes
index e7d321e959..a61bdb780e 100644
--- a/tutorials/heatTransfer/chtMultiRegionFoam/snappyMultiRegionHeater/system/fvSchemes
+++ b/tutorials/heatTransfer/chtMultiRegionFoam/snappyMultiRegionHeater/system/fvSchemes
@@ -38,9 +38,5 @@ snGradSchemes
 {
 }
 
-fluxRequired
-{
-}
-
 
 // ************************************************************************* //
diff --git a/tutorials/heatTransfer/chtMultiRegionFoam/snappyMultiRegionHeater/system/heater/fvSchemes b/tutorials/heatTransfer/chtMultiRegionFoam/snappyMultiRegionHeater/system/heater/fvSchemes
index 8a14cb557a..2adcc274a3 100644
--- a/tutorials/heatTransfer/chtMultiRegionFoam/snappyMultiRegionHeater/system/heater/fvSchemes
+++ b/tutorials/heatTransfer/chtMultiRegionFoam/snappyMultiRegionHeater/system/heater/fvSchemes
@@ -45,9 +45,5 @@ snGradSchemes
     default         corrected;
 }
 
-fluxRequired
-{
-    default         no;
-}
 
 // ************************************************************************* //
diff --git a/tutorials/heatTransfer/chtMultiRegionSimpleFoam/heatExchanger/system/air/fvSchemes b/tutorials/heatTransfer/chtMultiRegionSimpleFoam/heatExchanger/system/air/fvSchemes
index 52e15c826b..cd9de1b917 100644
--- a/tutorials/heatTransfer/chtMultiRegionSimpleFoam/heatExchanger/system/air/fvSchemes
+++ b/tutorials/heatTransfer/chtMultiRegionSimpleFoam/heatExchanger/system/air/fvSchemes
@@ -53,11 +53,5 @@ snGradSchemes
     default         limited 0.333;
 }
 
-fluxRequired
-{
-    default         no;
-    p_rgh;
-}
-
 
 // ************************************************************************* //
diff --git a/tutorials/heatTransfer/chtMultiRegionSimpleFoam/heatExchanger/system/fvSchemes b/tutorials/heatTransfer/chtMultiRegionSimpleFoam/heatExchanger/system/fvSchemes
index e7d321e959..a61bdb780e 100644
--- a/tutorials/heatTransfer/chtMultiRegionSimpleFoam/heatExchanger/system/fvSchemes
+++ b/tutorials/heatTransfer/chtMultiRegionSimpleFoam/heatExchanger/system/fvSchemes
@@ -38,9 +38,5 @@ snGradSchemes
 {
 }
 
-fluxRequired
-{
-}
-
 
 // ************************************************************************* //
diff --git a/tutorials/heatTransfer/chtMultiRegionSimpleFoam/heatExchanger/system/porous/fvSchemes b/tutorials/heatTransfer/chtMultiRegionSimpleFoam/heatExchanger/system/porous/fvSchemes
index 27a33bf7c4..e20a0291b4 100644
--- a/tutorials/heatTransfer/chtMultiRegionSimpleFoam/heatExchanger/system/porous/fvSchemes
+++ b/tutorials/heatTransfer/chtMultiRegionSimpleFoam/heatExchanger/system/porous/fvSchemes
@@ -52,10 +52,4 @@ snGradSchemes
     default         uncorrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p_rgh;
-}
-
 // ************************************************************************* //
diff --git a/tutorials/heatTransfer/chtMultiRegionSimpleFoam/multiRegionHeaterRadiation/system/bottomAir/fvSchemes b/tutorials/heatTransfer/chtMultiRegionSimpleFoam/multiRegionHeaterRadiation/system/bottomAir/fvSchemes
index f761dabb4a..7629bb9034 100644
--- a/tutorials/heatTransfer/chtMultiRegionSimpleFoam/multiRegionHeaterRadiation/system/bottomAir/fvSchemes
+++ b/tutorials/heatTransfer/chtMultiRegionSimpleFoam/multiRegionHeaterRadiation/system/bottomAir/fvSchemes
@@ -55,10 +55,4 @@ snGradSchemes
     default         uncorrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p_rgh;
-}
-
 // ************************************************************************* //
diff --git a/tutorials/heatTransfer/chtMultiRegionSimpleFoam/multiRegionHeaterRadiation/system/fvSchemes b/tutorials/heatTransfer/chtMultiRegionSimpleFoam/multiRegionHeaterRadiation/system/fvSchemes
index e7d321e959..a61bdb780e 100644
--- a/tutorials/heatTransfer/chtMultiRegionSimpleFoam/multiRegionHeaterRadiation/system/fvSchemes
+++ b/tutorials/heatTransfer/chtMultiRegionSimpleFoam/multiRegionHeaterRadiation/system/fvSchemes
@@ -38,9 +38,5 @@ snGradSchemes
 {
 }
 
-fluxRequired
-{
-}
-
 
 // ************************************************************************* //
diff --git a/tutorials/heatTransfer/chtMultiRegionSimpleFoam/multiRegionHeaterRadiation/system/heater/fvSchemes b/tutorials/heatTransfer/chtMultiRegionSimpleFoam/multiRegionHeaterRadiation/system/heater/fvSchemes
index ec4697cc46..7cdc6a2121 100644
--- a/tutorials/heatTransfer/chtMultiRegionSimpleFoam/multiRegionHeaterRadiation/system/heater/fvSchemes
+++ b/tutorials/heatTransfer/chtMultiRegionSimpleFoam/multiRegionHeaterRadiation/system/heater/fvSchemes
@@ -45,9 +45,5 @@ snGradSchemes
     default         uncorrected;
 }
 
-fluxRequired
-{
-    default         no;
-}
 
 // ************************************************************************* //
diff --git a/tutorials/lagrangian/DPMFoam/Goldschmidt/system/fvSchemes b/tutorials/lagrangian/DPMFoam/Goldschmidt/system/fvSchemes
index 18c11cd83e..080bc042fa 100644
--- a/tutorials/lagrangian/DPMFoam/Goldschmidt/system/fvSchemes
+++ b/tutorials/lagrangian/DPMFoam/Goldschmidt/system/fvSchemes
@@ -47,11 +47,5 @@ snGradSchemes
     default         corrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p;
-    kinematicCloud:theta;
-}
 
 // ************************************************************************* //
diff --git a/tutorials/lagrangian/MPPICFoam/Goldschmidt/system/fvSchemes b/tutorials/lagrangian/MPPICFoam/Goldschmidt/system/fvSchemes
index 15f5199ddf..d78fa6fa5d 100644
--- a/tutorials/lagrangian/MPPICFoam/Goldschmidt/system/fvSchemes
+++ b/tutorials/lagrangian/MPPICFoam/Goldschmidt/system/fvSchemes
@@ -49,11 +49,5 @@ snGradSchemes
     default         corrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p;
-    kinematicCloud:alpha;
-}
 
 // ************************************************************************* //
diff --git a/tutorials/lagrangian/MPPICFoam/column/system/fvSchemes b/tutorials/lagrangian/MPPICFoam/column/system/fvSchemes
index d06501ddd9..be85128ef5 100644
--- a/tutorials/lagrangian/MPPICFoam/column/system/fvSchemes
+++ b/tutorials/lagrangian/MPPICFoam/column/system/fvSchemes
@@ -54,11 +54,5 @@ snGradSchemes
     default         corrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p;
-    kinematicCloud:alpha;
-}
 
 // ************************************************************************* //
diff --git a/tutorials/lagrangian/MPPICFoam/cyclone/system/fvSchemes b/tutorials/lagrangian/MPPICFoam/cyclone/system/fvSchemes
index 04a26e623b..f820310d23 100644
--- a/tutorials/lagrangian/MPPICFoam/cyclone/system/fvSchemes
+++ b/tutorials/lagrangian/MPPICFoam/cyclone/system/fvSchemes
@@ -49,11 +49,5 @@ snGradSchemes
     default         corrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p;
-    kinematicCloud:alpha;
-}
 
 // ************************************************************************* //
diff --git a/tutorials/lagrangian/MPPICFoam/injectionChannel/system/fvSchemes b/tutorials/lagrangian/MPPICFoam/injectionChannel/system/fvSchemes
index c89c3eef94..b044660a05 100644
--- a/tutorials/lagrangian/MPPICFoam/injectionChannel/system/fvSchemes
+++ b/tutorials/lagrangian/MPPICFoam/injectionChannel/system/fvSchemes
@@ -47,10 +47,4 @@ snGradSchemes
     default         corrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p;
-}
-
 // ************************************************************************* //
diff --git a/tutorials/lagrangian/coalChemistryFoam/simplifiedSiwek/system/fvSchemes b/tutorials/lagrangian/coalChemistryFoam/simplifiedSiwek/system/fvSchemes
index dfc5123588..85910aef45 100644
--- a/tutorials/lagrangian/coalChemistryFoam/simplifiedSiwek/system/fvSchemes
+++ b/tutorials/lagrangian/coalChemistryFoam/simplifiedSiwek/system/fvSchemes
@@ -55,11 +55,5 @@ snGradSchemes
     default         orthogonal;
 }
 
-fluxRequired
-{
-    default         no;
-    p               ;
-}
-
 
 // ************************************************************************* //
diff --git a/tutorials/lagrangian/reactingParcelFilmFoam/cylinder/system/fvSchemes b/tutorials/lagrangian/reactingParcelFilmFoam/cylinder/system/fvSchemes
index f073a5ff5b..76448b808b 100644
--- a/tutorials/lagrangian/reactingParcelFilmFoam/cylinder/system/fvSchemes
+++ b/tutorials/lagrangian/reactingParcelFilmFoam/cylinder/system/fvSchemes
@@ -54,12 +54,6 @@ snGradSchemes
     default         corrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p_rgh;
-}
-
 
 
 // ************************************************************************* //
diff --git a/tutorials/lagrangian/reactingParcelFilmFoam/cylinder/system/wallFilmRegion/fvSchemes b/tutorials/lagrangian/reactingParcelFilmFoam/cylinder/system/wallFilmRegion/fvSchemes
index cab4ed8a5b..83a7faa077 100644
--- a/tutorials/lagrangian/reactingParcelFilmFoam/cylinder/system/wallFilmRegion/fvSchemes
+++ b/tutorials/lagrangian/reactingParcelFilmFoam/cylinder/system/wallFilmRegion/fvSchemes
@@ -61,11 +61,5 @@ snGradSchemes
     snGrad(deltaf) uncorrected;
 }
 
-fluxRequired
-{
-    default no;
-    deltaf;
-}
-
 
 // ************************************************************************* //
diff --git a/tutorials/lagrangian/reactingParcelFilmFoam/hotBoxes/system/fvSchemes b/tutorials/lagrangian/reactingParcelFilmFoam/hotBoxes/system/fvSchemes
index cc232dbb08..db567d0710 100644
--- a/tutorials/lagrangian/reactingParcelFilmFoam/hotBoxes/system/fvSchemes
+++ b/tutorials/lagrangian/reactingParcelFilmFoam/hotBoxes/system/fvSchemes
@@ -54,12 +54,6 @@ snGradSchemes
     default         uncorrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p_rgh;
-}
-
 
 
 // ************************************************************************* //
diff --git a/tutorials/lagrangian/reactingParcelFilmFoam/hotBoxes/system/wallFilmRegion.org/fvSchemes b/tutorials/lagrangian/reactingParcelFilmFoam/hotBoxes/system/wallFilmRegion.org/fvSchemes
index d93ea9bbbd..e82818faae 100644
--- a/tutorials/lagrangian/reactingParcelFilmFoam/hotBoxes/system/wallFilmRegion.org/fvSchemes
+++ b/tutorials/lagrangian/reactingParcelFilmFoam/hotBoxes/system/wallFilmRegion.org/fvSchemes
@@ -59,11 +59,5 @@ snGradSchemes
     snGrad(deltaf) uncorrected;
 }
 
-fluxRequired
-{
-    default no;
-    deltaf;
-}
-
 
 // ************************************************************************* //
diff --git a/tutorials/lagrangian/reactingParcelFilmFoam/rivuletPanel/system/fvSchemes b/tutorials/lagrangian/reactingParcelFilmFoam/rivuletPanel/system/fvSchemes
index 1885c5628c..5f39e30362 100644
--- a/tutorials/lagrangian/reactingParcelFilmFoam/rivuletPanel/system/fvSchemes
+++ b/tutorials/lagrangian/reactingParcelFilmFoam/rivuletPanel/system/fvSchemes
@@ -54,12 +54,6 @@ snGradSchemes
     default         orthogonal;
 }
 
-fluxRequired
-{
-    default         no;
-    p_rgh;
-}
-
 
 
 // ************************************************************************* //
diff --git a/tutorials/lagrangian/reactingParcelFilmFoam/rivuletPanel/system/wallFilmRegion/fvSchemes b/tutorials/lagrangian/reactingParcelFilmFoam/rivuletPanel/system/wallFilmRegion/fvSchemes
index 05a7bee966..529db4dc28 100644
--- a/tutorials/lagrangian/reactingParcelFilmFoam/rivuletPanel/system/wallFilmRegion/fvSchemes
+++ b/tutorials/lagrangian/reactingParcelFilmFoam/rivuletPanel/system/wallFilmRegion/fvSchemes
@@ -58,11 +58,5 @@ snGradSchemes
     snGrad(deltaf) orthogonal;
 }
 
-fluxRequired
-{
-    default no;
-    deltaf;
-}
-
 
 // ************************************************************************* //
diff --git a/tutorials/lagrangian/reactingParcelFilmFoam/splashPanel/system/fvSchemes b/tutorials/lagrangian/reactingParcelFilmFoam/splashPanel/system/fvSchemes
index cc232dbb08..db567d0710 100644
--- a/tutorials/lagrangian/reactingParcelFilmFoam/splashPanel/system/fvSchemes
+++ b/tutorials/lagrangian/reactingParcelFilmFoam/splashPanel/system/fvSchemes
@@ -54,12 +54,6 @@ snGradSchemes
     default         uncorrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p_rgh;
-}
-
 
 
 // ************************************************************************* //
diff --git a/tutorials/lagrangian/reactingParcelFilmFoam/splashPanel/system/wallFilmRegion/fvSchemes b/tutorials/lagrangian/reactingParcelFilmFoam/splashPanel/system/wallFilmRegion/fvSchemes
index 5ede0210d6..c07603f778 100644
--- a/tutorials/lagrangian/reactingParcelFilmFoam/splashPanel/system/wallFilmRegion/fvSchemes
+++ b/tutorials/lagrangian/reactingParcelFilmFoam/splashPanel/system/wallFilmRegion/fvSchemes
@@ -56,11 +56,5 @@ snGradSchemes
     snGrad(deltaf) uncorrected;
 }
 
-fluxRequired
-{
-    default no;
-    deltaf;
-}
-
 
 // ************************************************************************* //
diff --git a/tutorials/lagrangian/reactingParcelFoam/counterFlowFlame2DLTS/system/fvSchemes b/tutorials/lagrangian/reactingParcelFoam/counterFlowFlame2DLTS/system/fvSchemes
index d096520e35..f96bf8b822 100644
--- a/tutorials/lagrangian/reactingParcelFoam/counterFlowFlame2DLTS/system/fvSchemes
+++ b/tutorials/lagrangian/reactingParcelFoam/counterFlowFlame2DLTS/system/fvSchemes
@@ -54,11 +54,5 @@ snGradSchemes
     default         orthogonal;
 }
 
-fluxRequired
-{
-    default         no;
-    p;
-}
-
 
 // ************************************************************************* //
diff --git a/tutorials/lagrangian/reactingParcelFoam/filter/system/fvSchemes b/tutorials/lagrangian/reactingParcelFoam/filter/system/fvSchemes
index 536c43de09..bc634cf1f9 100644
--- a/tutorials/lagrangian/reactingParcelFoam/filter/system/fvSchemes
+++ b/tutorials/lagrangian/reactingParcelFoam/filter/system/fvSchemes
@@ -55,11 +55,5 @@ snGradSchemes
     default         corrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p               ;
-}
-
 
 // ************************************************************************* //
diff --git a/tutorials/lagrangian/reactingParcelFoam/parcelInBox/system/fvSchemes b/tutorials/lagrangian/reactingParcelFoam/parcelInBox/system/fvSchemes
index 890464255b..34498508b2 100644
--- a/tutorials/lagrangian/reactingParcelFoam/parcelInBox/system/fvSchemes
+++ b/tutorials/lagrangian/reactingParcelFoam/parcelInBox/system/fvSchemes
@@ -55,11 +55,5 @@ snGradSchemes
     default         orthogonal;
 }
 
-fluxRequired
-{
-    default         no;
-    p;
-}
-
 
 // ************************************************************************* //
diff --git a/tutorials/lagrangian/reactingParcelFoam/verticalChannel/system/fvSchemes b/tutorials/lagrangian/reactingParcelFoam/verticalChannel/system/fvSchemes
index 082adfea4b..71ab19b7d6 100644
--- a/tutorials/lagrangian/reactingParcelFoam/verticalChannel/system/fvSchemes
+++ b/tutorials/lagrangian/reactingParcelFoam/verticalChannel/system/fvSchemes
@@ -54,13 +54,6 @@ snGradSchemes
     default         uncorrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p;
-    Phi;
-}
-
 wallDist
 {
     method meshWave;
diff --git a/tutorials/lagrangian/reactingParcelFoam/verticalChannelLTS/system/fvSchemes b/tutorials/lagrangian/reactingParcelFoam/verticalChannelLTS/system/fvSchemes
index 316f64c021..ffd25b6fa7 100644
--- a/tutorials/lagrangian/reactingParcelFoam/verticalChannelLTS/system/fvSchemes
+++ b/tutorials/lagrangian/reactingParcelFoam/verticalChannelLTS/system/fvSchemes
@@ -55,12 +55,6 @@ snGradSchemes
     default         uncorrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p;
-}
-
 wallDist
 {
     method meshWave;
diff --git a/tutorials/lagrangian/simpleReactingParcelFoam/verticalChannel/system/fvSchemes b/tutorials/lagrangian/simpleReactingParcelFoam/verticalChannel/system/fvSchemes
index 994d4c27ff..298c772624 100644
--- a/tutorials/lagrangian/simpleReactingParcelFoam/verticalChannel/system/fvSchemes
+++ b/tutorials/lagrangian/simpleReactingParcelFoam/verticalChannel/system/fvSchemes
@@ -54,13 +54,6 @@ snGradSchemes
     default         uncorrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p;
-    Phi;
-}
-
 wallDist
 {
     method meshWave;
diff --git a/tutorials/lagrangian/sprayFoam/aachenBomb/system/fvSchemes b/tutorials/lagrangian/sprayFoam/aachenBomb/system/fvSchemes
index d064aca387..c9db21c07d 100644
--- a/tutorials/lagrangian/sprayFoam/aachenBomb/system/fvSchemes
+++ b/tutorials/lagrangian/sprayFoam/aachenBomb/system/fvSchemes
@@ -54,11 +54,5 @@ snGradSchemes
     default         orthogonal;
 }
 
-fluxRequired
-{
-    default         no;
-    p               ;
-}
-
 
 // ************************************************************************* //
diff --git a/tutorials/mesh/foamyHexMesh/blob/system/fvSchemes b/tutorials/mesh/foamyHexMesh/blob/system/fvSchemes
index 2e5c55b28b..f2b1c3d1e5 100644
--- a/tutorials/mesh/foamyHexMesh/blob/system/fvSchemes
+++ b/tutorials/mesh/foamyHexMesh/blob/system/fvSchemes
@@ -45,10 +45,4 @@ snGradSchemes
     default         none;
 }
 
-fluxRequired
-{
-    default         no;
-}
-
-
 // ************************************************************************* //
diff --git a/tutorials/mesh/foamyHexMesh/flange/system/fvSchemes b/tutorials/mesh/foamyHexMesh/flange/system/fvSchemes
index 046181f357..e23e380164 100644
--- a/tutorials/mesh/foamyHexMesh/flange/system/fvSchemes
+++ b/tutorials/mesh/foamyHexMesh/flange/system/fvSchemes
@@ -46,10 +46,4 @@ snGradSchemes
     default         corrected;
 }
 
-fluxRequired
-{
-    default         no;
-}
-
-
 // ************************************************************************* //
diff --git a/tutorials/mesh/foamyHexMesh/mixerVessel/system/fvSchemes b/tutorials/mesh/foamyHexMesh/mixerVessel/system/fvSchemes
index 59d9365ade..8fa0876f2f 100644
--- a/tutorials/mesh/foamyHexMesh/mixerVessel/system/fvSchemes
+++ b/tutorials/mesh/foamyHexMesh/mixerVessel/system/fvSchemes
@@ -55,12 +55,4 @@ snGradSchemes
     default         limited 0.333;
 }
 
-fluxRequired
-{
-    default         no;
-    p_rgh;
-    pcorr;
-}
-
-
 // ************************************************************************* //
diff --git a/tutorials/mesh/foamyHexMesh/simpleShapes/system/fvSchemes b/tutorials/mesh/foamyHexMesh/simpleShapes/system/fvSchemes
index d8d476c57f..7a6ec470ee 100644
--- a/tutorials/mesh/foamyHexMesh/simpleShapes/system/fvSchemes
+++ b/tutorials/mesh/foamyHexMesh/simpleShapes/system/fvSchemes
@@ -45,11 +45,5 @@ snGradSchemes
     default         uncorrected;
 }
 
-fluxRequired
-{
-    default         no;
-    D               ;
-}
-
 
 // ************************************************************************* //
diff --git a/tutorials/mesh/foamyQuadMesh/OpenCFD/system/fvSchemes b/tutorials/mesh/foamyQuadMesh/OpenCFD/system/fvSchemes
index 067f035d26..c2f6d12dbc 100644
--- a/tutorials/mesh/foamyQuadMesh/OpenCFD/system/fvSchemes
+++ b/tutorials/mesh/foamyQuadMesh/OpenCFD/system/fvSchemes
@@ -52,10 +52,4 @@ snGradSchemes
     default         corrected;
 }
 
-fluxRequired
-{
-    default         no;
-}
-
-
 // ************************************************************************* //
diff --git a/tutorials/mesh/foamyQuadMesh/jaggedBoundary/system/fvSchemes b/tutorials/mesh/foamyQuadMesh/jaggedBoundary/system/fvSchemes
index 2e5c55b28b..f2b1c3d1e5 100644
--- a/tutorials/mesh/foamyQuadMesh/jaggedBoundary/system/fvSchemes
+++ b/tutorials/mesh/foamyQuadMesh/jaggedBoundary/system/fvSchemes
@@ -45,10 +45,4 @@ snGradSchemes
     default         none;
 }
 
-fluxRequired
-{
-    default         no;
-}
-
-
 // ************************************************************************* //
diff --git a/tutorials/mesh/foamyQuadMesh/square/system/fvSchemes b/tutorials/mesh/foamyQuadMesh/square/system/fvSchemes
index 2e5c55b28b..f2b1c3d1e5 100644
--- a/tutorials/mesh/foamyQuadMesh/square/system/fvSchemes
+++ b/tutorials/mesh/foamyQuadMesh/square/system/fvSchemes
@@ -45,10 +45,4 @@ snGradSchemes
     default         none;
 }
 
-fluxRequired
-{
-    default         no;
-}
-
-
 // ************************************************************************* //
diff --git a/tutorials/mesh/moveDynamicMesh/SnakeRiverCanyon/system/fvSchemes b/tutorials/mesh/moveDynamicMesh/SnakeRiverCanyon/system/fvSchemes
index 633d26bfba..72d70d2c25 100644
--- a/tutorials/mesh/moveDynamicMesh/SnakeRiverCanyon/system/fvSchemes
+++ b/tutorials/mesh/moveDynamicMesh/SnakeRiverCanyon/system/fvSchemes
@@ -46,11 +46,5 @@ snGradSchemes
     default         corrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p;
-}
-
 
 // ************************************************************************* //
diff --git a/tutorials/multiphase/cavitatingFoam/les/throttle/system/fvSchemes b/tutorials/multiphase/cavitatingFoam/les/throttle/system/fvSchemes
index 9072b1b487..a864d386d8 100644
--- a/tutorials/multiphase/cavitatingFoam/les/throttle/system/fvSchemes
+++ b/tutorials/multiphase/cavitatingFoam/les/throttle/system/fvSchemes
@@ -49,12 +49,4 @@ snGradSchemes
     default         corrected;
 }
 
-fluxRequired
-{
-    default         none;
-    p               ;
-    rho             ;
-}
-
-
 // ************************************************************************* //
diff --git a/tutorials/multiphase/cavitatingFoam/les/throttle3D/system/fvSchemes b/tutorials/multiphase/cavitatingFoam/les/throttle3D/system/fvSchemes
index 8753ef178c..2b89341a0b 100644
--- a/tutorials/multiphase/cavitatingFoam/les/throttle3D/system/fvSchemes
+++ b/tutorials/multiphase/cavitatingFoam/les/throttle3D/system/fvSchemes
@@ -50,12 +50,4 @@ snGradSchemes
     default         corrected;
 }
 
-fluxRequired
-{
-    default         none;
-    p               ;
-    rho             ;
-}
-
-
 // ************************************************************************* //
diff --git a/tutorials/multiphase/cavitatingFoam/ras/throttle/system/fvSchemes b/tutorials/multiphase/cavitatingFoam/ras/throttle/system/fvSchemes
index 0235d8bc0f..98d90bf940 100644
--- a/tutorials/multiphase/cavitatingFoam/ras/throttle/system/fvSchemes
+++ b/tutorials/multiphase/cavitatingFoam/ras/throttle/system/fvSchemes
@@ -50,13 +50,6 @@ snGradSchemes
     default         corrected;
 }
 
-fluxRequired
-{
-    default         none;
-    p               ;
-    rho             ;
-}
-
 wallDist
 {
     method meshWave;
diff --git a/tutorials/multiphase/compressibleInterDyMFoam/ras/sloshingTank2D/system/fvSchemes b/tutorials/multiphase/compressibleInterDyMFoam/ras/sloshingTank2D/system/fvSchemes
index c64e1f8107..ba82276408 100644
--- a/tutorials/multiphase/compressibleInterDyMFoam/ras/sloshingTank2D/system/fvSchemes
+++ b/tutorials/multiphase/compressibleInterDyMFoam/ras/sloshingTank2D/system/fvSchemes
@@ -55,12 +55,4 @@ snGradSchemes
     default         corrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p_rgh;
-    pcorr;
-}
-
-
 // ************************************************************************* //
diff --git a/tutorials/multiphase/compressibleInterFoam/laminar/depthCharge2D/system/fvSchemes b/tutorials/multiphase/compressibleInterFoam/laminar/depthCharge2D/system/fvSchemes
index 990fea86e2..a8d12117cb 100644
--- a/tutorials/multiphase/compressibleInterFoam/laminar/depthCharge2D/system/fvSchemes
+++ b/tutorials/multiphase/compressibleInterFoam/laminar/depthCharge2D/system/fvSchemes
@@ -56,12 +56,4 @@ snGradSchemes
     default         uncorrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p_rgh;
-    pcorr;
-}
-
-
 // ************************************************************************* //
diff --git a/tutorials/multiphase/compressibleInterFoam/laminar/depthCharge3D/system/fvSchemes b/tutorials/multiphase/compressibleInterFoam/laminar/depthCharge3D/system/fvSchemes
index 990fea86e2..a8d12117cb 100644
--- a/tutorials/multiphase/compressibleInterFoam/laminar/depthCharge3D/system/fvSchemes
+++ b/tutorials/multiphase/compressibleInterFoam/laminar/depthCharge3D/system/fvSchemes
@@ -56,12 +56,4 @@ snGradSchemes
     default         uncorrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p_rgh;
-    pcorr;
-}
-
-
 // ************************************************************************* //
diff --git a/tutorials/multiphase/compressibleMultiphaseInterFoam/laminar/damBreak4phase/system/fvSchemes b/tutorials/multiphase/compressibleMultiphaseInterFoam/laminar/damBreak4phase/system/fvSchemes
index d32c577288..48b8225422 100644
--- a/tutorials/multiphase/compressibleMultiphaseInterFoam/laminar/damBreak4phase/system/fvSchemes
+++ b/tutorials/multiphase/compressibleMultiphaseInterFoam/laminar/damBreak4phase/system/fvSchemes
@@ -52,13 +52,5 @@ snGradSchemes
     default         corrected;
 }
 
-fluxRequired
-{
-    default         no;
-    pcorr;
-    p_rgh;
-    "alpha.*";
-}
-
 
 // ************************************************************************* //
diff --git a/tutorials/multiphase/driftFluxFoam/ras/dahl/system/fvSchemes b/tutorials/multiphase/driftFluxFoam/ras/dahl/system/fvSchemes
index c837fd2ae3..6f88448cd7 100644
--- a/tutorials/multiphase/driftFluxFoam/ras/dahl/system/fvSchemes
+++ b/tutorials/multiphase/driftFluxFoam/ras/dahl/system/fvSchemes
@@ -54,12 +54,4 @@ snGradSchemes
     default         corrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p_rgh;
-    "alpha.*";
-}
-
-
 // ************************************************************************* //
diff --git a/tutorials/multiphase/driftFluxFoam/ras/mixerVessel2D/system/fvSchemes b/tutorials/multiphase/driftFluxFoam/ras/mixerVessel2D/system/fvSchemes
index 16e1d971b7..f466df997d 100644
--- a/tutorials/multiphase/driftFluxFoam/ras/mixerVessel2D/system/fvSchemes
+++ b/tutorials/multiphase/driftFluxFoam/ras/mixerVessel2D/system/fvSchemes
@@ -56,12 +56,4 @@ snGradSchemes
     default         corrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p_rgh;
-    "alpha.*";
-}
-
-
 // ************************************************************************* //
diff --git a/tutorials/multiphase/driftFluxFoam/ras/tank3D/system/fvSchemes b/tutorials/multiphase/driftFluxFoam/ras/tank3D/system/fvSchemes
index e95a53b7aa..7e16ca35fd 100644
--- a/tutorials/multiphase/driftFluxFoam/ras/tank3D/system/fvSchemes
+++ b/tutorials/multiphase/driftFluxFoam/ras/tank3D/system/fvSchemes
@@ -54,12 +54,4 @@ snGradSchemes
     default         corrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p_rgh;
-    "alpha.*";
-}
-
-
 // ************************************************************************* //
diff --git a/tutorials/multiphase/interDyMFoam/ras/DTCHull/system/fvSchemes b/tutorials/multiphase/interDyMFoam/ras/DTCHull/system/fvSchemes
index 44668611df..59a74ecc06 100644
--- a/tutorials/multiphase/interDyMFoam/ras/DTCHull/system/fvSchemes
+++ b/tutorials/multiphase/interDyMFoam/ras/DTCHull/system/fvSchemes
@@ -51,14 +51,6 @@ snGradSchemes
     default         corrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p_rgh;
-    pcorr;
-    alpha.water;
-}
-
 wallDist
 {
     method meshWave;
diff --git a/tutorials/multiphase/interDyMFoam/ras/damBreakWithObstacle/system/fvSchemes b/tutorials/multiphase/interDyMFoam/ras/damBreakWithObstacle/system/fvSchemes
index 06de48abed..174990b05f 100644
--- a/tutorials/multiphase/interDyMFoam/ras/damBreakWithObstacle/system/fvSchemes
+++ b/tutorials/multiphase/interDyMFoam/ras/damBreakWithObstacle/system/fvSchemes
@@ -50,13 +50,6 @@ snGradSchemes
     default         corrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p_rgh;
-    pcorr;
-}
-
 wallDist
 {
     method meshWave;
diff --git a/tutorials/multiphase/interDyMFoam/ras/floatingObject/system/fvSchemes b/tutorials/multiphase/interDyMFoam/ras/floatingObject/system/fvSchemes
index bc09e928d4..591aa1c33f 100644
--- a/tutorials/multiphase/interDyMFoam/ras/floatingObject/system/fvSchemes
+++ b/tutorials/multiphase/interDyMFoam/ras/floatingObject/system/fvSchemes
@@ -50,13 +50,5 @@ snGradSchemes
     default         corrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p_rgh;
-    pcorr;
-    alpha.water;
-}
-
 
 // ************************************************************************* //
diff --git a/tutorials/multiphase/interDyMFoam/ras/mixerVesselAMI/system/fvSchemes b/tutorials/multiphase/interDyMFoam/ras/mixerVesselAMI/system/fvSchemes
index 59d9365ade..8fa0876f2f 100644
--- a/tutorials/multiphase/interDyMFoam/ras/mixerVesselAMI/system/fvSchemes
+++ b/tutorials/multiphase/interDyMFoam/ras/mixerVesselAMI/system/fvSchemes
@@ -55,12 +55,4 @@ snGradSchemes
     default         limited 0.333;
 }
 
-fluxRequired
-{
-    default         no;
-    p_rgh;
-    pcorr;
-}
-
-
 // ************************************************************************* //
diff --git a/tutorials/multiphase/interDyMFoam/ras/sloshingTank2D/system/fvSchemes b/tutorials/multiphase/interDyMFoam/ras/sloshingTank2D/system/fvSchemes
index a956c19382..2d0ecbd0e1 100644
--- a/tutorials/multiphase/interDyMFoam/ras/sloshingTank2D/system/fvSchemes
+++ b/tutorials/multiphase/interDyMFoam/ras/sloshingTank2D/system/fvSchemes
@@ -48,12 +48,4 @@ snGradSchemes
     default         corrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p_rgh;
-    pcorr;
-}
-
-
 // ************************************************************************* //
diff --git a/tutorials/multiphase/interDyMFoam/ras/sloshingTank2D3DoF/system/fvSchemes b/tutorials/multiphase/interDyMFoam/ras/sloshingTank2D3DoF/system/fvSchemes
index a956c19382..2d0ecbd0e1 100644
--- a/tutorials/multiphase/interDyMFoam/ras/sloshingTank2D3DoF/system/fvSchemes
+++ b/tutorials/multiphase/interDyMFoam/ras/sloshingTank2D3DoF/system/fvSchemes
@@ -48,12 +48,4 @@ snGradSchemes
     default         corrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p_rgh;
-    pcorr;
-}
-
-
 // ************************************************************************* //
diff --git a/tutorials/multiphase/interDyMFoam/ras/sloshingTank3D/system/fvSchemes b/tutorials/multiphase/interDyMFoam/ras/sloshingTank3D/system/fvSchemes
index a956c19382..2d0ecbd0e1 100644
--- a/tutorials/multiphase/interDyMFoam/ras/sloshingTank3D/system/fvSchemes
+++ b/tutorials/multiphase/interDyMFoam/ras/sloshingTank3D/system/fvSchemes
@@ -48,12 +48,4 @@ snGradSchemes
     default         corrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p_rgh;
-    pcorr;
-}
-
-
 // ************************************************************************* //
diff --git a/tutorials/multiphase/interDyMFoam/ras/sloshingTank3D3DoF/system/fvSchemes b/tutorials/multiphase/interDyMFoam/ras/sloshingTank3D3DoF/system/fvSchemes
index a956c19382..2d0ecbd0e1 100644
--- a/tutorials/multiphase/interDyMFoam/ras/sloshingTank3D3DoF/system/fvSchemes
+++ b/tutorials/multiphase/interDyMFoam/ras/sloshingTank3D3DoF/system/fvSchemes
@@ -48,12 +48,4 @@ snGradSchemes
     default         corrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p_rgh;
-    pcorr;
-}
-
-
 // ************************************************************************* //
diff --git a/tutorials/multiphase/interDyMFoam/ras/sloshingTank3D6DoF/system/fvSchemes b/tutorials/multiphase/interDyMFoam/ras/sloshingTank3D6DoF/system/fvSchemes
index a956c19382..2d0ecbd0e1 100644
--- a/tutorials/multiphase/interDyMFoam/ras/sloshingTank3D6DoF/system/fvSchemes
+++ b/tutorials/multiphase/interDyMFoam/ras/sloshingTank3D6DoF/system/fvSchemes
@@ -48,12 +48,4 @@ snGradSchemes
     default         corrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p_rgh;
-    pcorr;
-}
-
-
 // ************************************************************************* //
diff --git a/tutorials/multiphase/interDyMFoam/ras/testTubeMixer/system/fvSchemes b/tutorials/multiphase/interDyMFoam/ras/testTubeMixer/system/fvSchemes
index a956c19382..2d0ecbd0e1 100644
--- a/tutorials/multiphase/interDyMFoam/ras/testTubeMixer/system/fvSchemes
+++ b/tutorials/multiphase/interDyMFoam/ras/testTubeMixer/system/fvSchemes
@@ -48,12 +48,4 @@ snGradSchemes
     default         corrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p_rgh;
-    pcorr;
-}
-
-
 // ************************************************************************* //
diff --git a/tutorials/multiphase/interFoam/laminar/capillaryRise/system/fvSchemes b/tutorials/multiphase/interFoam/laminar/capillaryRise/system/fvSchemes
index 6f42b083ed..0f2f40daa3 100644
--- a/tutorials/multiphase/interFoam/laminar/capillaryRise/system/fvSchemes
+++ b/tutorials/multiphase/interFoam/laminar/capillaryRise/system/fvSchemes
@@ -48,13 +48,5 @@ snGradSchemes
     default         corrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p_rgh;
-    pcorr;
-    alpha.water;
-}
-
 
 // ************************************************************************* //
diff --git a/tutorials/multiphase/interFoam/laminar/damBreak/system/fvSchemes b/tutorials/multiphase/interFoam/laminar/damBreak/system/fvSchemes
index ba6f492d2e..7486a2b3d7 100644
--- a/tutorials/multiphase/interFoam/laminar/damBreak/system/fvSchemes
+++ b/tutorials/multiphase/interFoam/laminar/damBreak/system/fvSchemes
@@ -48,13 +48,5 @@ snGradSchemes
     default         corrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p_rgh;
-    pcorr;
-    alpha.water;
-}
-
 
 // ************************************************************************* //
diff --git a/tutorials/multiphase/interFoam/laminar/mixerVessel2D/system/fvSchemes b/tutorials/multiphase/interFoam/laminar/mixerVessel2D/system/fvSchemes
index e4c518a247..9b84cf5a12 100644
--- a/tutorials/multiphase/interFoam/laminar/mixerVessel2D/system/fvSchemes
+++ b/tutorials/multiphase/interFoam/laminar/mixerVessel2D/system/fvSchemes
@@ -48,13 +48,5 @@ snGradSchemes
     default         corrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p_rgh           ;
-    pcorr           ;
-    alpha.water          ;
-}
-
 
 // ************************************************************************* //
diff --git a/tutorials/multiphase/interFoam/les/nozzleFlow2D/system/fvSchemes b/tutorials/multiphase/interFoam/les/nozzleFlow2D/system/fvSchemes
index 9510ee686d..54f63c4c27 100644
--- a/tutorials/multiphase/interFoam/les/nozzleFlow2D/system/fvSchemes
+++ b/tutorials/multiphase/interFoam/les/nozzleFlow2D/system/fvSchemes
@@ -52,12 +52,4 @@ snGradSchemes
     default         corrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p_rgh;
-    pcorr;
-}
-
-
 // ************************************************************************* //
diff --git a/tutorials/multiphase/interFoam/ras/DTCHull/system/fvSchemes b/tutorials/multiphase/interFoam/ras/DTCHull/system/fvSchemes
index ab0fa54e31..194382fbd4 100644
--- a/tutorials/multiphase/interFoam/ras/DTCHull/system/fvSchemes
+++ b/tutorials/multiphase/interFoam/ras/DTCHull/system/fvSchemes
@@ -51,14 +51,6 @@ snGradSchemes
     default         corrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p_rgh;
-    pcorr;
-    alpha.water;
-}
-
 wallDist
 {
     method meshWave;
diff --git a/tutorials/multiphase/interFoam/ras/angledDuct/system/fvSchemes b/tutorials/multiphase/interFoam/ras/angledDuct/system/fvSchemes
index 749207137d..ede1fafbde 100644
--- a/tutorials/multiphase/interFoam/ras/angledDuct/system/fvSchemes
+++ b/tutorials/multiphase/interFoam/ras/angledDuct/system/fvSchemes
@@ -50,13 +50,5 @@ snGradSchemes
     default         corrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p_rgh;
-    pcorr;
-    alpha.water;
-}
-
 
 // ************************************************************************* //
diff --git a/tutorials/multiphase/interFoam/ras/damBreak/system/fvSchemes b/tutorials/multiphase/interFoam/ras/damBreak/system/fvSchemes
index 960ff2562c..e85c188cd5 100644
--- a/tutorials/multiphase/interFoam/ras/damBreak/system/fvSchemes
+++ b/tutorials/multiphase/interFoam/ras/damBreak/system/fvSchemes
@@ -50,13 +50,5 @@ snGradSchemes
     default         corrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p_rgh;
-    pcorr;
-    alpha.water;
-}
-
 
 // ************************************************************************* //
diff --git a/tutorials/multiphase/interFoam/ras/damBreakPorousBaffle/system/fvSchemes b/tutorials/multiphase/interFoam/ras/damBreakPorousBaffle/system/fvSchemes
index 960ff2562c..e85c188cd5 100644
--- a/tutorials/multiphase/interFoam/ras/damBreakPorousBaffle/system/fvSchemes
+++ b/tutorials/multiphase/interFoam/ras/damBreakPorousBaffle/system/fvSchemes
@@ -50,13 +50,5 @@ snGradSchemes
     default         corrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p_rgh;
-    pcorr;
-    alpha.water;
-}
-
 
 // ************************************************************************* //
diff --git a/tutorials/multiphase/interFoam/ras/waterChannel/system/fvSchemes b/tutorials/multiphase/interFoam/ras/waterChannel/system/fvSchemes
index 42584c41cb..e16c29b74f 100644
--- a/tutorials/multiphase/interFoam/ras/waterChannel/system/fvSchemes
+++ b/tutorials/multiphase/interFoam/ras/waterChannel/system/fvSchemes
@@ -52,14 +52,6 @@ snGradSchemes
     default         corrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p_rgh;
-    pcorr;
-    alpha.water;
-}
-
 wallDist
 {
     method meshWave;
diff --git a/tutorials/multiphase/interFoam/ras/weirOverflow/system/fvSchemes b/tutorials/multiphase/interFoam/ras/weirOverflow/system/fvSchemes
index ba84fd84f3..ce7188c53d 100644
--- a/tutorials/multiphase/interFoam/ras/weirOverflow/system/fvSchemes
+++ b/tutorials/multiphase/interFoam/ras/weirOverflow/system/fvSchemes
@@ -53,12 +53,4 @@ snGradSchemes
     default         corrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p_rgh;
-    pcorr;
-}
-
-
 // ************************************************************************* //
diff --git a/tutorials/multiphase/interMixingFoam/laminar/damBreak/system/fvSchemes b/tutorials/multiphase/interMixingFoam/laminar/damBreak/system/fvSchemes
index b0d1f73aac..afd30008e3 100644
--- a/tutorials/multiphase/interMixingFoam/laminar/damBreak/system/fvSchemes
+++ b/tutorials/multiphase/interMixingFoam/laminar/damBreak/system/fvSchemes
@@ -48,13 +48,5 @@ snGradSchemes
     default         corrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p_rgh;
-    pcorr;
-    "alpha.*";
-}
-
 
 // ************************************************************************* //
diff --git a/tutorials/multiphase/interPhaseChangeDyMFoam/propeller/system/fvSchemes b/tutorials/multiphase/interPhaseChangeDyMFoam/propeller/system/fvSchemes
index 7f42a48fe4..8f55f25eb7 100644
--- a/tutorials/multiphase/interPhaseChangeDyMFoam/propeller/system/fvSchemes
+++ b/tutorials/multiphase/interPhaseChangeDyMFoam/propeller/system/fvSchemes
@@ -54,13 +54,5 @@ snGradSchemes
     default         limited corrected 0.33;
 }
 
-fluxRequired
-{
-    default         no;
-    p_rgh;
-    pcorr;
-    alpha.water;
-}
-
 
 // ************************************************************************* //
diff --git a/tutorials/multiphase/interPhaseChangeFoam/cavitatingBullet/system/fvSchemes b/tutorials/multiphase/interPhaseChangeFoam/cavitatingBullet/system/fvSchemes
index a20fa5dc3e..868aa79f44 100644
--- a/tutorials/multiphase/interPhaseChangeFoam/cavitatingBullet/system/fvSchemes
+++ b/tutorials/multiphase/interPhaseChangeFoam/cavitatingBullet/system/fvSchemes
@@ -50,13 +50,5 @@ snGradSchemes
     default             limited corrected 0.5;
 }
 
-fluxRequired
-{
-    default             none;
-    Phi;
-    p_rgh;
-    pcorr;
-    alpha.water;
-}
 
 // ************************************************************************* //
diff --git a/tutorials/multiphase/multiphaseEulerFoam/bubbleColumn/system/fvSchemes b/tutorials/multiphase/multiphaseEulerFoam/bubbleColumn/system/fvSchemes
index a9532d1376..ac5bbc54b1 100644
--- a/tutorials/multiphase/multiphaseEulerFoam/bubbleColumn/system/fvSchemes
+++ b/tutorials/multiphase/multiphaseEulerFoam/bubbleColumn/system/fvSchemes
@@ -52,12 +52,4 @@ snGradSchemes
     default         corrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p_rgh           ;
-    pcorr           ;
-}
-
-
 // ************************************************************************* //
diff --git a/tutorials/multiphase/multiphaseEulerFoam/damBreak4phase/system/fvSchemes b/tutorials/multiphase/multiphaseEulerFoam/damBreak4phase/system/fvSchemes
index 95a8eb87f1..acf13bc703 100644
--- a/tutorials/multiphase/multiphaseEulerFoam/damBreak4phase/system/fvSchemes
+++ b/tutorials/multiphase/multiphaseEulerFoam/damBreak4phase/system/fvSchemes
@@ -50,12 +50,4 @@ snGradSchemes
     default         corrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p_rgh;
-    pcorr;
-}
-
-
 // ************************************************************************* //
diff --git a/tutorials/multiphase/multiphaseEulerFoam/damBreak4phaseFine/system/fvSchemes b/tutorials/multiphase/multiphaseEulerFoam/damBreak4phaseFine/system/fvSchemes
index 95a8eb87f1..acf13bc703 100644
--- a/tutorials/multiphase/multiphaseEulerFoam/damBreak4phaseFine/system/fvSchemes
+++ b/tutorials/multiphase/multiphaseEulerFoam/damBreak4phaseFine/system/fvSchemes
@@ -50,12 +50,4 @@ snGradSchemes
     default         corrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p_rgh;
-    pcorr;
-}
-
-
 // ************************************************************************* //
diff --git a/tutorials/multiphase/multiphaseEulerFoam/mixerVessel2D/system/fvSchemes b/tutorials/multiphase/multiphaseEulerFoam/mixerVessel2D/system/fvSchemes
index 95a8eb87f1..acf13bc703 100644
--- a/tutorials/multiphase/multiphaseEulerFoam/mixerVessel2D/system/fvSchemes
+++ b/tutorials/multiphase/multiphaseEulerFoam/mixerVessel2D/system/fvSchemes
@@ -50,12 +50,4 @@ snGradSchemes
     default         corrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p_rgh;
-    pcorr;
-}
-
-
 // ************************************************************************* //
diff --git a/tutorials/multiphase/multiphaseInterDyMFoam/laminar/mixerVesselAMI2D/system/fvSchemes b/tutorials/multiphase/multiphaseInterDyMFoam/laminar/mixerVesselAMI2D/system/fvSchemes
index 2234c3afd1..e71dc816e6 100644
--- a/tutorials/multiphase/multiphaseInterDyMFoam/laminar/mixerVesselAMI2D/system/fvSchemes
+++ b/tutorials/multiphase/multiphaseInterDyMFoam/laminar/mixerVesselAMI2D/system/fvSchemes
@@ -48,13 +48,5 @@ snGradSchemes
     default         corrected;
 }
 
-fluxRequired
-{
-    default         no;
-    pcorr;
-    p_rgh;
-    "alpha.*";
-}
-
 
 // ************************************************************************* //
diff --git a/tutorials/multiphase/multiphaseInterFoam/laminar/damBreak4phase/system/fvSchemes b/tutorials/multiphase/multiphaseInterFoam/laminar/damBreak4phase/system/fvSchemes
index f4c635c895..ba7a3e3460 100644
--- a/tutorials/multiphase/multiphaseInterFoam/laminar/damBreak4phase/system/fvSchemes
+++ b/tutorials/multiphase/multiphaseInterFoam/laminar/damBreak4phase/system/fvSchemes
@@ -50,13 +50,5 @@ snGradSchemes
     default         corrected;
 }
 
-fluxRequired
-{
-    default         no;
-    pcorr;
-    p_rgh;
-    "alpha.*";
-}
-
 
 // ************************************************************************* //
diff --git a/tutorials/multiphase/multiphaseInterFoam/laminar/damBreak4phaseFine/system/fvSchemes b/tutorials/multiphase/multiphaseInterFoam/laminar/damBreak4phaseFine/system/fvSchemes
index f4c635c895..ba7a3e3460 100644
--- a/tutorials/multiphase/multiphaseInterFoam/laminar/damBreak4phaseFine/system/fvSchemes
+++ b/tutorials/multiphase/multiphaseInterFoam/laminar/damBreak4phaseFine/system/fvSchemes
@@ -50,13 +50,5 @@ snGradSchemes
     default         corrected;
 }
 
-fluxRequired
-{
-    default         no;
-    pcorr;
-    p_rgh;
-    "alpha.*";
-}
-
 
 // ************************************************************************* //
diff --git a/tutorials/multiphase/multiphaseInterFoam/laminar/mixerVessel2D/system/fvSchemes b/tutorials/multiphase/multiphaseInterFoam/laminar/mixerVessel2D/system/fvSchemes
index 0844c2a1e1..afd30008e3 100644
--- a/tutorials/multiphase/multiphaseInterFoam/laminar/mixerVessel2D/system/fvSchemes
+++ b/tutorials/multiphase/multiphaseInterFoam/laminar/mixerVessel2D/system/fvSchemes
@@ -48,13 +48,5 @@ snGradSchemes
     default         corrected;
 }
 
-fluxRequired
-{
-    default         no;
-    pcorr;
-    p_rgh;
-    "alpha.*";
-}
-
 
 // ************************************************************************* //
diff --git a/tutorials/multiphase/potentialFreeSurfaceDyMFoam/oscillatingBox/system/fvSchemes b/tutorials/multiphase/potentialFreeSurfaceDyMFoam/oscillatingBox/system/fvSchemes
index a5bdba477d..89c658b469 100644
--- a/tutorials/multiphase/potentialFreeSurfaceDyMFoam/oscillatingBox/system/fvSchemes
+++ b/tutorials/multiphase/potentialFreeSurfaceDyMFoam/oscillatingBox/system/fvSchemes
@@ -47,12 +47,4 @@ snGradSchemes
     default         corrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p_gh;
-    pcorr;
-}
-
-
 // ************************************************************************* //
diff --git a/tutorials/multiphase/potentialFreeSurfaceFoam/oscillatingBox/system/fvSchemes b/tutorials/multiphase/potentialFreeSurfaceFoam/oscillatingBox/system/fvSchemes
index 4f34ad1222..1435d5120c 100644
--- a/tutorials/multiphase/potentialFreeSurfaceFoam/oscillatingBox/system/fvSchemes
+++ b/tutorials/multiphase/potentialFreeSurfaceFoam/oscillatingBox/system/fvSchemes
@@ -50,11 +50,5 @@ snGradSchemes
     default         corrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p_gh;
-}
-
 
 // ************************************************************************* //
diff --git a/tutorials/multiphase/reactingTwoPhaseEulerFoam/LES/bubbleColumn/system/fvSchemes b/tutorials/multiphase/reactingTwoPhaseEulerFoam/LES/bubbleColumn/system/fvSchemes
index 09bfa9fabf..7f00c9e2bc 100644
--- a/tutorials/multiphase/reactingTwoPhaseEulerFoam/LES/bubbleColumn/system/fvSchemes
+++ b/tutorials/multiphase/reactingTwoPhaseEulerFoam/LES/bubbleColumn/system/fvSchemes
@@ -58,11 +58,5 @@ snGradSchemes
     default         uncorrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p_rgh;
-}
-
 
 // ************************************************************************* //
diff --git a/tutorials/multiphase/reactingTwoPhaseEulerFoam/RAS/bubbleColumn/system/fvSchemes b/tutorials/multiphase/reactingTwoPhaseEulerFoam/RAS/bubbleColumn/system/fvSchemes
index ad38360562..f037499679 100644
--- a/tutorials/multiphase/reactingTwoPhaseEulerFoam/RAS/bubbleColumn/system/fvSchemes
+++ b/tutorials/multiphase/reactingTwoPhaseEulerFoam/RAS/bubbleColumn/system/fvSchemes
@@ -60,11 +60,5 @@ snGradSchemes
     default         uncorrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p_rgh;
-}
-
 
 // ************************************************************************* //
diff --git a/tutorials/multiphase/reactingTwoPhaseEulerFoam/RAS/bubbleColumnEvaporatingReacting/constant/phaseProperties b/tutorials/multiphase/reactingTwoPhaseEulerFoam/RAS/bubbleColumnEvaporatingReacting/constant/phaseProperties
index 80179162ba..23358cfec5 100644
--- a/tutorials/multiphase/reactingTwoPhaseEulerFoam/RAS/bubbleColumnEvaporatingReacting/constant/phaseProperties
+++ b/tutorials/multiphase/reactingTwoPhaseEulerFoam/RAS/bubbleColumnEvaporatingReacting/constant/phaseProperties
@@ -15,7 +15,7 @@ FoamFile
 }
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-type    heatMassAndMomentumTransferTwoPhaseSystem;
+type    interfaceCompositionPhaseChangeTwoPhaseSystem;
 
 phases (gas liquid);
 
diff --git a/tutorials/multiphase/reactingTwoPhaseEulerFoam/RAS/bubbleColumnEvaporatingReacting/system/fvSchemes b/tutorials/multiphase/reactingTwoPhaseEulerFoam/RAS/bubbleColumnEvaporatingReacting/system/fvSchemes
index 295452d600..6c75d330b2 100644
--- a/tutorials/multiphase/reactingTwoPhaseEulerFoam/RAS/bubbleColumnEvaporatingReacting/system/fvSchemes
+++ b/tutorials/multiphase/reactingTwoPhaseEulerFoam/RAS/bubbleColumnEvaporatingReacting/system/fvSchemes
@@ -61,12 +61,6 @@ snGradSchemes
     default         uncorrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p_rgh;
-}
-
 wallDist
 {
     method          meshWave;
diff --git a/tutorials/multiphase/reactingTwoPhaseEulerFoam/RAS/fluidisedBed/system/fvSchemes b/tutorials/multiphase/reactingTwoPhaseEulerFoam/RAS/fluidisedBed/system/fvSchemes
index e859411a19..caf67c41e8 100644
--- a/tutorials/multiphase/reactingTwoPhaseEulerFoam/RAS/fluidisedBed/system/fvSchemes
+++ b/tutorials/multiphase/reactingTwoPhaseEulerFoam/RAS/fluidisedBed/system/fvSchemes
@@ -65,13 +65,6 @@ snGradSchemes
     bounded     uncorrected;
 }
 
-fluxRequired
-{
-    default     no;
-    p_rgh       ;
-    alpha.particles;
-}
-
 wallDist
 {
     method      meshWave;
diff --git a/tutorials/multiphase/reactingTwoPhaseEulerFoam/laminar/bubbleColumn/system/fvSchemes b/tutorials/multiphase/reactingTwoPhaseEulerFoam/laminar/bubbleColumn/system/fvSchemes
index 2c05f079b6..996495e814 100644
--- a/tutorials/multiphase/reactingTwoPhaseEulerFoam/laminar/bubbleColumn/system/fvSchemes
+++ b/tutorials/multiphase/reactingTwoPhaseEulerFoam/laminar/bubbleColumn/system/fvSchemes
@@ -57,11 +57,5 @@ snGradSchemes
     default         uncorrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p_rgh;
-}
-
 
 // ************************************************************************* //
diff --git a/tutorials/multiphase/reactingTwoPhaseEulerFoam/laminar/bubbleColumnEvaporating/constant/phaseProperties b/tutorials/multiphase/reactingTwoPhaseEulerFoam/laminar/bubbleColumnEvaporating/constant/phaseProperties
index 7fd6f0c6c2..eb0bbd970e 100644
--- a/tutorials/multiphase/reactingTwoPhaseEulerFoam/laminar/bubbleColumnEvaporating/constant/phaseProperties
+++ b/tutorials/multiphase/reactingTwoPhaseEulerFoam/laminar/bubbleColumnEvaporating/constant/phaseProperties
@@ -15,7 +15,7 @@ FoamFile
 }
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-type    heatMassAndMomentumTransferTwoPhaseSystem;
+type    interfaceCompositionPhaseChangeTwoPhaseSystem;
 
 phases (gas liquid);
 
diff --git a/tutorials/multiphase/reactingTwoPhaseEulerFoam/laminar/bubbleColumnEvaporating/system/fvSchemes b/tutorials/multiphase/reactingTwoPhaseEulerFoam/laminar/bubbleColumnEvaporating/system/fvSchemes
index 2eb455d3e0..4e59054879 100644
--- a/tutorials/multiphase/reactingTwoPhaseEulerFoam/laminar/bubbleColumnEvaporating/system/fvSchemes
+++ b/tutorials/multiphase/reactingTwoPhaseEulerFoam/laminar/bubbleColumnEvaporating/system/fvSchemes
@@ -58,11 +58,5 @@ snGradSchemes
     default         uncorrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p_rgh;
-}
-
 
 // ************************************************************************* //
diff --git a/tutorials/multiphase/reactingTwoPhaseEulerFoam/laminar/bubbleColumnEvaporatingDissolving/constant/phaseProperties b/tutorials/multiphase/reactingTwoPhaseEulerFoam/laminar/bubbleColumnEvaporatingDissolving/constant/phaseProperties
index 9ac25e4513..6b628569c1 100644
--- a/tutorials/multiphase/reactingTwoPhaseEulerFoam/laminar/bubbleColumnEvaporatingDissolving/constant/phaseProperties
+++ b/tutorials/multiphase/reactingTwoPhaseEulerFoam/laminar/bubbleColumnEvaporatingDissolving/constant/phaseProperties
@@ -15,7 +15,7 @@ FoamFile
 }
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-type    heatMassAndMomentumTransferTwoPhaseSystem;
+type    interfaceCompositionPhaseChangeTwoPhaseSystem;
 
 phases (gas liquid);
 
diff --git a/tutorials/multiphase/reactingTwoPhaseEulerFoam/laminar/bubbleColumnEvaporatingDissolving/system/fvSchemes b/tutorials/multiphase/reactingTwoPhaseEulerFoam/laminar/bubbleColumnEvaporatingDissolving/system/fvSchemes
index fd4e48c43d..aa9a02819a 100644
--- a/tutorials/multiphase/reactingTwoPhaseEulerFoam/laminar/bubbleColumnEvaporatingDissolving/system/fvSchemes
+++ b/tutorials/multiphase/reactingTwoPhaseEulerFoam/laminar/bubbleColumnEvaporatingDissolving/system/fvSchemes
@@ -58,11 +58,5 @@ snGradSchemes
     default         uncorrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p_rgh;
-}
-
 
 // ************************************************************************* //
diff --git a/tutorials/multiphase/reactingTwoPhaseEulerFoam/laminar/bubbleColumnIATE/system/fvSchemes b/tutorials/multiphase/reactingTwoPhaseEulerFoam/laminar/bubbleColumnIATE/system/fvSchemes
index e17b4cee52..ebb603c3cc 100644
--- a/tutorials/multiphase/reactingTwoPhaseEulerFoam/laminar/bubbleColumnIATE/system/fvSchemes
+++ b/tutorials/multiphase/reactingTwoPhaseEulerFoam/laminar/bubbleColumnIATE/system/fvSchemes
@@ -59,11 +59,5 @@ snGradSchemes
     default         uncorrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p_rgh;
-}
-
 
 // ************************************************************************* //
diff --git a/tutorials/multiphase/reactingTwoPhaseEulerFoam/laminar/fluidisedBed/system/fvSchemes b/tutorials/multiphase/reactingTwoPhaseEulerFoam/laminar/fluidisedBed/system/fvSchemes
index 62ff44d8e7..4a0b2ace30 100644
--- a/tutorials/multiphase/reactingTwoPhaseEulerFoam/laminar/fluidisedBed/system/fvSchemes
+++ b/tutorials/multiphase/reactingTwoPhaseEulerFoam/laminar/fluidisedBed/system/fvSchemes
@@ -59,12 +59,4 @@ snGradSchemes
     bounded     uncorrected;
 }
 
-fluxRequired
-{
-    default     no;
-    p_rgh;
-    alpha.particles;
-}
-
-
 // ************************************************************************* //
diff --git a/tutorials/multiphase/reactingTwoPhaseEulerFoam/laminar/injection/system/fvSchemes b/tutorials/multiphase/reactingTwoPhaseEulerFoam/laminar/injection/system/fvSchemes
index ad0ccde96f..ce72eac3c2 100644
--- a/tutorials/multiphase/reactingTwoPhaseEulerFoam/laminar/injection/system/fvSchemes
+++ b/tutorials/multiphase/reactingTwoPhaseEulerFoam/laminar/injection/system/fvSchemes
@@ -57,11 +57,5 @@ snGradSchemes
     default         uncorrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p_rgh;
-}
-
 
 // ************************************************************************* //
diff --git a/tutorials/multiphase/reactingTwoPhaseEulerFoam/laminar/mixerVessel2D/system/fvSchemes b/tutorials/multiphase/reactingTwoPhaseEulerFoam/laminar/mixerVessel2D/system/fvSchemes
index 5b2fc02c45..b085840d99 100644
--- a/tutorials/multiphase/reactingTwoPhaseEulerFoam/laminar/mixerVessel2D/system/fvSchemes
+++ b/tutorials/multiphase/reactingTwoPhaseEulerFoam/laminar/mixerVessel2D/system/fvSchemes
@@ -57,11 +57,5 @@ snGradSchemes
     default         corrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p_rgh;
-}
-
 
 // ************************************************************************* //
diff --git a/tutorials/multiphase/twoLiquidMixingFoam/lockExchange/system/fvSchemes b/tutorials/multiphase/twoLiquidMixingFoam/lockExchange/system/fvSchemes
index 133816f9e5..329583146a 100644
--- a/tutorials/multiphase/twoLiquidMixingFoam/lockExchange/system/fvSchemes
+++ b/tutorials/multiphase/twoLiquidMixingFoam/lockExchange/system/fvSchemes
@@ -51,12 +51,4 @@ snGradSchemes
     default         corrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p_rgh;
-    alpha.sludge;
-}
-
-
 // ************************************************************************* //
diff --git a/tutorials/multiphase/twoPhaseEulerFoam/LES/bubbleColumn/system/fvSchemes b/tutorials/multiphase/twoPhaseEulerFoam/LES/bubbleColumn/system/fvSchemes
index 09bfa9fabf..7f00c9e2bc 100644
--- a/tutorials/multiphase/twoPhaseEulerFoam/LES/bubbleColumn/system/fvSchemes
+++ b/tutorials/multiphase/twoPhaseEulerFoam/LES/bubbleColumn/system/fvSchemes
@@ -58,11 +58,5 @@ snGradSchemes
     default         uncorrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p_rgh;
-}
-
 
 // ************************************************************************* //
diff --git a/tutorials/multiphase/twoPhaseEulerFoam/RAS/bubbleColumn/system/fvSchemes b/tutorials/multiphase/twoPhaseEulerFoam/RAS/bubbleColumn/system/fvSchemes
index ad38360562..f037499679 100644
--- a/tutorials/multiphase/twoPhaseEulerFoam/RAS/bubbleColumn/system/fvSchemes
+++ b/tutorials/multiphase/twoPhaseEulerFoam/RAS/bubbleColumn/system/fvSchemes
@@ -60,11 +60,5 @@ snGradSchemes
     default         uncorrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p_rgh;
-}
-
 
 // ************************************************************************* //
diff --git a/tutorials/multiphase/twoPhaseEulerFoam/RAS/fluidisedBed/system/fvSchemes b/tutorials/multiphase/twoPhaseEulerFoam/RAS/fluidisedBed/system/fvSchemes
index 5c1adb6f11..c08eb7fb7e 100644
--- a/tutorials/multiphase/twoPhaseEulerFoam/RAS/fluidisedBed/system/fvSchemes
+++ b/tutorials/multiphase/twoPhaseEulerFoam/RAS/fluidisedBed/system/fvSchemes
@@ -65,12 +65,4 @@ snGradSchemes
     bounded     uncorrected;
 }
 
-fluxRequired
-{
-    default     no;
-    p_rgh;
-    alpha.particles;
-}
-
-
 // ************************************************************************* //
diff --git a/tutorials/multiphase/twoPhaseEulerFoam/laminar/bubbleColumn/system/fvSchemes b/tutorials/multiphase/twoPhaseEulerFoam/laminar/bubbleColumn/system/fvSchemes
index 2c05f079b6..996495e814 100644
--- a/tutorials/multiphase/twoPhaseEulerFoam/laminar/bubbleColumn/system/fvSchemes
+++ b/tutorials/multiphase/twoPhaseEulerFoam/laminar/bubbleColumn/system/fvSchemes
@@ -57,11 +57,5 @@ snGradSchemes
     default         uncorrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p_rgh;
-}
-
 
 // ************************************************************************* //
diff --git a/tutorials/multiphase/twoPhaseEulerFoam/laminar/bubbleColumnIATE/system/fvSchemes b/tutorials/multiphase/twoPhaseEulerFoam/laminar/bubbleColumnIATE/system/fvSchemes
index 1a3eb4681e..ba3b6d5461 100644
--- a/tutorials/multiphase/twoPhaseEulerFoam/laminar/bubbleColumnIATE/system/fvSchemes
+++ b/tutorials/multiphase/twoPhaseEulerFoam/laminar/bubbleColumnIATE/system/fvSchemes
@@ -59,11 +59,5 @@ snGradSchemes
     default         uncorrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p_rgh;
-}
-
 
 // ************************************************************************* //
diff --git a/tutorials/multiphase/twoPhaseEulerFoam/laminar/fluidisedBed/system/fvSchemes b/tutorials/multiphase/twoPhaseEulerFoam/laminar/fluidisedBed/system/fvSchemes
index 62ff44d8e7..4a0b2ace30 100644
--- a/tutorials/multiphase/twoPhaseEulerFoam/laminar/fluidisedBed/system/fvSchemes
+++ b/tutorials/multiphase/twoPhaseEulerFoam/laminar/fluidisedBed/system/fvSchemes
@@ -59,12 +59,4 @@ snGradSchemes
     bounded     uncorrected;
 }
 
-fluxRequired
-{
-    default     no;
-    p_rgh;
-    alpha.particles;
-}
-
-
 // ************************************************************************* //
diff --git a/tutorials/multiphase/twoPhaseEulerFoam/laminar/injection/system/fvSchemes b/tutorials/multiphase/twoPhaseEulerFoam/laminar/injection/system/fvSchemes
index ad0ccde96f..ce72eac3c2 100644
--- a/tutorials/multiphase/twoPhaseEulerFoam/laminar/injection/system/fvSchemes
+++ b/tutorials/multiphase/twoPhaseEulerFoam/laminar/injection/system/fvSchemes
@@ -57,11 +57,5 @@ snGradSchemes
     default         uncorrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p_rgh;
-}
-
 
 // ************************************************************************* //
diff --git a/tutorials/multiphase/twoPhaseEulerFoam/laminar/mixerVessel2D/system/fvSchemes b/tutorials/multiphase/twoPhaseEulerFoam/laminar/mixerVessel2D/system/fvSchemes
index 5b2fc02c45..b085840d99 100644
--- a/tutorials/multiphase/twoPhaseEulerFoam/laminar/mixerVessel2D/system/fvSchemes
+++ b/tutorials/multiphase/twoPhaseEulerFoam/laminar/mixerVessel2D/system/fvSchemes
@@ -57,11 +57,5 @@ snGradSchemes
     default         corrected;
 }
 
-fluxRequired
-{
-    default         no;
-    p_rgh;
-}
-
 
 // ************************************************************************* //
diff --git a/tutorials/stressAnalysis/solidDisplacementFoam/plateHole/system/fvSchemes b/tutorials/stressAnalysis/solidDisplacementFoam/plateHole/system/fvSchemes
index a7c9b4c8d2..4590e5528a 100644
--- a/tutorials/stressAnalysis/solidDisplacementFoam/plateHole/system/fvSchemes
+++ b/tutorials/stressAnalysis/solidDisplacementFoam/plateHole/system/fvSchemes
@@ -55,12 +55,4 @@ snGradSchemes
     default         none;
 }
 
-fluxRequired
-{
-    default         no;
-    D               yes;
-    T               no;
-}
-
-
 // ************************************************************************* //
diff --git a/tutorials/stressAnalysis/solidEquilibriumDisplacementFoam/beamEndLoad/system/fvSchemes b/tutorials/stressAnalysis/solidEquilibriumDisplacementFoam/beamEndLoad/system/fvSchemes
index d8d476c57f..7a6ec470ee 100644
--- a/tutorials/stressAnalysis/solidEquilibriumDisplacementFoam/beamEndLoad/system/fvSchemes
+++ b/tutorials/stressAnalysis/solidEquilibriumDisplacementFoam/beamEndLoad/system/fvSchemes
@@ -45,11 +45,5 @@ snGradSchemes
     default         uncorrected;
 }
 
-fluxRequired
-{
-    default         no;
-    D               ;
-}
-
 
 // ************************************************************************* //