diff --git a/applications/solvers/heatTransfer/chtMultiRegionFoam/Make/files b/applications/solvers/heatTransfer/chtMultiRegionFoam/Make/files
index 9ae6090832..908d7b3a95 100644
--- a/applications/solvers/heatTransfer/chtMultiRegionFoam/Make/files
+++ b/applications/solvers/heatTransfer/chtMultiRegionFoam/Make/files
@@ -1,7 +1,6 @@
 fluid/compressibleCourantNo.C
 solid/solidRegionDiffNo.C
-
 chtMultiRegionFoam.C
 
-EXE = $(FOAM_APPBIN)/chtMultiRegionFoam
+EXE = $(FOAM_USER_APPBIN)/chtMultiRegionFoam
 
diff --git a/applications/solvers/heatTransfer/chtMultiRegionFoam/Make/options b/applications/solvers/heatTransfer/chtMultiRegionFoam/Make/options
index 2fcfff4126..95dee86bce 100644
--- a/applications/solvers/heatTransfer/chtMultiRegionFoam/Make/options
+++ b/applications/solvers/heatTransfer/chtMultiRegionFoam/Make/options
@@ -1,14 +1,23 @@
+
 EXE_INC = \
-    -Ifluid \
-    -Isolid \
-    -Iinclude \
+    -I./fluid \
+    -I./solid \
+    -I./porousFluid \
+    -I./porousSolid \
+    -I./include \
     -I$(LIB_SRC)/meshTools/lnInclude \
+    -I$(LIB_SRC)/sampling/lnInclude \
     -I$(LIB_SRC)/finiteVolume/lnInclude \
     -I$(LIB_SRC)/thermophysicalModels/basic/lnInclude \
     -I$(LIB_SRC)/thermophysicalModels/specie/lnInclude \
     -I$(LIB_SRC)/thermophysicalModels/basicSolidThermo/lnInclude \
+    -I$(LIB_SRC)/turbulenceModels/compressible/RAS/lnInclude \
     -I$(LIB_SRC)/turbulenceModels/compressible/turbulenceModel/lnInclude \
-    -I$(LIB_SRC)/thermophysicalModels/radiationModels/lnInclude
+    -I$(LIB_SRC)/turbulenceModels \
+    -I$(LIB_SRC)/thermophysicalModels/radiationModels/lnInclude \
+    -I$(LIB_SRC)/fieldSources/lnInclude \
+    -I$(LIB_SRC)/regionModels/regionModel/lnInclude
+
 
 EXE_LIBS = \
     -lbasicThermophysicalModels \
@@ -16,7 +25,9 @@ EXE_LIBS = \
     -lspecie \
     -lcompressibleTurbulenceModel \
     -lcompressibleRASModels \
-    -lcompressibleLESModels \
     -lmeshTools \
     -lfiniteVolume \
-    -lradiationModels
+    -lradiationModels \
+    -lfieldSources \
+    -lregionModels \
+    -lsampling
diff --git a/applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionFoam.C b/applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionFoam.C
index b65ecf5118..ab7b6add66 100644
--- a/applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionFoam.C
+++ b/applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionFoam.C
@@ -26,7 +26,13 @@ Application
 
 Description
     Combination of heatConductionFoam and buoyantFoam for conjugate heat
-    transfer between a solid region and fluid region
+    transfer between a solid region and fluid region. It includes
+    porous media in the primary fluid region treated explicitly.
+
+    It handles secondary fluid or solid circuits which can be coupled
+    thermally with the main fluid region. i.e radiators, etc.
+
+    The secondary fluid region is
 
 \*---------------------------------------------------------------------------*/
 
@@ -39,6 +45,9 @@ Description
 #include "solidRegionDiffNo.H"
 #include "basicSolidThermo.H"
 #include "radiationModel.H"
+#include "porousZones.H"
+#include "IObasicSourceList.H"
+
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -51,12 +60,16 @@ int main(int argc, char *argv[])
 
     #include "createFluidMeshes.H"
     #include "createSolidMeshes.H"
+    #include "createPorousFluidRegions.H"
+    #include "createPorousSolidMeshes.H"
 
     #include "createFluidFields.H"
     #include "createSolidFields.H"
+    #include "createPorousFluidFields.H"
+    #include "createPorousSolidFields.H"
+
 
     #include "initContinuityErrs.H"
-
     #include "readTimeControls.H"
     #include "readSolidTimeControls.H"
 
@@ -65,14 +78,12 @@ int main(int argc, char *argv[])
     #include "solidRegionDiffusionNo.H"
     #include "setInitialMultiRegionDeltaT.H"
 
-
     while (runTime.run())
     {
         #include "readTimeControls.H"
         #include "readSolidTimeControls.H"
         #include "readPIMPLEControls.H"
 
-
         #include "compressibleMultiRegionCourantNo.H"
         #include "solidRegionDiffusionNo.H"
         #include "setMultiRegionDeltaT.H"
@@ -105,6 +116,24 @@ int main(int argc, char *argv[])
                 #include "solveFluid.H"
             }
 
+            forAll(porousFluidRegions, i)
+            {
+                Info<< "\nSolving for fluid porous region "
+                    << porousFluidRegions[i].name() << endl;
+                #include "setPorousFluidFields.H"
+                #include "readPorousFluidRegionPIMPLEControls.H"
+                #include "solvePorousFluid.H"
+            }
+
+            forAll(porousSolidRegions, i)
+            {
+                Info<< "\nSolving for porous solid region "
+                    << porousSolidRegions[i].name() << endl;
+                #include "setPorousRegionSolidFields.H"
+                #include "readPorousSolidMultiRegionPIMPLEControls.H"
+                #include "solvePorousSolid.H"
+            }
+
             forAll(solidRegions, i)
             {
                 Info<< "\nSolving for solid region "
@@ -113,6 +142,7 @@ int main(int argc, char *argv[])
                 #include "readSolidMultiRegionPIMPLEControls.H"
                 #include "solveSolid.H"
             }
+
         }
 
         runTime.write();
diff --git a/applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/Make/options b/applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/Make/options
index ef9d1fbc84..306ea815f6 100644
--- a/applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/Make/options
+++ b/applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/Make/options
@@ -1,16 +1,21 @@
 EXE_INC = \
-    -I.. \
     -Ifluid \
     -Isolid \
+    -I./porousFluid \
+    -I./porousSolid \
     -I$(LIB_SRC)/finiteVolume/lnInclude \
     -I$(LIB_SRC)/meshTools/lnInclude \
+    -I$(LIB_SRC)/finiteVolume/cfdTools \
     -I$(LIB_SRC)/thermophysicalModels/basic/lnInclude \
     -I$(LIB_SRC)/thermophysicalModels/specie/lnInclude \
     -I$(LIB_SRC)/thermophysicalModels/basicSolidThermo/lnInclude \
     -I$(LIB_SRC)/thermophysicalModels/radiationModels/lnInclude \
     -I$(LIB_SRC)/turbulenceModels \
     -I$(LIB_SRC)/turbulenceModels/compressible/turbulenceModel/lnInclude \
-    -I$(LIB_SRC)/turbulenceModels/compressible/RAS/lnInclude
+    -I$(LIB_SRC)/turbulenceModels/compressible/RAS/lnInclude \
+    -I$(LIB_SRC)/fieldSources/lnInclude \
+    -I$(LIB_SRC)/sampling/lnInclude \
+    -I$(LIB_SRC)/regionModels/regionModel/lnInclude
 
 EXE_LIBS = \
     -lfiniteVolume \
@@ -20,4 +25,7 @@ EXE_LIBS = \
     -lcompressibleTurbulenceModel \
     -lcompressibleRASModels \
     -lcompressibleLESModels \
-    -lradiationModels
+    -lradiationModels \
+    -lfieldSources \
+    -lregionModels \
+    -lsampling
diff --git a/applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/chtMultiRegionSimpleFoam.C b/applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/chtMultiRegionSimpleFoam.C
index 905b0ca709..3cfc5af784 100644
--- a/applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/chtMultiRegionSimpleFoam.C
+++ b/applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/chtMultiRegionSimpleFoam.C
@@ -36,6 +36,8 @@ Description
 #include "regionProperties.H"
 #include "basicSolidThermo.H"
 #include "radiationModel.H"
+#include "porousZones.H"
+#include "IObasicSourceList.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -48,9 +50,13 @@ int main(int argc, char *argv[])
 
     #include "createFluidMeshes.H"
     #include "createSolidMeshes.H"
+    #include "createPorousFluidRegions.H"
+    #include "createPorousSolidMeshes.H"
 
     #include "createFluidFields.H"
     #include "createSolidFields.H"
+    #include "createPorousFluidFields.H"
+    #include "createPorousSolidFields.H"
 
     #include "initContinuityErrs.H"
 
@@ -68,6 +74,24 @@ int main(int argc, char *argv[])
             #include "solveFluid.H"
         }
 
+        forAll(porousFluidRegions, i)
+        {
+            Info<< "\nSolving for fluid porous region "
+                << porousFluidRegions[i].name() << endl;
+            #include "setPorousFluidFields.H"
+            #include "readPorousFluidRegionSIMPLEControls.H"
+            #include "solvePorousFluid.H"
+        }
+
+        forAll(porousSolidRegions, i)
+        {
+            Info<< "\nSolving for porous solid region "
+                << porousSolidRegions[i].name() << endl;
+            #include "setPorousRegionSolidFields.H"
+            #include "readPorousSolidMultiRegionSIMPLEControls.H"
+            #include "solvePorousSolid.H"
+        }
+
         forAll(solidRegions, i)
         {
             Info<< "\nSolving for solid region "
diff --git a/applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/fluid/UEqn.H b/applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/fluid/UEqn.H
index 68b29fd0c2..8bbc8be581 100644
--- a/applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/fluid/UEqn.H
+++ b/applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/fluid/UEqn.H
@@ -3,10 +3,14 @@
     (
         fvm::div(phi, U)
       + turb.divDevRhoReff(U)
+      + sources(rho, U)
     );
 
     UEqn().relax();
 
+    // Add porous resistance
+    pZones.addResistance(UEqn());
+
     solve
     (
         UEqn()
diff --git a/applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/fluid/createFluidFields.H b/applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/fluid/createFluidFields.H
index 14f51f4c50..0ce4a25ac3 100644
--- a/applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/fluid/createFluidFields.H
+++ b/applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/fluid/createFluidFields.H
@@ -18,6 +18,9 @@
     PtrList<dimensionedScalar> rhoMax(fluidRegions.size());
     PtrList<dimensionedScalar> rhoMin(fluidRegions.size());
 
+    PtrList<IObasicSourceList> heatSources(fluidRegions.size());
+    PtrList<porousZones> porousZonesFluid(fluidRegions.size());
+
     // Populate fluid field pointer lists
     forAll(fluidRegions, i)
     {
@@ -209,6 +212,20 @@
                 )
             )
         );
+
+        Info<< "    Adding sources\n" << endl;
+        heatSources.set
+        (
+            i,
+            new IObasicSourceList(fluidRegions[i])
+        );
+
+        Info<< "    Adding porous zones\n" << endl;
+        porousZonesFluid.set
+        (
+            i,
+            new porousZones(fluidRegions[i])
+        );
     }
 
 
diff --git a/applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/fluid/createFluidMeshes.H b/applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/fluid/createFluidMeshes.H
index 30a2e1089f..9ded78bb7a 100644
--- a/applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/fluid/createFluidMeshes.H
+++ b/applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/fluid/createFluidMeshes.H
@@ -1,8 +1,10 @@
-    PtrList<fvMesh> fluidRegions(rp.fluidRegionNames().size());
+    const wordList fluidNames(rp["fluid"]);
 
-    forAll(rp.fluidRegionNames(), i)
+    PtrList<fvMesh> fluidRegions(fluidNames.size());
+
+    forAll(fluidNames, i)
     {
-        Info<< "Create fluid mesh for region " << rp.fluidRegionNames()[i]
+        Info<< "Create fluid mesh for region " << fluidNames[i]
             << " for time = " << runTime.timeName() << nl << endl;
 
         fluidRegions.set
@@ -12,7 +14,7 @@
             (
                 IOobject
                 (
-                    rp.fluidRegionNames()[i],
+                    fluidNames[i],
                     runTime.timeName(),
                     runTime,
                     IOobject::MUST_READ
diff --git a/applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/fluid/hEqn.H b/applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/fluid/hEqn.H
index 4505f77ed0..e55b6d141d 100644
--- a/applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/fluid/hEqn.H
+++ b/applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/fluid/hEqn.H
@@ -7,6 +7,7 @@
      ==
       - fvc::div(phi, 0.5*magSqr(U), "div(phi,K)")
       + rad.Sh(thermo)
+      + sources(rho, h)
     );
 
     hEqn.relax();
diff --git a/applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/fluid/readFluidMultiRegionSIMPLEControls.H b/applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/fluid/readFluidMultiRegionSIMPLEControls.H
index f8a11b7159..616fabd7fe 100644
--- a/applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/fluid/readFluidMultiRegionSIMPLEControls.H
+++ b/applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/fluid/readFluidMultiRegionSIMPLEControls.H
@@ -3,9 +3,3 @@
     const int nNonOrthCorr =
         simple.lookupOrDefault<int>("nNonOrthogonalCorrectors", 0);
 
-    const bool momentumPredictor =
-        simple.lookupOrDefault("momentumPredictor", true);
-
-    const bool transonic =
-        simple.lookupOrDefault("transonic", false);
-
diff --git a/applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/fluid/setRegionFluidFields.H b/applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/fluid/setRegionFluidFields.H
index cbad65e1c2..39d3de9648 100644
--- a/applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/fluid/setRegionFluidFields.H
+++ b/applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/fluid/setRegionFluidFields.H
@@ -12,6 +12,10 @@
     const volScalarField& psi = thermo.psi();
     volScalarField& h = thermo.h();
 
+    IObasicSourceList& sources = heatSources[i];
+
+    const porousZones& pZones = porousZonesFluid[i];
+
     const dimensionedScalar initialMass
     (
         "initialMass",
diff --git a/applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/porousFluid/UPorousFluidEqn.H b/applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/porousFluid/UPorousFluidEqn.H
new file mode 100644
index 0000000000..4c1081f5d4
--- /dev/null
+++ b/applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/porousFluid/UPorousFluidEqn.H
@@ -0,0 +1,11 @@
+    // Solve the Momentum equation
+    tmp<fvVectorMatrix> porousUEqn
+    (
+        fvm::div(porousPhi, porousU)
+      + turbPorous.divDevRhoReff(porousU)
+      + porousSources(porousRho, porousU)
+    );
+
+    porousUEqn().relax();
+
+    solve(porousUEqn() == -fvc::grad(porousP));
diff --git a/applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/porousFluid/createPorousFluidFields.H b/applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/porousFluid/createPorousFluidFields.H
new file mode 100644
index 0000000000..fa925f4c87
--- /dev/null
+++ b/applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/porousFluid/createPorousFluidFields.H
@@ -0,0 +1,181 @@
+    // Initialise porous field pointer lists
+    PtrList<basicRhoThermo> thermoPorous(porousFluidRegions.size());
+    PtrList<volScalarField> rhoPorous(porousFluidRegions.size());
+    PtrList<volScalarField> kappaPorous(porousFluidRegions.size());
+    PtrList<volVectorField> UPorous(porousFluidRegions.size());
+    PtrList<surfaceScalarField> phiPorous(porousFluidRegions.size());
+    PtrList<compressible::turbulenceModel> turbulencePorous
+    (
+        porousFluidRegions.size()
+    );
+    PtrList<volScalarField> pPorous(porousFluidRegions.size());
+
+    List<scalar> initialMassFluidPorous(porousFluidRegions.size());
+    List<label> pRefCellFluidPorous(porousFluidRegions.size(),0);
+    List<scalar> pRefValueFluidPorous(porousFluidRegions.size(),0.0);
+
+    PtrList<dimensionedScalar> rhoMaxPorous(fluidRegions.size());
+    PtrList<dimensionedScalar> rhoMinPorous(fluidRegions.size());
+
+    PtrList<IObasicSourceList> heatPorousSources
+    (
+        porousFluidRegions.size()
+    );
+
+    forAll(porousFluidRegions, i)
+    {
+        Info<< "Reading fluid mesh thermophysical properties for porous "
+            << porousFluidRegions[i].name() << nl << endl;
+
+        Info<< "    Adding to thermoFluid porous\n" << endl;
+
+        thermoPorous.set
+        (
+            i,
+            basicRhoThermo::New(porousFluidRegions[i]).ptr()
+        );
+
+        Info<< "    Adding to rhoPorous\n" << endl;
+        rhoPorous.set
+        (
+            i,
+            new volScalarField
+            (
+                IOobject
+                (
+                    "rho",
+                    runTime.timeName(),
+                    porousFluidRegions[i],
+                    IOobject::NO_READ,
+                    IOobject::AUTO_WRITE
+                ),
+                thermoPorous[i].rho()
+            )
+        );
+
+        Info<< "    Adding to UPorous\n" << endl;
+        UPorous.set
+        (
+            i,
+            new volVectorField
+            (
+                IOobject
+                (
+                    "U",
+                    runTime.timeName(),
+                    porousFluidRegions[i],
+                    IOobject::MUST_READ,
+                    IOobject::AUTO_WRITE
+                ),
+                porousFluidRegions[i]
+            )
+        );
+
+        Info<< "    Adding to phiPorous\n" << endl;
+        phiPorous.set
+        (
+            i,
+            new surfaceScalarField
+            (
+                IOobject
+                (
+                    "phi",
+                    runTime.timeName(),
+                    porousFluidRegions[i],
+                    IOobject::READ_IF_PRESENT,
+                    IOobject::AUTO_WRITE
+                ),
+                linearInterpolate(rhoPorous[i]*UPorous[i])
+                    & porousFluidRegions[i].Sf()
+            )
+        );
+
+        Info<< "    Adding turbulence to porous\n" << endl;
+        turbulencePorous.set
+        (
+            i,
+            compressible::turbulenceModel::New
+            (
+                rhoPorous[i],
+                UPorous[i],
+                phiPorous[i],
+                thermoPorous[i]
+            ).ptr()
+        );
+
+        Info<< "    Adding to kappaFluid\n" << endl;
+        kappaPorous.set
+        (
+            i,
+            new volScalarField
+            (
+                IOobject
+                (
+                    "kappaPorous",
+                    runTime.timeName(),
+                    porousFluidRegions[i],
+                    IOobject::NO_READ,
+                    IOobject::NO_WRITE
+                ),
+                thermoPorous[i].Cp()*thermoPorous[i].alpha()
+            )
+        );
+
+        pPorous.set
+        (
+            i,
+            new volScalarField
+            (
+                IOobject
+                (
+                    "p",
+                    runTime.timeName(),
+                    porousFluidRegions[i],
+                    IOobject::MUST_READ,
+                    IOobject::AUTO_WRITE
+                ),
+                porousFluidRegions[i]
+            )
+        );
+
+        setRefCell
+        (
+            thermoPorous[i].p(),
+            pPorous[i],
+            porousFluidRegions[i].solutionDict().subDict("SIMPLE"),
+            pRefCellFluidPorous[i],
+            pRefValueFluidPorous[i]
+        );
+
+        rhoMaxPorous.set
+        (
+            i,
+            new dimensionedScalar
+            (
+                porousFluidRegions[i].solutionDict().subDict("SIMPLE").lookup
+                (
+                    "rhoMax"
+                )
+            )
+        );
+
+        rhoMinPorous.set
+        (
+            i,
+            new dimensionedScalar
+            (
+                porousFluidRegions[i].solutionDict().subDict("SIMPLE").lookup
+                (
+                    "rhoMin"
+                )
+            )
+        );
+
+        heatPorousSources.set
+        (
+            i,
+            new IObasicSourceList(porousFluidRegions[i])
+        );
+    }
+
+
diff --git a/applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/porousFluid/createPorousFluidRegions.H b/applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/porousFluid/createPorousFluidRegions.H
new file mode 100644
index 0000000000..a414d8a972
--- /dev/null
+++ b/applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/porousFluid/createPorousFluidRegions.H
@@ -0,0 +1,25 @@
+    const wordList porousFluidNames(rp["porousFluid"]);
+
+    PtrList<fvMesh> porousFluidRegions(porousFluidNames.size());
+
+    forAll (porousFluidNames, iPorous)
+    {
+        const word porousFluidName = porousFluidNames[iPorous];
+        Info<< "Create porous fluid region " << porousFluidName
+            << nl << endl;
+
+        porousFluidRegions.set
+        (
+            iPorous,
+            new fvMesh
+            (
+                IOobject
+                (
+                    porousFluidName,
+                    runTime.timeName(),
+                    runTime,
+                    IOobject::MUST_READ
+                )
+            )
+        );
+    }
diff --git a/applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/porousFluid/hPorousFluidEqn.H b/applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/porousFluid/hPorousFluidEqn.H
new file mode 100644
index 0000000000..653389b221
--- /dev/null
+++ b/applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/porousFluid/hPorousFluidEqn.H
@@ -0,0 +1,20 @@
+{
+    fvScalarMatrix hPorousEqn
+    (
+        fvm::div(porousPhi, porousH)
+      - fvm::Sp(fvc::div(porousPhi), porousH)
+      - fvm::laplacian(turbPorous.alphaEff(), porousH)
+     ==
+      - fvc::div(porousPhi, 0.5*magSqr(porousU), "div(phi,K)")
+      + porousSources(porousRho, porousH)
+    );
+
+    hPorousEqn.relax();
+    hPorousEqn.solve();
+
+    porousThermo.correct();
+
+    Info<< "Min/max in the porous T:"
+        << min(porousThermo.T()).value() << ' '
+        << max(porousThermo.T()).value() << endl;
+}
diff --git a/applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/porousFluid/pPorousFluidEqn.H b/applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/porousFluid/pPorousFluidEqn.H
new file mode 100644
index 0000000000..ca338975fb
--- /dev/null
+++ b/applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/porousFluid/pPorousFluidEqn.H
@@ -0,0 +1,54 @@
+porousRho = porousThermo.rho();
+porousRho = max(porousRho, rhoMin);
+porousRho = min(porousRho, rhoMax);
+porousRho.relax();
+
+volScalarField rAUPorous(1.0/porousUEqn().A());
+
+porousU = rAUPorous*porousUEqn().H();
+porousUEqn.clear();
+
+bool closedVolume = false;
+
+porousPhi =
+    fvc::interpolate(porousRho)
+    *(fvc::interpolate(porousU) & porousMesh.Sf());
+
+for (int nonOrth=0; nonOrth<=nNonOrthCorr; nonOrth++)
+{
+
+    fvScalarMatrix pEqn
+    (
+        fvm::laplacian(porousRho*rAUPorous, porousP) ==  fvc::div(porousPhi)
+    );
+
+    pEqn.setReference(pRefCell, pRefValue);
+
+    pEqn.solve();
+
+    if (nonOrth == nNonOrthCorr)
+    {
+        porousPhi -= pEqn.flux();
+
+    }
+}
+
+porousP.relax();
+
+porousU -= rAUPorous*fvc::grad(porousP);
+porousU.correctBoundaryConditions();
+
+if (closedVolume)
+{
+    porousP += (initialMass - fvc::domainIntegrate(porousPsi*porousP))
+        /fvc::domainIntegrate(porousPsi);
+}
+
+porousRho = porousThermo.rho();
+porousRho = max(porousRho, rhoMin);
+porousRho = min(porousRho, rhoMax);
+porousRho.relax();
+
+Info<< "rho max/min : "
+    << max(porousRho).value() << " "
+    << min(porousRho).value() << endl;
diff --git a/applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/porousFluid/readPorousFluidRegionSIMPLEControls.H b/applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/porousFluid/readPorousFluidRegionSIMPLEControls.H
new file mode 100644
index 0000000000..615524b075
--- /dev/null
+++ b/applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/porousFluid/readPorousFluidRegionSIMPLEControls.H
@@ -0,0 +1,4 @@
+    const dictionary& simple = porousMesh.solutionDict().subDict("SIMPLE");
+
+    const int nNonOrthCorr =
+        simple.lookupOrDefault<int>("nNonOrthogonalCorrectors", 0);
diff --git a/applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/porousFluid/setPorousFluidFields.H b/applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/porousFluid/setPorousFluidFields.H
new file mode 100644
index 0000000000..914a6a7b9c
--- /dev/null
+++ b/applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/porousFluid/setPorousFluidFields.H
@@ -0,0 +1,31 @@
+
+    const fvMesh& porousMesh = porousFluidRegions[i];
+
+    basicRhoThermo& porousThermo = thermoPorous[i];
+    volScalarField& porousRho = rhoPorous[i];
+
+    volVectorField& porousU = UPorous[i];
+    surfaceScalarField& porousPhi = phiPorous[i];
+
+    compressible::turbulenceModel& turbPorous = turbulencePorous[i];
+
+    volScalarField& porousP = porousThermo.p();
+    const volScalarField& porousPsi = porousThermo.psi();
+    volScalarField& porousH = porousThermo.h();
+
+    const dimensionedScalar initialMass
+    (
+        "initialMass",
+        dimMass,
+        initialMassFluidPorous[i]
+    );
+
+    IObasicSourceList& porousSources = heatPorousSources[i];
+
+    const label pRefCell = pRefCellFluidPorous[i];
+    const scalar pRefValue = pRefValueFluidPorous[i];
+
+    const scalar rhoMax = rhoMaxPorous[i].value();
+    const scalar rhoMin = rhoMinPorous[i].value();
+
+
diff --git a/applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/porousFluid/solvePorousFluid.H b/applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/porousFluid/solvePorousFluid.H
new file mode 100644
index 0000000000..635b3ef154
--- /dev/null
+++ b/applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/porousFluid/solvePorousFluid.H
@@ -0,0 +1,11 @@
+//  Pressure-velocity SIMPLE corrector
+
+    porousP.storePrevIter();
+    porousRho.storePrevIter();
+    {
+        #include "UPorousFluidEqn.H"
+        #include "hPorousFluidEqn.H"
+        #include "pPorousFluidEqn.H"
+    }
+
+    turbPorous.correct();
diff --git a/applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/porousSolid/createPorousSolidFields.H b/applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/porousSolid/createPorousSolidFields.H
new file mode 100644
index 0000000000..1b39bf0527
--- /dev/null
+++ b/applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/porousSolid/createPorousSolidFields.H
@@ -0,0 +1,43 @@
+    // Initialise solid field pointer lists
+    PtrList<basicSolidThermo> porousSolidThermos(porousSolidRegions.size());
+    PtrList<IObasicSourceList> solidHeatSources(porousSolidRegions.size());
+    PtrList<volScalarField> betavSolid(porousSolidRegions.size());
+
+    // Populate solid field pointer lists
+    forAll(porousSolidRegions, i)
+    {
+        Info<< "*** Reading porous solid mesh thermophysical "
+            << "properties for region "
+            << porousSolidRegions[i].name() << nl << endl;
+
+        Info<< "    Adding to thermos\n" << endl;
+        porousSolidThermos.set
+        (
+            i,
+            basicSolidThermo::New(porousSolidRegions[i])
+        );
+        Info<< "    Adding sources\n" << endl;
+        solidHeatSources.set
+        (
+            i,
+            new IObasicSourceList(porousSolidRegions[i])
+        );
+
+        Info<< "    Adding to betavSolid\n" << endl;
+        betavSolid.set
+        (
+            i,
+            new volScalarField
+            (
+                IOobject
+                (
+                    "betavSolid",
+                    runTime.timeName(),
+                    porousSolidRegions[i],
+                    IOobject::MUST_READ,
+                    IOobject::AUTO_WRITE
+                ),
+                porousSolidRegions[i]
+            )
+        );
+    }
diff --git a/applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/porousSolid/createPorousSolidMeshes.H b/applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/porousSolid/createPorousSolidMeshes.H
new file mode 100644
index 0000000000..fa61f55af4
--- /dev/null
+++ b/applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/porousSolid/createPorousSolidMeshes.H
@@ -0,0 +1,24 @@
+    const wordList porousSolidNames(rp["porousSolid"]);
+
+    PtrList<fvMesh> porousSolidRegions(porousSolidNames.size());
+
+    forAll(porousSolidNames, i)
+    {
+        Info<< "Create solid mesh for region " << porousSolidNames[i]
+            << " for time = " << runTime.timeName() << nl << endl;
+
+        porousSolidRegions.set
+        (
+            i,
+            new fvMesh
+            (
+                IOobject
+                (
+                    porousSolidNames[i],
+                    runTime.timeName(),
+                    runTime,
+                    IOobject::MUST_READ
+                )
+            )
+        );
+    }
diff --git a/applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/porousSolid/readPorousSolidMultiRegionSIMPLEControls.H b/applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/porousSolid/readPorousSolidMultiRegionSIMPLEControls.H
new file mode 100644
index 0000000000..4255ceb033
--- /dev/null
+++ b/applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/porousSolid/readPorousSolidMultiRegionSIMPLEControls.H
@@ -0,0 +1,4 @@
+    const dictionary& simple = mesh.solutionDict().subDict("SIMPLE");
+
+    const int nNonOrthCorr =
+        simple.lookupOrDefault<int>("nNonOrthogonalCorrectors", 0);
diff --git a/applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/porousSolid/setPorousRegionSolidFields.H b/applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/porousSolid/setPorousRegionSolidFields.H
new file mode 100644
index 0000000000..102ba89a09
--- /dev/null
+++ b/applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/porousSolid/setPorousRegionSolidFields.H
@@ -0,0 +1,20 @@
+    const fvMesh& mesh = porousSolidRegions[i];
+
+    basicSolidThermo& thermo = porousSolidThermos[i];
+    const volScalarField& betav = betavSolid[i];
+
+    tmp<volScalarField> trho = thermo.rho();
+    const volScalarField& rho = trho();
+
+    tmp<volScalarField> tcp = thermo.Cp();
+    const volScalarField& cp = tcp();
+
+    tmp<volScalarField> tkappa = thermo.K();
+    //tmp<volSymmTensorField> tkappa = thermo.directionalK()*betav;
+
+    const volScalarField& kappa = tkappa();
+    //const volSymmTensorField& K = tK();
+
+    volScalarField& T = thermo.T();
+
+    IObasicSourceList& sources = solidHeatSources[i];
diff --git a/applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/porousSolid/solidPorousRegionDiffusionNo.H b/applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/porousSolid/solidPorousRegionDiffusionNo.H
new file mode 100644
index 0000000000..77dc6f04bf
--- /dev/null
+++ b/applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/porousSolid/solidPorousRegionDiffusionNo.H
@@ -0,0 +1,18 @@
+    scalar DiNum = -GREAT;
+
+    forAll(solidRegions, i)
+    {
+#       include "setRegionSolidFields.H"
+
+        DiNum = max
+        (
+            solidRegionDiffNo
+            (
+                solidRegions[i],
+                runTime,
+                rho*cp,
+                K
+            ),
+            DiNum
+        );
+    }
diff --git a/applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/porousSolid/solvePorousSolid.H b/applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/porousSolid/solvePorousSolid.H
new file mode 100644
index 0000000000..b4346275e4
--- /dev/null
+++ b/applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/porousSolid/solvePorousSolid.H
@@ -0,0 +1,15 @@
+{
+    for (int nonOrth=0; nonOrth<=nNonOrthCorr; nonOrth++)
+    {
+        tmp<fvScalarMatrix> TEqn
+        (
+          - fvm::laplacian(betav*kappa, T, "laplacian(K,T)")
+          + sources(rho, T)
+        );
+
+        TEqn().relax();
+        TEqn().solve();
+    }
+
+    Info<< "Min/max T:" << min(T).value() << ' ' << max(T).value() << endl;
+}
diff --git a/applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/solid/createSolidMeshes.H b/applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/solid/createSolidMeshes.H
index eb50be2380..f2f2eea5ae 100644
--- a/applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/solid/createSolidMeshes.H
+++ b/applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/solid/createSolidMeshes.H
@@ -1,8 +1,10 @@
-    PtrList<fvMesh> solidRegions(rp.solidRegionNames().size());
+    const wordList solidsNames(rp["solid"]);
 
-    forAll(rp.solidRegionNames(), i)
+    PtrList<fvMesh> solidRegions(solidsNames.size());
+
+    forAll(solidsNames, i)
     {
-        Info<< "Create solid mesh for region " << rp.solidRegionNames()[i]
+        Info<< "Create solid mesh for region " << solidsNames[i]
             << " for time = " << runTime.timeName() << nl << endl;
 
         solidRegions.set
@@ -12,16 +14,11 @@
             (
                 IOobject
                 (
-                    rp.solidRegionNames()[i],
+                    solidsNames[i],
                     runTime.timeName(),
                     runTime,
                     IOobject::MUST_READ
                 )
             )
         );
-
-        // Force calculation of geometric properties to prevent it being done
-        // later in e.g. some boundary evaluation
-        //(void)solidRegions[i].weights();
-        //(void)solidRegions[i].deltaCoeffs();
     }
diff --git a/applications/solvers/heatTransfer/chtMultiRegionFoam/fluid/UEqn.H b/applications/solvers/heatTransfer/chtMultiRegionFoam/fluid/UEqn.H
index 69a23fa1d2..87bd5924f4 100644
--- a/applications/solvers/heatTransfer/chtMultiRegionFoam/fluid/UEqn.H
+++ b/applications/solvers/heatTransfer/chtMultiRegionFoam/fluid/UEqn.H
@@ -4,24 +4,28 @@
         fvm::ddt(rho, U)
       + fvm::div(phi, U)
       + turb.divDevRhoReff(U)
+      + sources(rho, U)
     );
 
     UEqn().relax();
 
+    // Add porous resistance
+    pZones.addResistance(UEqn());
+
     if (momentumPredictor)
     {
-         solve
-         (
+        solve
+        (
             UEqn()
-         ==
+          ==
             fvc::reconstruct
             (
                 (
-                  - ghf*fvc::snGrad(rho)
-                  - fvc::snGrad(p_rgh)
+                    - ghf*fvc::snGrad(rho)
+                    - fvc::snGrad(p_rgh)
                 )*mesh.magSf()
             ),
             mesh.solver(U.select(finalIter))
-         );
-         K = 0.5*magSqr(U);
+        );
+        K = 0.5*magSqr(U);
     }
diff --git a/applications/solvers/heatTransfer/chtMultiRegionFoam/fluid/compressibleMultiRegionCourantNo.H b/applications/solvers/heatTransfer/chtMultiRegionFoam/fluid/compressibleMultiRegionCourantNo.H
index b5db5078f1..313a11a9c9 100644
--- a/applications/solvers/heatTransfer/chtMultiRegionFoam/fluid/compressibleMultiRegionCourantNo.H
+++ b/applications/solvers/heatTransfer/chtMultiRegionFoam/fluid/compressibleMultiRegionCourantNo.H
@@ -14,3 +14,18 @@
             CoNum
         );
     }
+
+    forAll (porousFluidRegions, porousI)
+    {
+        CoNum = max
+        (
+            compressibleCourantNo
+            (
+                porousFluidRegions[porousI],
+                runTime,
+                rhoPorous[porousI],
+                phiPorous[porousI]
+            ),
+            CoNum
+        );
+    }
diff --git a/applications/solvers/heatTransfer/chtMultiRegionFoam/fluid/createFluidFields.H b/applications/solvers/heatTransfer/chtMultiRegionFoam/fluid/createFluidFields.H
index 7090319d94..27f63f9916 100644
--- a/applications/solvers/heatTransfer/chtMultiRegionFoam/fluid/createFluidFields.H
+++ b/applications/solvers/heatTransfer/chtMultiRegionFoam/fluid/createFluidFields.H
@@ -15,6 +15,9 @@
 
     List<scalar> initialMassFluid(fluidRegions.size());
 
+    PtrList<IObasicSourceList> heatSources(fluidRegions.size());
+    PtrList<porousZones> porousZonesFluid(fluidRegions.size());
+
     // Populate fluid field pointer lists
     forAll(fluidRegions, i)
     {
@@ -22,6 +25,7 @@
             << fluidRegions[i].name() << nl << endl;
 
         Info<< "    Adding to thermoFluid\n" << endl;
+
         thermoFluid.set
         (
             i,
@@ -118,19 +122,16 @@
             )
         );
 
-        Info<< "    Adding to turbulence\n" << endl;
+        Info<< "    Adding turbulence \n" << endl;
         turbulence.set
         (
             i,
-            autoPtr<compressible::turbulenceModel>
+            compressible::turbulenceModel::New
             (
-                compressible::turbulenceModel::New
-                (
-                    rhoFluid[i],
-                    UFluid[i],
-                    phiFluid[i],
-                    thermoFluid[i]
-                )
+                rhoFluid[i],
+                UFluid[i],
+                phiFluid[i],
+                thermoFluid[i]
             ).ptr()
         );
 
@@ -197,4 +198,20 @@
                 fvc::ddt(thermoFluid[i].p())
             )
         );
+
+        Info<< "    Adding sources\n" << endl;
+        heatSources.set
+        (
+            i,
+            new IObasicSourceList(fluidRegions[i])
+        );
+
+        Info<< "    Adding porous zones\n" << endl;
+        porousZonesFluid.set
+        (
+            i,
+            new porousZones(fluidRegions[i])
+        );
     }
+
+
diff --git a/applications/solvers/heatTransfer/chtMultiRegionFoam/fluid/createFluidMeshes.H b/applications/solvers/heatTransfer/chtMultiRegionFoam/fluid/createFluidMeshes.H
index 30a2e1089f..9ded78bb7a 100644
--- a/applications/solvers/heatTransfer/chtMultiRegionFoam/fluid/createFluidMeshes.H
+++ b/applications/solvers/heatTransfer/chtMultiRegionFoam/fluid/createFluidMeshes.H
@@ -1,8 +1,10 @@
-    PtrList<fvMesh> fluidRegions(rp.fluidRegionNames().size());
+    const wordList fluidNames(rp["fluid"]);
 
-    forAll(rp.fluidRegionNames(), i)
+    PtrList<fvMesh> fluidRegions(fluidNames.size());
+
+    forAll(fluidNames, i)
     {
-        Info<< "Create fluid mesh for region " << rp.fluidRegionNames()[i]
+        Info<< "Create fluid mesh for region " << fluidNames[i]
             << " for time = " << runTime.timeName() << nl << endl;
 
         fluidRegions.set
@@ -12,7 +14,7 @@
             (
                 IOobject
                 (
-                    rp.fluidRegionNames()[i],
+                    fluidNames[i],
                     runTime.timeName(),
                     runTime,
                     IOobject::MUST_READ
diff --git a/applications/solvers/heatTransfer/chtMultiRegionFoam/fluid/hEqn.H b/applications/solvers/heatTransfer/chtMultiRegionFoam/fluid/hEqn.H
index 293a2001c0..9a94f52b75 100644
--- a/applications/solvers/heatTransfer/chtMultiRegionFoam/fluid/hEqn.H
+++ b/applications/solvers/heatTransfer/chtMultiRegionFoam/fluid/hEqn.H
@@ -8,6 +8,7 @@
         dpdt
       - (fvc::ddt(rho, K) + fvc::div(phi, K))
       + rad.Sh(thermo)
+      + sources(rho, h)
     );
 
     hEqn.relax();
@@ -19,4 +20,5 @@
 
     Info<< "Min/max T:" << min(thermo.T()).value() << ' '
         << max(thermo.T()).value() << endl;
+
 }
diff --git a/applications/solvers/heatTransfer/chtMultiRegionFoam/fluid/pEqn.H b/applications/solvers/heatTransfer/chtMultiRegionFoam/fluid/pEqn.H
index 1df38d15bb..a582d09213 100644
--- a/applications/solvers/heatTransfer/chtMultiRegionFoam/fluid/pEqn.H
+++ b/applications/solvers/heatTransfer/chtMultiRegionFoam/fluid/pEqn.H
@@ -68,14 +68,11 @@
     // Correct velocity field
     U += rAU*fvc::reconstruct((phi - phiU)/rhorAUf);
     U.correctBoundaryConditions();
-    K = 0.5*magSqr(U);
-
     p = p_rgh + rho*gh;
 
     // Update pressure time derivative
     dpdt = fvc::ddt(p);
 
-
     // Solve continuity
     #include "rhoEqn.H"
 
diff --git a/applications/solvers/heatTransfer/chtMultiRegionFoam/fluid/readFluidMultiRegionPIMPLEControls.H b/applications/solvers/heatTransfer/chtMultiRegionFoam/fluid/readFluidMultiRegionPIMPLEControls.H
index 71e49a33a8..a6f6aad8af 100644
--- a/applications/solvers/heatTransfer/chtMultiRegionFoam/fluid/readFluidMultiRegionPIMPLEControls.H
+++ b/applications/solvers/heatTransfer/chtMultiRegionFoam/fluid/readFluidMultiRegionPIMPLEControls.H
@@ -8,4 +8,3 @@
 
     const bool momentumPredictor =
         pimple.lookupOrDefault("momentumPredictor", true);
-
diff --git a/applications/solvers/heatTransfer/chtMultiRegionFoam/fluid/setRegionFluidFields.H b/applications/solvers/heatTransfer/chtMultiRegionFoam/fluid/setRegionFluidFields.H
index 6529c13931..bd1f60c9b8 100644
--- a/applications/solvers/heatTransfer/chtMultiRegionFoam/fluid/setRegionFluidFields.H
+++ b/applications/solvers/heatTransfer/chtMultiRegionFoam/fluid/setRegionFluidFields.H
@@ -20,6 +20,10 @@
 
     radiation::radiationModel& rad = radiation[i];
 
+    IObasicSourceList& sources = heatSources[i];
+
+    const porousZones& pZones = porousZonesFluid[i];
+
     const dimensionedScalar initialMass
     (
         "initialMass",
diff --git a/applications/solvers/heatTransfer/chtMultiRegionFoam/porousFluid/UPorousFluidEqn.H b/applications/solvers/heatTransfer/chtMultiRegionFoam/porousFluid/UPorousFluidEqn.H
new file mode 100644
index 0000000000..2de604e0b0
--- /dev/null
+++ b/applications/solvers/heatTransfer/chtMultiRegionFoam/porousFluid/UPorousFluidEqn.H
@@ -0,0 +1,24 @@
+
+// Solve the Momentum equation
+    tmp<fvVectorMatrix> porousUEqn
+    (
+        fvm::ddt(porousRho, porousU)
+      + fvm::div(porousPhi, porousU)
+      + turbPorous.divDevRhoReff(porousU)
+      + porousSources(porousRho, porousU)
+    );
+
+    porousUEqn().relax();
+
+    volScalarField rAUPorous(1.0/porousUEqn().A());
+
+    if (momentumPredictor)
+    {
+        solve(porousUEqn() == -fvc::grad(porousP));
+    }
+    else
+    {
+        porousU = rAUPorous*(porousUEqn().H() - fvc::grad(porousP));
+        porousU.correctBoundaryConditions();
+    }
+
diff --git a/applications/solvers/heatTransfer/chtMultiRegionFoam/porousFluid/createPorousFluidFields.H b/applications/solvers/heatTransfer/chtMultiRegionFoam/porousFluid/createPorousFluidFields.H
new file mode 100644
index 0000000000..841ce1fee7
--- /dev/null
+++ b/applications/solvers/heatTransfer/chtMultiRegionFoam/porousFluid/createPorousFluidFields.H
@@ -0,0 +1,147 @@
+    // Initialise porous field pointer lists
+    PtrList<basicRhoThermo> thermoPorous(porousFluidRegions.size());
+    PtrList<volScalarField> rhoPorous(porousFluidRegions.size());
+    PtrList<volVectorField> UPorous(porousFluidRegions.size());
+    PtrList<surfaceScalarField> phiPorous(porousFluidRegions.size());
+    PtrList<volScalarField> KPorous(porousFluidRegions.size());
+    PtrList<volScalarField> dpdtPorous(fluidRegions.size());
+
+    PtrList<compressible::turbulenceModel> turbulencePorous
+    (
+        porousFluidRegions.size()
+    );
+    PtrList<volScalarField> pPorous(porousFluidRegions.size());
+
+    PtrList<IObasicSourceList> heatPorousSources
+    (
+        porousFluidRegions.size()
+    );
+
+    forAll(porousFluidRegions, i)
+    {
+        Info<< "Reading fluid mesh thermophysical properties for porous "
+            << porousFluidRegions[i].name() << nl << endl;
+
+        Info<< "    Adding to thermoFluid porous\n" << endl;
+
+        thermoPorous.set
+        (
+            i,
+            basicRhoThermo::New(porousFluidRegions[i]).ptr()
+        );
+
+        Info<< "    Adding to rhoPorous\n" << endl;
+        rhoPorous.set
+        (
+            i,
+            new volScalarField
+            (
+                IOobject
+                (
+                    "rho",
+                    runTime.timeName(),
+                    porousFluidRegions[i],
+                    IOobject::NO_READ,
+                    IOobject::AUTO_WRITE
+                ),
+                thermoPorous[i].rho()
+            )
+        );
+
+        Info<< "    Adding to UPorous\n" << endl;
+        UPorous.set
+        (
+            i,
+            new volVectorField
+            (
+                IOobject
+                (
+                    "U",
+                    runTime.timeName(),
+                    porousFluidRegions[i],
+                    IOobject::MUST_READ,
+                    IOobject::AUTO_WRITE
+                ),
+                porousFluidRegions[i]
+            )
+        );
+
+        Info<< "    Adding to phiPorous\n" << endl;
+        phiPorous.set
+        (
+            i,
+            new surfaceScalarField
+            (
+                IOobject
+                (
+                    "phi",
+                    runTime.timeName(),
+                    porousFluidRegions[i],
+                    IOobject::READ_IF_PRESENT,
+                    IOobject::AUTO_WRITE
+                ),
+                linearInterpolate(rhoPorous[i]*UPorous[i])
+                    & porousFluidRegions[i].Sf()
+            )
+        );
+
+        Info<< "    Adding turbulence to porous\n" << endl;
+        turbulencePorous.set
+        (
+            i,
+            compressible::turbulenceModel::New
+            (
+                rhoPorous[i],
+                UPorous[i],
+                phiPorous[i],
+                thermoPorous[i]
+            ).ptr()
+        );
+
+        Info<< "    Adding to KPorous\n" << endl;
+        KPorous.set
+        (
+            i,
+            new volScalarField
+            (
+                "KPorous",
+                0.5*magSqr(UPorous[i])
+            )
+        );
+
+        Info<< "    Adding to dpdtPorous\n" << endl;
+        dpdtPorous.set
+        (
+            i,
+            new volScalarField
+            (
+                "dpdtPorous",
+                fvc::ddt(thermoPorous[i].p())
+            )
+        );
+
+        pPorous.set
+        (
+            i,
+            new volScalarField
+            (
+                IOobject
+                (
+                    "p",
+                    runTime.timeName(),
+                    porousFluidRegions[i],
+                    IOobject::MUST_READ,
+                    IOobject::AUTO_WRITE
+                ),
+                porousFluidRegions[i]
+            )
+        );
+
+        heatPorousSources.set
+        (
+            i,
+            new IObasicSourceList(porousFluidRegions[i])
+        );
+    }
+
+
diff --git a/applications/solvers/heatTransfer/chtMultiRegionFoam/porousFluid/createPorousFluidRegions.H b/applications/solvers/heatTransfer/chtMultiRegionFoam/porousFluid/createPorousFluidRegions.H
new file mode 100644
index 0000000000..a414d8a972
--- /dev/null
+++ b/applications/solvers/heatTransfer/chtMultiRegionFoam/porousFluid/createPorousFluidRegions.H
@@ -0,0 +1,25 @@
+    const wordList porousFluidNames(rp["porousFluid"]);
+
+    PtrList<fvMesh> porousFluidRegions(porousFluidNames.size());
+
+    forAll (porousFluidNames, iPorous)
+    {
+        const word porousFluidName = porousFluidNames[iPorous];
+        Info<< "Create porous fluid region " << porousFluidName
+            << nl << endl;
+
+        porousFluidRegions.set
+        (
+            iPorous,
+            new fvMesh
+            (
+                IOobject
+                (
+                    porousFluidName,
+                    runTime.timeName(),
+                    runTime,
+                    IOobject::MUST_READ
+                )
+            )
+        );
+    }
diff --git a/applications/solvers/heatTransfer/chtMultiRegionFoam/porousFluid/hPorousFluidEqn.H b/applications/solvers/heatTransfer/chtMultiRegionFoam/porousFluid/hPorousFluidEqn.H
new file mode 100644
index 0000000000..6bf0564966
--- /dev/null
+++ b/applications/solvers/heatTransfer/chtMultiRegionFoam/porousFluid/hPorousFluidEqn.H
@@ -0,0 +1,21 @@
+{
+    fvScalarMatrix hPorousEqn
+    (
+        fvm::ddt(porousRho, porousH)
+      + fvm::div(porousPhi, porousH)
+      - fvm::laplacian(turbPorous.alphaEff(), porousH)
+     ==
+        porousdpdt
+      - (fvc::ddt(porousRho, porousK) + fvc::div(porousPhi, porousK))
+      + porousSources(porousRho, porousH)
+    );
+
+    hPorousEqn.relax();
+    hPorousEqn.solve();
+
+    porousThermo.correct();
+
+    Info<< "Min/max in the porous T:"
+        << min(porousThermo.T()).value() << ' '
+        << max(porousThermo.T()).value() << endl;
+}
diff --git a/applications/solvers/heatTransfer/chtMultiRegionFoam/porousFluid/pPorousFluidEqn.H b/applications/solvers/heatTransfer/chtMultiRegionFoam/porousFluid/pPorousFluidEqn.H
new file mode 100644
index 0000000000..cd3a309126
--- /dev/null
+++ b/applications/solvers/heatTransfer/chtMultiRegionFoam/porousFluid/pPorousFluidEqn.H
@@ -0,0 +1,61 @@
+porousRho = porousThermo.rho();
+
+porousU = rAUPorous*porousUEqn().H();
+
+if (nCorr <= 1)
+{
+    porousUEqn.clear();
+}
+
+porousPhi =
+    fvc::interpolate(porousRho)*
+    (
+        (fvc::interpolate(porousU) & porousMesh.Sf())
+        + fvc::ddtPhiCorr(rAUPorous, porousRho, porousU, porousPhi)
+    );
+
+for (int nonOrth=0; nonOrth<=nNonOrthCorr; nonOrth++)
+{
+    // Pressure corrector
+    fvScalarMatrix pEqn
+    (
+        fvm::ddt(porousPsi, porousP)
+      + fvc::div(porousPhi)
+      - fvm::laplacian(porousRho*rAUPorous, porousP)
+    );
+
+    pEqn.solve
+    (
+        porousMesh.solver
+        (
+            porousP.select
+            (
+                oCorr == nOuterCorr-1
+                && corr == nCorr-1
+                && nonOrth == nNonOrthCorr
+            )
+        )
+    );
+
+    if (nonOrth == nNonOrthCorr)
+    {
+        porousPhi += pEqn.flux();
+    }
+}
+
+solve(fvm::ddt(porousRho) + fvc::div(porousPhi));
+
+// Explicitly relax pressure for momentum corrector
+porousP.relax();
+
+// Recalculate density from the relaxed pressure
+porousRho = porousThermo.rho();
+
+
+porousU -= rAUPorous*fvc::grad(porousP);
+porousU.correctBoundaryConditions();
+porousK = 0.5*magSqr(porousU);
+
+// Update pressure time derivative
+porousdpdt = fvc::ddt(porousP);
+
diff --git a/applications/solvers/heatTransfer/chtMultiRegionFoam/porousFluid/readPorousFluidRegionPIMPLEControls.H b/applications/solvers/heatTransfer/chtMultiRegionFoam/porousFluid/readPorousFluidRegionPIMPLEControls.H
new file mode 100644
index 0000000000..395ee383eb
--- /dev/null
+++ b/applications/solvers/heatTransfer/chtMultiRegionFoam/porousFluid/readPorousFluidRegionPIMPLEControls.H
@@ -0,0 +1,11 @@
+    const dictionary& pimple = porousMesh.solutionDict().subDict("PIMPLE");
+
+    const int nCorr =
+        pimple.lookupOrDefault<int>("nCorrectors", 1);
+
+    const int nNonOrthCorr =
+        pimple.lookupOrDefault<int>("nNonOrthogonalCorrectors", 0);
+
+    const bool momentumPredictor =
+        pimple.lookupOrDefault("momentumPredictor", true);
+
diff --git a/applications/solvers/heatTransfer/chtMultiRegionFoam/porousFluid/setPorousFluidFields.H b/applications/solvers/heatTransfer/chtMultiRegionFoam/porousFluid/setPorousFluidFields.H
new file mode 100644
index 0000000000..c29a232724
--- /dev/null
+++ b/applications/solvers/heatTransfer/chtMultiRegionFoam/porousFluid/setPorousFluidFields.H
@@ -0,0 +1,18 @@
+
+    fvMesh& porousMesh = porousFluidRegions[i];
+
+    basicRhoThermo& porousThermo = thermoPorous[i];
+    volScalarField& porousRho = rhoPorous[i];
+
+    volVectorField& porousU = UPorous[i];
+    surfaceScalarField& porousPhi = phiPorous[i];
+
+    compressible::turbulenceModel& turbPorous = turbulencePorous[i];
+    volScalarField& porousK = KPorous[i];
+    volScalarField& porousdpdt = dpdtPorous[i];
+
+    volScalarField& porousP = porousThermo.p();
+    const volScalarField& porousPsi = porousThermo.psi();
+    volScalarField& porousH = porousThermo.h();
+
+    IObasicSourceList& porousSources = heatPorousSources[i];
diff --git a/applications/solvers/heatTransfer/chtMultiRegionFoam/porousFluid/solvePorousFluid.H b/applications/solvers/heatTransfer/chtMultiRegionFoam/porousFluid/solvePorousFluid.H
new file mode 100644
index 0000000000..d0f9168b86
--- /dev/null
+++ b/applications/solvers/heatTransfer/chtMultiRegionFoam/porousFluid/solvePorousFluid.H
@@ -0,0 +1,28 @@
+if (finalIter)
+{
+    porousMesh.data::add("finalIteration", true);
+}
+
+if (oCorr == 0)
+{
+    solve(fvm::ddt(porousRho) + fvc::div(porousPhi));
+}
+
+#include "UPorousFluidEqn.H"
+
+#include "hPorousFluidEqn.H"
+
+// --- PISO loop
+for (int corr=0; corr<nCorr; corr++)
+{
+    #include "pPorousFluidEqn.H"
+}
+
+turbPorous.correct();
+
+porousRho = porousThermo.rho();
+
+if (finalIter)
+{
+    porousMesh.data::remove("finalIteration");
+}
diff --git a/applications/solvers/heatTransfer/chtMultiRegionFoam/porousSolid/createPorousSolidFields.H b/applications/solvers/heatTransfer/chtMultiRegionFoam/porousSolid/createPorousSolidFields.H
new file mode 100644
index 0000000000..1b39bf0527
--- /dev/null
+++ b/applications/solvers/heatTransfer/chtMultiRegionFoam/porousSolid/createPorousSolidFields.H
@@ -0,0 +1,43 @@
+    // Initialise solid field pointer lists
+    PtrList<basicSolidThermo> porousSolidThermos(porousSolidRegions.size());
+    PtrList<IObasicSourceList> solidHeatSources(porousSolidRegions.size());
+    PtrList<volScalarField> betavSolid(porousSolidRegions.size());
+
+    // Populate solid field pointer lists
+    forAll(porousSolidRegions, i)
+    {
+        Info<< "*** Reading porous solid mesh thermophysical "
+            << "properties for region "
+            << porousSolidRegions[i].name() << nl << endl;
+
+        Info<< "    Adding to thermos\n" << endl;
+        porousSolidThermos.set
+        (
+            i,
+            basicSolidThermo::New(porousSolidRegions[i])
+        );
+        Info<< "    Adding sources\n" << endl;
+        solidHeatSources.set
+        (
+            i,
+            new IObasicSourceList(porousSolidRegions[i])
+        );
+
+        Info<< "    Adding to betavSolid\n" << endl;
+        betavSolid.set
+        (
+            i,
+            new volScalarField
+            (
+                IOobject
+                (
+                    "betavSolid",
+                    runTime.timeName(),
+                    porousSolidRegions[i],
+                    IOobject::MUST_READ,
+                    IOobject::AUTO_WRITE
+                ),
+                porousSolidRegions[i]
+            )
+        );
+    }
diff --git a/applications/solvers/heatTransfer/chtMultiRegionFoam/porousSolid/createPorousSolidMeshes.H b/applications/solvers/heatTransfer/chtMultiRegionFoam/porousSolid/createPorousSolidMeshes.H
new file mode 100644
index 0000000000..fa61f55af4
--- /dev/null
+++ b/applications/solvers/heatTransfer/chtMultiRegionFoam/porousSolid/createPorousSolidMeshes.H
@@ -0,0 +1,24 @@
+    const wordList porousSolidNames(rp["porousSolid"]);
+
+    PtrList<fvMesh> porousSolidRegions(porousSolidNames.size());
+
+    forAll(porousSolidNames, i)
+    {
+        Info<< "Create solid mesh for region " << porousSolidNames[i]
+            << " for time = " << runTime.timeName() << nl << endl;
+
+        porousSolidRegions.set
+        (
+            i,
+            new fvMesh
+            (
+                IOobject
+                (
+                    porousSolidNames[i],
+                    runTime.timeName(),
+                    runTime,
+                    IOobject::MUST_READ
+                )
+            )
+        );
+    }
diff --git a/applications/solvers/heatTransfer/chtMultiRegionFoam/porousSolid/readPorousSolidMultiRegionPIMPLEControls.H b/applications/solvers/heatTransfer/chtMultiRegionFoam/porousSolid/readPorousSolidMultiRegionPIMPLEControls.H
new file mode 100644
index 0000000000..e23883c5fa
--- /dev/null
+++ b/applications/solvers/heatTransfer/chtMultiRegionFoam/porousSolid/readPorousSolidMultiRegionPIMPLEControls.H
@@ -0,0 +1,4 @@
+    const dictionary& pimple = mesh.solutionDict().subDict("PIMPLE");
+
+    int nNonOrthCorr =
+        pimple.lookupOrDefault<int>("nNonOrthogonalCorrectors", 0);
diff --git a/applications/solvers/heatTransfer/chtMultiRegionFoam/porousSolid/setPorousRegionSolidFields.H b/applications/solvers/heatTransfer/chtMultiRegionFoam/porousSolid/setPorousRegionSolidFields.H
new file mode 100644
index 0000000000..f4c7081e9b
--- /dev/null
+++ b/applications/solvers/heatTransfer/chtMultiRegionFoam/porousSolid/setPorousRegionSolidFields.H
@@ -0,0 +1,20 @@
+    fvMesh& mesh = porousSolidRegions[i];
+
+    basicSolidThermo& thermo = porousSolidThermos[i];
+    const volScalarField& betav = betavSolid[i];
+
+    tmp<volScalarField> trho = thermo.rho();
+    const volScalarField& rho = trho();
+
+    tmp<volScalarField> tcp = thermo.Cp();
+    const volScalarField& cp = tcp();
+
+    tmp<volScalarField> tkappa = thermo.K();
+    //tmp<volSymmTensorField> tkappa = thermo.directionalK()*betav;
+
+    const volScalarField& kappa = tkappa();
+    //const volSymmTensorField& K = tK();
+
+    volScalarField& T = thermo.T();
+
+    IObasicSourceList& sources = solidHeatSources[i];
diff --git a/applications/solvers/heatTransfer/chtMultiRegionFoam/porousSolid/solidPorousRegionDiffusionNo.H b/applications/solvers/heatTransfer/chtMultiRegionFoam/porousSolid/solidPorousRegionDiffusionNo.H
new file mode 100644
index 0000000000..77dc6f04bf
--- /dev/null
+++ b/applications/solvers/heatTransfer/chtMultiRegionFoam/porousSolid/solidPorousRegionDiffusionNo.H
@@ -0,0 +1,18 @@
+    scalar DiNum = -GREAT;
+
+    forAll(solidRegions, i)
+    {
+#       include "setRegionSolidFields.H"
+
+        DiNum = max
+        (
+            solidRegionDiffNo
+            (
+                solidRegions[i],
+                runTime,
+                rho*cp,
+                K
+            ),
+            DiNum
+        );
+    }
diff --git a/applications/solvers/heatTransfer/chtMultiRegionFoam/porousSolid/solvePorousSolid.H b/applications/solvers/heatTransfer/chtMultiRegionFoam/porousSolid/solvePorousSolid.H
new file mode 100644
index 0000000000..e8941cf2ad
--- /dev/null
+++ b/applications/solvers/heatTransfer/chtMultiRegionFoam/porousSolid/solvePorousSolid.H
@@ -0,0 +1,28 @@
+if (finalIter)
+{
+    mesh.data::add("finalIteration", true);
+}
+
+{
+    for (int nonOrth=0; nonOrth<=nNonOrthCorr; nonOrth++)
+    {
+        tmp<fvScalarMatrix> TEqn
+        (
+            fvm::ddt(betav*rho*cp, T)
+          - fvm::laplacian(betav*kappa, T, "laplacian(K,T)")
+          + sources(rho, T)
+        );
+
+        TEqn().relax();
+        TEqn().solve(mesh.solver(T.select(finalIter)));
+    }
+
+    Info<< "Min/max T:" << min(T).value() << ' ' << max(T).value() << endl;
+}
+
+thermo.correct();
+
+if (finalIter)
+{
+    mesh.data::remove("finalIteration");
+}
diff --git a/applications/solvers/heatTransfer/chtMultiRegionFoam/solid/createSolidMeshes.H b/applications/solvers/heatTransfer/chtMultiRegionFoam/solid/createSolidMeshes.H
index eb50be2380..101d98ebe6 100644
--- a/applications/solvers/heatTransfer/chtMultiRegionFoam/solid/createSolidMeshes.H
+++ b/applications/solvers/heatTransfer/chtMultiRegionFoam/solid/createSolidMeshes.H
@@ -1,8 +1,10 @@
-    PtrList<fvMesh> solidRegions(rp.solidRegionNames().size());
+    const wordList solidsNames(rp["solid"]);
 
-    forAll(rp.solidRegionNames(), i)
+    PtrList<fvMesh> solidRegions(solidsNames.size());
+
+    forAll(solidsNames, i)
     {
-        Info<< "Create solid mesh for region " << rp.solidRegionNames()[i]
+        Info<< "Create solid mesh for region " << solidsNames[i]
             << " for time = " << runTime.timeName() << nl << endl;
 
         solidRegions.set
@@ -12,7 +14,7 @@
             (
                 IOobject
                 (
-                    rp.solidRegionNames()[i],
+                    solidsNames[i],
                     runTime.timeName(),
                     runTime,
                     IOobject::MUST_READ
diff --git a/applications/solvers/incompressible/pimpleFoam/Make/options b/applications/solvers/incompressible/pimpleFoam/Make/options
index ecb86aecbc..1be54a53a3 100644
--- a/applications/solvers/incompressible/pimpleFoam/Make/options
+++ b/applications/solvers/incompressible/pimpleFoam/Make/options
@@ -3,7 +3,10 @@ EXE_INC = \
     -I$(LIB_SRC)/transportModels \
     -I$(LIB_SRC)/transportModels/incompressible/singlePhaseTransportModel \
     -I$(LIB_SRC)/finiteVolume/lnInclude \
-    -I$(LIB_SRC)/meshTools/lnInclude
+    -I$(LIB_SRC)/meshTools/lnInclude \
+    -I$(LIB_SRC)/fieldSources/lnInclude \
+    -I$(LIB_SRC)/sampling/lnInclude
+
 
 EXE_LIBS = \
     -lincompressibleTransportModels \
@@ -11,4 +14,6 @@ EXE_LIBS = \
     -lincompressibleRASModels \
     -lincompressibleLESModels \
     -lfiniteVolume \
-    -lmeshTools
+    -lmeshTools \
+    -lfieldSources \
+    -lsampling
diff --git a/applications/solvers/incompressible/pimpleFoam/SRFPimpleFoam/Make/options b/applications/solvers/incompressible/pimpleFoam/SRFPimpleFoam/Make/options
index ecb86aecbc..5e77cdd21e 100644
--- a/applications/solvers/incompressible/pimpleFoam/SRFPimpleFoam/Make/options
+++ b/applications/solvers/incompressible/pimpleFoam/SRFPimpleFoam/Make/options
@@ -3,7 +3,9 @@ EXE_INC = \
     -I$(LIB_SRC)/transportModels \
     -I$(LIB_SRC)/transportModels/incompressible/singlePhaseTransportModel \
     -I$(LIB_SRC)/finiteVolume/lnInclude \
-    -I$(LIB_SRC)/meshTools/lnInclude
+    -I$(LIB_SRC)/meshTools/lnInclude \
+    -I$(LIB_SRC)/fieldSources/lnInclude \
+    -I$(LIB_SRC)/sampling/lnInclude
 
 EXE_LIBS = \
     -lincompressibleTransportModels \
@@ -11,4 +13,6 @@ EXE_LIBS = \
     -lincompressibleRASModels \
     -lincompressibleLESModels \
     -lfiniteVolume \
-    -lmeshTools
+    -lmeshTools \
+    -lfieldSources \
+    -lsampling
diff --git a/applications/solvers/incompressible/pimpleFoam/pimpleDyMFoam/Make/options b/applications/solvers/incompressible/pimpleFoam/pimpleDyMFoam/Make/options
index 6af3735d63..8aa441b18e 100644
--- a/applications/solvers/incompressible/pimpleFoam/pimpleDyMFoam/Make/options
+++ b/applications/solvers/incompressible/pimpleFoam/pimpleDyMFoam/Make/options
@@ -6,7 +6,10 @@ EXE_INC = \
     -I$(LIB_SRC)/turbulenceModels/incompressible/turbulenceModel \
     -I$(LIB_SRC)/transportModels \
     -I$(LIB_SRC)/transportModels/incompressible/singlePhaseTransportModel \
-    -I$(LIB_SRC)/finiteVolume/lnInclude
+    -I$(LIB_SRC)/finiteVolume/lnInclude \
+    -I$(LIB_SRC)/fieldSources/lnInclude \
+    -I$(LIB_SRC)/sampling/lnInclude
+
 
 EXE_LIBS = \
     -ldynamicFvMesh \
@@ -16,4 +19,6 @@ EXE_LIBS = \
     -lincompressibleTransportModels \
     -lincompressibleRASModels \
     -lincompressibleLESModels \
-    -lfiniteVolume
+    -lfiniteVolume \
+    -lfieldSources \
+    -lsampling
diff --git a/applications/solvers/incompressible/potentialFreeSurfaceFoam/Make/options b/applications/solvers/incompressible/potentialFreeSurfaceFoam/Make/options
index ecb86aecbc..1be54a53a3 100644
--- a/applications/solvers/incompressible/potentialFreeSurfaceFoam/Make/options
+++ b/applications/solvers/incompressible/potentialFreeSurfaceFoam/Make/options
@@ -3,7 +3,10 @@ EXE_INC = \
     -I$(LIB_SRC)/transportModels \
     -I$(LIB_SRC)/transportModels/incompressible/singlePhaseTransportModel \
     -I$(LIB_SRC)/finiteVolume/lnInclude \
-    -I$(LIB_SRC)/meshTools/lnInclude
+    -I$(LIB_SRC)/meshTools/lnInclude \
+    -I$(LIB_SRC)/fieldSources/lnInclude \
+    -I$(LIB_SRC)/sampling/lnInclude
+
 
 EXE_LIBS = \
     -lincompressibleTransportModels \
@@ -11,4 +14,6 @@ EXE_LIBS = \
     -lincompressibleRASModels \
     -lincompressibleLESModels \
     -lfiniteVolume \
-    -lmeshTools
+    -lmeshTools \
+    -lfieldSources \
+    -lsampling
diff --git a/applications/solvers/incompressible/simpleFoam/MRFSimpleFoam/Make/options b/applications/solvers/incompressible/simpleFoam/MRFSimpleFoam/Make/options
index 057788a483..e9f47baf9b 100644
--- a/applications/solvers/incompressible/simpleFoam/MRFSimpleFoam/Make/options
+++ b/applications/solvers/incompressible/simpleFoam/MRFSimpleFoam/Make/options
@@ -5,10 +5,15 @@ EXE_INC = \
     -I$(LIB_SRC)/transportModels \
     -I$(LIB_SRC)/transportModels/incompressible/singlePhaseTransportModel \
     -I$(LIB_SRC)/finiteVolume/lnInclude \
-    -I$(LIB_SRC)/meshTools/lnInclude
+    -I$(LIB_SRC)/meshTools/lnInclude \
+    -I$(LIB_SRC)/fieldSources/lnInclude \
+    -I$(LIB_SRC)/sampling/lnInclude
+
 
 EXE_LIBS = \
     -lincompressibleRASModels \
     -lincompressibleTransportModels \
     -lfiniteVolume \
-    -lmeshTools
+    -lmeshTools \
+    -lfieldSources \
+    -lsampling
diff --git a/applications/solvers/incompressible/simpleFoam/Make/options b/applications/solvers/incompressible/simpleFoam/Make/options
index 23014d8748..9ba4552938 100644
--- a/applications/solvers/incompressible/simpleFoam/Make/options
+++ b/applications/solvers/incompressible/simpleFoam/Make/options
@@ -4,11 +4,16 @@ EXE_INC = \
     -I$(LIB_SRC)/transportModels \
     -I$(LIB_SRC)/transportModels/incompressible/singlePhaseTransportModel \
     -I$(LIB_SRC)/finiteVolume/lnInclude \
-    -I$(LIB_SRC)/meshTools/lnInclude
+    -I$(LIB_SRC)/meshTools/lnInclude \
+    -I$(LIB_SRC)/fieldSources/lnInclude \
+    -I$(LIB_SRC)/sampling/lnInclude
+
 
 EXE_LIBS = \
     -lincompressibleTurbulenceModel \
     -lincompressibleRASModels \
     -lincompressibleTransportModels \
     -lfiniteVolume \
-    -lmeshTools
+    -lmeshTools \
+    -lfieldSources \
+    -lsampling
diff --git a/applications/solvers/incompressible/simpleFoam/SRFSimpleFoam/Make/options b/applications/solvers/incompressible/simpleFoam/SRFSimpleFoam/Make/options
index 7f0cca618c..046cbd0baf 100644
--- a/applications/solvers/incompressible/simpleFoam/SRFSimpleFoam/Make/options
+++ b/applications/solvers/incompressible/simpleFoam/SRFSimpleFoam/Make/options
@@ -5,10 +5,15 @@ EXE_INC = \
     -I$(LIB_SRC)/turbulenceModels/incompressible/RAS/RASModel \
     -I$(LIB_SRC)/transportModels \
     -I$(LIB_SRC)/transportModels/incompressible/singlePhaseTransportModel \
-    -I$(LIB_SRC)/meshTools/lnInclude
+    -I$(LIB_SRC)/meshTools/lnInclude \
+    -I$(LIB_SRC)/fieldSources/lnInclude \
+    -I$(LIB_SRC)/sampling/lnInclude
+
 
 EXE_LIBS = \
     -lincompressibleRASModels \
     -lincompressibleTransportModels \
     -lfiniteVolume \
-    -lmeshTools
+    -lmeshTools \
+    -lfieldSources \
+    -lsampling
diff --git a/applications/solvers/lagrangian/LTSReactingParcelFoam/Make/options b/applications/solvers/lagrangian/LTSReactingParcelFoam/Make/options
index 30c3b5d6a1..bfe0fa7d39 100644
--- a/applications/solvers/lagrangian/LTSReactingParcelFoam/Make/options
+++ b/applications/solvers/lagrangian/LTSReactingParcelFoam/Make/options
@@ -20,7 +20,10 @@ EXE_INC = \
     -I$(LIB_SRC)/ODE/lnInclude \
     -I$(LIB_SRC)/regionModels/regionModel/lnInclude \
     -I$(LIB_SRC)/regionModels/surfaceFilmModels/lnInclude \
-    -I$(LIB_SRC)/combustionModels/lnInclude
+    -I$(LIB_SRC)/combustionModels/lnInclude \
+    -I$(LIB_SRC)/fieldSources/lnInclude \
+    -I$(LIB_SRC)/sampling/lnInclude
+
 
 EXE_LIBS = \
     -lfiniteVolume \
@@ -44,4 +47,6 @@ EXE_LIBS = \
     -lODE \
     -lregionModels \
     -lsurfaceFilmModels \
-    -lcombustionModels
+    -lcombustionModels \
+    -lfieldSources \
+    -lsampling
diff --git a/applications/solvers/lagrangian/coalChemistryFoam/Make/options b/applications/solvers/lagrangian/coalChemistryFoam/Make/options
index 21461569f8..e008a3e3f5 100644
--- a/applications/solvers/lagrangian/coalChemistryFoam/Make/options
+++ b/applications/solvers/lagrangian/coalChemistryFoam/Make/options
@@ -21,7 +21,10 @@ EXE_INC = \
     -I$(LIB_SRC)/regionModels/surfaceFilmModels/lnInclude \
     -I$(LIB_SRC)/ODE/lnInclude \
     -I$(LIB_SRC)/combustionModels/lnInclude \
-    -I$(FOAM_SOLVERS)/combustion/reactingFoam
+    -I$(FOAM_SOLVERS)/combustion/reactingFoam \
+    -I$(LIB_SRC)/fieldSources/lnInclude \
+    -I$(LIB_SRC)/sampling/lnInclude
+
 
 
 EXE_LIBS = \
@@ -47,4 +50,7 @@ EXE_LIBS = \
     -lregionModels \
     -lsurfaceFilmModels \
     -lODE \
-    -lcombustionModels
+    -lcombustionModels \
+    -lfieldSources \
+    -lsampling
+
diff --git a/applications/solvers/lagrangian/porousExplicitSourceReactingParcelFoam/Make/options b/applications/solvers/lagrangian/porousExplicitSourceReactingParcelFoam/Make/options
index edcc596b79..7fc77306fd 100644
--- a/applications/solvers/lagrangian/porousExplicitSourceReactingParcelFoam/Make/options
+++ b/applications/solvers/lagrangian/porousExplicitSourceReactingParcelFoam/Make/options
@@ -21,6 +21,8 @@ EXE_INC = \
     -I$(LIB_SRC)/regionModels/regionModel/lnInclude \
     -I$(LIB_SRC)/regionModels/surfaceFilmModels/lnInclude \
     -I$(LIB_SRC)/combustionModels/lnInclude \
+    -I$(LIB_SRC)/fieldSources/lnInclude \
+    -I$(LIB_SRC)/sampling/lnInclude \
     -I$(FOAM_SOLVERS)/combustion/reactingFoam
 
 
@@ -46,4 +48,7 @@ EXE_LIBS = \
     -lODE \
     -lregionModels \
     -lsurfaceFilmModels \
-    -lcombustionModels
+    -lcombustionModels \
+    -lfieldSources \
+    -lsampling
+
diff --git a/applications/test/DLList/Test-DLList.C b/applications/test/DLList/Test-DLList.C
index 8e76baa6e1..d370348982 100644
--- a/applications/test/DLList/Test-DLList.C
+++ b/applications/test/DLList/Test-DLList.C
@@ -65,30 +65,36 @@ int main(int argc, char *argv[])
     }
 
     myList.append(500.3);
+    myList.append(200.3);
     myList.append(100.3);
 
 
     Info<< nl << "And again using STL const_iterator: " << nl << endl;
 
-    const DLList<scalar>& const_myList = myList;
 
-    forAllConstIter(DLList<scalar>, const_myList, iter)
+    forAllConstIter(DLList<scalar>, myList, iter)
     {
         Info<< "element:" << *iter << endl;
     }
 
+    Info<< nl << "Testing swapUp and swapDown: " << endl;
+
+    Info<< nl << "swapUp" << endl;
+
     myList.swapUp(myList.DLListBase::first());
     myList.swapUp(myList.DLListBase::last());
 
-    forAllConstIter(DLList<scalar>, const_myList, iter)
+    forAllIter(DLList<scalar>, myList, iter)
     {
         Info<< "element:" << *iter << endl;
     }
 
+    Info<< nl << "swapDown" << endl;
+
     myList.swapDown(myList.DLListBase::first());
     myList.swapDown(myList.DLListBase::last());
 
-    forAllConstIter(DLList<scalar>, const_myList, iter)
+    forAllIter(DLList<scalar>, myList, iter)
     {
         Info<< "element:" << *iter << endl;
     }
@@ -103,8 +109,8 @@ int main(int argc, char *argv[])
     Info<< nl << "source: " << myList << nl
         << nl << "target: " << newList << endl;
 
-
     Info<< nl << "Done." << endl;
+
     return 0;
 }
 
diff --git a/applications/test/List/Test-List.C b/applications/test/List/Test-List.C
index 681e6796ef..ca303d53b7 100644
--- a/applications/test/List/Test-List.C
+++ b/applications/test/List/Test-List.C
@@ -37,6 +37,8 @@ Description
 #include "vector.H"
 #include "ListOps.H"
 
+#include<list>
+
 using namespace Foam;
 
 
@@ -117,6 +119,35 @@ int main(int argc, char *argv[])
         << "-wordList: " << wLst << nl
         << "-stringList: " << sLst << endl;
 
+
+    Info<< nl
+        << "Test List Iterator Constuctor" << endl;
+
+    List<vector> initialList(IStringStream("((0 1 2) (3 4 5) (6 7 8))")());
+
+    Info<< "    Initial List: " << initialList << endl;
+
+    List<vector> iteratorList(initialList.begin(), initialList.end());
+
+    Info<< "    Foam::List constructed from Foam::List: "
+        << iteratorList << endl;
+
+    std::list<vector> stlList(initialList.begin(), initialList.end());
+
+    Info<< "    std::list constructed from Foam::List: ";
+
+    std::list<vector>::iterator it;
+    for (it=stlList.begin(); it != stlList.end(); it++)
+    {
+        Info<< *it << " ";
+    }
+    Info<< endl;
+
+    List<vector> iteratorSTLList(stlList.begin(), stlList.end());
+
+    Info<< "    Foam::List constructed from std::list: "
+        << iteratorList << endl;
+
     return 0;
 }
 
diff --git a/applications/utilities/mesh/manipulation/objToVTK/objToVTK.C b/applications/utilities/mesh/manipulation/objToVTK/objToVTK.C
index 76babb0b8c..4ff721f485 100644
--- a/applications/utilities/mesh/manipulation/objToVTK/objToVTK.C
+++ b/applications/utilities/mesh/manipulation/objToVTK/objToVTK.C
@@ -273,12 +273,16 @@ int main(int argc, char *argv[])
         }
     }
 
-    outFile << nl << "NORMALS pointNormals float\n";
-    forAll(pointNormals, i)
+    if (!pointNormals.empty())
     {
-        const vector& n = pointNormals[i];
+        outFile << nl << "NORMALS pointNormals float\n";
 
-        outFile << n.x() << ' ' << n.y() << ' ' << n.z() << nl;
+        forAll(pointNormals, i)
+        {
+            const vector& n = pointNormals[i];
+
+            outFile << n.x() << ' ' << n.y() << ' ' << n.z() << nl;
+        }
     }
 
     Info<< "End\n" << endl;
diff --git a/src/Allwmake b/src/Allwmake
index 97023aa700..27b72295ae 100755
--- a/src/Allwmake
+++ b/src/Allwmake
@@ -73,4 +73,6 @@ fvAgglomerationMethods/Allwmake $*
 wmake $makeType fvMotionSolver
 wmake $makeType engine
 
+wmake $makeType fieldSources
+
 # ----------------------------------------------------------------- end-of-file
diff --git a/src/OpenFOAM/containers/LinkedLists/linkTypes/DLListBase/DLListBase.C b/src/OpenFOAM/containers/LinkedLists/linkTypes/DLListBase/DLListBase.C
index f837ec3e66..95476fd89a 100644
--- a/src/OpenFOAM/containers/LinkedLists/linkTypes/DLListBase/DLListBase.C
+++ b/src/OpenFOAM/containers/LinkedLists/linkTypes/DLListBase/DLListBase.C
@@ -94,23 +94,23 @@ bool Foam::DLListBase::swapUp(DLListBase::link* a)
         if (ap == first_)
         {
             first_ = a;
+            ap->prev_ = a;
+        }
+        else
+        {
+            ap->prev_->next_ = a;
         }
 
         if (a == last_)
         {
             last_ = ap;
+            a->next_ = ap;
         }
-
-        if (a->next_)
+        else
         {
             a->next_->prev_ = ap;
         }
 
-        if (ap->prev_)
-        {
-            ap->prev_->next_ = a;
-        }
-
         a->prev_ = ap->prev_;
         ap->prev_ = a;
 
@@ -135,19 +135,19 @@ bool Foam::DLListBase::swapDown(DLListBase::link* a)
         if (a == first_)
         {
             first_ = an;
+            a->prev_ = an;
+        }
+        else
+        {
+            a->prev_->next_ = an;
         }
 
         if (an == last_)
         {
             last_ = a;
+            an->next_ = a;
         }
-
-        if (a->prev_)
-        {
-            a->prev_->next_ = an;
-        }
-
-        if (an->next_)
+        else
         {
             an->next_->prev_ = a;
         }
diff --git a/src/OpenFOAM/containers/Lists/List/List.C b/src/OpenFOAM/containers/Lists/List/List.C
index 7e9e741a0e..5f97921e3d 100644
--- a/src/OpenFOAM/containers/Lists/List/List.C
+++ b/src/OpenFOAM/containers/Lists/List/List.C
@@ -200,7 +200,7 @@ Foam::List<T>::List(InputIterator first, InputIterator last)
         ++iter
     )
     {
-        this->operator[](s++) = iter();
+        this->operator[](s++) = *iter;
     }
 }
 
diff --git a/src/OpenFOAM/interpolations/interpolation2DTable/interpolation2DTable.C b/src/OpenFOAM/interpolations/interpolation2DTable/interpolation2DTable.C
new file mode 100644
index 0000000000..e1f744b07e
--- /dev/null
+++ b/src/OpenFOAM/interpolations/interpolation2DTable/interpolation2DTable.C
@@ -0,0 +1,800 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "IFstream.H"
+#include "openFoamTableReader.H"
+
+// * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * * //
+
+template<class Type>
+void Foam::interpolation2DTable<Type>::readTable()
+{
+    fileName fName(fileName_);
+    fName.expand();
+
+    // Read data from file
+    reader_()(fName, *this);
+    //IFstream(fName)() >> *this;
+
+    if (this->empty())
+    {
+        FatalErrorIn
+        (
+            "Foam::interpolation2DTable<Type>::readTable()"
+        )   << "table read from " << fName << " is empty" << nl
+            << exit(FatalError);
+    }
+
+    // Check that the data are okay
+    check();
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+template<class Type>
+Foam::interpolation2DTable<Type>::interpolation2DTable()
+:
+    List<Tuple2<scalar, List<Tuple2<scalar, Type> > > >(),
+    boundsHandling_(interpolation2DTable::WARN),
+    fileName_("fileNameIsUndefined"),
+    reader_(NULL)
+{}
+
+
+template<class Type>
+Foam::interpolation2DTable<Type>::interpolation2DTable
+(
+    const List<Tuple2<scalar, List<Tuple2<scalar, Type> > > >& values,
+    const boundsHandling bounds,
+    const fileName& fName
+)
+:
+    List<Tuple2<scalar, List<Tuple2<scalar, Type> > > >(values),
+    boundsHandling_(bounds),
+    fileName_(fName),
+    reader_(NULL)
+{}
+
+
+template<class Type>
+Foam::interpolation2DTable<Type>::interpolation2DTable(const fileName& fName)
+:
+    List<Tuple2<scalar, List<Tuple2<scalar, Type> > > >(),
+    boundsHandling_(interpolation2DTable::WARN),
+    fileName_(fName),
+    reader_(new openFoamTableReader<Type>(dictionary()))
+{
+    readTable();
+}
+
+
+template<class Type>
+Foam::interpolation2DTable<Type>::interpolation2DTable(const dictionary& dict)
+:
+    List<Tuple2<scalar, List<Tuple2<scalar, Type> > > >(),
+    boundsHandling_(wordToBoundsHandling(dict.lookup("outOfBounds"))),
+    fileName_(dict.lookup("fileName")),
+    reader_(tableReader<Type>::New(dict))
+{
+    readTable();
+}
+
+
+template<class Type>
+Foam::interpolation2DTable<Type>::interpolation2DTable
+(
+     const interpolation2DTable& interpTable
+)
+:
+    List<Tuple2<scalar, List<Tuple2<scalar, Type> > > >(interpTable),
+    boundsHandling_(interpTable.boundsHandling_),
+    fileName_(interpTable.fileName_),
+    reader_(interpTable.reader_)    // note: steals reader. Used in write().
+{}
+
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+template<class Type>
+Type Foam::interpolation2DTable<Type>::interpolateValue
+(
+    const List<Tuple2<scalar, Type> >& data,
+    const scalar lookupValue
+) const
+{
+    label n = data.size();
+
+    scalar minLimit = data[0].first();
+    scalar maxLimit = data[n-1].first();
+
+    if (lookupValue < minLimit)
+    {
+        switch (boundsHandling_)
+        {
+            case interpolation2DTable::ERROR:
+            {
+                FatalErrorIn
+                (
+                    "Foam::interpolation2DTable<Type>::interpolateValue("
+                    "List<Tuple2<scalar, Type> > data,"
+                    "const scalar lookupValue)"
+                )   << "value (" << lookupValue << ") underflow" << nl
+                    << exit(FatalError);
+                break;
+            }
+            case interpolation2DTable::WARN:
+            {
+                WarningIn
+                (
+                    "Foam::interpolation2DTable<Type>::interpolateValue("
+                    "List<Tuple2<scalar, Type> > data,"
+                    "const scalar lookupValue)"
+                )   << "value (" << lookupValue << ") underflow" << nl
+                    << "    Continuing with the first entry"
+                    << endl;
+                // fall-through to 'CLAMP'
+            }
+            case interpolation2DTable::CLAMP:
+            {
+                return data[0].second();
+                break;
+            }
+        }
+    }
+    else if (lookupValue >= maxLimit)
+    {
+        switch (boundsHandling_)
+        {
+            case interpolation2DTable::ERROR:
+            {
+                FatalErrorIn
+                (
+                    "Foam::interpolation2DTable<Type>::interpolateValue("
+                    "List<Tuple2<scalar, Type> > data,"
+                    "const scalar lookupValue)"
+                )   << "value (" << lookupValue << ") overflow" << nl
+                    << exit(FatalError);
+                break;
+            }
+            case interpolation2DTable::WARN:
+            {
+                WarningIn
+                (
+                    "Foam::interpolation2DTable<Type>::interpolateValue("
+                    "List<Tuple2<scalar, Type> > data,"
+                    "const scalar lookupValue)"
+                )   << "value (" << lookupValue << ") overflow" << nl
+                    << "    Continuing with the last entry"
+                    << endl;
+                // fall-through to 'CLAMP'
+            }
+            case interpolation2DTable::CLAMP:
+            {
+                return data[n-1].second();
+                break;
+            }
+        }
+    }
+
+    // look for the correct range in X
+    label lo = 0;
+    label hi = 0;
+
+    for (label i = 0; i < n; ++i)
+    {
+        if (lookupValue >= data[i].first())
+        {
+            lo = hi = i;
+        }
+        else
+        {
+            hi = i;
+            break;
+        }
+    }
+
+    if (lo == hi)
+    {
+        return data[lo].second();
+    }
+    else
+    {
+        // normal interpolation
+        return
+        (
+            data[lo].second()
+          + (
+                data[hi].second()
+              - data[lo].second()
+            )
+           *(
+                lookupValue
+              - data[lo].first()
+            )
+           /(
+                data[hi].first()
+              - data[lo].first()
+            )
+        );
+    }
+
+}
+
+
+template<class Type>
+Foam::word Foam::interpolation2DTable<Type>::boundsHandlingToWord
+(
+     const boundsHandling& bound
+) const
+{
+    word enumName("warn");
+
+    switch (bound)
+    {
+        case interpolation2DTable::ERROR:
+        {
+            enumName = "error";
+            break;
+        }
+        case interpolation2DTable::WARN:
+        {
+            enumName = "warn";
+            break;
+        }
+        case interpolation2DTable::CLAMP:
+        {
+            enumName = "clamp";
+            break;
+        }
+    }
+
+    return enumName;
+}
+
+
+template<class Type>
+typename Foam::interpolation2DTable<Type>::boundsHandling
+Foam::interpolation2DTable<Type>::wordToBoundsHandling
+(
+    const word& bound
+) const
+{
+    if (bound == "error")
+    {
+        return interpolation2DTable::ERROR;
+    }
+    else if (bound == "warn")
+    {
+        return interpolation2DTable::WARN;
+    }
+    else if (bound == "clamp")
+    {
+        return interpolation2DTable::CLAMP;
+    }
+    else
+    {
+        WarningIn
+        (
+            "Foam::interpolation2DTable<Type>::wordToBoundsHandling"
+            "("
+            "    const word&"
+            ")"
+        )   << "bad outOfBounds specifier " << bound << " using 'warn'" << endl;
+
+        return interpolation2DTable::WARN;
+    }
+}
+
+
+template<class Type>
+typename Foam::interpolation2DTable<Type>::boundsHandling
+Foam::interpolation2DTable<Type>::outOfBounds
+(
+    const boundsHandling& bound
+)
+{
+    boundsHandling prev = boundsHandling_;
+    boundsHandling_ = bound;
+    return prev;
+}
+
+
+template<class Type>
+void Foam::interpolation2DTable<Type>::check() const
+{
+    label n = this->size();
+    typedef  List<Tuple2<scalar, List<Tuple2<scalar, Type> > > > matrix;
+    scalar prevValue = matrix::operator[](0).first();
+
+    for (label i=1; i<n; ++i)
+    {
+        const scalar currValue = matrix::operator[](i).first();
+
+        // avoid duplicate values (divide-by-zero error)
+        if (currValue <= prevValue)
+        {
+            FatalErrorIn
+            (
+                "Foam::interpolation2DTable<Type>::check() const"
+            )   << "out-of-order value: "
+                << currValue << " at index " << i << nl
+                << exit(FatalError);
+        }
+        prevValue = currValue;
+    }
+}
+
+
+template<class Type>
+void Foam::interpolation2DTable<Type>::write(Ostream& os) const
+{
+    os.writeKeyword("fileName")
+        << fileName_ << token::END_STATEMENT << nl;
+    os.writeKeyword("outOfBounds")
+        << boundsHandlingToWord(boundsHandling_) << token::END_STATEMENT << nl;
+
+    if (reader_.valid())
+    {
+        reader_->write(os);
+    }
+    //*this >> os;
+}
+
+
+// * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
+
+template<class Type>
+const Foam::List<Foam::Tuple2<Foam::scalar, Type> >&
+Foam::interpolation2DTable<Type>::operator[](const label i) const
+{
+    label ii = i;
+    label n  = this->size();
+
+    if (n <= 1)
+    {
+        ii = 0;
+    }
+    else if (ii < 0)
+    {
+        switch (boundsHandling_)
+        {
+            case interpolation2DTable::ERROR:
+            {
+                FatalErrorIn
+                (
+                    "Foam::interpolation2DTable<Type>::operator[]"
+                    "(const label) const"
+                )   << "index (" << ii << ") underflow" << nl
+                    << exit(FatalError);
+                break;
+            }
+            case interpolation2DTable::WARN:
+            {
+                WarningIn
+                (
+                    "Foam::interpolation2DTable<Type>::operator[]"
+                    "(const label) const"
+                )   << "index (" << ii << ") underflow" << nl
+                    << "    Continuing with the first entry"
+                    << endl;
+                // fall-through to 'CLAMP'
+            }
+            case interpolation2DTable::CLAMP:
+            {
+                ii = 0;
+                break;
+            }
+        }
+    }
+    else if (ii >= n)
+    {
+        switch (boundsHandling_)
+        {
+            case interpolation2DTable::ERROR:
+            {
+                FatalErrorIn
+                (
+                    "Foam::interpolation2DTable<Type>::operator[]"
+                    "(const label) const"
+                )   << "index (" << ii << ") overflow" << nl
+                    << exit(FatalError);
+                break;
+            }
+            case interpolation2DTable::WARN:
+            {
+                WarningIn
+                (
+                    "Foam::interpolation2DTable<Type>::operator[]"
+                    "(const label) const"
+                )   << "index (" << ii << ") overflow" << nl
+                    << "    Continuing with the last entry"
+                    << endl;
+                // fall-through to 'CLAMP'
+            }
+            case interpolation2DTable::CLAMP:
+            {
+                ii = n - 1;
+                break;
+            }
+        }
+    }
+
+    return List<Tuple2<scalar, List<Tuple2<scalar, Type> > > >::operator[](ii);
+}
+
+
+template<class Type>
+Type Foam::interpolation2DTable<Type>::operator()
+(
+    const scalar valueX,
+    const scalar valueY
+) const
+{
+    typedef  List<Tuple2<scalar, List<Tuple2<scalar, Type> > > > matrix;
+    label nX = this->size();
+
+    if (nX <= 1)
+    {
+        const List<Tuple2<scalar, Type> >& dataY =
+            matrix::operator[](0).second();
+
+        return interpolateValue(dataY, valueY);
+    }
+
+
+    scalar minLimit = matrix::operator[](0).first();
+    scalar maxLimit = matrix::operator[](nX-1).first();
+    scalar lookupValue = valueX;
+
+    if (lookupValue < minLimit)
+    {
+        switch (boundsHandling_)
+        {
+            case interpolation2DTable::ERROR:
+            {
+                FatalErrorIn
+                (
+                    "Foam::interpolation2DTable<Type>::operator[]"
+                    "(const scalar, const scalar) const"
+                )   << "value (" << lookupValue << ") underflow" << nl
+                    << exit(FatalError);
+                break;
+            }
+            case interpolation2DTable::WARN:
+            {
+                WarningIn
+                (
+                    "Foam::interpolation2DTable<Type>::operator[]"
+                    "(const scalar, const scalar) const"
+                )   << "value (" << lookupValue << ") underflow" << nl
+                    << "    Continuing with the first entry"
+                    << endl;
+                // fall-through to 'CLAMP'
+            }
+            case interpolation2DTable::CLAMP:
+            {
+                return interpolateValue
+                (
+                    matrix::operator[](0).second(), valueY
+                );
+                break;
+            }
+        }
+    }
+    else if (lookupValue >= maxLimit)
+    {
+        switch (boundsHandling_)
+        {
+            case interpolation2DTable::ERROR:
+            {
+                FatalErrorIn
+                (
+                    "Foam::interpolation2DTable<Type>::operator[]"
+                    "(const label, const scalar) const"
+                )   << "value (" << lookupValue << ") overflow" << nl
+                    << exit(FatalError);
+                break;
+            }
+            case interpolation2DTable::WARN:
+            {
+                WarningIn
+                (
+                    "Foam::interpolation2DTable<Type>::operator[]"
+                    "(const label, const scalar) const"
+                )   << "value (" << lookupValue << ") overflow" << nl
+                    << "    Continuing with the last entry"
+                    << endl;
+                // fall-through to 'CLAMP'
+            }
+            case interpolation2DTable::CLAMP:
+            {
+                return interpolateValue
+                (
+                    matrix::operator[](nX-1).second(), valueY
+                );
+                break;
+            }
+        }
+    }
+
+    label loX = 0;
+    label hiX = 0;
+
+    // look for the correct range in X
+    for (label i = 0; i < nX; ++i)
+    {
+        if (lookupValue >= matrix::operator[](i).first())
+        {
+            loX = hiX = i;
+        }
+        else
+        {
+            hiX = i;
+            break;
+        }
+    }
+
+    // look for the correct range in y
+    lookupValue = valueY;
+    label loY1 = 0;
+    label hiY1 = 0;
+
+    label nY = matrix::operator[](loX).second().size();
+
+    minLimit = matrix::operator[](loX).second()[0].first();
+    maxLimit = matrix::operator[](loX).second()[nY-1].first();
+
+    if (lookupValue < minLimit)
+    {
+        switch (boundsHandling_)
+        {
+            case interpolation2DTable::ERROR:
+            {
+                FatalErrorIn
+                (
+                    "Foam::interpolation2DTable<Type>::operator[]"
+                    "(const scalar, const scalar) const"
+                )   << "value (" << lookupValue << ") underflow" << nl
+                    << exit(FatalError);
+                break;
+            }
+            case interpolation2DTable::WARN:
+            {
+                WarningIn
+                (
+                    "Foam::interpolation2DTable<Type>::operator[]"
+                    "(const scalar, const scalar) const"
+                )   << "value (" << lookupValue << ") underflow" << nl
+                    << "    Continuing with the first entry"
+                    << endl;
+                // fall-through to 'CLAMP'
+            }
+            case interpolation2DTable::CLAMP:
+            {
+                hiY1 = 0;
+                hiY1 = 1;
+                break;
+            }
+        }
+    }
+    else if (lookupValue >= maxLimit)
+    {
+        switch (boundsHandling_)
+        {
+            case interpolation2DTable::ERROR:
+            {
+                FatalErrorIn
+                (
+                    "Foam::interpolation2DTable<Type>::operator[]"
+                    "(const scalar, const scalar) const"
+                )   << "value (" << lookupValue << ") overflow" << nl
+                    << exit(FatalError);
+                break;
+            }
+            case interpolation2DTable::WARN:
+            {
+                WarningIn
+                (
+                    "Foam::interpolation2DTable<Type>::operator[]"
+                    "(const scalar, const scalar) const"
+                )   << "value (" << lookupValue << ") overflow" << nl
+                    << "    Continuing with the last entry"
+                    << endl;
+                // fall-through to 'CLAMP'
+            }
+            case interpolation2DTable::CLAMP:
+            {
+                hiY1 = nY-1;
+                hiY1 = nY;
+                break;
+            }
+        }
+    }
+    else
+    {
+        // Finds the lo and hi of Y on the lowest x
+        for (label i = 0; i < nY; ++i)
+        {
+            if
+            (
+                lookupValue >= matrix::operator[](loX).second()[i].first()
+            )
+            {
+                loY1 = hiY1 = i;
+            }
+            else
+            {
+                hiY1 = i;
+                break;
+            }
+        }
+    }
+
+    label loY2 = 0;
+    label hiY2 = 0;
+
+    nY = matrix::operator[](hiX).second().size();
+
+    minLimit = matrix::operator[](loX).second()[0].first();
+    maxLimit = matrix::operator[](loX).second()[nY-1].first();
+
+    if (lookupValue < minLimit)
+    {
+        switch (boundsHandling_)
+        {
+            case interpolation2DTable::ERROR:
+            {
+                FatalErrorIn
+                (
+                    "Foam::interpolation2DTable<Type>::operator[]"
+                    "(const scalar, const scalar) const"
+                )   << "value (" << lookupValue << ") underflow" << nl
+                    << exit(FatalError);
+                break;
+            }
+            case interpolation2DTable::WARN:
+            {
+                WarningIn
+                (
+                    "Foam::interpolation2DTable<Type>::operator[]"
+                    "(const scalar, const scalar) const"
+                )   << "value (" << lookupValue << ") underflow" << nl
+                    << "    Continuing with the first entry"
+                    << endl;
+                // fall-through to 'CLAMP'
+            }
+            case interpolation2DTable::CLAMP:
+            {
+                loY2 = 0;
+                loY2 = 1;
+                break;
+            }
+        }
+    }
+    else if (lookupValue >= maxLimit)
+    {
+        switch (boundsHandling_)
+        {
+            case interpolation2DTable::ERROR:
+            {
+                FatalErrorIn
+                (
+                    "Foam::interpolation2DTable<Type>::operator[]"
+                    "(const scalar, const scalar) const"
+                )   << "value (" << lookupValue << ") overflow" << nl
+                    << exit(FatalError);
+                break;
+            }
+            case interpolation2DTable::WARN:
+            {
+                WarningIn
+                (
+                    "Foam::interpolation2DTable<Type>::operator[]"
+                    "(const scalar, const scalar) const"
+                )   << "value (" << lookupValue << ") overflow" << nl
+                    << "    Continuing with the last entry"
+                    << endl;
+                // fall-through to 'CLAMP'
+            }
+            case interpolation2DTable::CLAMP:
+            {
+                loY2 = nY-1;
+                loY2 = nY;
+                break;
+            }
+        }
+    }
+    else
+    {
+        // Finds the lo and hi of Y on the high x
+        for (label i = 0; i < nY; ++i)
+        {
+            if
+            (
+                lookupValue >= matrix::operator[](hiX).second()[i].first()
+            )
+            {
+                loY2 = hiY2 = i;
+            }
+            else
+            {
+                hiY2 = i;
+                break;
+            }
+        }
+    }
+
+    if (loX == hiX)
+    {
+        // we are at the end of the table - or there is only a single entry
+        return (interpolateValue(matrix::operator[](hiX).second(), valueY));
+    }
+    else
+    {
+        Type loXData = matrix::operator[](loX).second()[loY1].second();
+        Type hiXData = matrix::operator[](hiX).second()[loY1].second();
+
+        Type hiYData = matrix::operator[](loX).second()[hiY1].second();
+
+        Type refValue = matrix::operator[](loX).second()[loY1].second();
+
+        // normal interpolation on x
+        refValue +=
+            (
+                hiXData
+              - loXData
+            )
+            *(
+                valueX
+              - matrix::operator[](loX).first()
+             )
+            /(
+                matrix::operator[](hiX).first()
+              - matrix::operator[](loX).first()
+            );
+
+        // normal interpolation on y
+        refValue +=
+            (
+                hiYData
+              - loXData
+            )
+            *(
+                valueY
+              - matrix::operator[](loX).second()[loY1].first()
+            )
+            /(
+                matrix::operator[](loX).second()[hiY1].first()
+              - matrix::operator[](loX).second()[loY1].first()
+            );
+
+        return refValue;
+    }
+}
+
+
+// ************************************************************************* //
diff --git a/src/OpenFOAM/interpolations/interpolation2DTable/interpolation2DTable.H b/src/OpenFOAM/interpolations/interpolation2DTable/interpolation2DTable.H
new file mode 100644
index 0000000000..a76abcfaed
--- /dev/null
+++ b/src/OpenFOAM/interpolations/interpolation2DTable/interpolation2DTable.H
@@ -0,0 +1,165 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::interpolation2DTable
+
+Description
+    2D table interpolation. The data must be in ascending order in both
+    dimensions x and y.
+
+SourceFiles
+    interpolation2DTable.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef interpolation2DTable_H
+#define interpolation2DTable_H
+
+#include "List.H"
+#include "Tuple2.H"
+#include "tableReader.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                    Class interpolation2DTable Declaration
+\*---------------------------------------------------------------------------*/
+
+template<class Type>
+class interpolation2DTable
+:
+    public List<Tuple2<scalar, List<Tuple2<scalar, Type> > > >
+{
+public:
+
+    // Public data types
+
+        //- Enumeration for handling out-of-bound values
+        enum boundsHandling
+        {
+            ERROR,          /*!< Exit with a FatalError */
+            WARN,           /*!< Issue warning and clamp value (default) */
+            CLAMP           /*!< Clamp value to the start/end value */
+        };
+
+
+private:
+
+    // Private data
+
+        //- Enumeration for handling out-of-bound values
+        boundsHandling boundsHandling_;
+
+        //- File name
+        fileName fileName_;
+
+        //- the actual reader
+        autoPtr<tableReader<Type> > reader_;
+
+
+    // Private Member Functions
+
+        //- Read the table of data from file
+        void readTable();
+
+        //- Return interpolated value in List
+        Type interpolateValue
+        (
+            const List<Tuple2<scalar, Type> >& data,
+            const scalar
+        ) const;
+
+
+public:
+
+    // Constructors
+
+        //- Construct null
+        interpolation2DTable();
+
+        //- Construct from components
+        interpolation2DTable
+        (
+            const List<Tuple2<scalar, List<Tuple2<scalar, Type> > > >& values,
+            const boundsHandling bounds,
+            const fileName& fName
+        );
+
+        //- Construct given the name of the file containing the table of data
+        interpolation2DTable(const fileName& fName);
+
+        //- Construct by reading the fileName and boundsHandling from dictionary
+        interpolation2DTable(const dictionary& dict);
+
+        //- Construct copy
+        interpolation2DTable(const interpolation2DTable& interpTable);
+
+
+    // Member Functions
+
+        //- Return the out-of-bounds handling as a word
+        word boundsHandlingToWord(const boundsHandling& bound) const;
+
+        //- Return the out-of-bounds handling as an enumeration
+        boundsHandling wordToBoundsHandling(const word& bound) const;
+
+        //- Set the out-of-bounds handling from enum, return previous setting
+        boundsHandling outOfBounds(const boundsHandling& bound);
+
+        //- Check that list is monotonically increasing
+        //  Exit with a FatalError if there is a problem
+        void check() const;
+
+        //- Write
+        void write(Ostream& os) const;
+
+
+    // Member Operators
+
+        //- Return an element of constant Tuple2<scalar, Type>
+        const List<Tuple2<scalar, Type> >& operator[](const label) const;
+
+        //- Return an interpolated value
+        Type operator()(const scalar, const scalar) const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+#   include "interpolation2DTable.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/OpenFOAM/interpolations/interpolationTable/tableReaders/csv/csvTableReader.C b/src/OpenFOAM/interpolations/interpolationTable/tableReaders/csv/csvTableReader.C
index 03eba35033..b71e274842 100644
--- a/src/OpenFOAM/interpolations/interpolationTable/tableReaders/csv/csvTableReader.C
+++ b/src/OpenFOAM/interpolations/interpolationTable/tableReaders/csv/csvTableReader.C
@@ -162,6 +162,17 @@ void Foam::csvTableReader<Type>::operator()
 }
 
 
+template<class Type>
+void Foam::csvTableReader<Type>::operator()
+(
+    const fileName& fName,
+    List<Tuple2<scalar, List<Tuple2<scalar, Type> > > >& data
+)
+{
+    notImplemented("csvTableReader<Type>::operator()");
+}
+
+
 template<class Type>
 void Foam::csvTableReader<Type>::write(Ostream& os) const
 {
diff --git a/src/OpenFOAM/interpolations/interpolationTable/tableReaders/csv/csvTableReader.H b/src/OpenFOAM/interpolations/interpolationTable/tableReaders/csv/csvTableReader.H
index 282dd92ccb..de30604292 100644
--- a/src/OpenFOAM/interpolations/interpolationTable/tableReaders/csv/csvTableReader.H
+++ b/src/OpenFOAM/interpolations/interpolationTable/tableReaders/csv/csvTableReader.H
@@ -103,6 +103,13 @@ public:
         //- Read the table
         virtual void operator()(const fileName&, List<Tuple2<scalar, Type> >&);
 
+        //- Read 2D table
+        virtual void operator()
+        (
+            const fileName&,
+            List<Tuple2<scalar, List<Tuple2<scalar, Type> > > >&
+        );
+
         //- write the remaining parameters
         virtual void write(Ostream& os) const;
 };
diff --git a/src/OpenFOAM/interpolations/interpolationTable/tableReaders/openFoam/openFoamTableReader.C b/src/OpenFOAM/interpolations/interpolationTable/tableReaders/openFoam/openFoamTableReader.C
index 10500ad8fd..aa48da7b68 100644
--- a/src/OpenFOAM/interpolations/interpolationTable/tableReaders/openFoam/openFoamTableReader.C
+++ b/src/OpenFOAM/interpolations/interpolationTable/tableReaders/openFoam/openFoamTableReader.C
@@ -56,4 +56,16 @@ void Foam::openFoamTableReader<Type>::operator()
 }
 
 
+template<class Type>
+void Foam::openFoamTableReader<Type>::operator()
+(
+    const fileName& fName,
+    List<Tuple2<scalar, List<Tuple2<scalar, Type> > > >& data
+)
+{
+    // Read data from file
+    IFstream(fName)() >> data;
+}
+
+
 // ************************************************************************* //
diff --git a/src/OpenFOAM/interpolations/interpolationTable/tableReaders/openFoam/openFoamTableReader.H b/src/OpenFOAM/interpolations/interpolationTable/tableReaders/openFoam/openFoamTableReader.H
index 349ac96279..e40990cafd 100644
--- a/src/OpenFOAM/interpolations/interpolationTable/tableReaders/openFoam/openFoamTableReader.H
+++ b/src/OpenFOAM/interpolations/interpolationTable/tableReaders/openFoam/openFoamTableReader.H
@@ -84,6 +84,13 @@ public:
 
         //- Read the table
         virtual void operator()(const fileName&, List<Tuple2<scalar, Type> > &);
+
+        //- Read 2D table
+        virtual void operator()
+        (
+            const fileName&,
+            List<Tuple2<scalar, List<Tuple2<scalar, Type> > > >&
+        );
 };
 
 
diff --git a/src/OpenFOAM/interpolations/interpolationTable/tableReaders/tableReader.H b/src/OpenFOAM/interpolations/interpolationTable/tableReaders/tableReader.H
index 8ea2b71fc7..d68ea92e7d 100644
--- a/src/OpenFOAM/interpolations/interpolationTable/tableReaders/tableReader.H
+++ b/src/OpenFOAM/interpolations/interpolationTable/tableReaders/tableReader.H
@@ -103,6 +103,13 @@ public:
             List<Tuple2<scalar, Type> >&
         ) = 0;
 
+        //- Read the 2D table
+        virtual void operator()
+        (
+            const fileName&,
+            List<Tuple2<scalar, List<Tuple2<scalar, Type> > > >&
+        ) = 0;
+
         //- Write additional information
         virtual void write(Ostream& os) const;
 };
diff --git a/src/fieldSources/Make/files b/src/fieldSources/Make/files
new file mode 100644
index 0000000000..0df9defae4
--- /dev/null
+++ b/src/fieldSources/Make/files
@@ -0,0 +1,28 @@
+basicSource/basicSource/basicSource.C
+basicSource/basicSource/basicSourceIO.C
+basicSource/basicSource/basicSourceList.C
+basicSource/basicSource/IObasicSourceList.C
+
+basicSource/pressureGradientExplicitSource/pressureGradientExplicitSource.C
+basicSource/pressureGradientExplicitSource/pressureGradientExplicitSourceIO.C
+
+basicSource/explicitSource/explicitSource.C
+basicSource/explicitSetValue/explicitSetValue.C
+
+basicSource/rotorDiskSource/rotorDiskSource.C
+basicSource/rotorDiskSource/bladeModel/bladeModel.C
+basicSource/rotorDiskSource/profileModel/profileModel.C
+basicSource/rotorDiskSource/profileModel/profileModelList.C
+basicSource/rotorDiskSource/profileModel/lookup/lookupProfile.C
+basicSource/rotorDiskSource/profileModel/series/seriesProfile.C
+
+basicSource/actuationDiskSource/actuationDiskSource.C
+basicSource/radialActuationDiskSource/radialActuationDiskSource.C
+
+interRegion = basicSource/interRegionHeatTransferModel
+$(interRegion)/interRegionHeatTransferModel/interRegionHeatTransferModel.C
+$(interRegion)/constantHeatTransfer/constantHeatTransfer.C
+$(interRegion)/tabulatedHeatTransfer/tabulatedHeatTransfer.C
+$(interRegion)/variableHeatTransfer/variableHeatTransfer.C
+
+LIB = $(FOAM_LIBBIN)/libfieldSources
\ No newline at end of file
diff --git a/src/fieldSources/Make/options b/src/fieldSources/Make/options
new file mode 100644
index 0000000000..bb78896172
--- /dev/null
+++ b/src/fieldSources/Make/options
@@ -0,0 +1,17 @@
+EXE_INC = \
+    -I$(LIB_SRC)/finiteVolume/lnInclude \
+    -I$(LIB_SRC)/meshTools/lnInclude \
+    -I$(LIB_SRC)/sampling/lnInclude \
+    -I$(LIB_SRC)/thermophysicalModels/basicSolidThermo/lnInclude \
+    -I$(LIB_SRC)/thermophysicalModels/basic/lnInclude \
+    -I$(LIB_SRC)/thermophysicalModels/specie/lnInclude \
+    -I$(LIB_SRC)/turbulenceModels/compressible/turbulenceModel/lnInclude \
+    -I$(LIB_SRC)/turbulenceModels
+
+
+LIB_LIBS = \
+    -lfiniteVolume \
+    -lsampling \
+    -lmeshTools \
+    -lbasicSolidThermo \
+    -lcompressibleTurbulenceModel
diff --git a/src/finiteVolume/cfdTools/general/fieldSources/basicSource/actuationDiskSource/actuationDiskSource.C b/src/fieldSources/basicSource/actuationDiskSource/actuationDiskSource.C
similarity index 100%
rename from src/finiteVolume/cfdTools/general/fieldSources/basicSource/actuationDiskSource/actuationDiskSource.C
rename to src/fieldSources/basicSource/actuationDiskSource/actuationDiskSource.C
diff --git a/src/finiteVolume/cfdTools/general/fieldSources/basicSource/actuationDiskSource/actuationDiskSource.H b/src/fieldSources/basicSource/actuationDiskSource/actuationDiskSource.H
similarity index 100%
rename from src/finiteVolume/cfdTools/general/fieldSources/basicSource/actuationDiskSource/actuationDiskSource.H
rename to src/fieldSources/basicSource/actuationDiskSource/actuationDiskSource.H
diff --git a/src/finiteVolume/cfdTools/general/fieldSources/basicSource/actuationDiskSource/actuationDiskSourceTemplates.C b/src/fieldSources/basicSource/actuationDiskSource/actuationDiskSourceTemplates.C
similarity index 100%
rename from src/finiteVolume/cfdTools/general/fieldSources/basicSource/actuationDiskSource/actuationDiskSourceTemplates.C
rename to src/fieldSources/basicSource/actuationDiskSource/actuationDiskSourceTemplates.C
diff --git a/src/finiteVolume/cfdTools/general/fieldSources/basicSource/basicSource/IObasicSourceList.C b/src/fieldSources/basicSource/basicSource/IObasicSourceList.C
similarity index 100%
rename from src/finiteVolume/cfdTools/general/fieldSources/basicSource/basicSource/IObasicSourceList.C
rename to src/fieldSources/basicSource/basicSource/IObasicSourceList.C
diff --git a/src/finiteVolume/cfdTools/general/fieldSources/basicSource/basicSource/IObasicSourceList.H b/src/fieldSources/basicSource/basicSource/IObasicSourceList.H
similarity index 100%
rename from src/finiteVolume/cfdTools/general/fieldSources/basicSource/basicSource/IObasicSourceList.H
rename to src/fieldSources/basicSource/basicSource/IObasicSourceList.H
diff --git a/src/finiteVolume/cfdTools/general/fieldSources/basicSource/basicSource/basicSource.C b/src/fieldSources/basicSource/basicSource/basicSource.C
similarity index 78%
rename from src/finiteVolume/cfdTools/general/fieldSources/basicSource/basicSource/basicSource.C
rename to src/fieldSources/basicSource/basicSource/basicSource.C
index da790fab4d..40f283a78a 100644
--- a/src/finiteVolume/cfdTools/general/fieldSources/basicSource/basicSource/basicSource.C
+++ b/src/fieldSources/basicSource/basicSource/basicSource.C
@@ -38,16 +38,17 @@ namespace Foam
     template<> const char* NamedEnum
     <
         basicSource::selectionModeType,
-        4
+        5
         >::names[] =
     {
         "points",
         "cellSet",
         "cellZone",
+        "mapRegion",
         "all"
     };
 
-    const NamedEnum<basicSource::selectionModeType, 4>
+    const NamedEnum<basicSource::selectionModeType, 5>
         basicSource::selectionModeTypeNames_;
 }
 
@@ -73,6 +74,13 @@ void Foam::basicSource::setSelection(const dictionary& dict)
             dict.lookup("cellZone") >> cellSetName_;
             break;
         }
+        case smMapRegion:
+        {
+            dict_.lookup("secondarySourceName") >> secondarySourceName_;
+            dict_.lookup("mapRegionName") >> mapRegionName_;
+            master_  = readBool(dict_.lookup("master"));
+            break;
+        }
         case smAll:
         {
             break;
@@ -151,6 +159,47 @@ void Foam::basicSource::setCellSet()
 
             break;
         }
+        case smMapRegion:
+        {
+            if(active_)
+            {
+                Info<< indent << "- selecting inter region mapping" << endl;
+                const fvMesh& secondaryMesh =
+                    mesh_.time().lookupObject<fvMesh>(mapRegionName_);
+                const boundBox primaryBB = mesh_.bounds();
+                const boundBox secondaryBB = secondaryMesh.bounds();
+                if (secondaryBB.overlaps(primaryBB))
+                {
+
+                    // Dummy patches
+                    wordList cuttingPatches;
+                    HashTable<word> patchMap;
+
+                    secondaryToPrimaryInterpPtr_.reset
+                    (
+                        new meshToMesh
+                        (
+                            secondaryMesh,
+                            mesh_,
+                            patchMap,
+                            cuttingPatches
+                        )
+                    );
+                }
+                else
+                {
+                    FatalErrorIn
+                    (
+                        "Foam::basicSource::setCellSet()"
+                    )   << "regions dont overlap "
+                        << secondaryMesh.name()
+                        << " in region " << mesh_.name()
+                        << nl
+                        << exit(FatalError);
+                }
+            }
+            break;
+        }
         case smAll:
         {
             Info<< indent << "- selecting all cells" << endl;
@@ -169,16 +218,19 @@ void Foam::basicSource::setCellSet()
     }
 
     // Set volume information
-    V_ = 0.0;
-    forAll(cells_, i)
+    if(selectionMode_ != smMapRegion)
     {
-        V_ += mesh_.V()[cells_[i]];
-    }
-    reduce(V_, sumOp<scalar>());
+        V_ = 0.0;
+        forAll(cells_, i)
+        {
+            V_ += mesh_.V()[cells_[i]];
+        }
+        reduce(V_, sumOp<scalar>());
 
-    Info<< indent << "- selected "
-        << returnReduce(cells_.size(), sumOp<label>())
-        << " cell(s) with volume " << V_ << nl << decrIndent << endl;
+        Info<< indent << "- selected "
+            << returnReduce(cells_.size(), sumOp<label>())
+            << " cell(s) with volume " << V_ << nl << decrIndent << endl;
+    }
 }
 
 
@@ -205,6 +257,11 @@ Foam::basicSource::basicSource
     ),
     cellSetName_("none"),
     V_(0.0),
+    secondaryToPrimaryInterpPtr_(),
+    secondarySourceName_("none"),
+    mapRegionName_("none"),
+    master_(false),
+
     fieldNames_(),
     applied_()
 {
@@ -246,6 +303,13 @@ Foam::autoPtr<Foam::basicSource> Foam::basicSource::New
     return autoPtr<basicSource>(cstrIter()(name, modelType, coeffs, mesh));
 }
 
+Foam::basicSource::~basicSource()
+{
+    if (!secondaryToPrimaryInterpPtr_.empty())
+    {
+        secondaryToPrimaryInterpPtr_.clear();
+    }
+}
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
diff --git a/src/finiteVolume/cfdTools/general/fieldSources/basicSource/basicSource/basicSource.H b/src/fieldSources/basicSource/basicSource/basicSource.H
similarity index 91%
rename from src/finiteVolume/cfdTools/general/fieldSources/basicSource/basicSource/basicSource.H
rename to src/fieldSources/basicSource/basicSource/basicSource.H
index bf61cfe0ca..1bff312111 100644
--- a/src/finiteVolume/cfdTools/general/fieldSources/basicSource/basicSource/basicSource.H
+++ b/src/fieldSources/basicSource/basicSource/basicSource.H
@@ -32,6 +32,7 @@ Description
         timeStart       0.0;                    // start time
         duration        1000.0;                 // duration
         selectionMode   cellSet;                // cellSet // points //cellZone
+                                                // mapRegion
 
     On evaluation, source expects to be added to the rhs of the equation
 
@@ -48,6 +49,8 @@ SourceFiles
 #include "fvMatricesFwd.H"
 #include "cellSet.H"
 #include "autoPtr.H"
+#include "meshToMesh.H"
+
 #include "runTimeSelectionTables.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@@ -57,6 +60,7 @@ namespace Foam
 
 class fvMesh;
 
+
 /*---------------------------------------------------------------------------*\
                          Class basicSource Declaration
 \*---------------------------------------------------------------------------*/
@@ -73,11 +77,13 @@ public:
             smPoints,
             smCellSet,
             smCellZone,
+            smMapRegion,
             smAll
         };
 
         //- Word list of selection mode type names
-        static const NamedEnum<selectionModeType, 4> selectionModeTypeNames_;
+        static const NamedEnum<selectionModeType, 5>
+            selectionModeTypeNames_;
 
 
 protected:
@@ -120,6 +126,21 @@ protected:
         //- Sum of cell volumes
         scalar V_;
 
+        // Data for smMapRegion only
+
+            //- Mesh to mesh mapping for map optiom
+            autoPtr<meshToMesh> secondaryToPrimaryInterpPtr_;
+
+            //- Name of the source in the secondary mesh
+            word secondarySourceName_;
+
+            //- Name of the region to map
+            word mapRegionName_;
+
+            //- Master or slave region
+            bool master_;
+
+
         //- Field names to apply source to - populated by derived models
         wordList fieldNames_;
 
@@ -227,8 +248,8 @@ public:
 
 
     //- Destructor
-    virtual ~basicSource()
-    {}
+    virtual ~basicSource();
+
 
 
     // Member Functions
@@ -266,6 +287,16 @@ public:
             //- Return const access to the total cell volume
             inline scalar V() const;
 
+            //- Return const access to the secondarySourceName
+            inline const word secondarySourceName() const;
+
+            //- Return const access to the mapToMap Ptr
+            inline const autoPtr<meshToMesh>
+                secondaryToPrimaryInterpPtr() const;
+
+            //- Return const referenc to the mapRegion
+            inline const word mapRegionName() const;
+
             //- Return const access to the cell set
             inline const labelList& cells() const;
 
diff --git a/src/finiteVolume/cfdTools/general/fieldSources/basicSource/basicSource/basicSourceI.H b/src/fieldSources/basicSource/basicSource/basicSourceI.H
similarity index 88%
rename from src/finiteVolume/cfdTools/general/fieldSources/basicSource/basicSource/basicSourceI.H
rename to src/fieldSources/basicSource/basicSource/basicSourceI.H
index daf00bfc7c..84444144f3 100644
--- a/src/finiteVolume/cfdTools/general/fieldSources/basicSource/basicSource/basicSourceI.H
+++ b/src/fieldSources/basicSource/basicSource/basicSourceI.H
@@ -118,4 +118,21 @@ inline Foam::scalar& Foam::basicSource::duration()
 }
 
 
+inline const Foam::word Foam::basicSource::secondarySourceName() const
+{
+    return secondarySourceName_;
+}
+
+
+inline const Foam::autoPtr<Foam::meshToMesh> Foam::basicSource::
+secondaryToPrimaryInterpPtr() const
+{
+    return secondaryToPrimaryInterpPtr_;
+}
+
+inline const Foam::word Foam::basicSource::mapRegionName() const
+{
+    return mapRegionName_;
+}
+
 // ************************************************************************* //
diff --git a/src/finiteVolume/cfdTools/general/fieldSources/basicSource/basicSource/basicSourceIO.C b/src/fieldSources/basicSource/basicSource/basicSourceIO.C
similarity index 97%
rename from src/finiteVolume/cfdTools/general/fieldSources/basicSource/basicSource/basicSourceIO.C
rename to src/fieldSources/basicSource/basicSource/basicSourceIO.C
index 55eb290087..ce0c88cace 100644
--- a/src/finiteVolume/cfdTools/general/fieldSources/basicSource/basicSource/basicSourceIO.C
+++ b/src/fieldSources/basicSource/basicSource/basicSourceIO.C
@@ -72,6 +72,10 @@ void Foam::basicSource::writeData(Ostream& os) const
         {
             break;
         }
+        case smMapRegion:
+        {
+            break;
+        }
         default:
         {
             FatalErrorIn("basicSource::writeData(Ostream&) const")
diff --git a/src/finiteVolume/cfdTools/general/fieldSources/basicSource/basicSource/basicSourceList.C b/src/fieldSources/basicSource/basicSource/basicSourceList.C
similarity index 100%
rename from src/finiteVolume/cfdTools/general/fieldSources/basicSource/basicSource/basicSourceList.C
rename to src/fieldSources/basicSource/basicSource/basicSourceList.C
diff --git a/src/finiteVolume/cfdTools/general/fieldSources/basicSource/basicSource/basicSourceList.H b/src/fieldSources/basicSource/basicSource/basicSourceList.H
similarity index 100%
rename from src/finiteVolume/cfdTools/general/fieldSources/basicSource/basicSource/basicSourceList.H
rename to src/fieldSources/basicSource/basicSource/basicSourceList.H
diff --git a/src/finiteVolume/cfdTools/general/fieldSources/basicSource/basicSource/basicSourceListTemplates.C b/src/fieldSources/basicSource/basicSource/basicSourceListTemplates.C
similarity index 100%
rename from src/finiteVolume/cfdTools/general/fieldSources/basicSource/basicSource/basicSourceListTemplates.C
rename to src/fieldSources/basicSource/basicSource/basicSourceListTemplates.C
diff --git a/src/finiteVolume/cfdTools/general/fieldSources/basicSource/basicSource/makeBasicSource.H b/src/fieldSources/basicSource/basicSource/makeBasicSource.H
similarity index 100%
rename from src/finiteVolume/cfdTools/general/fieldSources/basicSource/basicSource/makeBasicSource.H
rename to src/fieldSources/basicSource/basicSource/makeBasicSource.H
diff --git a/src/finiteVolume/cfdTools/general/fieldSources/basicSource/explicitSetValue/ExplicitSetValue.C b/src/fieldSources/basicSource/explicitSetValue/ExplicitSetValue.C
similarity index 100%
rename from src/finiteVolume/cfdTools/general/fieldSources/basicSource/explicitSetValue/ExplicitSetValue.C
rename to src/fieldSources/basicSource/explicitSetValue/ExplicitSetValue.C
diff --git a/src/finiteVolume/cfdTools/general/fieldSources/basicSource/explicitSetValue/ExplicitSetValue.H b/src/fieldSources/basicSource/explicitSetValue/ExplicitSetValue.H
similarity index 100%
rename from src/finiteVolume/cfdTools/general/fieldSources/basicSource/explicitSetValue/ExplicitSetValue.H
rename to src/fieldSources/basicSource/explicitSetValue/ExplicitSetValue.H
diff --git a/src/finiteVolume/cfdTools/general/fieldSources/basicSource/explicitSetValue/ExplicitSetValueIO.C b/src/fieldSources/basicSource/explicitSetValue/ExplicitSetValueIO.C
similarity index 100%
rename from src/finiteVolume/cfdTools/general/fieldSources/basicSource/explicitSetValue/ExplicitSetValueIO.C
rename to src/fieldSources/basicSource/explicitSetValue/ExplicitSetValueIO.C
diff --git a/src/finiteVolume/cfdTools/general/fieldSources/basicSource/explicitSetValue/explicitSetValue.C b/src/fieldSources/basicSource/explicitSetValue/explicitSetValue.C
similarity index 100%
rename from src/finiteVolume/cfdTools/general/fieldSources/basicSource/explicitSetValue/explicitSetValue.C
rename to src/fieldSources/basicSource/explicitSetValue/explicitSetValue.C
diff --git a/src/finiteVolume/cfdTools/general/fieldSources/basicSource/explicitSource/ExplicitSource.C b/src/fieldSources/basicSource/explicitSource/ExplicitSource.C
similarity index 100%
rename from src/finiteVolume/cfdTools/general/fieldSources/basicSource/explicitSource/ExplicitSource.C
rename to src/fieldSources/basicSource/explicitSource/ExplicitSource.C
diff --git a/src/finiteVolume/cfdTools/general/fieldSources/basicSource/explicitSource/ExplicitSource.H b/src/fieldSources/basicSource/explicitSource/ExplicitSource.H
similarity index 100%
rename from src/finiteVolume/cfdTools/general/fieldSources/basicSource/explicitSource/ExplicitSource.H
rename to src/fieldSources/basicSource/explicitSource/ExplicitSource.H
diff --git a/src/finiteVolume/cfdTools/general/fieldSources/basicSource/explicitSource/ExplicitSourceI.H b/src/fieldSources/basicSource/explicitSource/ExplicitSourceI.H
similarity index 100%
rename from src/finiteVolume/cfdTools/general/fieldSources/basicSource/explicitSource/ExplicitSourceI.H
rename to src/fieldSources/basicSource/explicitSource/ExplicitSourceI.H
diff --git a/src/finiteVolume/cfdTools/general/fieldSources/basicSource/explicitSource/ExplicitSourceIO.C b/src/fieldSources/basicSource/explicitSource/ExplicitSourceIO.C
similarity index 100%
rename from src/finiteVolume/cfdTools/general/fieldSources/basicSource/explicitSource/ExplicitSourceIO.C
rename to src/fieldSources/basicSource/explicitSource/ExplicitSourceIO.C
diff --git a/src/finiteVolume/cfdTools/general/fieldSources/basicSource/explicitSource/explicitSource.C b/src/fieldSources/basicSource/explicitSource/explicitSource.C
similarity index 100%
rename from src/finiteVolume/cfdTools/general/fieldSources/basicSource/explicitSource/explicitSource.C
rename to src/fieldSources/basicSource/explicitSource/explicitSource.C
diff --git a/src/fieldSources/basicSource/interRegionHeatTransferModel/constantHeatTransfer/constantHeatTransfer.C b/src/fieldSources/basicSource/interRegionHeatTransferModel/constantHeatTransfer/constantHeatTransfer.C
new file mode 100644
index 0000000000..eb49266305
--- /dev/null
+++ b/src/fieldSources/basicSource/interRegionHeatTransferModel/constantHeatTransfer/constantHeatTransfer.C
@@ -0,0 +1,141 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "constantHeatTransfer.H"
+#include "fvm.H"
+#include "IObasicSourceList.H"
+#include "addToRunTimeSelectionTable.H"
+#include "fvcVolumeIntegrate.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(constantHeatTransfer, 0);
+    addToRunTimeSelectionTable
+    (
+        basicSource,
+        constantHeatTransfer,
+        dictionary
+    );
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::constantHeatTransfer::constantHeatTransfer
+(
+    const word& name,
+    const word& modelType,
+    const dictionary& dict,
+    const fvMesh& mesh
+)
+:
+    interRegionHeatTransferModel(name, modelType, dict, mesh),
+    htCoeffs_(),
+    area_()
+{
+    if (master_)
+    {
+        htCoeffs_.reset
+        (
+            new volScalarField
+            (
+                IOobject
+                (
+                    "htCoeffs",
+                    mesh_.time().timeName(),
+                    mesh_,
+                    IOobject::MUST_READ,
+                    IOobject::AUTO_WRITE
+                ),
+                mesh_
+            )
+        );
+
+        area_.reset
+        (
+            new volScalarField
+            (
+                IOobject
+                (
+                    "area",
+                    mesh_.time().timeName(),
+                    mesh_,
+                    IOobject::MUST_READ,
+                    IOobject::AUTO_WRITE
+                ),
+                mesh_
+            )
+        );
+
+        htc_.internalField() = htCoeffs_()*area_()/mesh_.V();
+        htc_.correctBoundaryConditions();
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::constantHeatTransfer::~constantHeatTransfer()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+const Foam::tmp<Foam::volScalarField>Foam::constantHeatTransfer::
+calculateHtc()
+{
+    return htc_;
+}
+
+
+void Foam::constantHeatTransfer::writeData(Ostream& os) const
+{
+    os  << indent << token::BEGIN_BLOCK << incrIndent << nl;
+    interRegionHeatTransferModel::writeData(os);
+
+    os << indent << "constantHeatTransfer";
+
+    dict_.write(os);
+
+    os << decrIndent << indent << token::END_BLOCK << endl;
+}
+
+
+bool Foam::constantHeatTransfer::read(const dictionary& dict)
+{
+    if (basicSource::read(dict))
+    {
+        return true;
+    }
+    else
+    {
+        return false;
+    }
+}
+
+
+// ************************************************************************* //
\ No newline at end of file
diff --git a/src/fieldSources/basicSource/interRegionHeatTransferModel/constantHeatTransfer/constantHeatTransfer.H b/src/fieldSources/basicSource/interRegionHeatTransferModel/constantHeatTransfer/constantHeatTransfer.H
new file mode 100644
index 0000000000..375d00ae8b
--- /dev/null
+++ b/src/fieldSources/basicSource/interRegionHeatTransferModel/constantHeatTransfer/constantHeatTransfer.H
@@ -0,0 +1,110 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::constantHeatTransfer
+
+Description
+    Constant heat transfer model. htCoeffs [W/m2/K] and area [m2] must be
+    provided.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef constantHeatTransfer_H
+#define constantHeatTransfer_H
+
+#include "interRegionHeatTransferModel.H"
+#include "autoPtr.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+/*---------------------------------------------------------------------------*\
+                        Class constantHeatTransfer Declaration
+\*---------------------------------------------------------------------------*/
+
+class constantHeatTransfer
+:
+    public interRegionHeatTransferModel
+{
+private:
+
+    // Private data
+
+        //- Heat transfer coefficient
+        autoPtr<volScalarField> htCoeffs_;
+
+        //- Area of heat exchange
+        autoPtr<volScalarField> area_;
+
+
+public:
+
+    //- Runtime type information
+        TypeName("constantHeatTransfer");
+
+
+    // Constructors
+
+        //- Construct from dictionary
+        constantHeatTransfer
+        (
+            const word& name,
+            const word& modelType,
+            const dictionary& dict,
+            const fvMesh& mesh
+        );
+
+
+    //- Destructor
+    virtual ~constantHeatTransfer();
+
+
+    // Public Functions
+
+        //- Calculate the heat transfer coefficient
+        virtual const tmp<volScalarField> calculateHtc();
+
+
+        // I-O
+
+            //- Write data
+            virtual void writeData(Ostream&) const;
+
+            //- Read dictionary
+            virtual bool read(const dictionary& dict) ;
+
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/fieldSources/basicSource/interRegionHeatTransferModel/interRegionHeatTransferModel/interRegionHeatTransferModel.C b/src/fieldSources/basicSource/interRegionHeatTransferModel/interRegionHeatTransferModel/interRegionHeatTransferModel.C
new file mode 100644
index 0000000000..24c0f612dd
--- /dev/null
+++ b/src/fieldSources/basicSource/interRegionHeatTransferModel/interRegionHeatTransferModel/interRegionHeatTransferModel.C
@@ -0,0 +1,270 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "interRegionHeatTransferModel.H"
+#include "basicThermo.H"
+#include "fvm.H"
+#include "IObasicSourceList.H"
+#include "zeroGradientFvPatchFields.H"
+#include "fvcVolumeIntegrate.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(interRegionHeatTransferModel, 0);
+};
+
+
+// * * * * * * * * * * * *  Private member functions * * * * * * * * * * * //
+
+void Foam::interRegionHeatTransferModel::check()
+{
+    const fvMesh& secondaryMesh =
+            mesh_.time().lookupObject<fvMesh>(mapRegionName_);
+
+    const basicSourceList& IObsl =
+        secondaryMesh.lookupObject<basicSourceList>
+        (
+            "sourcesProperties"
+        );
+
+    const PtrList<basicSource>& bsl = IObsl;
+
+    bool secSourceFound(false);
+
+    forAll(bsl, i)
+    {
+        if (bsl[i].name() == secondarySourceName_)
+        {
+            secIrht_ = &const_cast<interRegionHeatTransferModel&>
+            (
+                refCast<const interRegionHeatTransferModel>(bsl[i])
+            );
+            secSourceFound = true;
+            break;
+        }
+    }
+
+    if(!secSourceFound)
+    {
+        FatalErrorIn
+        (
+            "constantHeatTransfer::interRegionHeatTransferModel"
+            "("
+            "   const word& name,"
+            "   const word& modelType,"
+            "   const dictionary& dict,"
+            "   const fvMesh& mesh"
+            ")"
+        )   << "Secondary source name not found" << secondarySourceName_
+            << " in region " << secondaryMesh.name()
+            << nl
+            << exit(FatalError);
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::interRegionHeatTransferModel::interRegionHeatTransferModel
+(
+    const word& name,
+    const word& modelType,
+    const dictionary& dict,
+    const fvMesh& mesh
+)
+:
+    basicSource(name, modelType, dict, mesh),
+    secIrht_(),
+    firstIter_(true),
+    htc_
+    (
+        IOobject
+        (
+            "htc",
+            mesh.time().timeName(),
+            mesh,
+            IOobject::NO_READ,
+            IOobject::NO_WRITE
+        ),
+        mesh,
+        dimensionedScalar
+        (
+            "htc",
+            dimEnergy/dimTime/dimTemperature/dimVolume,
+            0.0
+        ),
+        zeroGradientFvPatchScalarField::typeName
+    )
+{
+    coeffs_.lookup("fieldNames") >> fieldNames_;
+    applied_.setSize(fieldNames_.size(), false);
+}
+
+
+Foam::interRegionHeatTransferModel::~interRegionHeatTransferModel()
+{}
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+
+void Foam::interRegionHeatTransferModel::addSup
+(
+    fvMatrix<scalar>& eEqn,
+    const label fieldI
+)
+{
+    if (firstIter_)
+    {
+        check();
+        firstIter_ = false;
+    }
+
+    const volScalarField& h = eEqn.psi();
+
+    tmp<volScalarField> tTmapped
+    (
+        new volScalarField
+        (
+            IOobject
+            (
+                "Tmapped" + mesh_.name(),
+                mesh_.time().timeName(),
+                mesh_,
+                IOobject::NO_READ,
+                IOobject::NO_WRITE
+            ),
+            mesh_,
+            dimensionedScalar("T", dimTemperature, 0.0)
+        )
+    );
+
+    volScalarField& Tmapped = tTmapped();
+
+    const fvMesh& secondaryMesh =
+        mesh_.time().lookupObject<fvMesh>(mapRegionName_);
+
+    const volScalarField& Tsecondary =
+        secondaryMesh.lookupObject<volScalarField>("T");
+
+    secondaryToPrimaryInterpPtr_->interpolateInternalField
+    (
+        Tmapped,
+        Tsecondary,
+        meshToMesh::MAP,
+        eqOp<scalar>()
+    );
+
+    if (!master_)
+    {
+        secondaryToPrimaryInterpPtr_->interpolateInternalField
+        (
+            htc_,
+            secIrht_->calculateHtc(),
+            meshToMesh::CELL_VOLUME_WEIGHT,
+            eqOp<scalar>()
+        );
+    }
+
+    if (debug)
+    {
+        Info<< " Volumetric integral of htc : "
+            << fvc::domainIntegrate(htc_).value()
+            << endl;
+    }
+
+    //SAF: temporarily output
+    if (mesh_.time().outputTime())
+    {
+        Tmapped.write();
+        htc_.write();
+    }
+
+    if (h.dimensions() == dimEnergy/dimMass)
+    {
+        const basicThermo& primaryThermo =
+            mesh_.lookupObject<basicThermo>("thermophysicalProperties");
+
+        eEqn += htc_*Tmapped - fvm::Sp(htc_/primaryThermo.Cp(), h);
+
+        if (debug)
+        {
+            Info<< " Energy exchange from region " << secondaryMesh.name()
+                << " To " << mesh_.name() << " : "
+                <<  fvc::domainIntegrate
+                    (
+                        htc_*(h/primaryThermo.Cp() - Tmapped)
+                    ).value()
+                << endl;
+        }
+    }
+    else if(h.dimensions() == dimTemperature)
+    {
+        eEqn += htc_*Tmapped - fvm::Sp(htc_, h);
+
+        if (debug)
+        {
+            Info<< " Enegy exchange from region " << secondaryMesh.name()
+                << " To " << mesh_.name() << " : "
+                <<  fvc::domainIntegrate(htc_*(h - Tmapped)).value()
+                << endl;
+        }
+    }
+}
+
+
+void Foam::interRegionHeatTransferModel::writeData(Ostream& os) const
+{
+    os.writeKeyword("name") << this->name() << token::END_STATEMENT << nl;
+    os.writeKeyword("mapRegionName") << mapRegionName_
+        << token::END_STATEMENT << nl;
+    os.writeKeyword("secondarySourceName") << secondarySourceName_
+        << token::END_STATEMENT << nl;
+
+    os.writeKeyword("master") << master_ << token::END_STATEMENT << nl;
+
+    if (dict_.found("note"))
+    {
+        os.writeKeyword("note") << string(dict_.lookup("note"))
+            << token::END_STATEMENT << nl;
+    }
+
+    dict_.write(os);
+}
+
+
+bool Foam::interRegionHeatTransferModel::read(const dictionary& dict)
+{
+    if (basicSource::read(dict))
+    {
+        return true;
+    }
+    else
+    {
+        return false;
+    }
+}
+// ************************************************************************* //
diff --git a/src/fieldSources/basicSource/interRegionHeatTransferModel/interRegionHeatTransferModel/interRegionHeatTransferModel.H b/src/fieldSources/basicSource/interRegionHeatTransferModel/interRegionHeatTransferModel/interRegionHeatTransferModel.H
new file mode 100644
index 0000000000..38c8141bed
--- /dev/null
+++ b/src/fieldSources/basicSource/interRegionHeatTransferModel/interRegionHeatTransferModel/interRegionHeatTransferModel.H
@@ -0,0 +1,139 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::interRegionHeatTransferModel
+
+Description
+    Base class for inter region heat exchange. The derived classes must
+    provide the heat transfer coefficient (htc)
+    NOTE: mapToMap does to work in paralell
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef interRegionHeatTransferModel_H
+#define interRegionHeatTransferModel_H
+
+#include "basicSource.H"
+#include "volFields.H"
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                       Class interRegionHeatTransferModel Declaration
+\*---------------------------------------------------------------------------*/
+
+class interRegionHeatTransferModel
+:
+    public  basicSource
+{
+
+private:
+
+    // Private data
+
+        //- Pointer to secondary interRegionHeatTransferModel
+        interRegionHeatTransferModel* secIrht_;
+
+        //- First iteration
+        bool firstIter_;
+
+
+    // Private members
+
+        //- Check coupled interRegionHeatTransferModel
+        void check();
+
+
+protected:
+
+    // Protected data
+
+        //- Heat transfer coefficient [W/m2/k] by area/volume [1/m]
+        // registered on the master mesh
+        volScalarField htc_;
+
+
+public:
+
+    //- Runtime type information
+    TypeName("interRegionHeatTransferModel");
+
+
+    // Constructors
+
+        //- Construct from dictionary
+        interRegionHeatTransferModel
+        (
+            const word& name,
+            const word& modelType,
+            const dictionary& dict,
+            const fvMesh& mesh
+        );
+
+
+    //- Destructor
+    virtual ~interRegionHeatTransferModel();
+
+
+    // Member Functions
+
+
+        // Access
+
+            //- Return the heat transfer coefficient
+            const volScalarField& htc() const
+            {
+                return  htc_;
+            }
+
+            //-Source term to fvMatrix<scalar>
+            virtual void addSup(fvMatrix<scalar>& eEqn, const label fieldI);
+
+            //- Calculate heat transfer coefficient
+            virtual const tmp<volScalarField> calculateHtc() = 0;
+
+
+        // I-O
+
+            //- Write data
+            virtual void writeData(Ostream&) const;
+
+            //- Read dictionary
+            virtual bool read(const dictionary& dict);
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+#endif
+
+// ************************************************************************* //
diff --git a/src/fieldSources/basicSource/interRegionHeatTransferModel/tabulatedHeatTransfer/tabulatedHeatTransfer.C b/src/fieldSources/basicSource/interRegionHeatTransferModel/tabulatedHeatTransfer/tabulatedHeatTransfer.C
new file mode 100644
index 0000000000..5a6a22d295
--- /dev/null
+++ b/src/fieldSources/basicSource/interRegionHeatTransferModel/tabulatedHeatTransfer/tabulatedHeatTransfer.C
@@ -0,0 +1,155 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "tabulatedHeatTransfer.H"
+
+#include "turbulenceModel.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(tabulatedHeatTransfer, 0);
+    addToRunTimeSelectionTable
+    (
+        basicSource,
+        tabulatedHeatTransfer,
+        dictionary
+    );
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::tabulatedHeatTransfer::tabulatedHeatTransfer
+(
+    const word& name,
+    const word& modelType,
+    const dictionary& dict,
+    const fvMesh& mesh
+)
+:
+    interRegionHeatTransferModel(name, modelType, dict, mesh),
+    hTable_(),
+    area_()
+{
+    if (master_)
+    {
+        hTable_.reset
+        (
+            new interpolation2DTable<scalar>
+            (
+                dict.subDict(typeName + "Coeffs")
+            )
+        );
+        area_.reset
+        (
+            new volScalarField
+            (
+                IOobject
+                (
+                    "area",
+                    mesh_.time().timeName(),
+                    mesh_,
+                    IOobject::MUST_READ,
+                    IOobject::AUTO_WRITE
+                ),
+                mesh_
+            )
+        );
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::tabulatedHeatTransfer::~tabulatedHeatTransfer()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+
+const Foam::tmp<Foam::volScalarField>Foam::tabulatedHeatTransfer::
+calculateHtc()
+{
+    const fvMesh& secondaryMesh =
+        mesh_.time().lookupObject<fvMesh>(mapRegionName());
+
+    const volVectorField& Usecondary =
+        secondaryMesh.lookupObject<volVectorField>("U");
+
+    scalarField UMagMapped(htc_.internalField().size(), 0.0);
+
+    secondaryToPrimaryInterpPtr_->interpolateInternalField
+    (
+        UMagMapped,
+        mag(Usecondary),
+        meshToMesh::MAP,
+        eqOp<scalar>()
+    );
+
+    const volVectorField& U = mesh_.lookupObject<volVectorField>("U");
+
+    forAll (htc_.internalField(), i)
+    {
+        htc_.internalField()[i] =
+            hTable_->operator()(mag(U[i]), UMagMapped[i]);
+    }
+
+    htc_.internalField() = htc_*area_/mesh_.V();
+
+    return htc_;
+}
+
+
+void Foam::tabulatedHeatTransfer::writeData(Ostream& os) const
+{
+    os  << indent << token::BEGIN_BLOCK << incrIndent << nl;
+    interRegionHeatTransferModel::writeData(os);
+
+    os << indent << "tabulatedHeatTransfer";
+
+    dict_.write(os);
+
+    os << decrIndent << indent << token::END_BLOCK << endl;
+}
+
+
+bool Foam::tabulatedHeatTransfer::read(const dictionary& dict)
+{
+    if (basicSource::read(dict))
+    {
+        return true;
+    }
+    else
+    {
+        return false;
+    }
+}
+
+
+// ************************************************************************* //
\ No newline at end of file
diff --git a/src/fieldSources/basicSource/interRegionHeatTransferModel/tabulatedHeatTransfer/tabulatedHeatTransfer.H b/src/fieldSources/basicSource/interRegionHeatTransferModel/tabulatedHeatTransfer/tabulatedHeatTransfer.H
new file mode 100644
index 0000000000..e5c37fdf3b
--- /dev/null
+++ b/src/fieldSources/basicSource/interRegionHeatTransferModel/tabulatedHeatTransfer/tabulatedHeatTransfer.H
@@ -0,0 +1,112 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::tabulatedHeatTransfer
+
+Description
+    Tabulated heat transfer model. The heat exchange area must be
+    provided. The 2D table look for heat transfer coefficients uses the
+    primary and secondary region velocities
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef tabulatedHeatTransfer_H
+#define tabulatedHeatTransfer_H
+
+#include "interRegionHeatTransferModel.H"
+#include "autoPtr.H"
+#include "interpolation2DTable.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+/*---------------------------------------------------------------------------*\
+                    Class tabulatedHeatTransfer Declaration
+\*---------------------------------------------------------------------------*/
+
+class tabulatedHeatTransfer
+:
+    public interRegionHeatTransferModel
+{
+private:
+
+    // Private data
+
+        //- 2D look up table
+        autoPtr<interpolation2DTable<scalar> > hTable_;
+
+        //- Area of heat exchange
+        autoPtr<volScalarField> area_;
+
+
+public:
+
+    //- Runtime type information
+        TypeName("tabulatedHeatTransfer");
+
+
+    // Constructors
+
+        //- Construct from dictionary
+        tabulatedHeatTransfer
+        (
+            const word& name,
+            const word& modelType,
+            const dictionary& dict,
+            const fvMesh& mesh
+        );
+
+
+    //- Destructor
+    virtual ~tabulatedHeatTransfer();
+
+
+    // Public Functions
+
+        //- Calculate the heat transfer coefficient
+        virtual const tmp<volScalarField> calculateHtc();
+
+
+        // I-O
+
+            //- Write data
+            virtual void writeData(Ostream&) const;
+
+            //- Read dictionary
+            virtual bool read(const dictionary& dict) ;
+
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/fieldSources/basicSource/interRegionHeatTransferModel/variableHeatTransfer/variableHeatTransfer.C b/src/fieldSources/basicSource/interRegionHeatTransferModel/variableHeatTransfer/variableHeatTransfer.C
new file mode 100644
index 0000000000..bce2c5a66a
--- /dev/null
+++ b/src/fieldSources/basicSource/interRegionHeatTransferModel/variableHeatTransfer/variableHeatTransfer.C
@@ -0,0 +1,187 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "variableHeatTransfer.H"
+#include "IObasicSourceList.H"
+#include "turbulenceModel.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(variableHeatTransfer, 0);
+    addToRunTimeSelectionTable
+    (
+        basicSource,
+        variableHeatTransfer,
+        dictionary
+    );
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::variableHeatTransfer::variableHeatTransfer
+(
+    const word& name,
+    const word& modelType,
+    const dictionary& dict,
+    const fvMesh& mesh
+)
+:
+    interRegionHeatTransferModel(name, modelType, dict, mesh),
+    a_(0),
+    b_(0),
+    c_(0),
+    ds_(0),
+    Pr_(0),
+    area_()
+{
+    if (master_)
+    {
+        a_ = readScalar(dict_.lookup("a"));
+        b_ = readScalar(dict_.lookup("b"));
+        c_ = readScalar(dict_.lookup("c"));
+        ds_ = readScalar(dict_.lookup("ds"));
+        Pr_ = readScalar(dict_.lookup("Pr"));
+        area_.reset
+        (
+            new volScalarField
+            (
+                IOobject
+                (
+                    "area",
+                    mesh_.time().timeName(),
+                    mesh_,
+                    IOobject::MUST_READ,
+                    IOobject::AUTO_WRITE
+                ),
+                mesh_
+            )
+        );
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::variableHeatTransfer::~variableHeatTransfer()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+
+const Foam::tmp<Foam::volScalarField> Foam::variableHeatTransfer::
+calculateHtc()
+{
+
+    const fvMesh& secondaryMesh =
+        mesh_.time().lookupObject<fvMesh>(mapRegionName());
+
+    const compressible::turbulenceModel& turb =
+        secondaryMesh.lookupObject<compressible::turbulenceModel>
+        (
+            "turbulenceModel"
+        );
+
+    const basicThermo& secondaryThermo =
+        secondaryMesh.lookupObject<basicThermo>
+        (
+            "thermophysicalProperties"
+        );
+
+    const volVectorField& U =
+        secondaryMesh.lookupObject<volVectorField>("U");
+
+    const volScalarField Re
+    (
+        mag(U)*ds_*secondaryThermo.rho()/turb.mut()
+    );
+
+    const volScalarField Nu(a_*pow(Re, b_)*pow(Pr_, c_));
+
+    const volScalarField K(turb.alphaEff()*secondaryThermo.Cp());
+
+    scalarField htcMapped(htc_.internalField().size(), 0.0);
+
+    secondaryToPrimaryInterpPtr_->interpolateInternalField
+    (
+        htcMapped,
+        Nu*K/ds_,
+        meshToMesh::MAP,
+        eqOp<scalar>()
+    );
+
+    htc_.internalField() = htcMapped*area_/mesh_.V();
+
+    return htc_;
+}
+
+
+void Foam::variableHeatTransfer::writeData(Ostream& os) const
+{
+    os  << indent << token::BEGIN_BLOCK << incrIndent << nl;
+    interRegionHeatTransferModel::writeData(os);
+
+    os.writeKeyword("a") << a_ << token::END_STATEMENT << nl;
+    os.writeKeyword("b") << b_ << token::END_STATEMENT << nl;
+    os.writeKeyword("c") << c_ << token::END_STATEMENT << nl;
+    os.writeKeyword("ds") << ds_ << token::END_STATEMENT << nl;
+    os.writeKeyword("Pr") << Pr_ << token::END_STATEMENT << nl;
+
+    os << indent << "variableHeatTransfer";
+
+    dict_.write(os);
+
+    os << decrIndent << indent << token::END_BLOCK << endl;
+}
+
+
+bool Foam::variableHeatTransfer::read(const dictionary& dict)
+{
+    if (basicSource::read(dict))
+    {
+
+        const dictionary& sourceDict = dict.subDict(name());
+        const dictionary& subDictCoeffs =
+            sourceDict.subDict(typeName + "Coeffs");
+        subDictCoeffs.readIfPresent("a", a_);
+        subDictCoeffs.readIfPresent("b", b_);
+        subDictCoeffs.readIfPresent("c", c_);
+        subDictCoeffs.readIfPresent("ds", ds_);
+        subDictCoeffs.readIfPresent("Pr", Pr_);
+
+        return true;
+    }
+    else
+    {
+        return false;
+    }
+}
+
+
+// ************************************************************************* //
\ No newline at end of file
diff --git a/src/fieldSources/basicSource/interRegionHeatTransferModel/variableHeatTransfer/variableHeatTransfer.H b/src/fieldSources/basicSource/interRegionHeatTransferModel/variableHeatTransfer/variableHeatTransfer.H
new file mode 100644
index 0000000000..1d8f25caad
--- /dev/null
+++ b/src/fieldSources/basicSource/interRegionHeatTransferModel/variableHeatTransfer/variableHeatTransfer.H
@@ -0,0 +1,128 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::variableHeatTransfer
+
+Description
+    Variable heat transfer model depending on local values. The area of contact
+    between regions (area) must be provided. The Nu number is calculated as:
+
+        Nu = a*pow(Re, b)*pow(Pr, c)
+
+        and the heat transfer coefficient as:
+
+        htc = Nu*K/ds
+
+        where:
+            K is the heat conduction
+            ds is the strut diameter
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef variableHeatTransfer_H
+#define variableHeatTransfer_H
+
+#include "interRegionHeatTransferModel.H"
+#include "autoPtr.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+/*---------------------------------------------------------------------------*\
+                        Class variableHeatTransfer Declaration
+\*---------------------------------------------------------------------------*/
+
+class variableHeatTransfer
+:
+    public interRegionHeatTransferModel
+{
+private:
+
+    // Private data
+
+        //- Model constants
+        scalar a_;
+        scalar b_;
+        scalar c_;
+
+        //- Strut diameter
+        scalar ds_;
+
+        //- Fluid Prandt number
+        scalar Pr_;
+
+        //- Area of heat exchange
+        autoPtr<volScalarField> area_;
+
+
+public:
+
+    //- Runtime type information
+        TypeName("variableHeatTransfer");
+
+
+    // Constructors
+
+        //- Construct from dictionary
+        variableHeatTransfer
+        (
+            const word& name,
+            const word& modelType,
+            const dictionary& dict,
+            const fvMesh& mesh
+        );
+
+
+    //- Destructor
+    virtual ~variableHeatTransfer();
+
+
+    // Public Functions
+
+        //- Calculate the heat transfer coefficient
+        virtual const tmp<volScalarField> calculateHtc();
+
+
+        // I-O
+
+            //- Write data
+            virtual void writeData(Ostream&) const;
+
+            //- Read dictionary
+            virtual bool read(const dictionary& dict) ;
+
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/finiteVolume/cfdTools/general/fieldSources/basicSource/pressureGradientExplicitSource/pressureGradientExplicitSource.C b/src/fieldSources/basicSource/pressureGradientExplicitSource/pressureGradientExplicitSource.C
similarity index 100%
rename from src/finiteVolume/cfdTools/general/fieldSources/basicSource/pressureGradientExplicitSource/pressureGradientExplicitSource.C
rename to src/fieldSources/basicSource/pressureGradientExplicitSource/pressureGradientExplicitSource.C
diff --git a/src/finiteVolume/cfdTools/general/fieldSources/basicSource/pressureGradientExplicitSource/pressureGradientExplicitSource.H b/src/fieldSources/basicSource/pressureGradientExplicitSource/pressureGradientExplicitSource.H
similarity index 100%
rename from src/finiteVolume/cfdTools/general/fieldSources/basicSource/pressureGradientExplicitSource/pressureGradientExplicitSource.H
rename to src/fieldSources/basicSource/pressureGradientExplicitSource/pressureGradientExplicitSource.H
diff --git a/src/finiteVolume/cfdTools/general/fieldSources/basicSource/pressureGradientExplicitSource/pressureGradientExplicitSourceIO.C b/src/fieldSources/basicSource/pressureGradientExplicitSource/pressureGradientExplicitSourceIO.C
similarity index 100%
rename from src/finiteVolume/cfdTools/general/fieldSources/basicSource/pressureGradientExplicitSource/pressureGradientExplicitSourceIO.C
rename to src/fieldSources/basicSource/pressureGradientExplicitSource/pressureGradientExplicitSourceIO.C
diff --git a/src/finiteVolume/cfdTools/general/fieldSources/basicSource/radialActuationDiskSource/radialActuationDiskSource.C b/src/fieldSources/basicSource/radialActuationDiskSource/radialActuationDiskSource.C
similarity index 100%
rename from src/finiteVolume/cfdTools/general/fieldSources/basicSource/radialActuationDiskSource/radialActuationDiskSource.C
rename to src/fieldSources/basicSource/radialActuationDiskSource/radialActuationDiskSource.C
diff --git a/src/finiteVolume/cfdTools/general/fieldSources/basicSource/radialActuationDiskSource/radialActuationDiskSource.H b/src/fieldSources/basicSource/radialActuationDiskSource/radialActuationDiskSource.H
similarity index 100%
rename from src/finiteVolume/cfdTools/general/fieldSources/basicSource/radialActuationDiskSource/radialActuationDiskSource.H
rename to src/fieldSources/basicSource/radialActuationDiskSource/radialActuationDiskSource.H
diff --git a/src/finiteVolume/cfdTools/general/fieldSources/basicSource/radialActuationDiskSource/radialActuationDiskSourceTemplates.C b/src/fieldSources/basicSource/radialActuationDiskSource/radialActuationDiskSourceTemplates.C
similarity index 100%
rename from src/finiteVolume/cfdTools/general/fieldSources/basicSource/radialActuationDiskSource/radialActuationDiskSourceTemplates.C
rename to src/fieldSources/basicSource/radialActuationDiskSource/radialActuationDiskSourceTemplates.C
diff --git a/src/finiteVolume/cfdTools/general/fieldSources/basicSource/rotorDiskSource/bladeModel/bladeModel.C b/src/fieldSources/basicSource/rotorDiskSource/bladeModel/bladeModel.C
similarity index 100%
rename from src/finiteVolume/cfdTools/general/fieldSources/basicSource/rotorDiskSource/bladeModel/bladeModel.C
rename to src/fieldSources/basicSource/rotorDiskSource/bladeModel/bladeModel.C
diff --git a/src/finiteVolume/cfdTools/general/fieldSources/basicSource/rotorDiskSource/bladeModel/bladeModel.H b/src/fieldSources/basicSource/rotorDiskSource/bladeModel/bladeModel.H
similarity index 100%
rename from src/finiteVolume/cfdTools/general/fieldSources/basicSource/rotorDiskSource/bladeModel/bladeModel.H
rename to src/fieldSources/basicSource/rotorDiskSource/bladeModel/bladeModel.H
diff --git a/src/finiteVolume/cfdTools/general/fieldSources/basicSource/rotorDiskSource/profileModel/lookup/lookupProfile.C b/src/fieldSources/basicSource/rotorDiskSource/profileModel/lookup/lookupProfile.C
similarity index 100%
rename from src/finiteVolume/cfdTools/general/fieldSources/basicSource/rotorDiskSource/profileModel/lookup/lookupProfile.C
rename to src/fieldSources/basicSource/rotorDiskSource/profileModel/lookup/lookupProfile.C
diff --git a/src/finiteVolume/cfdTools/general/fieldSources/basicSource/rotorDiskSource/profileModel/lookup/lookupProfile.H b/src/fieldSources/basicSource/rotorDiskSource/profileModel/lookup/lookupProfile.H
similarity index 100%
rename from src/finiteVolume/cfdTools/general/fieldSources/basicSource/rotorDiskSource/profileModel/lookup/lookupProfile.H
rename to src/fieldSources/basicSource/rotorDiskSource/profileModel/lookup/lookupProfile.H
diff --git a/src/finiteVolume/cfdTools/general/fieldSources/basicSource/rotorDiskSource/profileModel/profileModel.C b/src/fieldSources/basicSource/rotorDiskSource/profileModel/profileModel.C
similarity index 100%
rename from src/finiteVolume/cfdTools/general/fieldSources/basicSource/rotorDiskSource/profileModel/profileModel.C
rename to src/fieldSources/basicSource/rotorDiskSource/profileModel/profileModel.C
diff --git a/src/finiteVolume/cfdTools/general/fieldSources/basicSource/rotorDiskSource/profileModel/profileModel.H b/src/fieldSources/basicSource/rotorDiskSource/profileModel/profileModel.H
similarity index 100%
rename from src/finiteVolume/cfdTools/general/fieldSources/basicSource/rotorDiskSource/profileModel/profileModel.H
rename to src/fieldSources/basicSource/rotorDiskSource/profileModel/profileModel.H
diff --git a/src/finiteVolume/cfdTools/general/fieldSources/basicSource/rotorDiskSource/profileModel/profileModelList.C b/src/fieldSources/basicSource/rotorDiskSource/profileModel/profileModelList.C
similarity index 100%
rename from src/finiteVolume/cfdTools/general/fieldSources/basicSource/rotorDiskSource/profileModel/profileModelList.C
rename to src/fieldSources/basicSource/rotorDiskSource/profileModel/profileModelList.C
diff --git a/src/finiteVolume/cfdTools/general/fieldSources/basicSource/rotorDiskSource/profileModel/profileModelList.H b/src/fieldSources/basicSource/rotorDiskSource/profileModel/profileModelList.H
similarity index 100%
rename from src/finiteVolume/cfdTools/general/fieldSources/basicSource/rotorDiskSource/profileModel/profileModelList.H
rename to src/fieldSources/basicSource/rotorDiskSource/profileModel/profileModelList.H
diff --git a/src/finiteVolume/cfdTools/general/fieldSources/basicSource/rotorDiskSource/profileModel/series/seriesProfile.C b/src/fieldSources/basicSource/rotorDiskSource/profileModel/series/seriesProfile.C
similarity index 100%
rename from src/finiteVolume/cfdTools/general/fieldSources/basicSource/rotorDiskSource/profileModel/series/seriesProfile.C
rename to src/fieldSources/basicSource/rotorDiskSource/profileModel/series/seriesProfile.C
diff --git a/src/finiteVolume/cfdTools/general/fieldSources/basicSource/rotorDiskSource/profileModel/series/seriesProfile.H b/src/fieldSources/basicSource/rotorDiskSource/profileModel/series/seriesProfile.H
similarity index 100%
rename from src/finiteVolume/cfdTools/general/fieldSources/basicSource/rotorDiskSource/profileModel/series/seriesProfile.H
rename to src/fieldSources/basicSource/rotorDiskSource/profileModel/series/seriesProfile.H
diff --git a/src/finiteVolume/cfdTools/general/fieldSources/basicSource/rotorDiskSource/rotorDiskSource.C b/src/fieldSources/basicSource/rotorDiskSource/rotorDiskSource.C
similarity index 100%
rename from src/finiteVolume/cfdTools/general/fieldSources/basicSource/rotorDiskSource/rotorDiskSource.C
rename to src/fieldSources/basicSource/rotorDiskSource/rotorDiskSource.C
diff --git a/src/finiteVolume/cfdTools/general/fieldSources/basicSource/rotorDiskSource/rotorDiskSource.H b/src/fieldSources/basicSource/rotorDiskSource/rotorDiskSource.H
similarity index 100%
rename from src/finiteVolume/cfdTools/general/fieldSources/basicSource/rotorDiskSource/rotorDiskSource.H
rename to src/fieldSources/basicSource/rotorDiskSource/rotorDiskSource.H
diff --git a/src/finiteVolume/cfdTools/general/fieldSources/basicSource/rotorDiskSource/rotorDiskSourceTemplates.C b/src/fieldSources/basicSource/rotorDiskSource/rotorDiskSourceTemplates.C
similarity index 100%
rename from src/finiteVolume/cfdTools/general/fieldSources/basicSource/rotorDiskSource/rotorDiskSourceTemplates.C
rename to src/fieldSources/basicSource/rotorDiskSource/rotorDiskSourceTemplates.C
diff --git a/src/finiteVolume/Make/files b/src/finiteVolume/Make/files
index f887555f19..2d4930f385 100644
--- a/src/finiteVolume/Make/files
+++ b/src/finiteVolume/Make/files
@@ -378,26 +378,5 @@ $(SRF)/SRFModel/rpm/rpm.C
 $(SRF)/derivedFvPatchFields/SRFVelocityFvPatchVectorField/SRFVelocityFvPatchVectorField.C
 $(SRF)/derivedFvPatchFields/SRFFreestreamVelocityFvPatchVectorField/SRFFreestreamVelocityFvPatchVectorField.C
 
-basicSource = $(general)/fieldSources/basicSource
-$(basicSource)/basicSource/basicSource.C
-$(basicSource)/basicSource/basicSourceIO.C
-$(basicSource)/basicSource/basicSourceList.C
-$(basicSource)/basicSource/IObasicSourceList.C
-
-$(basicSource)/pressureGradientExplicitSource/pressureGradientExplicitSource.C
-$(basicSource)/pressureGradientExplicitSource/pressureGradientExplicitSourceIO.C
-
-$(basicSource)/explicitSource/explicitSource.C
-$(basicSource)/explicitSetValue/explicitSetValue.C
-
-$(basicSource)/rotorDiskSource/rotorDiskSource.C
-$(basicSource)/rotorDiskSource/bladeModel/bladeModel.C
-$(basicSource)/rotorDiskSource/profileModel/profileModel.C
-$(basicSource)/rotorDiskSource/profileModel/profileModelList.C
-$(basicSource)/rotorDiskSource/profileModel/lookup/lookupProfile.C
-$(basicSource)/rotorDiskSource/profileModel/series/seriesProfile.C
-
-$(basicSource)/actuationDiskSource/actuationDiskSource.C
-$(basicSource)/radialActuationDiskSource/radialActuationDiskSource.C
 
 LIB = $(FOAM_LIBBIN)/libfiniteVolume
diff --git a/src/finiteVolume/fvMesh/fvPatches/constraint/cyclicAMI/cyclicAMIFvPatch.C b/src/finiteVolume/fvMesh/fvPatches/constraint/cyclicAMI/cyclicAMIFvPatch.C
index 9717c96e6c..7b11172119 100644
--- a/src/finiteVolume/fvMesh/fvPatches/constraint/cyclicAMI/cyclicAMIFvPatch.C
+++ b/src/finiteVolume/fvMesh/fvPatches/constraint/cyclicAMI/cyclicAMIFvPatch.C
@@ -75,8 +75,8 @@ Foam::tmp<Foam::vectorField> Foam::cyclicAMIFvPatch::delta() const
     {
         forAll(patchD, faceI)
         {
-            vector ddi = patchD[faceI];
-            vector dni = nbrPatchD[faceI];
+            const vector& ddi = patchD[faceI];
+            const vector& dni = nbrPatchD[faceI];
 
             pdv[faceI] = ddi - dni;
         }
@@ -85,8 +85,8 @@ Foam::tmp<Foam::vectorField> Foam::cyclicAMIFvPatch::delta() const
     {
         forAll(patchD, faceI)
         {
-            vector ddi = patchD[faceI];
-            vector dni = nbrPatchD[faceI];
+            const vector& ddi = patchD[faceI];
+            const vector& dni = nbrPatchD[faceI];
 
             pdv[faceI] = ddi - transform(forwardT()[0], dni);
         }
diff --git a/src/lagrangian/intermediate/submodels/Reacting/PhaseChangeModel/LiquidEvaporation/LiquidEvaporation.C b/src/lagrangian/intermediate/submodels/Reacting/PhaseChangeModel/LiquidEvaporation/LiquidEvaporation.C
index d2825055ba..e5948b85a7 100644
--- a/src/lagrangian/intermediate/submodels/Reacting/PhaseChangeModel/LiquidEvaporation/LiquidEvaporation.C
+++ b/src/lagrangian/intermediate/submodels/Reacting/PhaseChangeModel/LiquidEvaporation/LiquidEvaporation.C
@@ -232,7 +232,7 @@ Foam::scalar Foam::LiquidEvaporation<CloudType>::dh
                     "const label, "
                     "const label, "
                     "const label"
-                ")"
+                ") const"
             )   << "Unknown enthalpyTransfer type" << abort(FatalError);
         }
     }
diff --git a/src/lagrangian/intermediate/submodels/Reacting/PhaseChangeModel/LiquidEvaporationBoil/LiquidEvaporationBoil.C b/src/lagrangian/intermediate/submodels/Reacting/PhaseChangeModel/LiquidEvaporationBoil/LiquidEvaporationBoil.C
index 651d95d1c6..643beb55e1 100644
--- a/src/lagrangian/intermediate/submodels/Reacting/PhaseChangeModel/LiquidEvaporationBoil/LiquidEvaporationBoil.C
+++ b/src/lagrangian/intermediate/submodels/Reacting/PhaseChangeModel/LiquidEvaporationBoil/LiquidEvaporationBoil.C
@@ -157,17 +157,23 @@ void Foam::LiquidEvaporationBoil<CloudType>::calculate
     // liquid volume fraction
     const scalarField X(liquids_.X(Yl));
 
-    // droplet surface pressure
-    scalar ps = liquids_.pv(pc, T, X);
+    // droplet surface pressure assumed to surface vapour pressure
+    scalar ps = liquids_.pv(pc, Ts, X);
 
     // vapour density at droplet surface [kg/m3]
     scalar rhos = ps*liquids_.W(X)/(specie::RR*Ts);
 
-    // thermal conductivity of carrier [W/m/K]
+    // carrier thermo properties
+    scalar Hsc = 0.0;
+    scalar Hc = 0.0;
+    scalar Cpc = 0.0;
     scalar kappac = 0.0;
     forAll(this->owner().thermo().carrier().Y(), i)
     {
-        const scalar Yc = this->owner().thermo().carrier().Y()[i][cellI];
+        scalar Yc = this->owner().thermo().carrier().Y()[i][cellI];
+        Hc += Yc*this->owner().thermo().carrier().H(i, Tc);
+        Hsc += Yc*this->owner().thermo().carrier().H(i, Ts);
+        Cpc += Yc*this->owner().thermo().carrier().Cp(i, Ts);
         kappac += Yc*this->owner().thermo().carrier().kappa(i, Ts);
     }
 
@@ -189,32 +195,77 @@ void Foam::LiquidEvaporationBoil<CloudType>::calculate
         // carrier phase concentration
         const scalar Xc = XcMix[gid];
 
+
         if (Xc*pc > pSat)
         {
             // saturated vapour - no phase change
         }
         else
         {
+            // vapour diffusivity [m2/s]
+            const scalar Dab = liquids_.properties()[lid].D(ps, Ts);
+
+            // Schmidt number
+            const scalar Sc = nu/(Dab + ROOTVSMALL);
+
+            // Sherwood number
+            const scalar Sh = this->Sh(Re, Sc);
+
+
             if (pSat > 0.999*pc)
             {
                 // boiling
 
-//                const scalar deltaT = max(Tc - Td, 0.5);
-                const scalar deltaT = max(Tc - T, 0.5);
+                const scalar deltaT = max(T - TBoil, 0.5);
 
-                // liquid specific heat capacity
-                const scalar Cp = liquids_.properties()[lid].Cp(pc, Td);
-
-                // vapour heat of fomation
+                // vapour heat of formation
                 const scalar hv = liquids_.properties()[lid].hl(pc, Td);
 
-                // Nusselt number
-                const scalar Nu = 2.0 + 0.6*sqrt(Re)*cbrt(Pr);
+                // empirical heat transfer coefficient W/m2/K
+                scalar alphaS = 0.0;
+                if (deltaT < 5.0)
+                {
+                    alphaS = 760.0*pow(deltaT, 0.26);
+                }
+                else if (deltaT < 25.0)
+                {
+                    alphaS = 27.0*pow(deltaT, 2.33);
+                }
+                else
+                {
+                    alphaS = 13800.0*pow(deltaT, 0.39);
+                }
 
-                const scalar lg = log(1.0 + Cp*deltaT/max(SMALL, hv));
+                // flash-boil vaporisation rate
+                const scalar Gf = alphaS*deltaT*pi*sqr(d)/hv;
 
-                // mass transfer [kg]
-                dMassPC[lid] += pi*kappac*Nu*lg*d/Cp*dt;
+                // model constants
+                // NOTE: using Sherwood number instead of Nusselt number
+                const scalar A = (Hc - Hsc)/hv;
+                const scalar B = pi*kappac/Cpc*d*Sh;
+
+                scalar G = 0.0;
+                if (A > 0.0)
+                {
+                    // heat transfer from the surroundings contributes
+                    // to the vaporisation process
+                    scalar Gr = 1e-5;
+
+                    for (label i=0; i<50; i++)
+                    {
+                        scalar GrDash = Gr;
+
+                        G = B/(1.0 + Gr)*log(1.0 + A*(1.0 + Gr));
+                        Gr = Gf/G;
+
+                        if (mag(Gr - GrDash)/GrDash < 1e-3)
+                        {
+                            break;
+                        }
+                    }
+                }
+
+                dMassPC[lid] += (G + Gf)*dt;
             }
             else
             {
@@ -226,23 +277,10 @@ void Foam::LiquidEvaporationBoil<CloudType>::calculate
                 // molar ratio
                 const scalar Xr = (Xs - Xc)/max(SMALL, 1.0 - Xs);
 
-
                 if (Xr > 0)
                 {
-                    // vapour diffusivity [m2/s]
-                    const scalar Dab = liquids_.properties()[lid].D(pc, Td);
-
-                    // Schmidt number
-                    const scalar Sc = nu/(Dab + ROOTVSMALL);
-
-                    // Sherwood number
-                    const scalar Sh = this->Sh(Re, Sc);
-
-                    // mass transfer coefficient [m/s]
-                    const scalar kc = Sh*Dab/(d + ROOTVSMALL);
-
                     // mass transfer [kg]
-                    dMassPC[lid] += pi*sqr(d)*kc*rhos*log(1.0 + Xr)*dt;
+                    dMassPC[lid] += pi*d*Sh*Dab*rhos*log(1.0 + Xr)*dt;
                 }
             }
         }
@@ -261,18 +299,24 @@ Foam::scalar Foam::LiquidEvaporationBoil<CloudType>::dh
 {
     scalar dh = 0;
 
+    scalar TDash = T;
+    if (liquids_.properties()[idl].pv(p, T) >= 0.999*p)
+    {
+        TDash = liquids_.properties()[idl].pvInvert(p);
+    }
+
     typedef PhaseChangeModel<CloudType> parent;
     switch (parent::enthalpyTransfer_)
     {
         case (parent::etLatentHeat):
         {
-            dh = liquids_.properties()[idl].hl(p, T);
+            dh = liquids_.properties()[idl].hl(p, TDash);
             break;
         }
         case (parent::etEnthalpyDifference):
         {
-            scalar hc = this->owner().composition().carrier().H(idc, T);
-            scalar hp = liquids_.properties()[idl].h(p, T);
+            scalar hc = this->owner().composition().carrier().H(idc, TDash);
+            scalar hp = liquids_.properties()[idl].h(p, TDash);
 
             dh = hc - hp;
             break;
@@ -287,7 +331,7 @@ Foam::scalar Foam::LiquidEvaporationBoil<CloudType>::dh
                     "const label, "
                     "const label, "
                     "const label"
-                ")"
+                ") const"
             )   << "Unknown enthalpyTransfer type" << abort(FatalError);
         }
     }
diff --git a/src/lagrangian/intermediate/submodels/Reacting/PhaseChangeModel/LiquidEvaporationBoil/LiquidEvaporationBoil.H b/src/lagrangian/intermediate/submodels/Reacting/PhaseChangeModel/LiquidEvaporationBoil/LiquidEvaporationBoil.H
index f16ea47be9..48d92292cd 100644
--- a/src/lagrangian/intermediate/submodels/Reacting/PhaseChangeModel/LiquidEvaporationBoil/LiquidEvaporationBoil.H
+++ b/src/lagrangian/intermediate/submodels/Reacting/PhaseChangeModel/LiquidEvaporationBoil/LiquidEvaporationBoil.H
@@ -27,7 +27,16 @@ Class
 Description
     Liquid evaporation model
     - uses ideal gas assumption
-    - includes boiling model
+    - includes boiling model based on:
+
+    \verbatim
+        "Studies of Superheated Fuel Spray Structures and Vaporization in
+        GDI Engines"
+
+        Zuo, B., Gomes, A. M. and Rutland C. J.
+
+        International Journal of Engine Research, 2000, Vol. 1(4), pp. 321-336
+    \endverbatim
 
 \*---------------------------------------------------------------------------*/
 
diff --git a/src/lagrangian/spray/submodels/BreakupModel/PilchErdman/PilchErdman.C b/src/lagrangian/spray/submodels/BreakupModel/PilchErdman/PilchErdman.C
index bb4477a83b..d900260410 100644
--- a/src/lagrangian/spray/submodels/BreakupModel/PilchErdman/PilchErdman.C
+++ b/src/lagrangian/spray/submodels/BreakupModel/PilchErdman/PilchErdman.C
@@ -101,25 +101,28 @@ bool Foam::PilchErdman<CloudType>::update
         // We > 1335, wave crest stripping
         scalar taubBar = 5.5;
 
-        if (We > 175.0)
+        if (We < 1335)
         {
-            // sheet stripping
-            taubBar = 0.766*pow(2.0*We - 12.0, 0.25);
-        }
-        else if (We > 22.0)
-        {
-            // Bag-and-stamen breakup
-            taubBar = 14.1*pow(2.0*We - 12.0, -0.25);
-        }
-        else if (We > 9.0)
-        {
-            // Bag breakup
-            taubBar = 2.45*pow(2.0*We - 12.0, 0.25);
-        }
-        else if (We > 6.0)
-        {
-            // Vibrational breakup
-            taubBar = 6.0*pow(2.0*We - 12.0, -0.25);
+            if (We > 175.0)
+            {
+                // sheet stripping
+                taubBar = 0.766*pow(2.0*We - 12.0, 0.25);
+            }
+            else if (We > 22.0)
+            {
+                // Bag-and-stamen breakup
+                taubBar = 14.1*pow(2.0*We - 12.0, -0.25);
+            }
+            else if (We > 9.0)
+            {
+                // Bag breakup
+                taubBar = 2.45*pow(2.0*We - 12.0, 0.25);
+            }
+            else if (We > 6.0)
+            {
+                // Vibrational breakup
+                taubBar = 6.0*pow(2.0*We - 12.0, -0.25);
+            }
         }
 
         scalar rho12 = sqrt(rhoc/rho);
diff --git a/src/regionModels/regionModel/Make/files b/src/regionModels/regionModel/Make/files
index 570b357b11..ab18530890 100644
--- a/src/regionModels/regionModel/Make/files
+++ b/src/regionModels/regionModel/Make/files
@@ -6,4 +6,6 @@ regionModel1D/regionModel1D.C
 /* Boundary conditions */
 derivedFvPatches/mappedVariableThicknessWall/mappedVariableThicknessWallFvPatch.C
 
+regionProperties/regionProperties.C
+
 LIB = $(FOAM_LIBBIN)/libregionModels
diff --git a/src/turbulenceModels/compressible/turbulenceModel/derivedFvPatchFields/turbulentTemperatureCoupledBaffle/regionProperties.C b/src/regionModels/regionModel/regionProperties/regionProperties.C
similarity index 70%
rename from src/turbulenceModels/compressible/turbulenceModel/derivedFvPatchFields/turbulentTemperatureCoupledBaffle/regionProperties.C
rename to src/regionModels/regionModel/regionProperties/regionProperties.C
index 7b3923139b..c2cd718cce 100644
--- a/src/turbulenceModels/compressible/turbulenceModel/derivedFvPatchFields/turbulentTemperatureCoupledBaffle/regionProperties.C
+++ b/src/regionModels/regionModel/regionProperties/regionProperties.C
@@ -24,24 +24,26 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "regionProperties.H"
+#include "IOdictionary.H"
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
 Foam::regionProperties::regionProperties(const Time& runTime)
 :
-    IOdictionary
+    HashTable<wordList>
     (
-        IOobject
+        IOdictionary
         (
-            "regionProperties",
-            runTime.time().constant(),
-            runTime.db(),
-            IOobject::MUST_READ_IF_MODIFIED,
-            IOobject::NO_WRITE
-        )
-    ),
-    fluidRegionNames_(lookup("fluidRegionNames")),
-    solidRegionNames_(lookup("solidRegionNames"))
+            IOobject
+            (
+                "regionProperties",
+                runTime.time().constant(),
+                runTime.db(),
+                IOobject::MUST_READ_IF_MODIFIED,
+                IOobject::NO_WRITE
+            )
+        ).lookup("regions")
+    )
 {}
 
 
@@ -50,19 +52,4 @@ Foam::regionProperties::regionProperties(const Time& runTime)
 Foam::regionProperties::~regionProperties()
 {}
 
-
-// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
-
-const Foam::List<Foam::word>& Foam::regionProperties::fluidRegionNames() const
-{
-    return fluidRegionNames_;
-}
-
-
-const Foam::List<Foam::word>& Foam::regionProperties::solidRegionNames() const
-{
-    return solidRegionNames_;
-}
-
-
 // ************************************************************************* //
diff --git a/src/turbulenceModels/compressible/turbulenceModel/derivedFvPatchFields/turbulentTemperatureCoupledBaffle/regionProperties.H b/src/regionModels/regionModel/regionProperties/regionProperties.H
similarity index 80%
rename from src/turbulenceModels/compressible/turbulenceModel/derivedFvPatchFields/turbulentTemperatureCoupledBaffle/regionProperties.H
rename to src/regionModels/regionModel/regionProperties/regionProperties.H
index 1c0f73a015..796b0f6405 100644
--- a/src/turbulenceModels/compressible/turbulenceModel/derivedFvPatchFields/turbulentTemperatureCoupledBaffle/regionProperties.H
+++ b/src/regionModels/regionModel/regionProperties/regionProperties.H
@@ -35,8 +35,8 @@ SourceFiles
 #ifndef regionProperties_H
 #define regionProperties_H
 
-#include "IOdictionary.H"
 #include "Time.H"
+#include "HashTable.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -49,18 +49,8 @@ namespace Foam
 
 class regionProperties
 :
-    public IOdictionary
+    public HashTable<wordList>
 {
-    // Private data
-
-        //- List of the fluid region names
-        List<word> fluidRegionNames_;
-
-        //- List of the solid region names
-        List<word> solidRegionNames_;
-
-
-    // Private Member Functions
 
         //- Disallow default bitwise copy construct
         regionProperties(const regionProperties&);
@@ -68,7 +58,6 @@ class regionProperties
         //- Disallow default bitwise assignment
         void operator=(const regionProperties&);
 
-
 public:
 
     // Constructors
@@ -80,16 +69,6 @@ public:
     //- Destructor
     ~regionProperties();
 
-
-    // Member Functions
-
-        // Access
-
-            //- Return const reference to the list of fluid region names
-            const List<word>& fluidRegionNames() const;
-
-            //- Return const reference to the list of solid region names
-            const List<word>& solidRegionNames() const;
 };
 
 
diff --git a/src/sampling/Make/files b/src/sampling/Make/files
index 0c89693a8e..17099071a5 100644
--- a/src/sampling/Make/files
+++ b/src/sampling/Make/files
@@ -69,4 +69,8 @@ $(meshToMesh)/meshToMesh.C
 $(meshToMesh)/calculateMeshToMeshAddressing.C
 $(meshToMesh)/calculateMeshToMeshWeights.C
 
+tetOverlapVolume = meshToMeshInterpolation/tetOverlapVolume
+$(tetOverlapVolume)/tetOverlapVolume.C
+
+
 LIB = $(FOAM_LIBBIN)/libsampling
diff --git a/src/sampling/meshToMeshInterpolation/meshToMesh/calculateMeshToMeshWeights.C b/src/sampling/meshToMeshInterpolation/meshToMesh/calculateMeshToMeshWeights.C
index 532fee3f85..c3db6586ad 100644
--- a/src/sampling/meshToMeshInterpolation/meshToMesh/calculateMeshToMeshWeights.C
+++ b/src/sampling/meshToMeshInterpolation/meshToMesh/calculateMeshToMeshWeights.C
@@ -24,6 +24,7 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "meshToMesh.H"
+#include "tetOverlapVolume.H"
 
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 
@@ -99,6 +100,108 @@ void Foam::meshToMesh::calculateInverseDistanceWeights() const
 }
 
 
+void Foam::meshToMesh::calculateInverseVolumeWeights() const
+{
+    if (debug)
+    {
+        Info<< "meshToMesh::calculateInverseVolumeWeights() : "
+            << "calculating inverse volume weighting factors" << endl;
+    }
+
+    if (inverseVolumeWeightsPtr_)
+    {
+        FatalErrorIn("meshToMesh::calculateInverseVolumeWeights()")
+            << "weighting factors already calculated"
+            << exit(FatalError);
+    }
+
+    inverseVolumeWeightsPtr_ = new scalarListList(toMesh_.nCells());
+    scalarListList& invVolCoeffs = *inverseVolumeWeightsPtr_;
+
+    labelListList& cellToCell = *cellToCellAddressingPtr_;
+
+    tetOverlapVolume overlapEngine;
+
+    forAll(cellToCell, celli)
+    {
+        const labelList& overlapCells = cellToCell[celli];
+
+        if (overlapCells.size() > 0)
+        {
+            invVolCoeffs[celli].setSize(overlapCells.size());
+            scalar v(0);
+            forAll (overlapCells, j)
+            {
+                label cellFrom = overlapCells[j];
+                treeBoundBox bbFromMesh
+                (
+                    pointField
+                    (
+                        fromMesh_.points(),
+                        fromMesh_.cellPoints()[cellFrom]
+                    )
+                );
+
+                v = overlapEngine.cellCellOverlapVolumeMinDecomp
+                (
+                    toMesh_,
+                    celli,
+
+                    fromMesh_,
+                    cellFrom,
+                    bbFromMesh
+                );
+                invVolCoeffs[celli][j] =  v/toMesh_.V()[celli];
+            }
+            if (celli == 2)
+            {
+                Info << "cellToCell :" << cellToCell[celli] << endl;
+                Info << "invVolCoeffs :" << invVolCoeffs[celli] << endl;
+            }
+        }
+    }
+}
+
+
+void  Foam::meshToMesh::calculateCellToCellAddressing() const
+{
+    if (debug)
+    {
+        Info<< "meshToMesh::calculateCellToCellAddressing() : "
+            << "calculating cell to cell addressing" << endl;
+    }
+
+    if (cellToCellAddressingPtr_)
+    {
+        FatalErrorIn("meshToMesh::calculateCellToCellAddressing()")
+            << "addressing already calculated"
+            << exit(FatalError);
+    }
+
+    tetOverlapVolume overlapEngine;
+
+    cellToCellAddressingPtr_ = new labelListList(toMesh_.nCells());
+    labelListList& cellToCell = *cellToCellAddressingPtr_;
+
+
+    forAll(cellToCell, iTo)
+    {
+        const labelList overLapCells =
+            overlapEngine.overlappingCells(fromMesh_, toMesh_, iTo);
+        if (overLapCells.size() > 0)
+        {
+            //Info << "To " << iTo << endl;
+            //Info << "cellToCell " << overLapCells << endl;
+
+            cellToCell[iTo].setSize(overLapCells.size());
+            forAll(overLapCells, j)
+            {
+                cellToCell[iTo][j] = overLapCells[j];
+            }
+        }
+    }
+}
+
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 const Foam::scalarListList& Foam::meshToMesh::inverseDistanceWeights() const
@@ -112,4 +215,24 @@ const Foam::scalarListList& Foam::meshToMesh::inverseDistanceWeights() const
 }
 
 
+const Foam::scalarListList& Foam::meshToMesh::inverseVolumeWeights() const
+{
+    if (!inverseVolumeWeightsPtr_)
+    {
+        calculateInverseVolumeWeights();
+    }
+
+    return *inverseVolumeWeightsPtr_;
+}
+
+const Foam::labelListList& Foam::meshToMesh::cellToCellAddressing() const
+{
+    if (!cellToCellAddressingPtr_)
+    {
+        calculateCellToCellAddressing();
+    }
+
+    return *cellToCellAddressingPtr_;
+}
+
 // ************************************************************************* //
diff --git a/src/sampling/meshToMeshInterpolation/meshToMesh/meshToMesh.C b/src/sampling/meshToMeshInterpolation/meshToMesh/meshToMesh.C
index c5f9587950..fa495c40ce 100644
--- a/src/sampling/meshToMeshInterpolation/meshToMesh/meshToMesh.C
+++ b/src/sampling/meshToMeshInterpolation/meshToMesh/meshToMesh.C
@@ -48,7 +48,9 @@ Foam::meshToMesh::meshToMesh
     patchMap_(patchMap),
     cellAddressing_(toMesh_.nCells()),
     boundaryAddressing_(toMesh_.boundaryMesh().size()),
-    inverseDistanceWeightsPtr_(NULL)
+    inverseDistanceWeightsPtr_(NULL),
+    inverseVolumeWeightsPtr_(NULL),
+    cellToCellAddressingPtr_(NULL)
 {
     forAll(fromMesh_.boundaryMesh(), patchi)
     {
@@ -118,7 +120,9 @@ Foam::meshToMesh::meshToMesh
     toMesh_(meshTo),
     cellAddressing_(toMesh_.nCells()),
     boundaryAddressing_(toMesh_.boundaryMesh().size()),
-    inverseDistanceWeightsPtr_(NULL)
+    inverseDistanceWeightsPtr_(NULL),
+    inverseVolumeWeightsPtr_(NULL),
+    cellToCellAddressingPtr_(NULL)
 {
     // check whether both meshes have got the same number
     // of boundary patches
@@ -198,6 +202,8 @@ Foam::meshToMesh::meshToMesh
 Foam::meshToMesh::~meshToMesh()
 {
     deleteDemandDrivenData(inverseDistanceWeightsPtr_);
+    deleteDemandDrivenData(inverseVolumeWeightsPtr_);
+    deleteDemandDrivenData(cellToCellAddressingPtr_);
 }
 
 
diff --git a/src/sampling/meshToMeshInterpolation/meshToMesh/meshToMesh.H b/src/sampling/meshToMeshInterpolation/meshToMesh/meshToMesh.H
index 83d1ee902a..e60871be25 100644
--- a/src/sampling/meshToMeshInterpolation/meshToMesh/meshToMesh.H
+++ b/src/sampling/meshToMeshInterpolation/meshToMesh/meshToMesh.H
@@ -88,6 +88,12 @@ class meshToMesh
         //- Inverse-distance interpolation weights
         mutable scalarListList* inverseDistanceWeightsPtr_;
 
+        //- Inverse-volume interpolation weights
+        mutable scalarListList* inverseVolumeWeightsPtr_;
+
+        //- Cell to cell overlap addressing
+        mutable labelListList* cellToCellAddressingPtr_;
+
 
     // Private Member Functions
 
@@ -104,8 +110,16 @@ class meshToMesh
 
         void calculateInverseDistanceWeights() const;
 
+        void calculateInverseVolumeWeights() const;
+
+        void calculateCellToCellAddressing() const;
+
         const scalarListList& inverseDistanceWeights() const;
 
+        const scalarListList& inverseVolumeWeights() const;
+
+        const labelListList& cellToCellAddressing() const;
+
 
     // Private static data members
 
@@ -124,7 +138,8 @@ public:
     {
         MAP,
         INTERPOLATE,
-        CELL_POINT_INTERPOLATE
+        CELL_POINT_INTERPOLATE,
+        CELL_VOLUME_WEIGHT
     };
 
 
@@ -239,6 +254,18 @@ public:
                 const CombineOp& cop
             ) const;
 
+            //- Interpolate field using inverse-volume weights
+            template<class Type, class CombineOp>
+            void interpolateField
+            (
+                Field<Type>&,
+                const GeometricField<Type, fvPatchField, volMesh>&,
+                const labelListList& adr,
+                const scalarListList& weights,
+                const CombineOp& cop
+            ) const;
+
+
             //- Interpolate field using cell-point interpolation
             template<class Type, class CombineOp>
             void interpolateField
diff --git a/src/sampling/meshToMeshInterpolation/meshToMesh/meshToMeshInterpolate.C b/src/sampling/meshToMeshInterpolation/meshToMesh/meshToMeshInterpolate.C
index 7ed543ed3c..372194e322 100644
--- a/src/sampling/meshToMeshInterpolation/meshToMesh/meshToMeshInterpolate.C
+++ b/src/sampling/meshToMeshInterpolation/meshToMesh/meshToMeshInterpolate.C
@@ -54,6 +54,33 @@ void Foam::meshToMesh::mapField
 }
 
 
+template<class Type, class CombineOp>
+void Foam::meshToMesh::interpolateField
+(
+    Field<Type>& toF,
+    const GeometricField<Type, fvPatchField, volMesh>& fromVf,
+    const labelListList& adr,
+    const scalarListList& weights,
+    const CombineOp& cop
+) const
+{
+    // Inverse volume weighted interpolation
+    forAll(toF, celli)
+    {
+        const labelList& overlapCells = adr[celli];
+        const scalarList& w = weights[celli];
+
+        Type f = pTraits<Type>::zero;
+        forAll(overlapCells, i)
+        {
+            label fromCelli = overlapCells[i];
+            f += fromVf[fromCelli]*w[i];
+            cop(toF[celli], f);
+        }
+    }
+}
+
+
 template<class Type, class CombineOp>
 void Foam::meshToMesh::interpolateField
 (
@@ -162,6 +189,7 @@ void Foam::meshToMesh::interpolateInternalField
         break;
 
         case INTERPOLATE:
+        {
             interpolateField
             (
                 toF,
@@ -170,9 +198,10 @@ void Foam::meshToMesh::interpolateInternalField
                 inverseDistanceWeights(),
                 cop
             );
-        break;
-
+            break;
+        }
         case CELL_POINT_INTERPOLATE:
+        {
             interpolateField
             (
                 toF,
@@ -181,8 +210,24 @@ void Foam::meshToMesh::interpolateInternalField
                 toMesh_.cellCentres(),
                 cop
             );
-        break;
 
+            break;
+        }
+        case CELL_VOLUME_WEIGHT:
+        {
+            const labelListList& cellToCell = cellToCellAddressing();
+            const scalarListList& invVolWeights = inverseVolumeWeights();
+
+            interpolateField
+            (
+                toF,
+                fromVf,
+                cellToCell,
+                invVolWeights,
+                cop
+            );
+            break;
+        }
         default:
             FatalErrorIn
             (
@@ -229,6 +274,7 @@ void Foam::meshToMesh::interpolate
             switch(ord)
             {
                 case MAP:
+                {
                     mapField
                     (
                         toVf.boundaryField()[patchi],
@@ -236,9 +282,11 @@ void Foam::meshToMesh::interpolate
                         boundaryAddressing_[patchi],
                         cop
                     );
-                break;
+                    break;
+                }
 
                 case INTERPOLATE:
+                {
                     interpolateField
                     (
                         toVf.boundaryField()[patchi],
@@ -247,9 +295,11 @@ void Foam::meshToMesh::interpolate
                         toPatch.Cf(),
                         cop
                     );
-                break;
+                    break;
+                }
 
                 case CELL_POINT_INTERPOLATE:
+                {
                     interpolateField
                     (
                         toVf.boundaryField()[patchi],
@@ -258,7 +308,13 @@ void Foam::meshToMesh::interpolate
                         toPatch.Cf(),
                         cop
                     );
-                break;
+                    break;
+                }
+                case CELL_VOLUME_WEIGHT:
+                {
+                    // Do nothing
+                    break;
+                }
 
                 default:
                     FatalErrorIn
diff --git a/src/sampling/meshToMeshInterpolation/tetOverlapVolume/tetOverlapVolume.C b/src/sampling/meshToMeshInterpolation/tetOverlapVolume/tetOverlapVolume.C
new file mode 100644
index 0000000000..d36730a0ee
--- /dev/null
+++ b/src/sampling/meshToMeshInterpolation/tetOverlapVolume/tetOverlapVolume.C
@@ -0,0 +1,795 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "tetOverlapVolume.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+defineTypeNameAndDebug(Foam::tetOverlapVolume, 0);
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::tetOverlapVolume::tetOverlapVolume()
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::tetOverlapVolume::~tetOverlapVolume()
+{}
+
+
+// * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * * * //
+
+Foam::point Foam::tetOverlapVolume::planeIntersection
+(
+    const FixedList<scalar, 4>& d,
+    const tetPoints& t,
+    const label negI,
+    const label posI
+)
+{
+    return (d[posI]*t[negI] - d[negI]*t[posI])/(-d[negI]+d[posI]);
+}
+
+
+template <class TetOp>
+inline void Foam::tetOverlapVolume::decomposePrism
+(
+    const FixedList<point, 6>& points,
+    TetOp& op
+)
+{
+    op(tetPoints(points[1], points[3], points[2], points[0]));
+    op(tetPoints(points[1], points[2], points[3], points[4]));
+    op(tetPoints(points[4], points[2], points[3], points[5]));
+}
+
+
+template <class AboveTetOp, class BelowTetOp>
+inline void Foam::tetOverlapVolume::tetSliceWithPlane
+(
+    const tetPoints& tet,
+    const plane& pl,
+
+    AboveTetOp& aboveOp,
+    BelowTetOp& belowOp
+)
+{
+    // Distance to plane
+    FixedList<scalar, 4> d;
+    label nPos = 0;
+    forAll(tet, i)
+    {
+        d[i] = ((tet[i]-pl.refPoint()) & pl.normal());
+        if (d[i] > 0)
+        {
+            nPos++;
+        }
+    }
+
+    if (nPos == 4)
+    {
+        aboveOp(tet);
+    }
+    else if (nPos == 3)
+    {
+        // Sliced into below tet and above prism. Prism gets split into
+        // two tets.
+
+        // Find the below tet
+        label i0 = -1;
+        forAll(d, i)
+        {
+            if (d[i] <= 0)
+            {
+                i0 = i;
+                break;
+            }
+        }
+
+        label i1 = d.fcIndex(i0);
+        label i2 = d.fcIndex(i1);
+        label i3 = d.fcIndex(i2);
+
+        point p01 = planeIntersection(d, tet, i0, i1);
+        point p02 = planeIntersection(d, tet, i0, i2);
+        point p03 = planeIntersection(d, tet, i0, i3);
+
+        // i0 = tetCell vertex 0: p01,p02,p03 outwards pointing triad
+        //          ,,         1 :     ,,     inwards pointing triad
+        //          ,,         2 :     ,,     outwards pointing triad
+        //          ,,         3 :     ,,     inwards pointing triad
+
+        //Pout<< "Split 3pos tet " << tet << " d:" << d << " into" << nl;
+
+        if (i0 == 0 || i0 == 2)
+        {
+            tetPoints t(tet[i0], p01, p02, p03);
+            //Pout<< "    belowtet:" << t << " around i0:" << i0 << endl;
+            //checkTet(t, "nPos 3, belowTet i0==0 or 2");
+            belowOp(t);
+
+            // Prism
+            FixedList<point, 6> p;
+            p[0] = tet[i1];
+            p[1] = tet[i3];
+            p[2] = tet[i2];
+            p[3] = p01;
+            p[4] = p03;
+            p[5] = p02;
+            //Pout<< "    aboveprism:" << p << endl;
+            decomposePrism(p, aboveOp);
+        }
+        else
+        {
+            tetPoints t(p01, p02, p03, tet[i0]);
+            //Pout<< "    belowtet:" << t << " around i0:" << i0 << endl;
+            //checkTet(t, "nPos 3, belowTet i0==1 or 3");
+            belowOp(t);
+
+            // Prism
+            FixedList<point, 6> p;
+            p[0] = tet[i3];
+            p[1] = tet[i1];
+            p[2] = tet[i2];
+            p[3] = p03;
+            p[4] = p01;
+            p[5] = p02;
+            //Pout<< "    aboveprism:" << p << endl;
+            decomposePrism(p, aboveOp);
+        }
+    }
+    else if (nPos == 2)
+    {
+        // Tet cut into two prisms. Determine the positive one.
+        label pos0 = -1;
+        label pos1 = -1;
+        label neg0 = -1;
+        label neg1 = -1;
+        forAll(d, i)
+        {
+            if (d[i] > 0)
+            {
+                if (pos0 == -1)
+                {
+                    pos0 = i;
+                }
+                else
+                {
+                    pos1 = i;
+                }
+            }
+            else
+            {
+                if (neg0 == -1)
+                {
+                    neg0 = i;
+                }
+                else
+                {
+                    neg1 = i;
+                }
+            }
+        }
+
+        //Pout<< "Split 2pos tet " << tet << " d:" << d
+        //    << " around pos0:" << pos0 << " pos1:" << pos1
+        //    << " neg0:" << neg0 << " neg1:" << neg1 << " into" << nl;
+
+        const edge posEdge(pos0, pos1);
+
+        if (posEdge == edge(0, 1))
+        {
+            point p02 = planeIntersection(d, tet, 0, 2);
+            point p03 = planeIntersection(d, tet, 0, 3);
+            point p12 = planeIntersection(d, tet, 1, 2);
+            point p13 = planeIntersection(d, tet, 1, 3);
+            // Split the resulting prism
+            {
+                FixedList<point, 6> p;
+                p[0] = tet[0];
+                p[1] = p02;
+                p[2] = p03;
+                p[3] = tet[1];
+                p[4] = p12;
+                p[5] = p13;
+                //Pout<< "    01 aboveprism:" << p << endl;
+                decomposePrism(p, aboveOp);
+            }
+            {
+                FixedList<point, 6> p;
+                p[0] = tet[2];
+                p[1] = p02;
+                p[2] = p12;
+                p[3] = tet[3];
+                p[4] = p03;
+                p[5] = p13;
+                //Pout<< "    01 belowprism:" << p << endl;
+                decomposePrism(p, belowOp);
+            }
+        }
+        else if (posEdge == edge(1, 2))
+        {
+            point p01 = planeIntersection(d, tet, 0, 1);
+            point p13 = planeIntersection(d, tet, 1, 3);
+            point p02 = planeIntersection(d, tet, 0, 2);
+            point p23 = planeIntersection(d, tet, 2, 3);
+            // Split the resulting prism
+            {
+                FixedList<point, 6> p;
+                p[0] = tet[1];
+                p[1] = p01;
+                p[2] = p13;
+                p[3] = tet[2];
+                p[4] = p02;
+                p[5] = p23;
+                //Pout<< "    12 aboveprism:" << p << endl;
+                decomposePrism(p, aboveOp);
+            }
+            {
+                FixedList<point, 6> p;
+                p[0] = tet[3];
+                p[1] = p23;
+                p[2] = p13;
+                p[3] = tet[0];
+                p[4] = p02;
+                p[5] = p01;
+                //Pout<< "    12 belowprism:" << p << endl;
+                decomposePrism(p, belowOp);
+            }
+        }
+        else if (posEdge == edge(2, 0))
+        {
+            point p01 = planeIntersection(d, tet, 0, 1);
+            point p03 = planeIntersection(d, tet, 0, 3);
+            point p12 = planeIntersection(d, tet, 1, 2);
+            point p23 = planeIntersection(d, tet, 2, 3);
+            // Split the resulting prism
+            {
+                FixedList<point, 6> p;
+                p[0] = tet[2];
+                p[1] = p12;
+                p[2] = p23;
+                p[3] = tet[0];
+                p[4] = p01;
+                p[5] = p03;
+                //Pout<< "    20 aboveprism:" << p << endl;
+                decomposePrism(p, aboveOp);
+            }
+            {
+                FixedList<point, 6> p;
+                p[0] = tet[1];
+                p[1] = p12;
+                p[2] = p01;
+                p[3] = tet[3];
+                p[4] = p23;
+                p[5] = p03;
+                //Pout<< "    20 belowprism:" << p << endl;
+                decomposePrism(p, belowOp);
+            }
+        }
+        else if (posEdge == edge(0, 3))
+        {
+            point p01 = planeIntersection(d, tet, 0, 1);
+            point p02 = planeIntersection(d, tet, 0, 2);
+            point p13 = planeIntersection(d, tet, 1, 3);
+            point p23 = planeIntersection(d, tet, 2, 3);
+            // Split the resulting prism
+            {
+                FixedList<point, 6> p;
+                p[0] = tet[3];
+                p[1] = p23;
+                p[2] = p13;
+                p[3] = tet[0];
+                p[4] = p02;
+                p[5] = p01;
+                //Pout<< "    03 aboveprism:" << p << endl;
+                decomposePrism(p, aboveOp);
+            }
+            {
+                FixedList<point, 6> p;
+                p[0] = tet[2];
+                p[1] = p23;
+                p[2] = p02;
+                p[3] = tet[1];
+                p[4] = p13;
+                p[5] = p01;
+                //Pout<< "    03 belowprism:" << p << endl;
+                decomposePrism(p, belowOp);
+            }
+        }
+        else if (posEdge == edge(1, 3))
+        {
+            point p01 = planeIntersection(d, tet, 0, 1);
+            point p12 = planeIntersection(d, tet, 1, 2);
+            point p03 = planeIntersection(d, tet, 0, 3);
+            point p23 = planeIntersection(d, tet, 2, 3);
+            // Split the resulting prism
+            {
+                FixedList<point, 6> p;
+                p[0] = tet[1];
+                p[1] = p12;
+                p[2] = p01;
+                p[3] = tet[3];
+                p[4] = p23;
+                p[5] = p03;
+                //Pout<< "    13 aboveprism:" << p << endl;
+                decomposePrism(p, aboveOp);
+            }
+            {
+                FixedList<point, 6> p;
+                p[0] = tet[2];
+                p[1] = p12;
+                p[2] = p23;
+                p[3] = tet[0];
+                p[4] = p01;
+                p[5] = p03;
+                //Pout<< "    13 belowprism:" << p << endl;
+                decomposePrism(p, belowOp);
+            }
+        }
+        else if (posEdge == edge(2, 3))
+        {
+            point p02 = planeIntersection(d, tet, 0, 2);
+            point p12 = planeIntersection(d, tet, 1, 2);
+            point p03 = planeIntersection(d, tet, 0, 3);
+            point p13 = planeIntersection(d, tet, 1, 3);
+            // Split the resulting prism
+            {
+                FixedList<point, 6> p;
+                p[0] = tet[2];
+                p[1] = p02;
+                p[2] = p12;
+                p[3] = tet[3];
+                p[4] = p03;
+                p[5] = p13;
+                //Pout<< "    23 aboveprism:" << p << endl;
+                decomposePrism(p, aboveOp);
+            }
+            {
+                FixedList<point, 6> p;
+                p[0] = tet[0];
+                p[1] = p02;
+                p[2] = p03;
+                p[3] = tet[1];
+                p[4] = p12;
+                p[5] = p13;
+                //Pout<< "    23 belowprism:" << p << endl;
+                decomposePrism(p, belowOp);
+            }
+        }
+        else
+        {
+            FatalErrorIn("tetSliceWithPlane(..)") << "Missed edge:" << posEdge
+                << abort(FatalError);
+        }
+    }
+    else if (nPos == 1)
+    {
+        // Find the positive tet
+        label i0 = -1;
+        forAll(d, i)
+        {
+            if (d[i] > 0)
+            {
+                i0 = i;
+                break;
+            }
+        }
+
+        label i1 = d.fcIndex(i0);
+        label i2 = d.fcIndex(i1);
+        label i3 = d.fcIndex(i2);
+
+        point p01 = planeIntersection(d, tet, i0, i1);
+        point p02 = planeIntersection(d, tet, i0, i2);
+        point p03 = planeIntersection(d, tet, i0, i3);
+
+        //Pout<< "Split 1pos tet " << tet << " d:" << d << " into" << nl;
+
+        if (i0 == 0 || i0 == 2)
+        {
+            tetPoints t(tet[i0], p01, p02, p03);
+            //Pout<< "    abovetet:" << t << " around i0:" << i0 << endl;
+            //checkTet(t, "nPos 1, aboveTets i0==0 or 2");
+            aboveOp(t);
+
+            // Prism
+            FixedList<point, 6> p;
+            p[0] = tet[i1];
+            p[1] = tet[i3];
+            p[2] = tet[i2];
+            p[3] = p01;
+            p[4] = p03;
+            p[5] = p02;
+            //Pout<< "    belowprism:" << p << endl;
+            decomposePrism(p, belowOp);
+        }
+        else
+        {
+            tetPoints t(p01, p02, p03, tet[i0]);
+            //Pout<< "    abovetet:" << t << " around i0:" << i0 << endl;
+            //checkTet(t, "nPos 1, aboveTets i0==1 or 3");
+            aboveOp(t);
+
+            // Prism
+            FixedList<point, 6> p;
+            p[0] = tet[i3];
+            p[1] = tet[i1];
+            p[2] = tet[i2];
+            p[3] = p03;
+            p[4] = p01;
+            p[5] = p02;
+            //Pout<< "    belowprism:" << p << endl;
+            decomposePrism(p, belowOp);
+        }
+    }
+    else    // nPos == 0
+    {
+        belowOp(tet);
+    }
+}
+
+
+void Foam::tetOverlapVolume::tetTetOverlap
+(
+    const tetPoints& tetA,
+    const tetPoints& tetB,
+    FixedList<tetPoints, 200>& insideTets,
+    label& nInside,
+    FixedList<tetPoints, 200>& outsideTets,
+    label& nOutside
+)
+{
+    // Work storage
+    FixedList<tetPoints, 200> cutInsideTets;
+    label nCutInside = 0;
+
+    storeTetOp inside(insideTets, nInside);
+    storeTetOp cutInside(cutInsideTets, nCutInside);
+    dummyTetOp outside;
+
+
+
+    // Cut tetA with all inwards pointing faces of tetB. Any tets remaining
+    // in aboveTets are inside tetB.
+
+    {
+        // face0
+        plane pl0(tetB[1], tetB[3], tetB[2]);
+
+        // Cut and insert subtets into cutInsideTets (either by getting
+        // an index from freeSlots or by appending to insideTets) or
+        // insert into outsideTets
+        tetSliceWithPlane(tetA, pl0, cutInside, outside);
+    }
+
+    if (nCutInside == 0)
+    {
+        nInside = nCutInside;
+        return;
+    }
+
+    {
+        // face1
+        plane pl1(tetB[0], tetB[2], tetB[3]);
+
+        nInside = 0;
+
+        for (label i = 0; i < nCutInside; i++)
+        {
+            tetSliceWithPlane(cutInsideTets[i], pl1, inside, outside);
+        }
+
+        if (nInside == 0)
+        {
+            return;
+        }
+    }
+
+    {
+        // face2
+        plane pl2(tetB[0], tetB[3], tetB[1]);
+
+        nCutInside = 0;
+
+        for (label i = 0; i < nInside; i++)
+        {
+            tetSliceWithPlane(insideTets[i], pl2, cutInside, outside);
+        }
+
+        if (nCutInside == 0)
+        {
+            nInside = nCutInside;
+            return;
+        }
+    }
+
+    {
+        // face3
+        plane pl3(tetB[0], tetB[1], tetB[2]);
+
+        nInside = 0;
+
+        for (label i = 0; i < nCutInside; i++)
+        {
+            tetSliceWithPlane(cutInsideTets[i], pl3, inside, outside);
+        }
+    }
+}
+
+
+inline Foam::scalar
+Foam::tetOverlapVolume::tetTetOverlapVol
+(
+    const tetPoints& tetA,
+    const tetPoints& tetB
+)
+{
+    FixedList<tetPoints, 200> insideTets;
+    label nInside = 0;
+    FixedList<tetPoints, 200> cutInsideTets;
+    label nCutInside = 0;
+
+    storeTetOp inside(insideTets, nInside);
+    storeTetOp cutInside(cutInsideTets, nCutInside);
+    sumTetVolOp volInside;
+    dummyTetOp outside;
+
+    // face0
+    plane pl0(tetB[1], tetB[3], tetB[2]);
+    tetA.tet().sliceWithPlane(pl0, cutInside, outside);
+    if (nCutInside == 0)
+    {
+        return 0.0;
+    }
+
+    // face1
+    plane pl1(tetB[0], tetB[2], tetB[3]);
+    nInside = 0;
+    for (label i = 0; i < nCutInside; i++)
+    {
+        const tetPointRef t = cutInsideTets[i].tet();
+        t.sliceWithPlane(pl1, inside, outside);
+    }
+    if (nInside == 0)
+    {
+        return 0.0;
+    }
+
+    // face2
+    plane pl2(tetB[0], tetB[3], tetB[1]);
+    nCutInside = 0;
+    for (label i = 0; i < nInside; i++)
+    {
+        const tetPointRef t = insideTets[i].tet();
+        t.sliceWithPlane(pl2, cutInside, outside);
+    }
+    if (nCutInside == 0)
+    {
+        return 0.0;
+    }
+
+    // face3
+    plane pl3(tetB[0], tetB[1], tetB[2]);
+    for (label i = 0; i < nCutInside; i++)
+    {
+        const tetPointRef t = cutInsideTets[i].tet();
+        t.sliceWithPlane(pl3, volInside, outside);
+    }
+
+    return volInside.vol_;
+}
+
+
+inline const Foam::treeBoundBox Foam::tetOverlapVolume::pyrBb
+(
+    const pointField& points,
+    const face& f,
+    const point& fc
+)
+{
+    treeBoundBox bb(fc, fc);
+    forAll(f, fp)
+    {
+        const point& pt = points[f[fp]];
+        bb.min() = min(bb.min(), pt);
+        bb.max() = max(bb.max(), pt);
+    }
+    return bb;
+}
+
+
+// * * * * * * * * * * * Public Member Functions  * * * * * * * * * * * * * //
+
+Foam::scalar Foam::tetOverlapVolume::cellCellOverlapVolumeMinDecomp
+(
+    const primitiveMesh& meshA,
+    const label cellAI,
+
+    const primitiveMesh& meshB,
+    const label cellBI,
+    const treeBoundBox& cellBbB
+)
+{
+    const cell& cFacesA = meshA.cells()[cellAI];
+    const point& ccA = meshA.cellCentres()[cellAI];
+
+    const cell& cFacesB = meshB.cells()[cellBI];
+    const point& ccB = meshB.cellCentres()[cellBI];
+
+    scalar vol = 0.0;
+
+    forAll(cFacesA, cFA)
+    {
+        label faceAI = cFacesA[cFA];
+
+        const face& fA = meshA.faces()[faceAI];
+        const treeBoundBox pyrA = pyrBb(meshA.points(), fA, ccA);
+        if (!pyrA.overlaps(cellBbB))
+        {
+            continue;
+        }
+
+        bool ownA = (meshA.faceOwner()[faceAI] == cellAI);
+
+        label tetBasePtAI = 0;
+
+        const point& tetBasePtA = meshA.points()[fA[tetBasePtAI]];
+
+        for (label tetPtI = 1; tetPtI < fA.size() - 1; tetPtI++)
+        {
+            label facePtAI = (tetPtI + tetBasePtAI) % fA.size();
+            label otherFacePtAI = fA.fcIndex(facePtAI);
+
+            label pt0I = -1;
+            label pt1I = -1;
+
+            if (ownA)
+            {
+                pt0I = fA[facePtAI];
+                pt1I = fA[otherFacePtAI];
+            }
+            else
+            {
+                pt0I = fA[otherFacePtAI];
+                pt1I = fA[facePtAI];
+            }
+
+            const tetPoints tetA
+            (
+                ccA,
+                tetBasePtA,
+                meshA.points()[pt0I],
+                meshA.points()[pt1I]
+            );
+            const treeBoundBox tetABb(tetA.bounds());
+
+
+            // Loop over tets of cellB
+            forAll(cFacesB, cFB)
+            {
+                label faceBI = cFacesB[cFB];
+
+                const face& fB = meshB.faces()[faceBI];
+                const treeBoundBox pyrB = pyrBb(meshB.points(), fB, ccB);
+                if (!pyrB.overlaps(pyrA))
+                {
+                    continue;
+                }
+
+                bool ownB = (meshB.faceOwner()[faceBI] == cellBI);
+
+                label tetBasePtBI = 0;
+
+                const point& tetBasePtB = meshB.points()[fB[tetBasePtBI]];
+
+                for (label tetPtI = 1; tetPtI < fB.size() - 1; tetPtI++)
+                {
+                    label facePtBI = (tetPtI + tetBasePtBI) % fB.size();
+                    label otherFacePtBI = fB.fcIndex(facePtBI);
+
+                    label pt0I = -1;
+                    label pt1I = -1;
+
+                    if (ownB)
+                    {
+                        pt0I = fB[facePtBI];
+                        pt1I = fB[otherFacePtBI];
+                    }
+                    else
+                    {
+                        pt0I = fB[otherFacePtBI];
+                        pt1I = fB[facePtBI];
+                    }
+
+                    const tetPoints tetB
+                    (
+                        ccB,
+                        tetBasePtB,
+                        meshB.points()[pt0I],
+                        meshB.points()[pt1I]
+                    );
+                    if (!tetB.bounds().overlaps(tetABb))
+                    {
+                        continue;
+                    }
+
+                    vol += tetTetOverlapVol(tetA, tetB);
+                }
+            }
+        }
+    }
+
+    return vol;
+}
+
+
+Foam::labelList Foam::tetOverlapVolume::overlappingCells
+(
+    const fvMesh& fromMesh,
+    const fvMesh& toMesh,
+    const label iTo
+) const
+{
+    const indexedOctree<treeDataCell>& treeA = fromMesh.cellTree();
+
+    treeBoundBox bbB
+    (
+        pointField(toMesh.points(), toMesh.cellPoints()[iTo])
+    );
+
+    return treeA.findBox(bbB);
+}
+
+
+/*
+
+        forAll(cellsA, i)
+        {
+            label cellAI = cellsA[i];
+            treeBoundBox bbA
+            (
+                pointField(meshA.points(), meshA.cellPoints()[cellAI])
+            );
+
+            scalar v = cellCellOverlapVolumeMinDecomp
+            (
+                meshA,
+                cellAI,
+                bbA,
+                meshB,
+                cellBI,
+                bbB
+            );
+
+            overlapVol += v;
+            nOverlapTests++;
+        }
+
+*/
+
+// ************************************************************************* //
diff --git a/src/sampling/meshToMeshInterpolation/tetOverlapVolume/tetOverlapVolume.H b/src/sampling/meshToMeshInterpolation/tetOverlapVolume/tetOverlapVolume.H
new file mode 100644
index 0000000000..d0891c14d1
--- /dev/null
+++ b/src/sampling/meshToMeshInterpolation/tetOverlapVolume/tetOverlapVolume.H
@@ -0,0 +1,218 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+
+Class
+    Foam::tetOverlapVolume
+
+Description
+    Calculates overlap volume of two tets.
+
+SourceFiles
+    tetOverlapVolume.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef tetOverlapVolume_H
+#define tetOverlapVolume_H
+
+#include "tetrahedron.H"
+#include "fvMesh.H"
+#include "plane.H"
+#include "tetPointRef.H"
+#include "OFstream.H"
+#include "meshTools.H"
+#include "indexedOctree.H"
+#include "treeDataCell.H"
+#include "tetPoints.H"
+#include "tetCell.H"
+#include "EdgeMap.H"
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                         Class tetOverlapVolume Declaration
+\*---------------------------------------------------------------------------*/
+
+class tetOverlapVolume
+{
+    // Private member functions
+
+        //- Plane intersection
+        inline point planeIntersection
+        (
+            const FixedList<scalar, 4>& d,
+            const tetPoints& t,
+            const label negI,
+            const label posI
+        );
+
+
+        //- Decompose prism
+        template <class TetOp> inline void decomposePrism
+        (
+            const FixedList<point, 6>& points,
+            TetOp& op
+        );
+
+
+        //- Helping cľasses
+        class dummyTetOp
+        {
+         public:
+
+            inline void operator()(const tetPoints&){}
+        };
+
+
+        class sumTetVolOp
+        {
+         public:
+            scalar vol_;
+
+            inline sumTetVolOp()
+            :
+                vol_(0.0)
+            {}
+
+            inline void operator()(const tetPoints& tet)
+            {
+                vol_ += tet.tet().mag();
+            }
+        };
+
+
+        class storeTetOp
+        {
+            FixedList<tetPoints, 200>& tets_;
+            label& nTets_;
+
+         public:
+
+            inline storeTetOp(FixedList<tetPoints, 200>& tets, label& nTets)
+            :
+                tets_(tets),
+                nTets_(nTets)
+            {}
+
+            inline void operator()(const tetPoints& tet)
+            {
+                tets_[nTets_++] = tet;
+            }
+        };
+
+
+        //- Slice. Split tet into subtets above and below plane
+        template <class AboveTetOp, class BelowTetOp>
+        inline void tetSliceWithPlane
+        (
+            const tetPoints& tet,
+            const plane& pl,
+
+            AboveTetOp& aboveOp,
+            BelowTetOp& belowOp
+        );
+
+
+        //- Tet overlap
+        void tetTetOverlap
+        (
+            const tetPoints& tetA,
+            const tetPoints& tetB,
+            FixedList<tetPoints, 200>& insideTets,
+            label& nInside,
+            FixedList<tetPoints, 200>& outsideTets,
+            label& nOutside
+        );
+
+
+        //- Tet Overlap Vol
+        inline scalar tetTetOverlapVol
+        (
+            const tetPoints& tetA,
+            const tetPoints& tetB
+        );
+
+
+        //- Return a const treeBoundBox
+        inline const treeBoundBox pyrBb
+        (
+            const pointField& points,
+            const face& f,
+            const point& fc
+        );
+
+
+public:
+
+
+    //- Runtime type information
+    TypeName("tetOverlapVolume");
+
+
+    // Constructors
+
+        //- Null constructor
+        tetOverlapVolume();
+
+
+    //- Destructor
+     virtual ~tetOverlapVolume();
+
+
+    // Public members
+
+        //- Return a list of cells in meshA which overlaps with cellBI in
+        // meshB
+        labelList overlappingCells
+        (
+            const fvMesh& meshA,
+            const fvMesh& meshB,
+            const label cellBI
+        ) const;
+
+
+        //- Calculates the overlap volume
+        scalar cellCellOverlapVolumeMinDecomp
+        (
+            const primitiveMesh& meshA,
+            const label cellAI,
+
+            const primitiveMesh& meshB,
+            const label cellBI,
+            const treeBoundBox& cellBbB
+        );
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/sampling/meshToMeshInterpolation/tetOverlapVolume/tetPoints.H b/src/sampling/meshToMeshInterpolation/tetOverlapVolume/tetPoints.H
new file mode 100644
index 0000000000..b23f7540dc
--- /dev/null
+++ b/src/sampling/meshToMeshInterpolation/tetOverlapVolume/tetPoints.H
@@ -0,0 +1,114 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012-2012 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::tetPoints
+
+Description
+    Tet storage. Null constructable (unfortunately tetrahedron<point, point>
+    is not)
+
+SourceFiles
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef tetPoints_H
+#define tetPoints_H
+
+#include "FixedList.H"
+#include "treeBoundBox.H"
+#include "tetPointRef.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                         Class tetPoints Declaration
+\*---------------------------------------------------------------------------*/
+
+class tetPoints
+:
+    public FixedList<point, 4>
+{
+public:
+
+    // Constructors
+
+        //- Construct null
+        inline tetPoints()
+        {}
+
+        //- Construct from four points
+        inline tetPoints
+        (
+            const point& a,
+            const point& b,
+            const point& c,
+            const point& d
+        )
+        {
+            operator[](0) = a;
+            operator[](1) = b;
+            operator[](2) = c;
+            operator[](3) = d;
+        }
+
+    // Member Functions
+
+        //- Return the tetrahedron
+        inline tetPointRef tet() const
+        {
+            return tetPointRef
+            (
+                operator[](0),
+                operator[](1),
+                operator[](2),
+                operator[](3)
+            );
+        }
+
+        //- Calculate the bounding box
+        inline treeBoundBox bounds() const
+        {
+            treeBoundBox bb(operator[](0), operator[](0));
+            for (label i = 1; i < size(); i++)
+            {
+                bb.min() = min(bb.min(), operator[](i));
+                bb.max() = max(bb.max(), operator[](i));
+            }
+            return bb;
+        }
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/sampling/meshToMeshInterpolation/tetOverlapVolume/tetrahedron.C b/src/sampling/meshToMeshInterpolation/tetOverlapVolume/tetrahedron.C
new file mode 100644
index 0000000000..d82cf30a50
--- /dev/null
+++ b/src/sampling/meshToMeshInterpolation/tetOverlapVolume/tetrahedron.C
@@ -0,0 +1,341 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012-2012 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Description
+    Calculation of shape function product for a tetrahedron
+
+\*---------------------------------------------------------------------------*/
+
+#include "tetrahedron.H"
+#include "triPointRef.H"
+#include "scalarField.H"
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+// (Probably very inefficient) minimum containment sphere calculation.
+// From http://www.imr.sandia.gov/papers/imr11/shewchuk2.pdf:
+// Sphere ctr is smallest one of
+// - tet circumcentre
+// - triangle circumcentre
+// - edge mids
+template<class Point, class PointRef>
+Foam::pointHit Foam::tetrahedron<Point, PointRef>::containmentSphere
+(
+    const scalar tol
+) const
+{
+    const scalar fac = 1 + tol;
+
+    // Halve order of tolerance for comparisons of sqr.
+    const scalar facSqr = Foam::sqrt(fac);
+
+
+    // 1. Circumcentre itself.
+
+    pointHit pHit(circumCentre());
+    pHit.setHit();
+    scalar minRadiusSqr = magSqr(pHit.rawPoint() - a_);
+
+
+    // 2. Try circumcentre of tet triangles. Create circumcircle for triFace and
+    // check if 4th point is inside.
+
+    {
+        point ctr = triPointRef(a_, b_, c_).circumCentre();
+        scalar radiusSqr = magSqr(ctr - a_);
+
+        if
+        (
+            radiusSqr < minRadiusSqr
+         && Foam::magSqr(d_-ctr) <= facSqr*radiusSqr
+        )
+        {
+            pHit.setMiss(false);
+            pHit.setPoint(ctr);
+            minRadiusSqr = radiusSqr;
+        }
+    }
+    {
+        point ctr = triPointRef(a_, b_, d_).circumCentre();
+        scalar radiusSqr = magSqr(ctr - a_);
+
+        if
+        (
+            radiusSqr < minRadiusSqr
+         && Foam::magSqr(c_-ctr) <= facSqr*radiusSqr
+        )
+        {
+            pHit.setMiss(false);
+            pHit.setPoint(ctr);
+            minRadiusSqr = radiusSqr;
+        }
+    }
+    {
+        point ctr = triPointRef(a_, c_, d_).circumCentre();
+        scalar radiusSqr = magSqr(ctr - a_);
+
+        if
+        (
+            radiusSqr < minRadiusSqr
+         && Foam::magSqr(b_-ctr) <= facSqr*radiusSqr
+        )
+        {
+            pHit.setMiss(false);
+            pHit.setPoint(ctr);
+            minRadiusSqr = radiusSqr;
+        }
+    }
+    {
+        point ctr = triPointRef(b_, c_, d_).circumCentre();
+        scalar radiusSqr = magSqr(ctr - b_);
+
+        if
+        (
+            radiusSqr < minRadiusSqr
+         && Foam::magSqr(a_-ctr) <= facSqr*radiusSqr
+        )
+        {
+            pHit.setMiss(false);
+            pHit.setPoint(ctr);
+            minRadiusSqr = radiusSqr;
+        }
+    }
+
+
+    // 3. Try midpoints of edges
+
+    // mid of edge A-B
+    {
+        point ctr = 0.5*(a_ + b_);
+        scalar radiusSqr = magSqr(a_ - ctr);
+        scalar testRadSrq = facSqr*radiusSqr;
+
+        if
+        (
+            radiusSqr < minRadiusSqr
+         && magSqr(c_-ctr) <= testRadSrq
+         && magSqr(d_-ctr) <= testRadSrq)
+        {
+            pHit.setMiss(false);
+            pHit.setPoint(ctr);
+            minRadiusSqr = radiusSqr;
+        }
+    }
+
+    // mid of edge A-C
+    {
+        point ctr = 0.5*(a_ + c_);
+        scalar radiusSqr = magSqr(a_ - ctr);
+        scalar testRadSrq = facSqr*radiusSqr;
+
+        if
+        (
+            radiusSqr < minRadiusSqr
+         && magSqr(b_-ctr) <= testRadSrq
+         && magSqr(d_-ctr) <= testRadSrq
+        )
+        {
+            pHit.setMiss(false);
+            pHit.setPoint(ctr);
+            minRadiusSqr = radiusSqr;
+        }
+    }
+
+    // mid of edge A-D
+    {
+        point ctr = 0.5*(a_ + d_);
+        scalar radiusSqr = magSqr(a_ - ctr);
+        scalar testRadSrq = facSqr*radiusSqr;
+
+        if
+        (
+            radiusSqr < minRadiusSqr
+         && magSqr(b_-ctr) <= testRadSrq
+         && magSqr(c_-ctr) <= testRadSrq
+        )
+        {
+            pHit.setMiss(false);
+            pHit.setPoint(ctr);
+            minRadiusSqr = radiusSqr;
+        }
+    }
+
+    // mid of edge B-C
+    {
+        point ctr = 0.5*(b_ + c_);
+        scalar radiusSqr = magSqr(b_ - ctr);
+        scalar testRadSrq = facSqr*radiusSqr;
+
+        if
+        (
+            radiusSqr < minRadiusSqr
+         && magSqr(a_-ctr) <= testRadSrq
+         && magSqr(d_-ctr) <= testRadSrq
+        )
+        {
+            pHit.setMiss(false);
+            pHit.setPoint(ctr);
+            minRadiusSqr = radiusSqr;
+        }
+    }
+
+    // mid of edge B-D
+    {
+        point ctr = 0.5*(b_ + d_);
+        scalar radiusSqr = magSqr(b_ - ctr);
+        scalar testRadSrq = facSqr*radiusSqr;
+
+        if
+        (
+            radiusSqr < minRadiusSqr
+         && magSqr(a_-ctr) <= testRadSrq
+         && magSqr(c_-ctr) <= testRadSrq)
+        {
+            pHit.setMiss(false);
+            pHit.setPoint(ctr);
+            minRadiusSqr = radiusSqr;
+        }
+    }
+
+    // mid of edge C-D
+    {
+        point ctr = 0.5*(c_ + d_);
+        scalar radiusSqr = magSqr(c_ - ctr);
+        scalar testRadSrq = facSqr*radiusSqr;
+
+        if
+        (
+            radiusSqr < minRadiusSqr
+         && magSqr(a_-ctr) <= testRadSrq
+         && magSqr(b_-ctr) <= testRadSrq
+        )
+        {
+            pHit.setMiss(false);
+            pHit.setPoint(ctr);
+            minRadiusSqr = radiusSqr;
+        }
+    }
+
+
+    pHit.setDistance(sqrt(minRadiusSqr));
+
+    return pHit;
+}
+
+
+template<class Point, class PointRef>
+void Foam::tetrahedron<Point, PointRef>::gradNiSquared
+(
+    scalarField& buffer
+) const
+{
+    // Change of sign between face area vector and gradient
+    // does not matter because of square
+
+    // Warning: Added a mag to produce positive coefficients even if
+    // the tetrahedron is twisted inside out.  This is pretty
+    // dangerous, but essential for mesh motion.
+    scalar magVol = Foam::mag(mag());
+
+    buffer[0] = (1.0/9.0)*magSqr(Sa())/magVol;
+    buffer[1] = (1.0/9.0)*magSqr(Sb())/magVol;
+    buffer[2] = (1.0/9.0)*magSqr(Sc())/magVol;
+    buffer[3] = (1.0/9.0)*magSqr(Sd())/magVol;
+}
+
+
+template<class Point, class PointRef>
+void Foam::tetrahedron<Point, PointRef>::gradNiDotGradNj
+(
+    scalarField& buffer
+) const
+{
+    // Warning. Ordering of edges needs to be the same for a tetrahedron
+    // class, a tetrahedron cell shape model and a tetCell
+
+    // Warning: Added a mag to produce positive coefficients even if
+    // the tetrahedron is twisted inside out.  This is pretty
+    // dangerous, but essential for mesh motion.
+
+    // Double change of sign between face area vector and gradient
+
+    scalar magVol = Foam::mag(mag());
+    vector sa = Sa();
+    vector sb = Sb();
+    vector sc = Sc();
+    vector sd = Sd();
+
+    buffer[0] = (1.0/9.0)*(sa & sb)/magVol;
+    buffer[1] = (1.0/9.0)*(sa & sc)/magVol;
+    buffer[2] = (1.0/9.0)*(sa & sd)/magVol;
+    buffer[3] = (1.0/9.0)*(sd & sb)/magVol;
+    buffer[4] = (1.0/9.0)*(sb & sc)/magVol;
+    buffer[5] = (1.0/9.0)*(sd & sc)/magVol;
+}
+
+
+template<class Point, class PointRef>
+void Foam::tetrahedron<Point, PointRef>::gradNiGradNi
+(
+    tensorField& buffer
+) const
+{
+    // Change of sign between face area vector and gradient
+    // does not matter because of square
+
+    scalar magVol = Foam::mag(mag());
+
+    buffer[0] = (1.0/9.0)*sqr(Sa())/magVol;
+    buffer[1] = (1.0/9.0)*sqr(Sb())/magVol;
+    buffer[2] = (1.0/9.0)*sqr(Sc())/magVol;
+    buffer[3] = (1.0/9.0)*sqr(Sd())/magVol;
+}
+
+
+template<class Point, class PointRef>
+void Foam::tetrahedron<Point, PointRef>::gradNiGradNj
+(
+    tensorField& buffer
+) const
+{
+    // Warning. Ordering of edges needs to be the same for a tetrahedron
+    // class, a tetrahedron cell shape model and a tetCell
+
+    // Double change of sign between face area vector and gradient
+
+    scalar magVol = Foam::mag(mag());
+    vector sa = Sa();
+    vector sb = Sb();
+    vector sc = Sc();
+    vector sd = Sd();
+
+    buffer[0] = (1.0/9.0)*(sa * sb)/magVol;
+    buffer[1] = (1.0/9.0)*(sa * sc)/magVol;
+    buffer[2] = (1.0/9.0)*(sa * sd)/magVol;
+    buffer[3] = (1.0/9.0)*(sd * sb)/magVol;
+    buffer[4] = (1.0/9.0)*(sb * sc)/magVol;
+    buffer[5] = (1.0/9.0)*(sd * sc)/magVol;
+}
+
+
+// ************************************************************************* //
diff --git a/src/sampling/meshToMeshInterpolation/tetOverlapVolume/tetrahedron.H b/src/sampling/meshToMeshInterpolation/tetOverlapVolume/tetrahedron.H
new file mode 100644
index 0000000000..13e7acd4eb
--- /dev/null
+++ b/src/sampling/meshToMeshInterpolation/tetOverlapVolume/tetrahedron.H
@@ -0,0 +1,315 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012-2012 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::tetrahedron
+
+Description
+    A tetrahedron primitive.
+
+    Ordering of edges needs to be the same for a tetrahedron
+    class, a tetrahedron cell shape model and a tetCell.
+
+SourceFiles
+    tetrahedronI.H
+    tetrahedron.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef tetrahedron_H
+#define tetrahedron_H
+
+#include "point.H"
+#include "primitiveFieldsFwd.H"
+#include "pointHit.H"
+#include "cachedRandom.H"
+#include "Random.H"
+#include "FixedList.H"
+#include "UList.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+class Istream;
+class Ostream;
+class tetPoints;
+class plane;
+
+// Forward declaration of friend functions and operators
+
+template<class Point, class PointRef> class tetrahedron;
+
+template<class Point, class PointRef>
+inline Istream& operator>>
+(
+    Istream&,
+    tetrahedron<Point, PointRef>&
+);
+
+template<class Point, class PointRef>
+inline Ostream& operator<<
+(
+    Ostream&,
+    const tetrahedron<Point, PointRef>&
+);
+
+
+/*---------------------------------------------------------------------------*\
+                           class tetrahedron Declaration
+\*---------------------------------------------------------------------------*/
+
+template<class Point, class PointRef>
+class tetrahedron
+{
+public:
+
+        // Classes for use in sliceWithPlane. What to do with decomposition
+        // of tet.
+
+            //- Dummy
+            class dummyOp
+            {
+            public:
+                inline void operator()(const tetPoints&);
+            };
+
+            //- Sum resulting volumes
+            class sumVolOp
+            {
+            public:
+                scalar vol_;
+
+                inline sumVolOp();
+
+                inline void operator()(const tetPoints&);
+            };
+
+            //- Store resulting tets
+            class storeOp
+            {
+                FixedList<tetPoints, 200>& tets_;
+                label& nTets_;
+
+            public:
+                inline storeOp(FixedList<tetPoints, 200>&, label&);
+
+                inline void operator()(const tetPoints&);
+            };
+
+private:
+
+    // Private data
+
+        PointRef a_, b_, c_, d_;
+
+        inline static point planeIntersection
+        (
+            const FixedList<scalar, 4>&,
+            const tetPoints&,
+            const label,
+            const label
+        );
+
+        template<class TetOp>
+        inline static void decomposePrism
+        (
+            const FixedList<point, 6>& points,
+            TetOp& op
+        );
+
+        template<class AboveTetOp, class BelowTetOp>
+        inline static void tetSliceWithPlane
+        (
+            const plane& pl,
+            const tetPoints& tet,
+            AboveTetOp& aboveOp,
+            BelowTetOp& belowOp
+        );
+
+
+public:
+
+    // Member constants
+
+        enum
+        {
+            nVertices = 4,  // Number of vertices in tetrahedron
+            nEdges = 6      // Number of edges in tetrahedron
+        };
+
+
+    // Constructors
+
+        //- Construct from points
+        inline tetrahedron
+        (
+            const Point& a,
+            const Point& b,
+            const Point& c,
+            const Point& d
+        );
+
+        //- Construct from four points in the list of points
+        inline tetrahedron
+        (
+            const UList<Point>&,
+            const FixedList<label, 4>& indices
+        );
+
+        //- Construct from Istream
+        inline tetrahedron(Istream&);
+
+
+    // Member Functions
+
+        // Access
+
+            //- Return vertices
+            inline const Point& a() const;
+
+            inline const Point& b() const;
+
+            inline const Point& c() const;
+
+            inline const Point& d() const;
+
+
+        // Properties
+
+            //- Return face normal
+            inline vector Sa() const;
+
+            inline vector Sb() const;
+
+            inline vector Sc() const;
+
+            inline vector Sd() const;
+
+            //- Return centre (centroid)
+            inline Point centre() const;
+
+            //- Return volume
+            inline scalar mag() const;
+
+            //- Return circum-centre
+            inline Point circumCentre() const;
+
+            //- Return circum-radius
+            inline scalar circumRadius() const;
+
+            //- Return quality: Ratio of tetrahedron and circum-sphere
+            //  volume, scaled so that a regular tetrahedron has a
+            //  quality of 1
+            inline scalar quality() const;
+
+            //- Return a random point in the tetrahedron from a
+            //  uniform distribution
+            inline Point randomPoint(Random& rndGen) const;
+
+            //- Return a random point in the tetrahedron from a
+            //  uniform distribution
+            inline Point randomPoint(cachedRandom& rndGen) const;
+
+            //- Calculate the barycentric coordinates of the given
+            //  point, in the same order as a, b, c, d.  Returns the
+            //  determinant of the solution.
+            inline scalar barycentric
+            (
+                const point& pt,
+                List<scalar>& bary
+            ) const;
+
+            //- Return nearest point to p on tetrahedron
+            inline pointHit nearestPoint(const point& p) const;
+
+            //- Return true if point is inside tetrahedron
+            inline bool inside(const point& pt) const;
+
+            //- Decompose tet into tets above and below plane
+            template<class AboveTetOp, class BelowTetOp>
+            inline void sliceWithPlane
+            (
+                const plane& pl,
+                AboveTetOp& aboveOp,
+                BelowTetOp& belowOp
+            ) const;
+
+
+            //- Return (min)containment sphere, i.e. the smallest sphere with
+            //  all points inside. Returns pointHit with:
+            //  - hit         : if sphere is equal to circumsphere
+            //                  (biggest sphere)
+            //  - point       : centre of sphere
+            //  - distance    : radius of sphere
+            //  - eligiblemiss: false
+            // Tol (small compared to 1, e.g. 1E-9) is used to determine
+            // whether point is inside: mag(pt - ctr) < (1+tol)*radius.
+            pointHit containmentSphere(const scalar tol) const;
+
+            //- Fill buffer with shape function products
+            void gradNiSquared(scalarField& buffer) const;
+
+            void gradNiDotGradNj(scalarField& buffer) const;
+
+            void gradNiGradNi(tensorField& buffer) const;
+
+            void gradNiGradNj(tensorField& buffer) const;
+
+
+    // IOstream operators
+
+        friend Istream& operator>> <Point, PointRef>
+        (
+            Istream&,
+            tetrahedron&
+        );
+
+        friend Ostream& operator<< <Point, PointRef>
+        (
+            Ostream&,
+            const tetrahedron&
+        );
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#include "tetrahedronI.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+#   include "tetrahedron.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/sampling/meshToMeshInterpolation/tetOverlapVolume/tetrahedronI.H b/src/sampling/meshToMeshInterpolation/tetOverlapVolume/tetrahedronI.H
new file mode 100644
index 0000000000..922ae0057e
--- /dev/null
+++ b/src/sampling/meshToMeshInterpolation/tetOverlapVolume/tetrahedronI.H
@@ -0,0 +1,1012 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012-2012 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "triangle.H"
+#include "IOstreams.H"
+#include "triPointRef.H"
+#include "tetPoints.H"
+#include "plane.H"
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+template<class Point, class PointRef>
+inline Foam::tetrahedron<Point, PointRef>::tetrahedron
+(
+    const Point& a,
+    const Point& b,
+    const Point& c,
+    const Point& d
+)
+:
+    a_(a),
+    b_(b),
+    c_(c),
+    d_(d)
+{}
+
+
+template<class Point, class PointRef>
+inline Foam::tetrahedron<Point, PointRef>::tetrahedron
+(
+    const UList<Point>& points,
+    const FixedList<label, 4>& indices
+)
+:
+    a_(points[indices[0]]),
+    b_(points[indices[1]]),
+    c_(points[indices[2]]),
+    d_(points[indices[3]])
+{}
+
+
+template<class Point, class PointRef>
+inline Foam::tetrahedron<Point, PointRef>::tetrahedron(Istream& is)
+{
+    is  >> *this;
+}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+template<class Point, class PointRef>
+inline const Point& Foam::tetrahedron<Point, PointRef>::a() const
+{
+    return a_;
+}
+
+
+template<class Point, class PointRef>
+inline const Point& Foam::tetrahedron<Point, PointRef>::b() const
+{
+    return b_;
+}
+
+
+template<class Point, class PointRef>
+inline const Point& Foam::tetrahedron<Point, PointRef>::c() const
+{
+    return c_;
+}
+
+
+template<class Point, class PointRef>
+inline const Point& Foam::tetrahedron<Point, PointRef>::d() const
+{
+    return d_;
+}
+
+
+template<class Point, class PointRef>
+inline Foam::vector Foam::tetrahedron<Point, PointRef>::Sa() const
+{
+    return triangle<Point, PointRef>(b_, c_, d_).normal();
+}
+
+
+template<class Point, class PointRef>
+inline Foam::vector Foam::tetrahedron<Point, PointRef>::Sb() const
+{
+    return triangle<Point, PointRef>(a_, d_, c_).normal();
+}
+
+
+template<class Point, class PointRef>
+inline Foam::vector Foam::tetrahedron<Point, PointRef>::Sc() const
+{
+    return triangle<Point, PointRef>(a_, b_, d_).normal();
+}
+
+
+template<class Point, class PointRef>
+inline Foam::vector Foam::tetrahedron<Point, PointRef>::Sd() const
+{
+    return triangle<Point, PointRef>(a_, c_, b_).normal();
+}
+
+
+template<class Point, class PointRef>
+inline Point Foam::tetrahedron<Point, PointRef>::centre() const
+{
+    return 0.25*(a_ + b_ + c_ + d_);
+}
+
+
+template<class Point, class PointRef>
+inline Foam::scalar Foam::tetrahedron<Point, PointRef>::mag() const
+{
+    return (1.0/6.0)*(((b_ - a_) ^ (c_ - a_)) & (d_ - a_));
+}
+
+
+template<class Point, class PointRef>
+inline Point Foam::tetrahedron<Point, PointRef>::circumCentre() const
+{
+    vector a = b_ - a_;
+    vector b = c_ - a_;
+    vector c = d_ - a_;
+
+    scalar lambda = magSqr(c) - (a & c);
+    scalar mu = magSqr(b) - (a & b);
+
+    vector ba = b ^ a;
+    vector ca = c ^ a;
+
+    vector num = lambda*ba - mu*ca;
+    scalar denom = (c & ba);
+
+    if (Foam::mag(denom) < ROOTVSMALL)
+    {
+        // Degenerate tetrahedron, returning centre instead of circumCentre.
+
+        return centre();
+    }
+
+    return a_ + 0.5*(a + num/denom);
+}
+
+
+template<class Point, class PointRef>
+inline Foam::scalar Foam::tetrahedron<Point, PointRef>::circumRadius() const
+{
+    vector a = b_ - a_;
+    vector b = c_ - a_;
+    vector c = d_ - a_;
+
+    scalar lambda = magSqr(c) - (a & c);
+    scalar mu = magSqr(b) - (a & b);
+
+    vector ba = b ^ a;
+    vector ca = c ^ a;
+
+    vector num = lambda*ba - mu*ca;
+    scalar denom = (c & ba);
+
+    if (Foam::mag(denom) < ROOTVSMALL)
+    {
+        // Degenerate tetrahedron, returning GREAT for circumRadius.
+        return GREAT;
+    }
+
+    return Foam::mag(0.5*(a + num/denom));
+}
+
+
+template<class Point, class PointRef>
+inline Foam::scalar Foam::tetrahedron<Point, PointRef>::quality() const
+{
+    return
+        mag()
+       /(
+            8.0/(9.0*sqrt(3.0))
+           *pow3(min(circumRadius(), GREAT))
+          + ROOTVSMALL
+        );
+}
+
+
+template<class Point, class PointRef>
+inline Point Foam::tetrahedron<Point, PointRef>::randomPoint
+(
+    Random& rndGen
+) const
+{
+    // Adapted from
+    // http://vcg.isti.cnr.it/activities/geometryegraphics/pointintetraedro.html
+
+    scalar s = rndGen.scalar01();
+    scalar t = rndGen.scalar01();
+    scalar u = rndGen.scalar01();
+
+    if (s + t > 1.0)
+    {
+        s = 1.0 - s;
+        t = 1.0 - t;
+    }
+
+    if (t + u > 1.0)
+    {
+        scalar tmp = u;
+        u = 1.0 - s - t;
+        t = 1.0 - tmp;
+    }
+    else if (s + t + u > 1.0)
+    {
+        scalar tmp = u;
+        u = s + t + u - 1.0;
+        s = 1.0 - t - tmp;
+    }
+
+    return (1 - s - t - u)*a_ + s*b_ + t*c_ + u*d_;
+}
+
+
+template<class Point, class PointRef>
+inline Point Foam::tetrahedron<Point, PointRef>::randomPoint
+(
+    cachedRandom& rndGen
+) const
+{
+    // Adapted from
+    // http://vcg.isti.cnr.it/activities/geometryegraphics/pointintetraedro.html
+
+    scalar s = rndGen.sample01<scalar>();
+    scalar t = rndGen.sample01<scalar>();
+    scalar u = rndGen.sample01<scalar>();
+
+    if (s + t > 1.0)
+    {
+        s = 1.0 - s;
+        t = 1.0 - t;
+    }
+
+    if (t + u > 1.0)
+    {
+        scalar tmp = u;
+        u = 1.0 - s - t;
+        t = 1.0 - tmp;
+    }
+    else if (s + t + u > 1.0)
+    {
+        scalar tmp = u;
+        u = s + t + u - 1.0;
+        s = 1.0 - t - tmp;
+    }
+
+    return (1 - s - t - u)*a_ + s*b_ + t*c_ + u*d_;
+}
+
+
+template<class Point, class PointRef>
+Foam::scalar Foam::tetrahedron<Point, PointRef>::barycentric
+(
+    const point& pt,
+    List<scalar>& bary
+) const
+{
+    // From:
+    // http://en.wikipedia.org/wiki/Barycentric_coordinate_system_(mathematics)
+
+    vector e0(a_ - d_);
+    vector e1(b_ - d_);
+    vector e2(c_ - d_);
+
+    tensor t
+    (
+        e0.x(), e1.x(), e2.x(),
+        e0.y(), e1.y(), e2.y(),
+        e0.z(), e1.z(), e2.z()
+    );
+
+    scalar detT = det(t);
+
+    if (Foam::mag(detT) < SMALL)
+    {
+        // Degenerate tetrahedron, returning 1/4 barycentric coordinates.
+
+        bary = List<scalar>(4, 0.25);
+
+        return detT;
+    }
+
+    vector res = inv(t, detT) & (pt - d_);
+
+    bary.setSize(4);
+
+    bary[0] = res.x();
+    bary[1] = res.y();
+    bary[2] = res.z();
+    bary[3] = (1.0 - res.x() - res.y() - res.z());
+
+    return detT;
+}
+
+
+template<class Point, class PointRef>
+inline Foam::pointHit Foam::tetrahedron<Point, PointRef>::nearestPoint
+(
+    const point& p
+) const
+{
+    // Adapted from:
+    // Real-time collision detection, Christer Ericson, 2005, p142-144
+
+    // Assuming initially that the point is inside all of the
+    // halfspaces, so closest to itself.
+
+    point closestPt = p;
+
+    scalar minOutsideDistance = VGREAT;
+
+    bool inside = true;
+
+    if (((p - b_) & Sa()) >= 0)
+    {
+        // p is outside halfspace plane of tri
+        pointHit info = triangle<Point, PointRef>(b_, c_, d_).nearestPoint(p);
+
+        inside = false;
+
+        if (info.distance() < minOutsideDistance)
+        {
+            closestPt = info.rawPoint();
+
+            minOutsideDistance = info.distance();
+        }
+    }
+
+    if (((p - a_) & Sb()) >= 0)
+    {
+        // p is outside halfspace plane of tri
+        pointHit info = triangle<Point, PointRef>(a_, d_, c_).nearestPoint(p);
+
+        inside = false;
+
+        if (info.distance() < minOutsideDistance)
+        {
+            closestPt = info.rawPoint();
+
+            minOutsideDistance = info.distance();
+        }
+    }
+
+    if (((p - a_) & Sc()) >= 0)
+    {
+        // p is outside halfspace plane of tri
+        pointHit info = triangle<Point, PointRef>(a_, b_, d_).nearestPoint(p);
+
+        inside = false;
+
+        if (info.distance() < minOutsideDistance)
+        {
+            closestPt = info.rawPoint();
+
+            minOutsideDistance = info.distance();
+        }
+    }
+
+    if (((p - a_) & Sd()) >= 0)
+    {
+        // p is outside halfspace plane of tri
+        pointHit info = triangle<Point, PointRef>(a_, c_, b_).nearestPoint(p);
+
+        inside = false;
+
+        if (info.distance() < minOutsideDistance)
+        {
+            closestPt = info.rawPoint();
+
+            minOutsideDistance = info.distance();
+        }
+    }
+
+    // If the point is inside, then the distance to the closest point
+    // is zero
+    if (inside)
+    {
+        minOutsideDistance = 0;
+    }
+
+    return pointHit
+    (
+        inside,
+        closestPt,
+        minOutsideDistance,
+        !inside
+    );
+}
+
+
+template<class Point, class PointRef>
+bool Foam::tetrahedron<Point, PointRef>::inside(const point& pt) const
+{
+    // For robustness, assuming that the point is in the tet unless
+    // "definitively" shown otherwise by obtaining a positive dot
+    // product greater than a tolerance of SMALL.
+
+    // The tet is defined: tet(Cc, tetBasePt, pA, pB) where the normal
+    // vectors and base points for the half-space planes are:
+    // area[0] = Sa();
+    // area[1] = Sb();
+    // area[2] = Sc();
+    // area[3] = Sd();
+    // planeBase[0] = tetBasePt = b_
+    // planeBase[1] = ptA       = c_
+    // planeBase[2] = tetBasePt = b_
+    // planeBase[3] = tetBasePt = b_
+
+    vector n = vector::zero;
+
+    {
+        // 0, a
+        const point& basePt = b_;
+
+        n = Sa();
+        n /= (Foam::mag(n) + VSMALL);
+
+        if (((pt - basePt) & n) > SMALL)
+        {
+            return false;
+        }
+    }
+
+    {
+        // 1, b
+        const point& basePt = c_;
+
+        n = Sb();
+        n /= (Foam::mag(n) + VSMALL);
+
+        if (((pt - basePt) & n) > SMALL)
+        {
+            return false;
+        }
+    }
+
+    {
+        // 2, c
+        const point& basePt = b_;
+
+        n = Sc();
+        n /= (Foam::mag(n) + VSMALL);
+
+        if (((pt - basePt) & n) > SMALL)
+        {
+            return false;
+        }
+    }
+
+    {
+        // 3, d
+        const point& basePt = b_;
+
+        n = Sd();
+        n /= (Foam::mag(n) + VSMALL);
+
+        if (((pt - basePt) & n) > SMALL)
+        {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+
+template<class Point, class PointRef>
+inline void Foam::tetrahedron<Point, PointRef>::dummyOp::operator()
+(
+    const tetPoints&
+)
+{}
+
+
+template<class Point, class PointRef>
+inline Foam::tetrahedron<Point, PointRef>::sumVolOp::sumVolOp()
+:
+    vol_(0.0)
+{}
+
+
+template<class Point, class PointRef>
+inline void Foam::tetrahedron<Point, PointRef>::sumVolOp::operator()
+(
+    const tetPoints& tet
+)
+{
+    vol_ += tet.tet().mag();
+}
+
+
+template<class Point, class PointRef>
+inline Foam::tetrahedron<Point, PointRef>::storeOp::storeOp
+(
+    FixedList<tetPoints, 200>& tets,
+    label& nTets
+)
+:
+    tets_(tets),
+    nTets_(nTets)
+{}
+
+
+template<class Point, class PointRef>
+inline void Foam::tetrahedron<Point, PointRef>::storeOp::operator()
+(
+    const tetPoints& tet
+)
+{
+    tets_[nTets_++] = tet;
+}
+
+
+template<class Point, class PointRef>
+inline Foam::point Foam::tetrahedron<Point, PointRef>::planeIntersection
+(
+    const FixedList<scalar, 4>& d,
+    const tetPoints& t,
+    const label negI,
+    const label posI
+)
+{
+    return
+        (d[posI]*t[negI] - d[negI]*t[posI])
+      / (-d[negI]+d[posI]);
+}
+
+
+template<class Point, class PointRef>
+template<class TetOp>
+inline void Foam::tetrahedron<Point, PointRef>::decomposePrism
+(
+    const FixedList<point, 6>& points,
+    TetOp& op
+)
+{
+    op(tetPoints(points[1], points[3], points[2], points[0]));
+    op(tetPoints(points[1], points[2], points[3], points[4]));
+    op(tetPoints(points[4], points[2], points[3], points[5]));
+}
+
+
+template<class Point, class PointRef>
+template<class AboveTetOp, class BelowTetOp>
+inline void Foam::tetrahedron<Point, PointRef>::
+tetSliceWithPlane
+(
+    const plane& pl,
+    const tetPoints& tet,
+    AboveTetOp& aboveOp,
+    BelowTetOp& belowOp
+)
+{
+    // Distance to plane
+    FixedList<scalar, 4> d;
+    label nPos = 0;
+    forAll(tet, i)
+    {
+        d[i] = ((tet[i]-pl.refPoint()) & pl.normal());
+        if (d[i] > 0)
+        {
+            nPos++;
+        }
+    }
+
+    if (nPos == 4)
+    {
+        aboveOp(tet);
+    }
+    else if (nPos == 3)
+    {
+        // Sliced into below tet and above prism. Prism gets split into
+        // two tets.
+
+        // Find the below tet
+        label i0 = -1;
+        forAll(d, i)
+        {
+            if (d[i] <= 0)
+            {
+                i0 = i;
+                break;
+            }
+        }
+
+        label i1 = d.fcIndex(i0);
+        label i2 = d.fcIndex(i1);
+        label i3 = d.fcIndex(i2);
+
+        point p01 = planeIntersection(d, tet, i0, i1);
+        point p02 = planeIntersection(d, tet, i0, i2);
+        point p03 = planeIntersection(d, tet, i0, i3);
+
+        // i0 = tetCell vertex 0: p01,p02,p03 outwards pointing triad
+        //          ,,         1 :     ,,     inwards pointing triad
+        //          ,,         2 :     ,,     outwards pointing triad
+        //          ,,         3 :     ,,     inwards pointing triad
+
+        //Pout<< "Split 3pos tet " << tet << " d:" << d << " into" << nl;
+
+        if (i0 == 0 || i0 == 2)
+        {
+            tetPoints t(tet[i0], p01, p02, p03);
+            //Pout<< "    belowtet:" << t << " around i0:" << i0 << endl;
+            //checkTet(t, "nPos 3, belowTet i0==0 or 2");
+            belowOp(t);
+
+            // Prism
+            FixedList<point, 6> p;
+            p[0] = tet[i1];
+            p[1] = tet[i3];
+            p[2] = tet[i2];
+            p[3] = p01;
+            p[4] = p03;
+            p[5] = p02;
+            //Pout<< "    aboveprism:" << p << endl;
+            decomposePrism(p, aboveOp);
+        }
+        else
+        {
+            tetPoints t(p01, p02, p03, tet[i0]);
+            //Pout<< "    belowtet:" << t << " around i0:" << i0 << endl;
+            //checkTet(t, "nPos 3, belowTet i0==1 or 3");
+            belowOp(t);
+
+            // Prism
+            FixedList<point, 6> p;
+            p[0] = tet[i3];
+            p[1] = tet[i1];
+            p[2] = tet[i2];
+            p[3] = p03;
+            p[4] = p01;
+            p[5] = p02;
+            //Pout<< "    aboveprism:" << p << endl;
+            decomposePrism(p, aboveOp);
+        }
+    }
+    else if (nPos == 2)
+    {
+        // Tet cut into two prisms. Determine the positive one.
+        label pos0 = -1;
+        label pos1 = -1;
+        label neg0 = -1;
+        label neg1 = -1;
+        forAll(d, i)
+        {
+            if (d[i] > 0)
+            {
+                if (pos0 == -1)
+                {
+                    pos0 = i;
+                }
+                else
+                {
+                    pos1 = i;
+                }
+            }
+            else
+            {
+                if (neg0 == -1)
+                {
+                    neg0 = i;
+                }
+                else
+                {
+                    neg1 = i;
+                }
+            }
+        }
+
+        //Pout<< "Split 2pos tet " << tet << " d:" << d
+        //    << " around pos0:" << pos0 << " pos1:" << pos1
+        //    << " neg0:" << neg0 << " neg1:" << neg1 << " into" << nl;
+
+        const edge posEdge(pos0, pos1);
+
+        if (posEdge == edge(0, 1))
+        {
+            point p02 = planeIntersection(d, tet, 0, 2);
+            point p03 = planeIntersection(d, tet, 0, 3);
+            point p12 = planeIntersection(d, tet, 1, 2);
+            point p13 = planeIntersection(d, tet, 1, 3);
+            // Split the resulting prism
+            {
+                FixedList<point, 6> p;
+                p[0] = tet[0];
+                p[1] = p02;
+                p[2] = p03;
+                p[3] = tet[1];
+                p[4] = p12;
+                p[5] = p13;
+                //Pout<< "    01 aboveprism:" << p << endl;
+                decomposePrism(p, aboveOp);
+            }
+            {
+                FixedList<point, 6> p;
+                p[0] = tet[2];
+                p[1] = p02;
+                p[2] = p12;
+                p[3] = tet[3];
+                p[4] = p03;
+                p[5] = p13;
+                //Pout<< "    01 belowprism:" << p << endl;
+                decomposePrism(p, belowOp);
+            }
+        }
+        else if (posEdge == edge(1, 2))
+        {
+            point p01 = planeIntersection(d, tet, 0, 1);
+            point p13 = planeIntersection(d, tet, 1, 3);
+            point p02 = planeIntersection(d, tet, 0, 2);
+            point p23 = planeIntersection(d, tet, 2, 3);
+            // Split the resulting prism
+            {
+                FixedList<point, 6> p;
+                p[0] = tet[1];
+                p[1] = p01;
+                p[2] = p13;
+                p[3] = tet[2];
+                p[4] = p02;
+                p[5] = p23;
+                //Pout<< "    12 aboveprism:" << p << endl;
+                decomposePrism(p, aboveOp);
+            }
+            {
+                FixedList<point, 6> p;
+                p[0] = tet[3];
+                p[1] = p23;
+                p[2] = p13;
+                p[3] = tet[0];
+                p[4] = p02;
+                p[5] = p01;
+                //Pout<< "    12 belowprism:" << p << endl;
+                decomposePrism(p, belowOp);
+            }
+        }
+        else if (posEdge == edge(2, 0))
+        {
+            point p01 = planeIntersection(d, tet, 0, 1);
+            point p03 = planeIntersection(d, tet, 0, 3);
+            point p12 = planeIntersection(d, tet, 1, 2);
+            point p23 = planeIntersection(d, tet, 2, 3);
+            // Split the resulting prism
+            {
+                FixedList<point, 6> p;
+                p[0] = tet[2];
+                p[1] = p12;
+                p[2] = p23;
+                p[3] = tet[0];
+                p[4] = p01;
+                p[5] = p03;
+                //Pout<< "    20 aboveprism:" << p << endl;
+                decomposePrism(p, aboveOp);
+            }
+            {
+                FixedList<point, 6> p;
+                p[0] = tet[1];
+                p[1] = p12;
+                p[2] = p01;
+                p[3] = tet[3];
+                p[4] = p23;
+                p[5] = p03;
+                //Pout<< "    20 belowprism:" << p << endl;
+                decomposePrism(p, belowOp);
+            }
+        }
+        else if (posEdge == edge(0, 3))
+        {
+            point p01 = planeIntersection(d, tet, 0, 1);
+            point p02 = planeIntersection(d, tet, 0, 2);
+            point p13 = planeIntersection(d, tet, 1, 3);
+            point p23 = planeIntersection(d, tet, 2, 3);
+            // Split the resulting prism
+            {
+                FixedList<point, 6> p;
+                p[0] = tet[3];
+                p[1] = p23;
+                p[2] = p13;
+                p[3] = tet[0];
+                p[4] = p02;
+                p[5] = p01;
+                //Pout<< "    03 aboveprism:" << p << endl;
+                decomposePrism(p, aboveOp);
+            }
+            {
+                FixedList<point, 6> p;
+                p[0] = tet[2];
+                p[1] = p23;
+                p[2] = p02;
+                p[3] = tet[1];
+                p[4] = p13;
+                p[5] = p01;
+                //Pout<< "    03 belowprism:" << p << endl;
+                decomposePrism(p, belowOp);
+            }
+        }
+        else if (posEdge == edge(1, 3))
+        {
+            point p01 = planeIntersection(d, tet, 0, 1);
+            point p12 = planeIntersection(d, tet, 1, 2);
+            point p03 = planeIntersection(d, tet, 0, 3);
+            point p23 = planeIntersection(d, tet, 2, 3);
+            // Split the resulting prism
+            {
+                FixedList<point, 6> p;
+                p[0] = tet[1];
+                p[1] = p12;
+                p[2] = p01;
+                p[3] = tet[3];
+                p[4] = p23;
+                p[5] = p03;
+                //Pout<< "    13 aboveprism:" << p << endl;
+                decomposePrism(p, aboveOp);
+            }
+            {
+                FixedList<point, 6> p;
+                p[0] = tet[2];
+                p[1] = p12;
+                p[2] = p23;
+                p[3] = tet[0];
+                p[4] = p01;
+                p[5] = p03;
+                //Pout<< "    13 belowprism:" << p << endl;
+                decomposePrism(p, belowOp);
+            }
+        }
+        else if (posEdge == edge(2, 3))
+        {
+            point p02 = planeIntersection(d, tet, 0, 2);
+            point p12 = planeIntersection(d, tet, 1, 2);
+            point p03 = planeIntersection(d, tet, 0, 3);
+            point p13 = planeIntersection(d, tet, 1, 3);
+            // Split the resulting prism
+            {
+                FixedList<point, 6> p;
+                p[0] = tet[2];
+                p[1] = p02;
+                p[2] = p12;
+                p[3] = tet[3];
+                p[4] = p03;
+                p[5] = p13;
+                //Pout<< "    23 aboveprism:" << p << endl;
+                decomposePrism(p, aboveOp);
+            }
+            {
+                FixedList<point, 6> p;
+                p[0] = tet[0];
+                p[1] = p02;
+                p[2] = p03;
+                p[3] = tet[1];
+                p[4] = p12;
+                p[5] = p13;
+                //Pout<< "    23 belowprism:" << p << endl;
+                decomposePrism(p, belowOp);
+            }
+        }
+        else
+        {
+            FatalErrorIn("tetSliceWithPlane(..)")
+                << "Missed edge:" << posEdge
+                << abort(FatalError);
+        }
+    }
+    else if (nPos == 1)
+    {
+        // Find the positive tet
+        label i0 = -1;
+        forAll(d, i)
+        {
+            if (d[i] > 0)
+            {
+                i0 = i;
+                break;
+            }
+        }
+
+        label i1 = d.fcIndex(i0);
+        label i2 = d.fcIndex(i1);
+        label i3 = d.fcIndex(i2);
+
+        point p01 = planeIntersection(d, tet, i0, i1);
+        point p02 = planeIntersection(d, tet, i0, i2);
+        point p03 = planeIntersection(d, tet, i0, i3);
+
+        //Pout<< "Split 1pos tet " << tet << " d:" << d << " into" << nl;
+
+        if (i0 == 0 || i0 == 2)
+        {
+            tetPoints t(tet[i0], p01, p02, p03);
+            //Pout<< "    abovetet:" << t << " around i0:" << i0 << endl;
+            //checkTet(t, "nPos 1, aboveTets i0==0 or 2");
+            aboveOp(t);
+
+            // Prism
+            FixedList<point, 6> p;
+            p[0] = tet[i1];
+            p[1] = tet[i3];
+            p[2] = tet[i2];
+            p[3] = p01;
+            p[4] = p03;
+            p[5] = p02;
+            //Pout<< "    belowprism:" << p << endl;
+            decomposePrism(p, belowOp);
+        }
+        else
+        {
+            tetPoints t(p01, p02, p03, tet[i0]);
+            //Pout<< "    abovetet:" << t << " around i0:" << i0 << endl;
+            //checkTet(t, "nPos 1, aboveTets i0==1 or 3");
+            aboveOp(t);
+
+            // Prism
+            FixedList<point, 6> p;
+            p[0] = tet[i3];
+            p[1] = tet[i1];
+            p[2] = tet[i2];
+            p[3] = p03;
+            p[4] = p01;
+            p[5] = p02;
+            //Pout<< "    belowprism:" << p << endl;
+            decomposePrism(p, belowOp);
+        }
+    }
+    else    // nPos == 0
+    {
+        belowOp(tet);
+    }
+}
+
+
+template<class Point, class PointRef>
+template<class AboveTetOp, class BelowTetOp>
+inline void Foam::tetrahedron<Point, PointRef>::sliceWithPlane
+(
+    const plane& pl,
+    AboveTetOp& aboveOp,
+    BelowTetOp& belowOp
+) const
+{
+    tetSliceWithPlane(pl, tetPoints(a_, b_, c_, d_), aboveOp, belowOp);
+}
+
+
+// * * * * * * * * * * * * * * * Ostream Operator  * * * * * * * * * * * * * //
+
+template<class Point, class PointRef>
+inline Foam::Istream& Foam::operator>>
+(
+    Istream& is,
+    tetrahedron<Point, PointRef>& t
+)
+{
+    is.readBegin("tetrahedron");
+    is  >> t.a_ >> t.b_ >> t.c_ >> t.d_;
+    is.readEnd("tetrahedron");
+
+    is.check("Istream& operator>>(Istream&, tetrahedron&)");
+
+    return is;
+}
+
+
+template<class Point, class PointRef>
+inline Foam::Ostream& Foam::operator<<
+(
+    Ostream& os,
+    const tetrahedron<Point, PointRef>& t
+)
+{
+    os  << nl
+        << token::BEGIN_LIST
+        << t.a_ << token::SPACE
+        << t.b_ << token::SPACE
+        << t.c_ << token::SPACE
+        << t.d_
+        << token::END_LIST;
+
+    return os;
+}
+
+
+// ************************************************************************* //
diff --git a/src/turbulenceModels/compressible/turbulenceModel/Make/files b/src/turbulenceModels/compressible/turbulenceModel/Make/files
index cb4d10d56f..3544505a72 100644
--- a/src/turbulenceModels/compressible/turbulenceModel/Make/files
+++ b/src/turbulenceModels/compressible/turbulenceModel/Make/files
@@ -3,9 +3,7 @@ laminar/laminar.C
 
 derivedFvPatchFields/turbulentHeatFluxTemperature/turbulentHeatFluxTemperatureFvPatchScalarField.C
 derivedFvPatchFields/temperatureCoupledBase/temperatureCoupledBase.C
-derivedFvPatchFields/turbulentTemperatureCoupledBaffle/turbulentTemperatureCoupledBaffleFvPatchScalarField.C
 derivedFvPatchFields/turbulentTemperatureCoupledBaffleMixed/turbulentTemperatureCoupledBaffleMixedFvPatchScalarField.C
-derivedFvPatchFields/turbulentTemperatureCoupledBaffle/regionProperties.C
 derivedFvPatchFields/temperatureThermoBaffle1D/temperatureThermoBaffle1DFvPatchScalarFields.C
 derivedFvPatchFields/totalFlowRateAdvectiveDiffusive/totalFlowRateAdvectiveDiffusiveFvPatchScalarField.C
 derivedFvPatchFields/turbulentTemperatureRadCoupledMixed/turbulentTemperatureRadCoupledMixedFvPatchScalarField.C
diff --git a/src/turbulenceModels/compressible/turbulenceModel/derivedFvPatchFields/turbulentTemperatureCoupledBaffle/turbulentTemperatureCoupledBaffleFvPatchScalarField.C b/src/turbulenceModels/compressible/turbulenceModel/derivedFvPatchFields/turbulentTemperatureCoupledBaffle/turbulentTemperatureCoupledBaffleFvPatchScalarField.C
deleted file mode 100644
index 20c0545609..0000000000
--- a/src/turbulenceModels/compressible/turbulenceModel/derivedFvPatchFields/turbulentTemperatureCoupledBaffle/turbulentTemperatureCoupledBaffleFvPatchScalarField.C
+++ /dev/null
@@ -1,308 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-\*---------------------------------------------------------------------------*/
-
-#include "turbulentTemperatureCoupledBaffleFvPatchScalarField.H"
-#include "addToRunTimeSelectionTable.H"
-#include "fvPatchFieldMapper.H"
-#include "volFields.H"
-#include "mappedPatchBase.H"
-#include "regionProperties.H"
-
-// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
-
-bool Foam::turbulentTemperatureCoupledBaffleFvPatchScalarField::interfaceOwner
-(
-    const polyMesh& nbrRegion,
-    const polyPatch& nbrPatch
-) const
-{
-    const fvMesh& myRegion = patch().boundaryMesh().mesh();
-
-    if (nbrRegion.name() == myRegion.name())
-    {
-        return patch().index() < nbrPatch.index();
-    }
-    else
-    {
-        const regionProperties& props =
-            myRegion.objectRegistry::parent().lookupObject<regionProperties>
-            (
-                "regionProperties"
-            );
-
-        label myIndex = findIndex(props.fluidRegionNames(), myRegion.name());
-        if (myIndex == -1)
-        {
-            label i = findIndex(props.solidRegionNames(), myRegion.name());
-
-            if (i == -1)
-            {
-                FatalErrorIn
-                (
-                    "turbulentTemperatureCoupledBaffleFvPatchScalarField"
-                    "::interfaceOwner(const polyMesh&"
-                    ", const polyPatch&)const"
-                )   << "Cannot find region " << myRegion.name()
-                    << " neither in fluids " << props.fluidRegionNames()
-                    << " nor in solids " << props.solidRegionNames()
-                    << exit(FatalError);
-            }
-            myIndex = props.fluidRegionNames().size() + i;
-        }
-        label nbrIndex = findIndex
-        (
-            props.fluidRegionNames(),
-            nbrRegion.name()
-        );
-        if (nbrIndex == -1)
-        {
-            label i = findIndex(props.solidRegionNames(), nbrRegion.name());
-
-            if (i == -1)
-            {
-                FatalErrorIn
-                (
-                    "coupleManager::interfaceOwner"
-                    "(const polyMesh&, const polyPatch&) const"
-                )   << "Cannot find region " << nbrRegion.name()
-                    << " neither in fluids " << props.fluidRegionNames()
-                    << " nor in solids " << props.solidRegionNames()
-                    << exit(FatalError);
-            }
-            nbrIndex = props.fluidRegionNames().size() + i;
-        }
-
-        return myIndex < nbrIndex;
-    }
-}
-
-
-// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
-
-Foam::turbulentTemperatureCoupledBaffleFvPatchScalarField::
-turbulentTemperatureCoupledBaffleFvPatchScalarField
-(
-    const fvPatch& p,
-    const DimensionedField<scalar, volMesh>& iF
-)
-:
-    fixedValueFvPatchScalarField(p, iF),
-    temperatureCoupledBase(patch(), "undefined", "undefined-K"),
-    neighbourFieldName_("undefined-neighbourFieldName")
-{}
-
-
-Foam::turbulentTemperatureCoupledBaffleFvPatchScalarField::
-turbulentTemperatureCoupledBaffleFvPatchScalarField
-(
-    const turbulentTemperatureCoupledBaffleFvPatchScalarField& ptf,
-    const fvPatch& p,
-    const DimensionedField<scalar, volMesh>& iF,
-    const fvPatchFieldMapper& mapper
-)
-:
-    fixedValueFvPatchScalarField(ptf, p, iF, mapper),
-    temperatureCoupledBase(patch(), ptf.KMethod(), ptf.KName()),
-    neighbourFieldName_(ptf.neighbourFieldName_)
-{}
-
-
-Foam::turbulentTemperatureCoupledBaffleFvPatchScalarField::
-turbulentTemperatureCoupledBaffleFvPatchScalarField
-(
-    const fvPatch& p,
-    const DimensionedField<scalar, volMesh>& iF,
-    const dictionary& dict
-)
-:
-    fixedValueFvPatchScalarField(p, iF, dict),
-    temperatureCoupledBase(patch(), dict),
-    neighbourFieldName_(dict.lookup("neighbourFieldName"))
-{
-    if (!isA<mappedPatchBase>(this->patch().patch()))
-    {
-        FatalErrorIn
-        (
-            "turbulentTemperatureCoupledBaffleFvPatchScalarField::"
-            "turbulentTemperatureCoupledBaffleFvPatchScalarField\n"
-            "(\n"
-            "    const fvPatch& p,\n"
-            "    const DimensionedField<scalar, volMesh>& iF,\n"
-            "    const dictionary& dict\n"
-            ")\n"
-        )   << "\n    patch type '" << p.type()
-            << "' not type '" << mappedPatchBase::typeName << "'"
-            << "\n    for patch " << p.name()
-            << " of field " << dimensionedInternalField().name()
-            << " in file " << dimensionedInternalField().objectPath()
-            << exit(FatalError);
-    }
-}
-
-
-Foam::turbulentTemperatureCoupledBaffleFvPatchScalarField::
-turbulentTemperatureCoupledBaffleFvPatchScalarField
-(
-    const turbulentTemperatureCoupledBaffleFvPatchScalarField& wtcsf,
-    const DimensionedField<scalar, volMesh>& iF
-)
-:
-    fixedValueFvPatchScalarField(wtcsf, iF),
-    temperatureCoupledBase(patch(), wtcsf.KMethod(), wtcsf.KName()),
-    neighbourFieldName_(wtcsf.neighbourFieldName_)
-{}
-
-
-// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
-
-void Foam::turbulentTemperatureCoupledBaffleFvPatchScalarField::updateCoeffs()
-{
-    if (updated())
-    {
-        return;
-    }
-
-    // Since we're inside initEvaluate/evaluate there might be processor
-    // comms underway. Change the tag we use.
-    int oldTag = UPstream::msgType();
-    UPstream::msgType() = oldTag+1;
-
-    // Get the coupling information from the mappedPatchBase
-    const mappedPatchBase& mpp = refCast<const mappedPatchBase>
-    (
-        this->patch().patch()
-    );
-    const polyMesh& nbrMesh = mpp.sampleMesh();
-    const fvPatch& nbrPatch = refCast<const fvMesh>
-    (
-        nbrMesh
-    ).boundary()[mpp.samplePolyPatch().index()];
-
-    // Force recalculation of mapping and schedule
-    const mapDistribute& distMap = mpp.map();
-    (void)distMap.schedule();
-
-    tmp<scalarField> intFld = patchInternalField();
-
-    if (interfaceOwner(nbrMesh, nbrPatch.patch()))
-    {
-        // Note: other side information could be cached - it only needs
-        // to be updated the first time round the iteration (i.e. when
-        // switching regions) but unfortunately we don't have this information.
-
-
-        // Calculate the temperature by harmonic averaging
-        // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-        const turbulentTemperatureCoupledBaffleFvPatchScalarField& nbrField =
-        refCast<const turbulentTemperatureCoupledBaffleFvPatchScalarField>
-        (
-            nbrPatch.lookupPatchField<volScalarField, scalar>
-            (
-                neighbourFieldName_
-            )
-        );
-
-        // Swap to obtain full local values of neighbour internal field
-        scalarField nbrIntFld(nbrField.patchInternalField());
-        distMap.distribute(nbrIntFld);
-
-        // Swap to obtain full local values of neighbour K*delta
-        scalarField nbrKDelta(nbrField.K(nbrField)*nbrPatch.deltaCoeffs());
-        distMap.distribute(nbrKDelta);
-
-        tmp<scalarField> myKDelta = K(*this)*patch().deltaCoeffs();
-
-        // Calculate common wall temperature. Reuse *this to store common value.
-        scalarField Twall
-        (
-            (myKDelta()*intFld() + nbrKDelta*nbrIntFld)
-          / (myKDelta() + nbrKDelta)
-        );
-        // Assign to me
-        fvPatchScalarField::operator=(Twall);
-        // Distribute back and assign to neighbour
-        distMap.reverseDistribute(nbrField.size(), Twall);
-        const_cast<turbulentTemperatureCoupledBaffleFvPatchScalarField&>
-        (
-            nbrField
-        ).fvPatchScalarField::operator=(Twall);
-    }
-
-    if (debug)
-    {
-        //tmp<scalarField> normalGradient =
-        //    (*this-intFld())
-        //  * patch().deltaCoeffs();
-
-        scalar Q = gSum(K(*this)*patch().magSf()*snGrad());
-
-        Info<< patch().boundaryMesh().mesh().name() << ':'
-            << patch().name() << ':'
-            << this->dimensionedInternalField().name() << " <- "
-            << nbrMesh.name() << ':'
-            << nbrPatch.name() << ':'
-            << this->dimensionedInternalField().name() << " :"
-            << " heat[W]:" << Q
-            << " walltemperature "
-            << " min:" << gMin(*this)
-            << " max:" << gMax(*this)
-            << " avg:" << gAverage(*this)
-            << endl;
-    }
-
-    // Restore tag
-    UPstream::msgType() = oldTag;
-
-    fixedValueFvPatchScalarField::updateCoeffs();
-}
-
-
-void Foam::turbulentTemperatureCoupledBaffleFvPatchScalarField::write
-(
-    Ostream& os
-) const
-{
-    fixedValueFvPatchScalarField::write(os);
-    os.writeKeyword("neighbourFieldName")<< neighbourFieldName_
-        << token::END_STATEMENT << nl;
-    temperatureCoupledBase::write(os);
-}
-
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-namespace Foam
-{
-
-makePatchTypeField
-(
-    fvPatchScalarField,
-    turbulentTemperatureCoupledBaffleFvPatchScalarField
-);
-
-} // End namespace Foam
-
-// ************************************************************************* //
diff --git a/src/turbulenceModels/compressible/turbulenceModel/derivedFvPatchFields/turbulentTemperatureCoupledBaffle/turbulentTemperatureCoupledBaffleFvPatchScalarField.H b/src/turbulenceModels/compressible/turbulenceModel/derivedFvPatchFields/turbulentTemperatureCoupledBaffle/turbulentTemperatureCoupledBaffleFvPatchScalarField.H
deleted file mode 100644
index 0854f13639..0000000000
--- a/src/turbulenceModels/compressible/turbulenceModel/derivedFvPatchFields/turbulentTemperatureCoupledBaffle/turbulentTemperatureCoupledBaffleFvPatchScalarField.H
+++ /dev/null
@@ -1,179 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-Class
-    turbulentTemperatureCoupledBaffleFvPatchScalarField
-
-Description
-    Harmonic fixed value boundary condition for temperature, to be used
-    for heat-transfer on back-to-back baffles.
-
-    If my temperature is T1, heat conductivity K1 and neighbour is T2,K2
-
-    both sides get fixedValue (K1/dx1*T1 + K2/dx2*T2)/(K1/dx1+K2/dx2)
-
-    Example usage:
-        myInterfacePatchName
-        {
-            type    compressible::turbulentTemperatureCoupledBaffle;
-            neighbourFieldName  T;
-            K                   lookup;
-            KName               K; // or none
-            value               uniform 300;
-        }
-
-    Needs to be on underlying mapped(Wall)FvPatch.
-
-    Note: see temperatureCoupledBase on ways to specify K.
-
-    Note: runs in parallel with arbitrary decomposition. Uses mapped
-    functionality to calculate exchange.
-
-    Note: lags interface data so both sides use same data.
-    - problem: schedule to calculate average would interfere
-    with standard processor swaps.
-    - so: updateCoeffs sets both to same Twall. Only need to do
-    this for last outer iteration but don't have access to this.
-
-SourceFiles
-    turbulentTemperatureCoupledBaffleFvPatchScalarField.C
-
-\*---------------------------------------------------------------------------*/
-
-#ifndef turbulentTemperatureCoupledBaffleFvPatchScalarField_H
-#define turbulentTemperatureCoupledBaffleFvPatchScalarField_H
-
-#include "fixedValueFvPatchFields.H"
-#include "temperatureCoupledBase.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-namespace Foam
-{
-
-/*---------------------------------------------------------------------------*\
-        Class turbulentTemperatureCoupledBaffleFvPatchScalarField Declaration
-\*---------------------------------------------------------------------------*/
-
-class turbulentTemperatureCoupledBaffleFvPatchScalarField
-:
-    public fixedValueFvPatchScalarField,
-    public temperatureCoupledBase
-{
-    // Private data
-
-        //- Name of field on the neighbour region
-        const word neighbourFieldName_;
-
-
-    // Private Member Functions
-
-        //- Am I or neighbour owner of interface
-        bool interfaceOwner(const polyMesh&, const polyPatch&) const;
-
-
-public:
-
-    //- Runtime type information
-    TypeName("compressible::turbulentTemperatureCoupledBaffle");
-
-
-    // Constructors
-
-        //- Construct from patch and internal field
-        turbulentTemperatureCoupledBaffleFvPatchScalarField
-        (
-            const fvPatch&,
-            const DimensionedField<scalar, volMesh>&
-        );
-
-        //- Construct from patch, internal field and dictionary
-        turbulentTemperatureCoupledBaffleFvPatchScalarField
-        (
-            const fvPatch&,
-            const DimensionedField<scalar, volMesh>&,
-            const dictionary&
-        );
-
-        //- Construct by mapping given
-        //  turbulentTemperatureCoupledBaffleFvPatchScalarField onto a new patch
-        turbulentTemperatureCoupledBaffleFvPatchScalarField
-        (
-            const turbulentTemperatureCoupledBaffleFvPatchScalarField&,
-            const fvPatch&,
-            const DimensionedField<scalar, volMesh>&,
-            const fvPatchFieldMapper&
-        );
-
-        //- Construct and return a clone
-        virtual tmp<fvPatchScalarField> clone() const
-        {
-            return tmp<fvPatchScalarField>
-            (
-                new turbulentTemperatureCoupledBaffleFvPatchScalarField(*this)
-            );
-        }
-
-        //- Construct as copy setting internal field reference
-        turbulentTemperatureCoupledBaffleFvPatchScalarField
-        (
-            const turbulentTemperatureCoupledBaffleFvPatchScalarField&,
-            const DimensionedField<scalar, volMesh>&
-        );
-
-        //- Construct and return a clone setting internal field reference
-        virtual tmp<fvPatchScalarField> clone
-        (
-            const DimensionedField<scalar, volMesh>& iF
-        ) const
-        {
-            return tmp<fvPatchScalarField>
-            (
-                new turbulentTemperatureCoupledBaffleFvPatchScalarField
-                (
-                    *this,
-                    iF
-                )
-            );
-        }
-
-
-    // Member functions
-
-        //- Update the coefficients associated with the patch field
-        virtual void updateCoeffs();
-
-        //- Write
-        virtual void write(Ostream&) const;
-};
-
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#endif
-
-// ************************************************************************* //
diff --git a/tutorials/heatTransfer/chtMultiRegionFoam/multiRegionHeater/Allrun b/tutorials/heatTransfer/chtMultiRegionFoam/multiRegionHeater/Allrun
index a63bfce6ab..b9137a48fa 100755
--- a/tutorials/heatTransfer/chtMultiRegionFoam/multiRegionHeater/Allrun
+++ b/tutorials/heatTransfer/chtMultiRegionFoam/multiRegionHeater/Allrun
@@ -37,13 +37,13 @@ do
 done
 
 # Run
-runParallel `getApplication` 4
+#runParallel `getApplication` 4
 
 # Reconstruct
-for i in bottomAir topAir heater leftSolid rightSolid
-do
-   reconstructPar -region $i > log.reconstructPar.$i2 >&1
-done
+#for i in bottomAir topAir heater leftSolid rightSolid
+#do
+#   reconstructPar -region $i > log.reconstructPar.$i2 >&1
+#done
 
 
 echo
diff --git a/tutorials/heatTransfer/chtMultiRegionFoam/multiRegionHeater/constant/regionProperties b/tutorials/heatTransfer/chtMultiRegionFoam/multiRegionHeater/constant/regionProperties
index 67629a878b..dc0d1417d5 100644
--- a/tutorials/heatTransfer/chtMultiRegionFoam/multiRegionHeater/constant/regionProperties
+++ b/tutorials/heatTransfer/chtMultiRegionFoam/multiRegionHeater/constant/regionProperties
@@ -15,8 +15,12 @@ FoamFile
 }
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-fluidRegionNames ( bottomAir topAir );
-
-solidRegionNames ( heater leftSolid rightSolid );
+regions
+(
+    fluid       (bottomAir topAir)
+    solid       (heater leftSolid rightSolid)
+    porousFluid ()
+    porousSolid ()
+);
 
 // ************************************************************************* //
diff --git a/tutorials/heatTransfer/chtMultiRegionFoam/multiRegionLiquidHeater/constant/regionProperties b/tutorials/heatTransfer/chtMultiRegionFoam/multiRegionLiquidHeater/constant/regionProperties
index 138248c73f..d76684c2cd 100644
--- a/tutorials/heatTransfer/chtMultiRegionFoam/multiRegionLiquidHeater/constant/regionProperties
+++ b/tutorials/heatTransfer/chtMultiRegionFoam/multiRegionLiquidHeater/constant/regionProperties
@@ -15,8 +15,12 @@ FoamFile
 }
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-fluidRegionNames ( bottomWater topAir );
-
-solidRegionNames ( heater leftSolid rightSolid );
+regions
+(
+    fluid       (bottomWater topAir)
+    solid       (heater leftSolid rightSolid)
+    porousFluid ()
+    porousSolid ()
+);
 
 // ************************************************************************* //
diff --git a/tutorials/heatTransfer/chtMultiRegionFoam/snappyMultiRegionHeater/constant/regionProperties b/tutorials/heatTransfer/chtMultiRegionFoam/snappyMultiRegionHeater/constant/regionProperties
index 67629a878b..9ca5dc857c 100644
--- a/tutorials/heatTransfer/chtMultiRegionFoam/snappyMultiRegionHeater/constant/regionProperties
+++ b/tutorials/heatTransfer/chtMultiRegionFoam/snappyMultiRegionHeater/constant/regionProperties
@@ -15,8 +15,13 @@ FoamFile
 }
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-fluidRegionNames ( bottomAir topAir );
+regions
+(
+    fluid       (bottomAir topAir)
+    solid       (heater leftSolid rightSolid)
+    porousFluid ()
+    porousSolid ()
+);
 
-solidRegionNames ( heater leftSolid rightSolid );
 
 // ************************************************************************* //
diff --git a/tutorials/heatTransfer/chtMultiRegionSimpleFoam/multiRegionHeater/constant/regionProperties b/tutorials/heatTransfer/chtMultiRegionSimpleFoam/multiRegionHeater/constant/regionProperties
index 67629a878b..dc0d1417d5 100644
--- a/tutorials/heatTransfer/chtMultiRegionSimpleFoam/multiRegionHeater/constant/regionProperties
+++ b/tutorials/heatTransfer/chtMultiRegionSimpleFoam/multiRegionHeater/constant/regionProperties
@@ -15,8 +15,12 @@ FoamFile
 }
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-fluidRegionNames ( bottomAir topAir );
-
-solidRegionNames ( heater leftSolid rightSolid );
+regions
+(
+    fluid       (bottomAir topAir)
+    solid       (heater leftSolid rightSolid)
+    porousFluid ()
+    porousSolid ()
+);
 
 // ************************************************************************* //
diff --git a/tutorials/heatTransfer/chtMultiRegionSimpleFoam/multiRegionHeaterRadiation/constant/regionProperties b/tutorials/heatTransfer/chtMultiRegionSimpleFoam/multiRegionHeaterRadiation/constant/regionProperties
index 67629a878b..dc0d1417d5 100644
--- a/tutorials/heatTransfer/chtMultiRegionSimpleFoam/multiRegionHeaterRadiation/constant/regionProperties
+++ b/tutorials/heatTransfer/chtMultiRegionSimpleFoam/multiRegionHeaterRadiation/constant/regionProperties
@@ -15,8 +15,12 @@ FoamFile
 }
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-fluidRegionNames ( bottomAir topAir );
-
-solidRegionNames ( heater leftSolid rightSolid );
+regions
+(
+    fluid       (bottomAir topAir)
+    solid       (heater leftSolid rightSolid)
+    porousFluid ()
+    porousSolid ()
+);
 
 // ************************************************************************* //
diff --git a/tutorials/lagrangian/porousExplicitSourceReactingParcelFoam/parcelInBox/system/fvSolution b/tutorials/lagrangian/porousExplicitSourceReactingParcelFoam/parcelInBox/system/fvSolution
index 6622d336f4..b4db5d1593 100644
--- a/tutorials/lagrangian/porousExplicitSourceReactingParcelFoam/parcelInBox/system/fvSolution
+++ b/tutorials/lagrangian/porousExplicitSourceReactingParcelFoam/parcelInBox/system/fvSolution
@@ -59,6 +59,7 @@ solvers
         nCellsInCoarsestLevel 10;
         agglomerator    faceAreaPair;
         mergeLevels     1;
+        maxIter         20;
     }
 
     pFinal
@@ -66,7 +67,6 @@ solvers
         $p;
         tolerance       1e-06;
         relTol          0;
-        maxIter         20;
     }
 
     "(Yi|O2|N2|H2O)"
diff --git a/tutorials/multiphase/interFoam/ras/damBreakPorousBaffle/system/fvSolution b/tutorials/multiphase/interFoam/ras/damBreakPorousBaffle/system/fvSolution
index 8ae8ee05ae..97d24d6130 100644
--- a/tutorials/multiphase/interFoam/ras/damBreakPorousBaffle/system/fvSolution
+++ b/tutorials/multiphase/interFoam/ras/damBreakPorousBaffle/system/fvSolution
@@ -68,11 +68,11 @@ PIMPLE
     cAlpha          2;
 }
 
-relaxation
+relaxationFactors
 {
-    U           1;
-    k           1;
-    epsilon     1;
+    "U.*"           1;
+    "k.*"           1;
+    "epsilon.*"     1;
 }
 
 // ************************************************************************* //