diff --git a/applications/test/extendedStencil/Test-ExtendedStencil.C b/applications/test/extendedStencil/Test-ExtendedStencil.C
index 72c1afb2c1..0e50f8710f 100644
--- a/applications/test/extendedStencil/Test-ExtendedStencil.C
+++ b/applications/test/extendedStencil/Test-ExtendedStencil.C
@@ -56,6 +56,8 @@ Description
 //#include "centredCFCFaceToCellStencilObject.H"
 
 #include "centredCECCellToCellStencilObject.H"
+#include "centredCFCCellToCellStencilObject.H"
+#include "centredCPCCellToCellStencilObject.H"
 
 using namespace Foam;
 
@@ -460,7 +462,63 @@ int main(int argc, char *argv[])
         {
             writeStencilOBJ
             (
-                runTime.path()/"centredCell" + Foam::name(cellI) + ".obj",
+                runTime.path()/"centredCECCell" + Foam::name(cellI) + ".obj",
+                mesh.cellCentres()[cellI],
+                stencilPoints[cellI]
+            );
+        }
+    }
+    {
+        const extendedCentredCellToCellStencil& addressing =
+        centredCPCCellToCellStencilObject::New
+        (
+            mesh
+        );
+
+        Info<< "cellCellCell:" << endl;
+        writeStencilStats(addressing.stencil());
+
+        // Collect stencil cell centres
+        List<List<point> > stencilPoints(mesh.nCells());
+        addressing.collectData
+        (
+            mesh.C(),
+            stencilPoints
+        );
+
+        forAll(stencilPoints, cellI)
+        {
+            writeStencilOBJ
+            (
+                runTime.path()/"centredCPCCell" + Foam::name(cellI) + ".obj",
+                mesh.cellCentres()[cellI],
+                stencilPoints[cellI]
+            );
+        }
+    }
+    {
+        const extendedCentredCellToCellStencil& addressing =
+        centredCFCCellToCellStencilObject::New
+        (
+            mesh
+        );
+
+        Info<< "cellCellCell:" << endl;
+        writeStencilStats(addressing.stencil());
+
+        // Collect stencil cell centres
+        List<List<point> > stencilPoints(mesh.nCells());
+        addressing.collectData
+        (
+            mesh.C(),
+            stencilPoints
+        );
+
+        forAll(stencilPoints, cellI)
+        {
+            writeStencilOBJ
+            (
+                runTime.path()/"centredCFCCell" + Foam::name(cellI) + ".obj",
                 mesh.cellCentres()[cellI],
                 stencilPoints[cellI]
             );
diff --git a/applications/utilities/mesh/generation/extrude/extrudeMesh/extrudeMesh.C b/applications/utilities/mesh/generation/extrude/extrudeMesh/extrudeMesh.C
index f4ce2cc95d..f2c091e4ad 100644
--- a/applications/utilities/mesh/generation/extrude/extrudeMesh/extrudeMesh.C
+++ b/applications/utilities/mesh/generation/extrude/extrudeMesh/extrudeMesh.C
@@ -493,7 +493,6 @@ int main(int argc, char *argv[])
                         mesh.nFaces(),      // start
                         patchI,             // index
                         mesh.boundaryMesh(),// polyBoundaryMesh
-                        Pstream::worldComm, // communicator
                         Pstream::myProcNo(),// myProcNo
                         nbrProcI            // neighbProcNo
                     )
diff --git a/applications/utilities/mesh/generation/snappyHexMesh/snappyHexMeshDict b/applications/utilities/mesh/generation/snappyHexMesh/snappyHexMeshDict
index f448faa40c..ca4a9dc6b5 100644
--- a/applications/utilities/mesh/generation/snappyHexMesh/snappyHexMeshDict
+++ b/applications/utilities/mesh/generation/snappyHexMesh/snappyHexMeshDict
@@ -180,6 +180,12 @@ castellatedMeshControls
     // - used if feature snapping (see snapControls below) is used
     resolveFeatureAngle 30;
 
+    // Planar angle:
+    // - used to determine if neighbouring surface normals
+    //   are roughly the same so e.g. free-standing baffles can be merged
+    // If not specified same as resolveFeatureAngle
+    //planarAngle 30;
+
 
     // Region-wise refinement
     // ~~~~~~~~~~~~~~~~~~~~~~
diff --git a/applications/utilities/mesh/manipulation/createBaffles/createBafflesDict b/applications/utilities/mesh/manipulation/createBaffles/createBafflesDict
index b392f07642..ef2eb96227 100644
--- a/applications/utilities/mesh/manipulation/createBaffles/createBafflesDict
+++ b/applications/utilities/mesh/manipulation/createBaffles/createBafflesDict
@@ -14,6 +14,20 @@ FoamFile
 }
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
+// Sample for creating baffles:
+// - usually converting internal faces into two boundary faces
+// - or converting boundary faces into a boundary face
+//   (internalFacesOnly=false)(though should use really createPatch
+//    to do this)
+// - can also create duplicate (overlapping) sets of baffles:
+//      - internalFacesOnly = false
+//      - have 4 entries in patches:
+//          - master
+//          - slave
+//          - additional master
+//          - additional slave
+
+
 // Whether to convert internal faces only (so leave boundary faces intact).
 // This is only relevant if your face selection type can pick up boundary
 // faces.
diff --git a/applications/utilities/parallelProcessing/decomposePar/domainDecomposition.C b/applications/utilities/parallelProcessing/decomposePar/domainDecomposition.C
index f563978b60..15cbd85d11 100644
--- a/applications/utilities/parallelProcessing/decomposePar/domainDecomposition.C
+++ b/applications/utilities/parallelProcessing/decomposePar/domainDecomposition.C
@@ -448,7 +448,6 @@ bool Foam::domainDecomposition::writeDecomposition()
                             curStart,
                             nPatches,
                             procMesh.boundaryMesh(),
-                            Pstream::worldComm,
                             procI,
                             curNeighbourProcessors[procPatchI]
                         );
@@ -476,7 +475,6 @@ bool Foam::domainDecomposition::writeDecomposition()
                             curStart,
                             nPatches,
                             procMesh.boundaryMesh(),
-                            Pstream::worldComm,
                             procI,
                             curNeighbourProcessors[procPatchI],
                             referPatch,
diff --git a/applications/utilities/postProcessing/dataConversion/foamToEnsight/foamToEnsight.C b/applications/utilities/postProcessing/dataConversion/foamToEnsight/foamToEnsight.C
index edb29d3998..d50bf96448 100644
--- a/applications/utilities/postProcessing/dataConversion/foamToEnsight/foamToEnsight.C
+++ b/applications/utilities/postProcessing/dataConversion/foamToEnsight/foamToEnsight.C
@@ -240,7 +240,7 @@ int main(int argc, char *argv[])
     wordHashSet allCloudNames;
     if (Pstream::master())
     {
-        word geomFileName = prepend + "000";
+        word geomFileName = prepend + "0000";
 
         // test pre check variable if there is a moving mesh
         if (meshMoving)
diff --git a/applications/utilities/preProcessing/viewFactorsGen/searchingEngine.H b/applications/utilities/preProcessing/viewFactorsGen/searchingEngine.H
index ed1d9031ec..ef5b264a54 100644
--- a/applications/utilities/preProcessing/viewFactorsGen/searchingEngine.H
+++ b/applications/utilities/preProcessing/viewFactorsGen/searchingEngine.H
@@ -26,7 +26,8 @@ dict.add("mergeDistance", SMALL);
 labelHashSet includePatches;
 forAll(patches, patchI)
 {
-    if (!isA<processorPolyPatch>(patches[patchI]))
+    const polyPatch& pp = patches[patchI];
+    if (!pp.coupled() && !isA<cyclicAMIPolyPatch>(pp))
     {
         includePatches.insert(patchI);
     }
diff --git a/applications/utilities/preProcessing/viewFactorsGen/viewFactorsGen.C b/applications/utilities/preProcessing/viewFactorsGen/viewFactorsGen.C
index c9aa219d13..8276528945 100644
--- a/applications/utilities/preProcessing/viewFactorsGen/viewFactorsGen.C
+++ b/applications/utilities/preProcessing/viewFactorsGen/viewFactorsGen.C
@@ -44,6 +44,7 @@ Description
 #include "volFields.H"
 #include "surfaceFields.H"
 #include "distributedTriSurfaceMesh.H"
+#include "cyclicAMIPolyPatch.H"
 #include "triSurfaceTools.H"
 #include "mapDistribute.H"
 
diff --git a/etc/caseDicts/setConstraintTypes b/etc/caseDicts/setConstraintTypes
index 85d6ec525c..1678e2a147 100644
--- a/etc/caseDicts/setConstraintTypes
+++ b/etc/caseDicts/setConstraintTypes
@@ -16,6 +16,11 @@ cyclicAMI
     type  cyclicAMI;
 }
 
+cyclicACMI
+{
+    type  cyclicACMI;
+}
+
 cyclicSlip
 {
     type  cyclicSlip;
diff --git a/etc/controlDict b/etc/controlDict
index b9c41cb3a4..fba02069de 100644
--- a/etc/controlDict
+++ b/etc/controlDict
@@ -135,7 +135,7 @@ DebugSwitches
     FDIC                0;
     FaceCellWave        0;
     GAMG                0;
-    GAMGAgglomeration   0;
+    GAMGAgglomeration   1;
     GAMGInterface       0;
     GAMGInterfaceField  0;
     Gamma               0;
diff --git a/src/OpenFOAM/Make/files b/src/OpenFOAM/Make/files
index a261a58572..8fbcde54bc 100644
--- a/src/OpenFOAM/Make/files
+++ b/src/OpenFOAM/Make/files
@@ -332,10 +332,8 @@ eagerGAMGProcAgglomeration = $(GAMGProcAgglomerations)/eagerGAMGProcAgglomeratio
 $(eagerGAMGProcAgglomeration)/eagerGAMGProcAgglomeration.C
 noneGAMGProcAgglomeration = $(GAMGProcAgglomerations)/noneGAMGProcAgglomeration
 $(noneGAMGProcAgglomeration)/noneGAMGProcAgglomeration.C
-/*
-cellFaceRatioGAMGProcAgglomeration = $(GAMGProcAgglomerations)/cellFaceRatioGAMGProcAgglomeration
-$(cellFaceRatioGAMGProcAgglomeration)/cellFaceRatioGAMGProcAgglomeration.C
-*/
+procFacesGAMGProcAgglomeration = $(GAMGProcAgglomerations)/procFacesGAMGProcAgglomeration
+$(procFacesGAMGProcAgglomeration)/procFacesGAMGProcAgglomeration.C
 
 
 meshes/lduMesh/lduMesh.C
diff --git a/src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricBoundaryField.C b/src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricBoundaryField.C
index c1b516e97c..c024d98389 100644
--- a/src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricBoundaryField.C
+++ b/src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricBoundaryField.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -49,21 +49,16 @@ readField
             << endl;
     }
 
-    // Patch or patch-groups. (using non-wild card entries of dictionaries)
+
+    // 1. Handle explicit patch names
     forAllConstIter(dictionary, dict, iter)
     {
         if (iter().isDict() && !iter().keyword().isPattern())
         {
-            const labelList patchIDs = bmesh_.findIndices
-            (
-                iter().keyword(),
-                true
-            );
+            label patchi = bmesh_.findPatchID(iter().keyword());
 
-            forAll(patchIDs, i)
+            if (patchi != -1)
             {
-                label patchi = patchIDs[i];
-
                 this->set
                 (
                     patchi,
@@ -78,7 +73,43 @@ readField
         }
     }
 
-    // Check for wildcard patch overrides
+
+    // 2. Patch-groups. (using non-wild card entries of dictionaries)
+    // (patchnames already matched above)
+    // Note: in order of entries in the dictionary (first patchGroups wins)
+    forAllConstIter(dictionary, dict, iter)
+    {
+        if (iter().isDict() && !iter().keyword().isPattern())
+        {
+            const labelList patchIDs = bmesh_.findIndices
+            (
+                iter().keyword(),
+                true                    // use patchGroups
+            );
+
+            forAll(patchIDs, i)
+            {
+                label patchi = patchIDs[i];
+
+                if (!this->set(patchi))
+                {
+                    this->set
+                    (
+                        patchi,
+                        PatchField<Type>::New
+                        (
+                            bmesh_[patchi],
+                            field,
+                            iter().dict()
+                        )
+                    );
+                }
+            }
+        }
+    }
+
+
+    // 3. Wildcard patch overrides
     forAll(bmesh_, patchi)
     {
         if (!this->set(patchi))
diff --git a/src/OpenFOAM/matrices/lduMatrix/solvers/GAMG/GAMGAgglomerations/GAMGAgglomeration/GAMGAgglomerateLduAddressing.C b/src/OpenFOAM/matrices/lduMatrix/solvers/GAMG/GAMGAgglomerations/GAMGAgglomeration/GAMGAgglomerateLduAddressing.C
index e6781ed23f..066aa39d3b 100644
--- a/src/OpenFOAM/matrices/lduMatrix/solvers/GAMG/GAMGAgglomerations/GAMGAgglomeration/GAMGAgglomerateLduAddressing.C
+++ b/src/OpenFOAM/matrices/lduMatrix/solvers/GAMG/GAMGAgglomerations/GAMGAgglomeration/GAMGAgglomerateLduAddressing.C
@@ -351,7 +351,7 @@ void Foam::GAMGAgglomeration::agglomerateLduAddressing
     );
 
 
-    if (debug)
+    if (debug & 2)
     {
         Pout<< "GAMGAgglomeration :"
             << " agglomerated level " << fineLevelIndex
diff --git a/src/OpenFOAM/matrices/lduMatrix/solvers/GAMG/GAMGAgglomerations/GAMGAgglomeration/GAMGAgglomeration.C b/src/OpenFOAM/matrices/lduMatrix/solvers/GAMG/GAMGAgglomerations/GAMGAgglomeration/GAMGAgglomeration.C
index d1551eb399..75af8eb20a 100644
--- a/src/OpenFOAM/matrices/lduMatrix/solvers/GAMG/GAMGAgglomerations/GAMGAgglomeration/GAMGAgglomeration.C
+++ b/src/OpenFOAM/matrices/lduMatrix/solvers/GAMG/GAMGAgglomerations/GAMGAgglomeration/GAMGAgglomeration.C
@@ -27,9 +27,9 @@ License
 #include "lduMesh.H"
 #include "lduMatrix.H"
 #include "Time.H"
-#include "dlLibraryTable.H"
 #include "GAMGInterface.H"
 #include "GAMGProcAgglomeration.H"
+#include "IOmanip.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
@@ -67,23 +67,112 @@ void Foam::GAMGAgglomeration::compactLevels(const label nCreatedLevels)
         procBoundaryFaceMap_.setSize(nCreatedLevels);
 
         procAgglomeratorPtr_().agglomerate();
-    }
 
-    if (debug)
-    {
-        for (label levelI = 0; levelI <= size(); levelI++)
+
+        if (debug)
         {
-            if (hasMeshLevel(levelI))
+
+            Info<< "GAMGAgglomeration:" << nl
+                << "    local agglomerator     : " << type() << nl
+                << "    processor agglomerator : "
+                << procAgglomeratorPtr_().type() << nl
+                << nl;
+
+            Info<< setw(40) << "nCells"
+                << setw(24) << "nFaces/nCells"
+                << setw(24) << "nInterfaces"
+                << setw(24) << "nIntFaces/nCells" << nl
+                << setw(8) << "Level"
+                << setw(8) << "nProcs"
+                << "        "
+                << setw(8) << "avg"
+                << setw(8) << "max"
+                << "        "
+                << setw(8) << "avg"
+                << setw(8) << "max"
+                << "        "
+                << setw(8) << "avg"
+                << setw(8) << "max"
+                << "            " << setw(4) << "avg"
+                << "    " << setw(4) << "max"
+                << nl
+                << setw(8) << "-----"
+                << setw(8) << "------"
+                << "        "
+                << setw(8) << "---"
+                << setw(8) << "---"
+                << "        "
+                << setw(8) << "---"
+                << setw(8) << "---"
+                << "            " << setw(4) << "---"
+                << "    " << setw(4) << "---"
+                << nl;
+
+            for (label levelI = 0; levelI <= size(); levelI++)
             {
-                const lduMesh& fineMesh = meshLevel(levelI);
-                Pout<< "Level " << levelI << " fine mesh:"<< nl;
-                Pout<< fineMesh.info() << endl;
-            }
-            else
-            {
-                Pout<< "Level " << levelI << " has no fine mesh:" << nl
-                    << endl;
+                label nProcs = 0;
+                label nCells = 0;
+                scalar faceCellRatio = 0;
+                label nInterfaces = 0;
+                label nIntFaces = 0;
+                scalar ratio = 0.0;
+
+                if (hasMeshLevel(levelI))
+                {
+                    nProcs = 1;
+
+                    const lduMesh& fineMesh = meshLevel(levelI);
+                    nCells = fineMesh.lduAddr().size();
+                    faceCellRatio =
+                        scalar(fineMesh.lduAddr().lowerAddr().size())/nCells;
+
+                    const lduInterfacePtrsList interfaces =
+                        fineMesh.interfaces();
+                    forAll(interfaces, i)
+                    {
+                        if (interfaces.set(i))
+                        {
+                            nInterfaces++;
+                            nIntFaces += interfaces[i].faceCells().size();
+                        }
+                    }
+                    ratio = scalar(nIntFaces)/nCells;
+                }
+
+                label totNprocs = returnReduce(nProcs, sumOp<label>());
+
+                label maxNCells = returnReduce(nCells, maxOp<label>());
+                label totNCells = returnReduce(nCells, sumOp<label>());
+
+                scalar maxFaceCellRatio =
+                    returnReduce(faceCellRatio, maxOp<scalar>());
+                scalar totFaceCellRatio =
+                    returnReduce(faceCellRatio, sumOp<scalar>());
+
+                label maxNInt = returnReduce(nInterfaces, maxOp<label>());
+                label totNInt = returnReduce(nInterfaces, sumOp<label>());
+
+                scalar maxRatio = returnReduce(ratio, maxOp<scalar>());
+                scalar totRatio = returnReduce(ratio, sumOp<scalar>());
+
+                Info<< setw(8) << levelI
+                    << setw(8) << totNprocs
+
+                    << setw(16) << totNCells/totNprocs
+                    << setw(8) << maxNCells
+
+                    << "        "
+                    << setw(8) << setprecision(4) << totFaceCellRatio/totNprocs
+                    << setw(8) << setprecision(4) << maxFaceCellRatio
+                    << "        "
+                    << setw(8) << totNInt/totNprocs
+                    << setw(8) << maxNInt
+                    << "        "
+                    << setw(8) << setprecision(4) << totRatio/totNprocs
+                    << setw(8) << setprecision(4) << maxRatio
+                    << nl;
             }
+            Info<< endl;
         }
     }
 }
@@ -190,9 +279,9 @@ const Foam::GAMGAgglomeration& Foam::GAMGAgglomeration::New
                 "(const lduMesh& mesh, const dictionary& controlDict)"
             )   << "Unknown GAMGAgglomeration type "
                 << agglomeratorType << ".\n"
-                << "Valid algebraic GAMGAgglomeration types are :"
+                << "Valid matrix GAMGAgglomeration types are :"
                 << lduMatrixConstructorTablePtr_->sortedToc() << endl
-                << "Valid algebraic GAMGAgglomeration types are :"
+                << "Valid geometric GAMGAgglomeration types are :"
                 << lduMeshConstructorTablePtr_->sortedToc()
                 << exit(FatalError);
         }
@@ -285,7 +374,8 @@ Foam::autoPtr<Foam::GAMGAgglomeration> Foam::GAMGAgglomeration::New
         FatalErrorIn
         (
             "GAMGAgglomeration::New"
-            "(const lduMesh& mesh, const dictionary& controlDict)"
+            "(const lduMesh& mesh, const scalarField&"
+            ", const vectorField&, const dictionary& controlDict)"
         )   << "Unknown GAMGAgglomeration type "
             << agglomeratorType << ".\n"
             << "Valid geometric GAMGAgglomeration types are :"
diff --git a/src/OpenFOAM/matrices/lduMatrix/solvers/GAMG/GAMGAgglomerations/pairGAMGAgglomeration/pairGAMGAgglomeration.H b/src/OpenFOAM/matrices/lduMatrix/solvers/GAMG/GAMGAgglomerations/pairGAMGAgglomeration/pairGAMGAgglomeration.H
index 2867cac2f6..59de4b1e4d 100644
--- a/src/OpenFOAM/matrices/lduMatrix/solvers/GAMG/GAMGAgglomerations/pairGAMGAgglomeration/pairGAMGAgglomeration.H
+++ b/src/OpenFOAM/matrices/lduMatrix/solvers/GAMG/GAMGAgglomerations/pairGAMGAgglomeration/pairGAMGAgglomeration.H
@@ -61,14 +61,6 @@ protected:
 
     // Protected Member Functions
 
-        //- Calculate and return agglomeration of given level
-        tmp<labelField> agglomerate
-        (
-            label& nCoarseCells,
-            const lduAddressing& fineMatrixAddressing,
-            const scalarField& faceWeights
-        );
-
         //- Agglomerate all levels starting from the given face weights
         void agglomerate
         (
@@ -97,6 +89,15 @@ public:
             const lduMesh& mesh,
             const dictionary& controlDict
         );
+
+        //- Calculate and return agglomeration
+        static tmp<labelField> agglomerate
+        (
+            label& nCoarseCells,
+            const lduAddressing& fineMatrixAddressing,
+            const scalarField& faceWeights
+        );
+
 };
 
 
diff --git a/src/OpenFOAM/matrices/lduMatrix/solvers/GAMG/GAMGProcAgglomerations/procFacesGAMGProcAgglomeration/procFacesGAMGProcAgglomeration.C b/src/OpenFOAM/matrices/lduMatrix/solvers/GAMG/GAMGProcAgglomerations/procFacesGAMGProcAgglomeration/procFacesGAMGProcAgglomeration.C
new file mode 100644
index 0000000000..6e13d52c99
--- /dev/null
+++ b/src/OpenFOAM/matrices/lduMatrix/solvers/GAMG/GAMGProcAgglomerations/procFacesGAMGProcAgglomeration/procFacesGAMGProcAgglomeration.C
@@ -0,0 +1,333 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 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 "procFacesGAMGProcAgglomeration.H"
+#include "addToRunTimeSelectionTable.H"
+#include "GAMGAgglomeration.H"
+#include "Random.H"
+#include "lduMesh.H"
+#include "processorLduInterface.H"
+#include "processorGAMGInterface.H"
+#include "pairGAMGAgglomeration.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(procFacesGAMGProcAgglomeration, 0);
+
+    addToRunTimeSelectionTable
+    (
+        GAMGProcAgglomeration,
+        procFacesGAMGProcAgglomeration,
+        GAMGAgglomeration
+    );
+}
+
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+// Create single cell mesh
+Foam::autoPtr<Foam::lduPrimitiveMesh>
+Foam::procFacesGAMGProcAgglomeration::singleCellMesh
+(
+    const label singleCellMeshComm,
+    const lduMesh& mesh,
+    scalarField& faceWeights
+) const
+{
+    // Count number of faces per processor
+    List<Map<label> > procFaces(UPstream::nProcs(mesh.comm()));
+    Map<label>& myNeighbours = procFaces[UPstream::myProcNo(mesh.comm())];
+
+    {
+        const lduInterfacePtrsList interfaces(mesh.interfaces());
+        forAll(interfaces, intI)
+        {
+            if (interfaces.set(intI))
+            {
+                const processorLduInterface& pp =
+                    refCast<const processorLduInterface>
+                    (
+                        interfaces[intI]
+                    );
+                label size = interfaces[intI].faceCells().size();
+                myNeighbours.insert(pp.neighbProcNo(), size);
+            }
+        }
+    }
+
+    Pstream::gatherList(procFaces, Pstream::msgType(), mesh.comm());
+    Pstream::scatterList(procFaces, Pstream::msgType(), mesh.comm());
+
+    autoPtr<lduPrimitiveMesh> singleCellMeshPtr;
+
+    if (Pstream::master(mesh.comm()))
+    {
+        // I am master
+        label nCells = Pstream::nProcs(mesh.comm());
+
+        DynamicList<label> l(3*nCells);
+        DynamicList<label> u(3*nCells);
+        DynamicList<scalar> weight(3*nCells);
+
+        DynamicList<label> nbrs;
+        DynamicList<scalar> weights;
+
+        forAll(procFaces, procI)
+        {
+            const Map<label>& neighbours = procFaces[procI];
+
+            // Add all the higher processors
+            nbrs.clear();
+            weights.clear();
+            forAllConstIter(Map<label>, neighbours, iter)
+            {
+                if (iter.key() > procI)
+                {
+                    nbrs.append(iter.key());
+                    weights.append(iter());
+                }
+                sort(nbrs);
+                forAll(nbrs, i)
+                {
+                    l.append(procI);
+                    u.append(nbrs[i]);
+                    weight.append(weights[i]);
+                }
+            }
+        }
+
+        faceWeights.transfer(weight);
+
+        PtrList<const lduInterface> primitiveInterfaces(0);
+        const lduSchedule ps(0);
+
+        singleCellMeshPtr.reset
+        (
+            new lduPrimitiveMesh
+            (
+                nCells,
+                l,
+                u,
+                primitiveInterfaces,
+                ps,
+                singleCellMeshComm
+            )
+        );
+    }
+    return singleCellMeshPtr;
+}
+
+
+Foam::tmp<Foam::labelField>
+Foam::procFacesGAMGProcAgglomeration::processorAgglomeration
+(
+    const lduMesh& mesh
+) const
+{
+    label singleCellMeshComm = UPstream::allocateCommunicator
+    (
+        mesh.comm(),
+        labelList(1, 0)            // only processor 0
+    );
+
+    scalarField faceWeights;
+    autoPtr<lduPrimitiveMesh> singleCellMeshPtr
+    (
+        singleCellMesh
+        (
+            singleCellMeshComm,
+            mesh,
+            faceWeights
+        )
+    );
+
+    tmp<labelField> tfineToCoarse(new labelField(0));
+    labelField& fineToCoarse = tfineToCoarse();
+
+    if (singleCellMeshPtr.valid())
+    {
+        // On master call the agglomerator
+        const lduPrimitiveMesh& singleCellMesh = singleCellMeshPtr();
+
+        label nCoarseProcs;
+        fineToCoarse = pairGAMGAgglomeration::agglomerate
+        (
+            nCoarseProcs,
+            singleCellMesh,
+            faceWeights
+        );
+
+        labelList coarseToMaster(nCoarseProcs, labelMax);
+        forAll(fineToCoarse, cellI)
+        {
+            label coarseI = fineToCoarse[cellI];
+            coarseToMaster[coarseI] = min(coarseToMaster[coarseI], cellI);
+        }
+
+        // Sort according to master and redo restriction
+        labelList newToOld;
+        sortedOrder(coarseToMaster, newToOld);
+        labelList oldToNew(invert(newToOld.size(), newToOld));
+
+        fineToCoarse = UIndirectList<label>(oldToNew, fineToCoarse)();
+    }
+
+    Pstream::scatter(fineToCoarse, Pstream::msgType(), mesh.comm());
+    UPstream::freeCommunicator(singleCellMeshComm);
+
+    return tfineToCoarse;
+}
+
+
+bool Foam::procFacesGAMGProcAgglomeration::doProcessorAgglomeration
+(
+    const lduMesh& mesh
+) const
+{
+    // Check the need for further agglomeration on all processors
+    bool doAgg = mesh.lduAddr().size() < nAgglomeratingCells_;
+    mesh.reduce(doAgg, orOp<bool>());
+    return doAgg;
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::procFacesGAMGProcAgglomeration::procFacesGAMGProcAgglomeration
+(
+    GAMGAgglomeration& agglom,
+    const dictionary& controlDict
+)
+:
+    GAMGProcAgglomeration(agglom, controlDict),
+    nAgglomeratingCells_(readLabel(controlDict.lookup("nAgglomeratingCells")))
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::procFacesGAMGProcAgglomeration::~procFacesGAMGProcAgglomeration()
+{
+    forAllReverse(comms_, i)
+    {
+        if (comms_[i] != -1)
+        {
+            UPstream::freeCommunicator(comms_[i]);
+        }
+    }
+}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+bool Foam::procFacesGAMGProcAgglomeration::agglomerate()
+{
+    if (debug)
+    {
+        Pout<< nl << "Starting mesh overview" << endl;
+        printStats(Pout, agglom_);
+    }
+
+    if (agglom_.size() >= 1)
+    {
+        Random rndGen(0);
+
+        for
+        (
+            label fineLevelIndex = 2;
+            fineLevelIndex < agglom_.size();
+            fineLevelIndex++
+        )
+        {
+            if (agglom_.hasMeshLevel(fineLevelIndex))
+            {
+                // Get the fine mesh
+                const lduMesh& levelMesh = agglom_.meshLevel(fineLevelIndex);
+
+                label levelComm = levelMesh.comm();
+                label nProcs = UPstream::nProcs(levelComm);
+
+                if (nProcs > 1 && doProcessorAgglomeration(levelMesh))
+                {
+                    tmp<labelField> tprocAgglomMap
+                    (
+                        processorAgglomeration(levelMesh)
+                    );
+                    const labelField& procAgglomMap = tprocAgglomMap();
+
+                    // Master processor
+                    labelList masterProcs;
+                    // Local processors that agglomerate. agglomProcIDs[0] is in
+                    // masterProc.
+                    List<int> agglomProcIDs;
+                    GAMGAgglomeration::calculateRegionMaster
+                    (
+                        levelComm,
+                        procAgglomMap,
+                        masterProcs,
+                        agglomProcIDs
+                    );
+
+                    // Allocate a communicator for the processor-agglomerated
+                    // matrix
+                    comms_.append
+                    (
+                        UPstream::allocateCommunicator
+                        (
+                            levelComm,
+                            masterProcs
+                        )
+                    );
+
+
+                    // Use procesor agglomeration maps to do the actual
+                    // collecting.
+                    GAMGProcAgglomeration::agglomerate
+                    (
+                        fineLevelIndex,
+                        procAgglomMap,
+                        masterProcs,
+                        agglomProcIDs,
+                        comms_.last()
+                    );
+                }
+            }
+        }
+    }
+
+    // Print a bit
+    if (debug)
+    {
+        Pout<< nl << "Agglomerated mesh overview" << endl;
+        printStats(Pout, agglom_);
+    }
+
+    return true;
+}
+
+
+// ************************************************************************* //
diff --git a/src/OpenFOAM/matrices/lduMatrix/solvers/GAMG/GAMGProcAgglomerations/procFacesGAMGProcAgglomeration/procFacesGAMGProcAgglomeration.H b/src/OpenFOAM/matrices/lduMatrix/solvers/GAMG/GAMGProcAgglomerations/procFacesGAMGProcAgglomeration/procFacesGAMGProcAgglomeration.H
new file mode 100644
index 0000000000..5c574c4158
--- /dev/null
+++ b/src/OpenFOAM/matrices/lduMatrix/solvers/GAMG/GAMGProcAgglomerations/procFacesGAMGProcAgglomeration/procFacesGAMGProcAgglomeration.H
@@ -0,0 +1,136 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 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::procFacesGAMGProcAgglomeration
+
+Description
+    Processor agglomeration of GAMGAgglomerations. Needs nAgglomeratingCells
+    which is when to start agglomerating processors. Processors get agglomerated
+    by constructing a single cell mesh for each processor with each
+    processor interface a face. This then gets agglomerated using
+    the pairGAMGAgglomeration algorithm with the number of faces
+    on the original processor interface as face weight.
+
+SourceFiles
+    procFacesGAMGProcAgglomeration.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef procFacesGAMGProcAgglomeration_H
+#define procFacesGAMGProcAgglomeration_H
+
+#include "GAMGProcAgglomeration.H"
+#include "DynamicList.H"
+#include "labelField.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+class GAMGAgglomeration;
+class lduMesh;
+class lduPrimitiveMesh;
+
+/*---------------------------------------------------------------------------*\
+                    Class procFacesGAMGProcAgglomeration Declaration
+\*---------------------------------------------------------------------------*/
+
+class procFacesGAMGProcAgglomeration
+:
+    public GAMGProcAgglomeration
+{
+    // Private data
+
+        //- When to processor agglomerate
+        const label nAgglomeratingCells_;
+
+        //- Allocated communicators
+        DynamicList<label> comms_;
+
+    // Private Member Functions
+
+        //- Return (on master) all single-cell meshes collected. single-cell
+        //  meshes are just one cell with all proc faces intact.
+        autoPtr<lduPrimitiveMesh> singleCellMesh
+        (
+            const label singleCellMeshComm,
+            const lduMesh& mesh,
+            scalarField& faceWeights
+        ) const;
+
+        //- Construct processor agglomeration: for every processor the
+        //  coarse processor-cluster it agglomerates onto
+        tmp<labelField> processorAgglomeration(const lduMesh&) const;
+
+        //- Do we need to agglomerate across processors?
+        bool doProcessorAgglomeration(const lduMesh&) const;
+
+        //- Disallow default bitwise copy construct
+        procFacesGAMGProcAgglomeration
+        (
+            const procFacesGAMGProcAgglomeration&
+        );
+
+        //- Disallow default bitwise assignment
+        void operator=(const procFacesGAMGProcAgglomeration&);
+
+
+public:
+
+    //- Runtime type information
+    TypeName("procFaces");
+
+
+    // Constructors
+
+        //- Construct given agglomerator and controls
+        procFacesGAMGProcAgglomeration
+        (
+            GAMGAgglomeration& agglom,
+            const dictionary& controlDict
+        );
+
+
+    //- Destructor
+    virtual ~procFacesGAMGProcAgglomeration();
+
+
+    // Member Functions
+
+       //- Modify agglomeration. Return true if modified
+        virtual bool agglomerate();
+
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/OpenFOAM/memory/autoPtr/autoPtr.H b/src/OpenFOAM/memory/autoPtr/autoPtr.H
index 7732ecc1cf..0d5944128e 100644
--- a/src/OpenFOAM/memory/autoPtr/autoPtr.H
+++ b/src/OpenFOAM/memory/autoPtr/autoPtr.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -67,6 +67,10 @@ public:
         //  setting the arguments pointer to NULL
         inline autoPtr(const autoPtr<T>&);
 
+        //- Construct either by transfering pointer or cloning. Should
+        //  only be called with type that supports cloning.
+        inline autoPtr(const autoPtr<T>&, const bool reUse);
+
 
     //- Destructor, delete object if pointer is not NULL
     inline ~autoPtr();
diff --git a/src/OpenFOAM/memory/autoPtr/autoPtrI.H b/src/OpenFOAM/memory/autoPtr/autoPtrI.H
index df7ea51d1a..55e032fcd4 100644
--- a/src/OpenFOAM/memory/autoPtr/autoPtrI.H
+++ b/src/OpenFOAM/memory/autoPtr/autoPtrI.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -24,6 +24,7 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "error.H"
+#include <typeinfo>
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
@@ -43,6 +44,21 @@ inline Foam::autoPtr<T>::autoPtr(const autoPtr<T>& ap)
 }
 
 
+template<class T>
+inline Foam::autoPtr<T>::autoPtr(const autoPtr<T>& ap, const bool reUse)
+{
+    if (reUse)
+    {
+        ptr_ = ap.ptr_;
+        ap.ptr_ = 0;
+    }
+    else
+    {
+        ptr_ = ap().clone().ptr();
+    }
+}
+
+
 template<class T>
 inline Foam::autoPtr<T>::~autoPtr()
 {
@@ -81,7 +97,8 @@ inline void Foam::autoPtr<T>::set(T* p)
     if (ptr_)
     {
         FatalErrorIn("void Foam::autoPtr<T>::set(T*)")
-            << "object already allocated"
+            << "object of type " << typeid(T).name()
+            << " already allocated"
             << abort(FatalError);
     }
 
@@ -116,7 +133,8 @@ inline T& Foam::autoPtr<T>::operator()()
     if (!ptr_)
     {
         FatalErrorIn("T& Foam::autoPtr<T>::operator()()")
-            << "object is not allocated"
+            << "object of type " << typeid(T).name()
+            << " is not allocated"
             << abort(FatalError);
     }
 
@@ -130,7 +148,8 @@ inline const T& Foam::autoPtr<T>::operator()() const
     if (!ptr_)
     {
         FatalErrorIn("const T& Foam::autoPtr<T>::operator()() const")
-            << "object is not allocated"
+            << "object of type " << typeid(T).name()
+            << " is not allocated"
             << abort(FatalError);
     }
 
@@ -151,7 +170,8 @@ inline T* Foam::autoPtr<T>::operator->()
     if (!ptr_)
     {
         FatalErrorIn("Foam::autoPtr<T>::operator->()")
-            << "object is not allocated"
+            << "object of type " << typeid(T).name()
+            << " is not allocated"
             << abort(FatalError);
     }
 
diff --git a/src/OpenFOAM/memory/tmp/tmpI.H b/src/OpenFOAM/memory/tmp/tmpI.H
index c3a51f3564..ad34bb4b17 100644
--- a/src/OpenFOAM/memory/tmp/tmpI.H
+++ b/src/OpenFOAM/memory/tmp/tmpI.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -24,6 +24,7 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "error.H"
+#include <typeinfo>
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
@@ -62,6 +63,7 @@ inline Foam::tmp<T>::tmp(const tmp<T>& t)
         {
             FatalErrorIn("Foam::tmp<T>::tmp(const tmp<T>&)")
                 << "attempted copy of a deallocated temporary"
+                << " of type " << typeid(T).name()
                 << abort(FatalError);
         }
     }
@@ -93,6 +95,7 @@ inline Foam::tmp<T>::tmp(const tmp<T>& t, bool allowTransfer)
                 (
                     "Foam::tmp<T>::tmp(const tmp<T>&, bool allowTransfer)"
                 )   << "attempted copy of a deallocated temporary"
+                    << " of type " << typeid(T).name()
                     << abort(FatalError);
             }
         }
@@ -149,7 +152,7 @@ inline T* Foam::tmp<T>::ptr() const
          if (!ptr_)
          {
              FatalErrorIn("Foam::tmp<T>::ptr() const")
-                 << "temporary deallocated"
+                 << "temporary of type " << typeid(T).name() << " deallocated"
                  << abort(FatalError);
          }
 
@@ -188,7 +191,7 @@ inline T& Foam::tmp<T>::operator()()
         if (!ptr_)
         {
             FatalErrorIn("T& Foam::tmp<T>::operator()()")
-                << "temporary deallocated"
+                << "temporary of type " << typeid(T).name() << " deallocated"
                 << abort(FatalError);
         }
 
@@ -217,7 +220,7 @@ inline const T& Foam::tmp<T>::operator()() const
         if (!ptr_)
         {
             FatalErrorIn("const T& Foam::tmp<T>::operator()() const")
-                << "temporary deallocated"
+                << "temporary of type " << typeid(T).name() << " deallocated"
                 << abort(FatalError);
         }
 
@@ -245,7 +248,7 @@ inline T* Foam::tmp<T>::operator->()
          if (!ptr_)
          {
              FatalErrorIn("Foam::tmp<T>::operator->()")
-                 << "temporary deallocated"
+                 << "temporary of type " << typeid(T).name() << " deallocated"
                  << abort(FatalError);
          }
 
@@ -294,6 +297,7 @@ inline void Foam::tmp<T>::operator=(const tmp<T>& t)
         {
             FatalErrorIn("Foam::tmp<T>::operator=(const tmp<T>&)")
                 << "attempted copy of a deallocated temporary"
+                << " of type " << typeid(T).name()
                 << abort(FatalError);
         }
     }
@@ -301,6 +305,7 @@ inline void Foam::tmp<T>::operator=(const tmp<T>& t)
     {
         FatalErrorIn("Foam::tmp<T>::operator=(const tmp<T>&)")
             << "attempted to assign to a const reference to constant object"
+            << " of type " << typeid(T).name()
             << abort(FatalError);
     }
 }
diff --git a/src/OpenFOAM/meshes/MeshObject/meshObject.C b/src/OpenFOAM/meshes/MeshObject/meshObject.C
index 7130f38b5d..a616f777b0 100644
--- a/src/OpenFOAM/meshes/MeshObject/meshObject.C
+++ b/src/OpenFOAM/meshes/MeshObject/meshObject.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
diff --git a/src/OpenFOAM/meshes/lduMesh/lduPrimitiveMesh.C b/src/OpenFOAM/meshes/lduMesh/lduPrimitiveMesh.C
index 070edd4b69..507fc425ef 100644
--- a/src/OpenFOAM/meshes/lduMesh/lduPrimitiveMesh.C
+++ b/src/OpenFOAM/meshes/lduMesh/lduPrimitiveMesh.C
@@ -254,7 +254,7 @@ Foam::lduPrimitiveMesh::lduPrimitiveMesh
     const label nCells,
     labelList& l,
     labelList& u,
-    const Xfer<PtrList<const lduInterface> >& primitiveInterfaces,
+    PtrList<const lduInterface>& primitiveInterfaces,
     const lduSchedule& ps,
     const label comm
 )
@@ -262,10 +262,12 @@ Foam::lduPrimitiveMesh::lduPrimitiveMesh
     lduAddressing(nCells),
     lowerAddr_(l, true),
     upperAddr_(u, true),
-    primitiveInterfaces_(primitiveInterfaces),
+    primitiveInterfaces_(0),
     patchSchedule_(ps),
     comm_(comm)
 {
+    primitiveInterfaces_.transfer(primitiveInterfaces);
+
     // Create interfaces
     interfaces_.setSize(primitiveInterfaces_.size());
     forAll(primitiveInterfaces_, i)
diff --git a/src/OpenFOAM/meshes/lduMesh/lduPrimitiveMesh.H b/src/OpenFOAM/meshes/lduMesh/lduPrimitiveMesh.H
index 66c26dc37e..5bd7901c8b 100644
--- a/src/OpenFOAM/meshes/lduMesh/lduPrimitiveMesh.H
+++ b/src/OpenFOAM/meshes/lduMesh/lduPrimitiveMesh.H
@@ -133,7 +133,7 @@ public:
             const label nCells,
             labelList& l,
             labelList& u,
-            const Xfer<PtrList<const lduInterface> >& primitiveInterfaces,
+            PtrList<const lduInterface>& primitiveInterfaces,
             const lduSchedule& ps,
             const label comm
         );
diff --git a/src/OpenFOAM/meshes/pointMesh/pointBoundaryMesh/pointBoundaryMesh.C b/src/OpenFOAM/meshes/pointMesh/pointBoundaryMesh/pointBoundaryMesh.C
index c8ec20fff2..adddf9777c 100644
--- a/src/OpenFOAM/meshes/pointMesh/pointBoundaryMesh/pointBoundaryMesh.C
+++ b/src/OpenFOAM/meshes/pointMesh/pointBoundaryMesh/pointBoundaryMesh.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -58,6 +58,12 @@ Foam::pointBoundaryMesh::pointBoundaryMesh
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
+Foam::label Foam::pointBoundaryMesh::findPatchID(const word& patchName) const
+{
+    return mesh()().boundaryMesh().findPatchID(patchName);
+}
+
+
 Foam::labelList Foam::pointBoundaryMesh::findIndices
 (
     const keyType& key,
diff --git a/src/OpenFOAM/meshes/pointMesh/pointBoundaryMesh/pointBoundaryMesh.H b/src/OpenFOAM/meshes/pointMesh/pointBoundaryMesh/pointBoundaryMesh.H
index afbc52c93f..f07b03ea9a 100644
--- a/src/OpenFOAM/meshes/pointMesh/pointBoundaryMesh/pointBoundaryMesh.H
+++ b/src/OpenFOAM/meshes/pointMesh/pointBoundaryMesh/pointBoundaryMesh.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -96,6 +96,9 @@ public:
             return mesh_;
         }
 
+        //- Find patch index given a name
+        label findPatchID(const word& patchName) const;
+
         //- Find patch indices given a name
         labelList findIndices(const keyType&, const bool useGroups) const;
 
diff --git a/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processor/processorPolyPatch.C b/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processor/processorPolyPatch.C
index ad9c0c9f62..37e2fb4d71 100644
--- a/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processor/processorPolyPatch.C
+++ b/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processor/processorPolyPatch.C
@@ -54,14 +54,12 @@ Foam::processorPolyPatch::processorPolyPatch
     const label start,
     const label index,
     const polyBoundaryMesh& bm,
-    const label comm,
     const int myProcNo,
     const int neighbProcNo,
     const transformType transform
 )
 :
     coupledPolyPatch(name, size, start, index, bm, typeName, transform),
-//    comm_(comm),
     myProcNo_(myProcNo),
     neighbProcNo_(neighbProcNo),
     neighbFaceCentres_(),
@@ -80,10 +78,6 @@ Foam::processorPolyPatch::processorPolyPatch
 )
 :
     coupledPolyPatch(name, dict, index, bm, patchType),
-//    comm_
-//    (
-//        dict.lookupOrDefault("communicator", UPstream::worldComm)
-//    ),
     myProcNo_(readLabel(dict.lookup("myProcNo"))),
     neighbProcNo_(readLabel(dict.lookup("neighbProcNo"))),
     neighbFaceCentres_(),
@@ -99,7 +93,6 @@ Foam::processorPolyPatch::processorPolyPatch
 )
 :
     coupledPolyPatch(pp, bm),
-//    comm_(pp.comm_),
     myProcNo_(pp.myProcNo_),
     neighbProcNo_(pp.neighbProcNo_),
     neighbFaceCentres_(),
@@ -118,7 +111,6 @@ Foam::processorPolyPatch::processorPolyPatch
 )
 :
     coupledPolyPatch(pp, bm, index, newSize, newStart),
-//    comm_(pp.comm_),
     myProcNo_(pp.myProcNo_),
     neighbProcNo_(pp.neighbProcNo_),
     neighbFaceCentres_(),
@@ -137,7 +129,6 @@ Foam::processorPolyPatch::processorPolyPatch
 )
 :
     coupledPolyPatch(pp, bm, index, mapAddressing, newStart),
-//    comm_(pp.comm_),
     myProcNo_(pp.myProcNo_),
     neighbProcNo_(pp.neighbProcNo_),
     neighbFaceCentres_(),
@@ -1091,11 +1082,6 @@ bool Foam::processorPolyPatch::order
 void Foam::processorPolyPatch::write(Ostream& os) const
 {
     coupledPolyPatch::write(os);
-//    if (comm_ != UPstream::worldComm)
-//    {
-//        os.writeKeyword("communicator") << comm_
-//            << token::END_STATEMENT << nl;
-//    }
     os.writeKeyword("myProcNo") << myProcNo_
         << token::END_STATEMENT << nl;
     os.writeKeyword("neighbProcNo") << neighbProcNo_
diff --git a/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processor/processorPolyPatch.H b/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processor/processorPolyPatch.H
index c5a6226dc8..6a3d202a42 100644
--- a/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processor/processorPolyPatch.H
+++ b/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processor/processorPolyPatch.H
@@ -134,7 +134,6 @@ public:
             const label start,
             const label index,
             const polyBoundaryMesh& bm,
-            const label comm,
             const int myProcNo,
             const int neighbProcNo,
             const transformType transform = UNKNOWN  // transformation type
diff --git a/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processorCyclic/processorCyclicPolyPatch.C b/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processorCyclic/processorCyclicPolyPatch.C
index fd8ed4d30f..137339e631 100644
--- a/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processorCyclic/processorCyclicPolyPatch.C
+++ b/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processorCyclic/processorCyclicPolyPatch.C
@@ -46,7 +46,6 @@ Foam::processorCyclicPolyPatch::processorCyclicPolyPatch
     const label start,
     const label index,
     const polyBoundaryMesh& bm,
-    const label comm,
     const int myProcNo,
     const int neighbProcNo,
     const word& referPatchName,
@@ -60,7 +59,6 @@ Foam::processorCyclicPolyPatch::processorCyclicPolyPatch
         start,
         index,
         bm,
-        comm,
         myProcNo,
         neighbProcNo,
         transform
diff --git a/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processorCyclic/processorCyclicPolyPatch.H b/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processorCyclic/processorCyclicPolyPatch.H
index 7f749b3286..76a833ba61 100644
--- a/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processorCyclic/processorCyclicPolyPatch.H
+++ b/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processorCyclic/processorCyclicPolyPatch.H
@@ -119,7 +119,6 @@ public:
             const label start,
             const label index,
             const polyBoundaryMesh& bm,
-            const label comm,
             const int myProcNo,
             const int neighbProcNo,
             const word& referPatchName,
diff --git a/src/OpenFOAM/primitives/functions/DataEntry/DataEntry/DataEntry.H b/src/OpenFOAM/primitives/functions/DataEntry/DataEntry/DataEntry.H
index 9cfdb66e25..a9b1686d58 100644
--- a/src/OpenFOAM/primitives/functions/DataEntry/DataEntry/DataEntry.H
+++ b/src/OpenFOAM/primitives/functions/DataEntry/DataEntry/DataEntry.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -142,62 +142,60 @@ public:
             virtual void convertTimeBase(const Time& t);
 
 
-public:
+        // Evaluation
+
+            //- Return value as a function of (scalar) independent variable
+            virtual Type value(const scalar x) const;
+
+            //- Return value as a function of (scalar) independent variable
+            virtual tmp<Field<Type> > value(const scalarField& x) const;
+
+            //- Integrate between two (scalar) values
+            virtual Type integrate(const scalar x1, const scalar x2) const;
+
+            //- Integrate between two (scalar) values
+            virtual tmp<Field<Type> > integrate
+            (
+                const scalarField& x1,
+                const scalarField& x2
+            ) const;
+
+            //- Return dimensioned type
+            virtual dimensioned<Type> dimValue(const scalar x) const;
+
+            //- Return dimensioned type as a function of (scalar)
+            virtual tmp<Field<dimensioned<Type> > > dimValue
+            (
+                const scalarField& x
+            ) const;
+
+            //- Integrate between two scalars and return a dimensioned type
+            virtual dimensioned<Type> dimIntegrate
+            (
+                const scalar x1,
+                const scalar x2
+            ) const;
+
+            //- Integrate between two scalar fields and return a field of
+            //  dimensioned type
+            virtual tmp<Field<dimensioned<Type> > > dimIntegrate
+            (
+                const scalarField& x1,
+                const scalarField& x2
+            ) const;
 
 
-    // Evaluation
+        // I/O
 
-        //- Return value as a function of (scalar) independent variable
-        virtual Type value(const scalar x) const;
+            //- Ostream Operator
+            friend Ostream& operator<< <Type>
+            (
+                Ostream& os,
+                const DataEntry<Type>& de
+            );
 
-        //- Return value as a function of (scalar) independent variable
-        virtual tmp<Field<Type> > value(const scalarField& x) const;
-
-        //- Integrate between two (scalar) values
-        virtual Type integrate(const scalar x1, const scalar x2) const;
-
-        //- Integrate between two (scalar) values
-        virtual tmp<Field<Type> > integrate
-        (
-            const scalarField& x1,
-            const scalarField& x2
-        ) const;
-
-        //- Return dimensioned type
-        virtual dimensioned<Type> dimValue(const scalar x) const;
-
-        //- Return dimensioned type as a function of (scalar)
-        virtual tmp<Field<dimensioned<Type> > > dimValue
-        (
-            const scalarField& x
-        ) const;
-
-        //- Integrate between two scalars and returns a dimensioned type
-        virtual dimensioned<Type> dimIntegrate
-        (
-            const scalar x1,
-            const scalar x2
-        ) const;
-
-        //- Integrate between two scalars and returns list of dimensioned type
-        virtual tmp<Field<dimensioned<Type> > > dimIntegrate
-        (
-            const scalarField& x1,
-            const scalarField& x2
-        ) const;
-
-
-    // I/O
-
-        //- Ostream Operator
-        friend Ostream& operator<< <Type>
-        (
-            Ostream& os,
-            const DataEntry<Type>& de
-        );
-
-        //- Write in dictionary format
-        virtual void writeData(Ostream& os) const;
+            //- Write in dictionary format
+            virtual void writeData(Ostream& os) const;
 };
 
 
diff --git a/src/OpenFOAM/primitives/strings/word/wordIOList.C b/src/OpenFOAM/primitives/strings/word/wordIOList.C
index ede987af53..58456cb0ac 100644
--- a/src/OpenFOAM/primitives/strings/word/wordIOList.C
+++ b/src/OpenFOAM/primitives/strings/word/wordIOList.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2012-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -38,12 +38,17 @@ namespace Foam
 }
 
 
-void Foam::printTable(const List<wordList>& wll, Ostream& os)
+void Foam::printTable
+(
+    const List<wordList>& wll,
+    List<string::size_type>& columnWidth,
+    Ostream& os
+)
 {
     if (!wll.size()) return;
 
     // Find the maximum word length for each column
-    List<string::size_type> columnWidth(wll[0].size(), string::size_type(0));
+    columnWidth.setSize(wll[0].size(), string::size_type(0));
     forAll(columnWidth, j)
     {
         forAll(wll, i)
@@ -75,4 +80,11 @@ void Foam::printTable(const List<wordList>& wll, Ostream& os)
 }
 
 
+void Foam::printTable(const List<wordList>& wll, Ostream& os)
+{
+    List<string::size_type> columnWidth;
+    printTable(wll, columnWidth, os);
+}
+
+
 // ************************************************************************* //
diff --git a/src/OpenFOAM/primitives/strings/word/wordIOList.H b/src/OpenFOAM/primitives/strings/word/wordIOList.H
index c560a33a95..da9d5aa426 100644
--- a/src/OpenFOAM/primitives/strings/word/wordIOList.H
+++ b/src/OpenFOAM/primitives/strings/word/wordIOList.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2012-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -43,6 +43,7 @@ namespace Foam
     typedef IOList<wordList> wordListIOList;
 
     // Print word list list as a table
+    void printTable(const List<wordList>&, List<string::size_type>&, Ostream&);
     void printTable(const List<wordList>&, Ostream&);
 }
 
diff --git a/src/dynamicMesh/fvMeshDistribute/fvMeshDistribute.C b/src/dynamicMesh/fvMeshDistribute/fvMeshDistribute.C
index f6e8bc02dc..61cc9986a8 100644
--- a/src/dynamicMesh/fvMeshDistribute/fvMeshDistribute.C
+++ b/src/dynamicMesh/fvMeshDistribute/fvMeshDistribute.C
@@ -945,7 +945,6 @@ void Foam::fvMeshDistribute::addProcPatches
                         mesh_.nFaces(),
                         mesh_.boundaryMesh().size(),
                         mesh_.boundaryMesh(),
-                        Pstream::worldComm,
                         Pstream::myProcNo(),
                         nbrProc[bFaceI]
                     );
@@ -989,7 +988,6 @@ void Foam::fvMeshDistribute::addProcPatches
                         mesh_.nFaces(),
                         mesh_.boundaryMesh().size(),
                         mesh_.boundaryMesh(),
-                        Pstream::worldComm,
                         Pstream::myProcNo(),
                         nbrProc[bFaceI],
                         cycName,
diff --git a/src/finiteVolume/Make/files b/src/finiteVolume/Make/files
index 35a308ff00..7316c116cb 100644
--- a/src/finiteVolume/Make/files
+++ b/src/finiteVolume/Make/files
@@ -18,6 +18,7 @@ $(basicFvPatches)/generic/genericFvPatch.C
 constraintFvPatches = $(fvPatches)/constraint
 $(constraintFvPatches)/cyclic/cyclicFvPatch.C
 $(constraintFvPatches)/cyclicAMI/cyclicAMIFvPatch.C
+$(constraintFvPatches)/cyclicACMI/cyclicACMIFvPatch.C
 $(constraintFvPatches)/cyclicSlip/cyclicSlipFvPatch.C
 $(constraintFvPatches)/empty/emptyFvPatch.C
 $(constraintFvPatches)/nonuniformTransformCyclic/nonuniformTransformCyclicFvPatch.C
@@ -109,6 +110,7 @@ $(basicFvPatchFields)/zeroGradient/zeroGradientFvPatchFields.C
 constraintFvPatchFields = $(fvPatchFields)/constraint
 $(constraintFvPatchFields)/cyclic/cyclicFvPatchFields.C
 $(constraintFvPatchFields)/cyclicAMI/cyclicAMIFvPatchFields.C
+$(constraintFvPatchFields)/cyclicACMI/cyclicACMIFvPatchFields.C
 $(constraintFvPatchFields)/cyclicSlip/cyclicSlipFvPatchFields.C
 $(constraintFvPatchFields)/empty/emptyFvPatchFields.C
 $(constraintFvPatchFields)/jumpCyclic/jumpCyclicFvPatchFields.C
@@ -203,6 +205,7 @@ $(basicFvsPatchFields)/sliced/slicedFvsPatchFields.C
 constraintFvsPatchFields = $(fvsPatchFields)/constraint
 $(constraintFvsPatchFields)/cyclic/cyclicFvsPatchFields.C
 $(constraintFvsPatchFields)/cyclicAMI/cyclicAMIFvsPatchFields.C
+$(constraintFvsPatchFields)/cyclicACMI/cyclicACMIFvsPatchFields.C
 $(constraintFvsPatchFields)/cyclicSlip/cyclicSlipFvsPatchFields.C
 $(constraintFvsPatchFields)/empty/emptyFvsPatchFields.C
 $(constraintFvsPatchFields)/nonuniformTransformCyclic/nonuniformTransformCyclicFvsPatchFields.C
diff --git a/src/finiteVolume/cfdTools/general/adjustPhi/adjustPhi.C b/src/finiteVolume/cfdTools/general/adjustPhi/adjustPhi.C
index 206e7c4e95..27622aeeb7 100644
--- a/src/finiteVolume/cfdTools/general/adjustPhi/adjustPhi.C
+++ b/src/finiteVolume/cfdTools/general/adjustPhi/adjustPhi.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -56,11 +56,7 @@ bool Foam::adjustPhi
 
             if (!isA<processorFvsPatchScalarField>(phip))
             {
-                if
-                (
-                    Up.fixesValue()
-                 && !isA<inletOutletFvPatchVectorField>(Up)
-                )
+                if (Up.fixesValue() && !isA<inletOutletFvPatchVectorField>(Up))
                 {
                     forAll(phip, i)
                     {
@@ -113,8 +109,12 @@ bool Foam::adjustPhi
         {
             FatalErrorIn
             (
-                "adjustPhi(surfaceScalarField& phi, const volVectorField& U,"
-                "const volScalarField& p"
+                "adjustPhi"
+                "("
+                    "surfaceScalarField&, "
+                    "const volVectorField&,"
+                    "volScalarField&"
+                ")"
             )   << "Continuity error cannot be removed by adjusting the"
                    " outflow.\nPlease check the velocity boundary conditions"
                    " and/or run potentialFoam to initialise the outflow." << nl
diff --git a/src/finiteVolume/cfdTools/general/porosityModel/porosityModel/porosityModel.C b/src/finiteVolume/cfdTools/general/porosityModel/porosityModel/porosityModel.C
index ad83fb0cda..738f87d0a8 100644
--- a/src/finiteVolume/cfdTools/general/porosityModel/porosityModel/porosityModel.C
+++ b/src/finiteVolume/cfdTools/general/porosityModel/porosityModel/porosityModel.C
@@ -155,7 +155,7 @@ Foam::tmp<Foam::vectorField> Foam::porosityModel::porosityModel::force
 }
 
 
-void Foam::porosityModel::porosityModel::addResistance
+void Foam::porosityModel::addResistance
 (
     fvVectorMatrix& UEqn
 ) const
@@ -169,7 +169,7 @@ void Foam::porosityModel::porosityModel::addResistance
 }
 
 
-void Foam::porosityModel::porosityModel::addResistance
+void Foam::porosityModel::addResistance
 (
     fvVectorMatrix& UEqn,
     const volScalarField& rho,
@@ -185,7 +185,7 @@ void Foam::porosityModel::porosityModel::addResistance
 }
 
 
-void Foam::porosityModel::porosityModel::addResistance
+void Foam::porosityModel::addResistance
 (
     const fvVectorMatrix& UEqn,
     volTensorField& AU,
@@ -209,14 +209,14 @@ void Foam::porosityModel::porosityModel::addResistance
 }
 
 
-bool Foam::porosityModel::porosityModel::movePoints()
+bool Foam::porosityModel::movePoints()
 {
     // no updates necessary; all member data independent of mesh
     return true;
 }
 
 
-void Foam::porosityModel::porosityModel::updateMesh(const mapPolyMesh& mpm)
+void Foam::porosityModel::updateMesh(const mapPolyMesh& mpm)
 {
     // no updates necessary; all member data independent of mesh
 }
diff --git a/src/finiteVolume/fields/fvPatchFields/constraint/cyclicACMI/cyclicACMIFvPatchField.C b/src/finiteVolume/fields/fvPatchFields/constraint/cyclicACMI/cyclicACMIFvPatchField.C
new file mode 100644
index 0000000000..bc3bab534d
--- /dev/null
+++ b/src/finiteVolume/fields/fvPatchFields/constraint/cyclicACMI/cyclicACMIFvPatchField.C
@@ -0,0 +1,387 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 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 "cyclicACMIFvPatchField.H"
+#include "transformField.H"
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+template<class Type>
+Foam::cyclicACMIFvPatchField<Type>::cyclicACMIFvPatchField
+(
+    const fvPatch& p,
+    const DimensionedField<Type, volMesh>& iF
+)
+:
+    cyclicACMILduInterfaceField(),
+    coupledFvPatchField<Type>(p, iF),
+    cyclicACMIPatch_(refCast<const cyclicACMIFvPatch>(p))
+{}
+
+
+template<class Type>
+Foam::cyclicACMIFvPatchField<Type>::cyclicACMIFvPatchField
+(
+    const cyclicACMIFvPatchField<Type>& ptf,
+    const fvPatch& p,
+    const DimensionedField<Type, volMesh>& iF,
+    const fvPatchFieldMapper& mapper
+)
+:
+    cyclicACMILduInterfaceField(),
+    coupledFvPatchField<Type>(ptf, p, iF, mapper),
+    cyclicACMIPatch_(refCast<const cyclicACMIFvPatch>(p))
+{
+    if (!isA<cyclicACMIFvPatch>(this->patch()))
+    {
+        FatalErrorIn
+        (
+            "cyclicACMIFvPatchField<Type>::cyclicACMIFvPatchField"
+            "("
+                "const cyclicACMIFvPatchField<Type>& ,"
+                "const fvPatch&, "
+                "const DimensionedField<Type, volMesh>&, "
+                "const fvPatchFieldMapper&"
+            ")"
+        )   << "    patch type '" << p.type()
+            << "' not constraint type '" << typeName << "'"
+            << "\n    for patch " << p.name()
+            << " of field " << this->dimensionedInternalField().name()
+            << " in file " << this->dimensionedInternalField().objectPath()
+            << exit(FatalIOError);
+    }
+}
+
+
+template<class Type>
+Foam::cyclicACMIFvPatchField<Type>::cyclicACMIFvPatchField
+(
+    const fvPatch& p,
+    const DimensionedField<Type, volMesh>& iF,
+    const dictionary& dict
+)
+:
+    cyclicACMILduInterfaceField(),
+    coupledFvPatchField<Type>(p, iF, dict),
+    cyclicACMIPatch_(refCast<const cyclicACMIFvPatch>(p))
+{
+    if (!isA<cyclicACMIFvPatch>(p))
+    {
+        FatalIOErrorIn
+        (
+            "cyclicACMIFvPatchField<Type>::cyclicACMIFvPatchField"
+            "("
+                "const fvPatch&, "
+                "const DimensionedField<Type, volMesh>&, "
+                "const dictionary&"
+            ")",
+            dict
+        )   << "    patch type '" << p.type()
+            << "' not constraint type '" << typeName << "'"
+            << "\n    for patch " << p.name()
+            << " of field " << this->dimensionedInternalField().name()
+            << " in file " << this->dimensionedInternalField().objectPath()
+            << exit(FatalIOError);
+    }
+
+    if (!dict.found("value") && this->coupled())
+    {
+        this->evaluate(Pstream::blocking);
+    }
+}
+
+
+template<class Type>
+Foam::cyclicACMIFvPatchField<Type>::cyclicACMIFvPatchField
+(
+    const cyclicACMIFvPatchField<Type>& ptf
+)
+:
+    cyclicACMILduInterfaceField(),
+    coupledFvPatchField<Type>(ptf),
+    cyclicACMIPatch_(ptf.cyclicACMIPatch_)
+{}
+
+
+template<class Type>
+Foam::cyclicACMIFvPatchField<Type>::cyclicACMIFvPatchField
+(
+    const cyclicACMIFvPatchField<Type>& ptf,
+    const DimensionedField<Type, volMesh>& iF
+)
+:
+    cyclicACMILduInterfaceField(),
+    coupledFvPatchField<Type>(ptf, iF),
+    cyclicACMIPatch_(ptf.cyclicACMIPatch_)
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+template<class Type>
+bool Foam::cyclicACMIFvPatchField<Type>::coupled() const
+{
+    return cyclicACMIPatch_.coupled();
+}
+
+
+template<class Type>
+Foam::tmp<Foam::Field<Type> >
+Foam::cyclicACMIFvPatchField<Type>::patchNeighbourField() const
+{
+    const Field<Type>& iField = this->internalField();
+    const labelUList& nbrFaceCellsCoupled =
+        cyclicACMIPatch_.cyclicACMIPatch().neighbPatch().faceCells();
+    const labelUList& nbrFaceCellsNonOverlap =
+        cyclicACMIPatch_.cyclicACMIPatch().nonOverlapPatch().faceCells();
+
+    Field<Type> pnfCoupled(iField, nbrFaceCellsCoupled);
+    Field<Type> pnfNonOverlap(iField, nbrFaceCellsNonOverlap);
+
+    tmp<Field<Type> > tpnf
+    (
+        new Field<Type>
+        (
+            cyclicACMIPatch_.interpolate
+            (
+                pnfCoupled,
+                pnfNonOverlap
+            )
+        )
+    );
+
+    if (doTransform())
+    {
+        tpnf() = transform(forwardT(), tpnf());
+    }
+
+    return tpnf;
+}
+
+
+template<class Type>
+const Foam::cyclicACMIFvPatchField<Type>&
+Foam::cyclicACMIFvPatchField<Type>::neighbourPatchField() const
+{
+    const GeometricField<Type, fvPatchField, volMesh>& fld =
+        static_cast<const GeometricField<Type, fvPatchField, volMesh>&>
+        (
+            this->internalField()
+        );
+
+    return refCast<const cyclicACMIFvPatchField<Type> >
+    (
+        fld.boundaryField()[cyclicACMIPatch_.neighbPatchID()]
+    );
+}
+
+
+template<class Type>
+const Foam::fvPatchField<Type>&
+Foam::cyclicACMIFvPatchField<Type>::nonOverlapPatchField() const
+{
+    const GeometricField<Type, fvPatchField, volMesh>& fld =
+        static_cast<const GeometricField<Type, fvPatchField, volMesh>&>
+        (
+            this->internalField()
+        );
+
+    return fld.boundaryField()[cyclicACMIPatch_.nonOverlapPatchID()];
+}
+
+
+template<class Type>
+void Foam::cyclicACMIFvPatchField<Type>::updateInterfaceMatrix
+(
+    scalarField& result,
+    const scalarField& psiInternal,
+    const scalarField& coeffs,
+    const direction cmpt,
+    const Pstream::commsTypes
+) const
+{
+    // note: only applying coupled contribution
+
+    const labelUList& nbrFaceCellsCoupled =
+        cyclicACMIPatch_.cyclicACMIPatch().neighbPatch().faceCells();
+
+    scalarField pnf(psiInternal, nbrFaceCellsCoupled);
+
+    // Transform according to the transformation tensors
+    transformCoupleField(pnf, cmpt);
+
+    const labelUList& faceCells = cyclicACMIPatch_.faceCells();
+
+    pnf = cyclicACMIPatch_.interpolate(pnf);
+
+    forAll(faceCells, elemI)
+    {
+        result[faceCells[elemI]] -= coeffs[elemI]*pnf[elemI];
+    }
+}
+
+
+template<class Type>
+void Foam::cyclicACMIFvPatchField<Type>::updateInterfaceMatrix
+(
+    Field<Type>& result,
+    const Field<Type>& psiInternal,
+    const scalarField& coeffs,
+    const Pstream::commsTypes
+) const
+{
+    // note: only applying coupled contribution
+
+    const labelUList& nbrFaceCellsCoupled =
+        cyclicACMIPatch_.cyclicACMIPatch().neighbPatch().faceCells();
+
+    Field<Type> pnf(psiInternal, nbrFaceCellsCoupled);
+
+    // Transform according to the transformation tensors
+    transformCoupleField(pnf);
+
+    const labelUList& faceCells = cyclicACMIPatch_.faceCells();
+
+    pnf = cyclicACMIPatch_.interpolate(pnf);
+
+    forAll(faceCells, elemI)
+    {
+        result[faceCells[elemI]] -= coeffs[elemI]*pnf[elemI];
+    }
+}
+
+
+template<class Type>
+Foam::tmp<Foam::Field<Type> > Foam::cyclicACMIFvPatchField<Type>::snGrad
+(
+    const scalarField& deltaCoeffs
+) const
+{
+    // note: only applying coupled contribution
+    return coupledFvPatchField<Type>::snGrad(deltaCoeffs);
+}
+
+
+template<class Type>
+void Foam::cyclicACMIFvPatchField<Type>::evaluate
+(
+    const Pstream::commsTypes comms
+)
+{
+    // blend contrubutions from the coupled and non-overlap patches
+    const fvPatchField<Type>& npf = nonOverlapPatchField();
+    const_cast<fvPatchField<Type>&>(npf).evaluate();
+
+    coupledFvPatchField<Type>::evaluate(comms);
+    const Field<Type>& cpf = *this;
+
+    const scalarField& mask = cyclicACMIPatch_.cyclicACMIPatch().mask();
+    Field<Type>::operator=(mask*cpf + (1.0 - mask)*npf);
+
+    fvPatchField<Type>::evaluate();
+}
+
+
+template<class Type>
+Foam::tmp<Foam::Field<Type> >
+Foam::cyclicACMIFvPatchField<Type>::valueInternalCoeffs
+(
+    const tmp<scalarField>& w
+) const
+{
+    // note: do not blend based on mask field
+    // - when applied this is scaled by the areas which area already scaled
+    return coupledFvPatchField<Type>::valueInternalCoeffs(w);
+}
+
+
+template<class Type>
+Foam::tmp<Foam::Field<Type> >
+Foam::cyclicACMIFvPatchField<Type>::valueBoundaryCoeffs
+(
+    const tmp<scalarField>& w
+) const
+{
+    // note: do not blend based on mask field
+    // - when applied this is scaled by the areas which area already scaled
+    return coupledFvPatchField<Type>::valueBoundaryCoeffs(w);
+}
+
+
+template<class Type>
+Foam::tmp<Foam::Field<Type> >
+Foam::cyclicACMIFvPatchField<Type>::gradientInternalCoeffs
+(
+    const scalarField& deltaCoeffs
+) const
+{
+    // note: do not blend based on mask field
+    // - when applied this is scaled by the areas which area already scaled
+    return coupledFvPatchField<Type>::gradientInternalCoeffs(deltaCoeffs);
+}
+
+
+template<class Type>
+Foam::tmp<Foam::Field<Type> >
+Foam::cyclicACMIFvPatchField<Type>::gradientInternalCoeffs() const
+{
+    // note: do not blend based on mask field
+    // - when applied this is scaled by the areas which area already scaled
+    return coupledFvPatchField<Type>::gradientInternalCoeffs();
+}
+
+
+template<class Type>
+Foam::tmp<Foam::Field<Type> >
+Foam::cyclicACMIFvPatchField<Type>::gradientBoundaryCoeffs
+(
+    const scalarField& deltaCoeffs
+) const
+{
+    // note: do not blend based on mask field
+    // - when applied this is scaled by the areas which area already scaled
+    return coupledFvPatchField<Type>::gradientBoundaryCoeffs(deltaCoeffs);
+}
+
+
+template<class Type>
+Foam::tmp<Foam::Field<Type> >
+Foam::cyclicACMIFvPatchField<Type>::gradientBoundaryCoeffs() const
+{
+    // note: do not blend based on mask field
+    // - when applied this is scaled by the areas which area already scaled
+    return coupledFvPatchField<Type>::gradientBoundaryCoeffs();
+}
+
+
+template<class Type>
+void Foam::cyclicACMIFvPatchField<Type>::write(Ostream& os) const
+{
+    fvPatchField<Type>::write(os);
+    this->writeEntry("value", os);
+}
+
+
+// ************************************************************************* //
diff --git a/src/finiteVolume/fields/fvPatchFields/constraint/cyclicACMI/cyclicACMIFvPatchField.H b/src/finiteVolume/fields/fvPatchFields/constraint/cyclicACMI/cyclicACMIFvPatchField.H
new file mode 100644
index 0000000000..9848505be1
--- /dev/null
+++ b/src/finiteVolume/fields/fvPatchFields/constraint/cyclicACMI/cyclicACMIFvPatchField.H
@@ -0,0 +1,298 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 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::cyclicACMIFvPatchField
+
+Group
+    grpCoupledBoundaryConditions
+
+Description
+    This boundary condition enforces a cyclic condition between a pair of
+    boundaries, whereby communication between the patches is performed using
+    an arbitrarily coupled mesh interface (ACMI) interpolation.
+
+    \heading Patch usage
+
+    Example of the boundary condition specification:
+    \verbatim
+    myPatch
+    {
+        type            cyclicACMI;
+    }
+    \endverbatim
+
+SeeAlso
+    Foam::AMIInterpolation
+
+SourceFiles
+    cyclicACMIFvPatchField.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef cyclicACMIFvPatchField_H
+#define cyclicACMIFvPatchField_H
+
+#include "coupledFvPatchField.H"
+#include "cyclicACMILduInterfaceField.H"
+#include "cyclicACMIFvPatch.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                   Class cyclicACMIFvPatchField Declaration
+\*---------------------------------------------------------------------------*/
+
+template<class Type>
+class cyclicACMIFvPatchField
+:
+    virtual public cyclicACMILduInterfaceField,
+    public coupledFvPatchField<Type>
+{
+    // Private data
+
+        //- Local reference cast into the cyclic patch
+        const cyclicACMIFvPatch& cyclicACMIPatch_;
+
+
+    // Private Member Functions
+
+        //- Return neighbour side field given internal fields
+        template<class Type2>
+        tmp<Field<Type2> > neighbourSideField
+        (
+            const Field<Type2>&
+        ) const;
+
+
+public:
+
+    //- Runtime type information
+    TypeName(cyclicACMIFvPatch::typeName_());
+
+
+    // Constructors
+
+        //- Construct from patch and internal field
+        cyclicACMIFvPatchField
+        (
+            const fvPatch&,
+            const DimensionedField<Type, volMesh>&
+        );
+
+        //- Construct from patch, internal field and dictionary
+        cyclicACMIFvPatchField
+        (
+            const fvPatch&,
+            const DimensionedField<Type, volMesh>&,
+            const dictionary&
+        );
+
+        //- Construct by mapping given cyclicACMIFvPatchField onto a new patch
+        cyclicACMIFvPatchField
+        (
+            const cyclicACMIFvPatchField<Type>&,
+            const fvPatch&,
+            const DimensionedField<Type, volMesh>&,
+            const fvPatchFieldMapper&
+        );
+
+        //- Construct as copy
+        cyclicACMIFvPatchField(const cyclicACMIFvPatchField<Type>&);
+
+        //- Construct and return a clone
+        virtual tmp<fvPatchField<Type> > clone() const
+        {
+            return tmp<fvPatchField<Type> >
+            (
+                new cyclicACMIFvPatchField<Type>(*this)
+            );
+        }
+
+        //- Construct as copy setting internal field reference
+        cyclicACMIFvPatchField
+        (
+            const cyclicACMIFvPatchField<Type>&,
+            const DimensionedField<Type, volMesh>&
+        );
+
+        //- Construct and return a clone setting internal field reference
+        virtual tmp<fvPatchField<Type> > clone
+        (
+            const DimensionedField<Type, volMesh>& iF
+        ) const
+        {
+            return tmp<fvPatchField<Type> >
+            (
+                new cyclicACMIFvPatchField<Type>(*this, iF)
+            );
+        }
+
+
+    // Member functions
+
+        // Access
+
+            //- Return local reference cast into the cyclic AMI patch
+            const cyclicACMIFvPatch& cyclicACMIPatch() const
+            {
+                return cyclicACMIPatch_;
+            }
+
+
+        // Evaluation functions
+
+            //- Return true if coupled. Note that the underlying patch
+            //  is not coupled() - the points don't align.
+            virtual bool coupled() const;
+
+            //- Return neighbour coupled internal cell data
+            virtual tmp<Field<Type> > patchNeighbourField() const;
+
+            //- Return reference to neighbour patchField
+            const cyclicACMIFvPatchField<Type>& neighbourPatchField() const;
+
+            //- Return reference to non-overlapping patchField
+            const fvPatchField<Type>& nonOverlapPatchField() const;
+
+            //- Return patch-normal gradient
+            virtual tmp<Field<Type> > snGrad
+            (
+                const scalarField& deltaCoeffs
+            ) const;
+
+            //- Evaluate the patch field
+            virtual void evaluate
+            (
+                const Pstream::commsTypes commsType
+            );
+
+            //- Return the matrix diagonal coefficients corresponding to the
+            //  evaluation of the value of this patchField with given weights
+            virtual tmp<Field<Type> > valueInternalCoeffs
+            (
+                const tmp<scalarField>&
+            ) const;
+
+            //- Return the matrix source coefficients corresponding to the
+            //  evaluation of the value of this patchField with given weights
+            virtual tmp<Field<Type> > valueBoundaryCoeffs
+            (
+                const tmp<scalarField>&
+            ) const;
+
+            //- Return the matrix diagonal coefficients corresponding to the
+            //  evaluation of the gradient of this patchField
+            virtual tmp<Field<Type> > gradientInternalCoeffs
+            (
+                const scalarField& deltaCoeffs
+            ) const;
+
+            //- Return the matrix diagonal coefficients corresponding to the
+            //  evaluation of the gradient of this patchField
+            virtual tmp<Field<Type> > gradientInternalCoeffs() const;
+
+            //- Return the matrix source coefficients corresponding to the
+            //  evaluation of the gradient of this patchField
+            virtual tmp<Field<Type> > gradientBoundaryCoeffs
+            (
+                const scalarField& deltaCoeffs
+            ) const;
+
+            //- Return the matrix source coefficients corresponding to the
+            //  evaluation of the gradient of this patchField
+            virtual tmp<Field<Type> > gradientBoundaryCoeffs() const;
+
+            //- Update result field based on interface functionality
+            virtual void updateInterfaceMatrix
+            (
+                scalarField& result,
+                const scalarField& psiInternal,
+                const scalarField& coeffs,
+                const direction cmpt,
+                const Pstream::commsTypes commsType
+            ) const;
+
+            //- Update result field based on interface functionality
+            virtual void updateInterfaceMatrix
+            (
+                Field<Type>&,
+                const Field<Type>&,
+                const scalarField&,
+                const Pstream::commsTypes commsType
+            ) const;
+
+
+        // Cyclic AMI coupled interface functions
+
+            //- Does the patch field perform the transformation
+            virtual bool doTransform() const
+            {
+                return
+                    !(cyclicACMIPatch_.parallel() || pTraits<Type>::rank == 0);
+            }
+
+            //- Return face transformation tensor
+            virtual const tensorField& forwardT() const
+            {
+                return cyclicACMIPatch_.forwardT();
+            }
+
+            //- Return neighbour-cell transformation tensor
+            virtual const tensorField& reverseT() const
+            {
+                return cyclicACMIPatch_.reverseT();
+            }
+
+            //- Return rank of component for transform
+            virtual int rank() const
+            {
+                return pTraits<Type>::rank;
+            }
+
+
+        // I-O
+
+            //- Write
+            virtual void write(Ostream& os) const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+#   include "cyclicACMIFvPatchField.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/finiteVolume/fields/fvPatchFields/constraint/cyclicACMI/cyclicACMIFvPatchFields.C b/src/finiteVolume/fields/fvPatchFields/constraint/cyclicACMI/cyclicACMIFvPatchFields.C
new file mode 100644
index 0000000000..470a1613d3
--- /dev/null
+++ b/src/finiteVolume/fields/fvPatchFields/constraint/cyclicACMI/cyclicACMIFvPatchFields.C
@@ -0,0 +1,43 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 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 "cyclicACMIFvPatchFields.H"
+#include "addToRunTimeSelectionTable.H"
+#include "volFields.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+makePatchFields(cyclicACMI);
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// ************************************************************************* //
diff --git a/src/finiteVolume/fields/fvPatchFields/constraint/cyclicACMI/cyclicACMIFvPatchFields.H b/src/finiteVolume/fields/fvPatchFields/constraint/cyclicACMI/cyclicACMIFvPatchFields.H
new file mode 100644
index 0000000000..13aee99a84
--- /dev/null
+++ b/src/finiteVolume/fields/fvPatchFields/constraint/cyclicACMI/cyclicACMIFvPatchFields.H
@@ -0,0 +1,49 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef cyclicACMIFvPatchFields_H
+#define cyclicACMIFvPatchFields_H
+
+#include "cyclicACMIFvPatchField.H"
+#include "fieldTypes.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+makePatchTypeFieldTypedefs(cyclicACMI);
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/finiteVolume/fields/fvPatchFields/constraint/cyclicACMI/cyclicACMIFvPatchFieldsFwd.H b/src/finiteVolume/fields/fvPatchFields/constraint/cyclicACMI/cyclicACMIFvPatchFieldsFwd.H
new file mode 100644
index 0000000000..155d6a8f2b
--- /dev/null
+++ b/src/finiteVolume/fields/fvPatchFields/constraint/cyclicACMI/cyclicACMIFvPatchFieldsFwd.H
@@ -0,0 +1,50 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef cyclicACMIFvPatchFieldsFwd_H
+#define cyclicACMIFvPatchFieldsFwd_H
+
+#include "fieldTypes.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+template<class Type> class cyclicACMIFvPatchField;
+
+makePatchTypeFieldTypedefs(cyclicACMI);
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/finiteVolume/fields/fvPatchFields/derived/timeVaryingMappedFixedValue/timeVaryingMappedFixedValueFvPatchField.C b/src/finiteVolume/fields/fvPatchFields/derived/timeVaryingMappedFixedValue/timeVaryingMappedFixedValueFvPatchField.C
index 6ea997f3fd..df9c571397 100644
--- a/src/finiteVolume/fields/fvPatchFields/derived/timeVaryingMappedFixedValue/timeVaryingMappedFixedValueFvPatchField.C
+++ b/src/finiteVolume/fields/fvPatchFields/derived/timeVaryingMappedFixedValue/timeVaryingMappedFixedValueFvPatchField.C
@@ -46,6 +46,7 @@ timeVaryingMappedFixedValueFvPatchField
     fieldTableName_(iF.name()),
     setAverage_(false),
     perturb_(0),
+    mapperPtr_(NULL),
     sampleTimes_(0),
     startSampleTime_(-1),
     startSampledValues_(0),
@@ -71,7 +72,7 @@ timeVaryingMappedFixedValueFvPatchField
     fieldTableName_(ptf.fieldTableName_),
     setAverage_(ptf.setAverage_),
     perturb_(ptf.perturb_),
-    mapperPtr_(ptf.mapperPtr_),
+    mapperPtr_(NULL),
     sampleTimes_(0),
     startSampleTime_(-1),
     startSampledValues_(0),
@@ -79,7 +80,12 @@ timeVaryingMappedFixedValueFvPatchField
     endSampleTime_(-1),
     endSampledValues_(0),
     endAverage_(pTraits<Type>::zero),
-    offset_(ptf.offset_().clone().ptr())
+    offset_
+    (
+        ptf.offset_.valid()
+      ? ptf.offset_().clone().ptr()
+      : NULL
+    )
 {}
 
 
@@ -130,7 +136,7 @@ timeVaryingMappedFixedValueFvPatchField
     fieldTableName_(ptf.fieldTableName_),
     setAverage_(ptf.setAverage_),
     perturb_(ptf.perturb_),
-    mapperPtr_(ptf.mapperPtr_),
+    mapperPtr_(NULL),
     sampleTimes_(ptf.sampleTimes_),
     startSampleTime_(ptf.startSampleTime_),
     startSampledValues_(ptf.startSampledValues_),
@@ -138,11 +144,15 @@ timeVaryingMappedFixedValueFvPatchField
     endSampleTime_(ptf.endSampleTime_),
     endSampledValues_(ptf.endSampledValues_),
     endAverage_(ptf.endAverage_),
-    offset_(ptf.offset_().clone().ptr())
+    offset_
+    (
+        ptf.offset_.valid()
+      ? ptf.offset_().clone().ptr()
+      : NULL
+    )
 {}
 
 
-
 template<class Type>
 timeVaryingMappedFixedValueFvPatchField<Type>::
 timeVaryingMappedFixedValueFvPatchField
@@ -155,7 +165,7 @@ timeVaryingMappedFixedValueFvPatchField
     fieldTableName_(ptf.fieldTableName_),
     setAverage_(ptf.setAverage_),
     perturb_(ptf.perturb_),
-    mapperPtr_(ptf.mapperPtr_),
+    mapperPtr_(NULL),
     sampleTimes_(ptf.sampleTimes_),
     startSampleTime_(ptf.startSampleTime_),
     startSampledValues_(ptf.startSampledValues_),
@@ -163,7 +173,12 @@ timeVaryingMappedFixedValueFvPatchField
     endSampleTime_(ptf.endSampleTime_),
     endSampledValues_(ptf.endSampledValues_),
     endAverage_(ptf.endAverage_),
-    offset_(ptf.offset_().clone().ptr())
+    offset_
+    (
+        ptf.offset_.valid()
+      ? ptf.offset_().clone().ptr()
+      : NULL
+    )
 {}
 
 
diff --git a/src/finiteVolume/fields/fvsPatchFields/constraint/cyclicACMI/cyclicACMIFvsPatchField.C b/src/finiteVolume/fields/fvsPatchFields/constraint/cyclicACMI/cyclicACMIFvsPatchField.C
new file mode 100644
index 0000000000..7fc9d7688c
--- /dev/null
+++ b/src/finiteVolume/fields/fvsPatchFields/constraint/cyclicACMI/cyclicACMIFvsPatchField.C
@@ -0,0 +1,149 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 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 "cyclicACMIFvsPatchField.H"
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+template<class Type>
+Foam::cyclicACMIFvsPatchField<Type>::cyclicACMIFvsPatchField
+(
+    const fvPatch& p,
+    const DimensionedField<Type, surfaceMesh>& iF
+)
+:
+    coupledFvsPatchField<Type>(p, iF),
+    cyclicACMIPatch_(refCast<const cyclicACMIFvPatch>(p))
+{}
+
+
+template<class Type>
+Foam::cyclicACMIFvsPatchField<Type>::cyclicACMIFvsPatchField
+(
+    const cyclicACMIFvsPatchField<Type>& ptf,
+    const fvPatch& p,
+    const DimensionedField<Type, surfaceMesh>& iF,
+    const fvPatchFieldMapper& mapper
+)
+:
+    coupledFvsPatchField<Type>(ptf, p, iF, mapper),
+    cyclicACMIPatch_(refCast<const cyclicACMIFvPatch>(p))
+{
+    if (!isA<cyclicACMIFvPatch>(this->patch()))
+    {
+        FatalErrorIn
+        (
+            "cyclicACMIFvsPatchField<Type>::cyclicACMIFvsPatchField\n"
+            "("
+                "const cyclicACMIFvsPatchField<Type>&, "
+                "const fvPatch&, "
+                "const DimensionedField<Type, surfaceMesh>&, "
+                "const fvPatchFieldMapper&"
+            ")"
+        )   << "Field type does not correspond to patch type for patch "
+            << this->patch().index() << "." << endl
+            << "Field type: " << typeName << endl
+            << "Patch type: " << this->patch().type()
+            << exit(FatalError);
+    }
+}
+
+
+template<class Type>
+Foam::cyclicACMIFvsPatchField<Type>::cyclicACMIFvsPatchField
+(
+    const fvPatch& p,
+    const DimensionedField<Type, surfaceMesh>& iF,
+    const dictionary& dict
+)
+:
+    coupledFvsPatchField<Type>(p, iF, dict),
+    cyclicACMIPatch_(refCast<const cyclicACMIFvPatch>(p))
+{
+    if (!isA<cyclicACMIFvPatch>(p))
+    {
+        FatalIOErrorIn
+        (
+            "cyclicACMIFvsPatchField<Type>::cyclicACMIFvsPatchField"
+            "("
+                "const fvPatch&, "
+                "const Field<Type>&, "
+                "const dictionary&"
+            ")",
+            dict
+        )   << "patch " << this->patch().index() << " not cyclicACMI type. "
+            << "Patch type = " << p.type()
+            << exit(FatalIOError);
+    }
+}
+
+
+template<class Type>
+Foam::cyclicACMIFvsPatchField<Type>::cyclicACMIFvsPatchField
+(
+    const cyclicACMIFvsPatchField<Type>& ptf
+)
+:
+    coupledFvsPatchField<Type>(ptf),
+    cyclicACMIPatch_(ptf.cyclicACMIPatch_)
+{}
+
+
+template<class Type>
+Foam::cyclicACMIFvsPatchField<Type>::cyclicACMIFvsPatchField
+(
+    const cyclicACMIFvsPatchField<Type>& ptf,
+    const DimensionedField<Type, surfaceMesh>& iF
+)
+:
+    coupledFvsPatchField<Type>(ptf, iF),
+    cyclicACMIPatch_(ptf.cyclicACMIPatch_)
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+template<class Type>
+bool Foam::cyclicACMIFvsPatchField<Type>::coupled() const
+{
+    if
+    (
+        Pstream::parRun()
+     || (
+            this->cyclicACMIPatch_.size()
+         && this->cyclicACMIPatch_.cyclicACMIPatch().neighbPatch().size()
+        )
+    )
+    {
+        return true;
+    }
+    else
+    {
+        return false;
+    }
+}
+
+
+// ************************************************************************* //
diff --git a/src/finiteVolume/fields/fvsPatchFields/constraint/cyclicACMI/cyclicACMIFvsPatchField.H b/src/finiteVolume/fields/fvsPatchFields/constraint/cyclicACMI/cyclicACMIFvsPatchField.H
new file mode 100644
index 0000000000..edd7b9bf15
--- /dev/null
+++ b/src/finiteVolume/fields/fvsPatchFields/constraint/cyclicACMI/cyclicACMIFvsPatchField.H
@@ -0,0 +1,150 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 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::cyclicACMIFvsPatchField
+
+Description
+    Foam::cyclicACMIFvsPatchField
+
+SourceFiles
+    cyclicACMIFvsPatchField.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef cyclicACMIFvsPatchField_H
+#define cyclicACMIFvsPatchField_H
+
+#include "coupledFvsPatchField.H"
+#include "cyclicACMIFvPatch.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                   Class cyclicACMIFvsPatchField Declaration
+\*---------------------------------------------------------------------------*/
+
+template<class Type>
+class cyclicACMIFvsPatchField
+:
+    public coupledFvsPatchField<Type>
+{
+    // Private data
+
+        //- Local reference cast into the cyclic patch
+        const cyclicACMIFvPatch& cyclicACMIPatch_;
+
+
+public:
+
+    //- Runtime type information
+    TypeName(cyclicACMIFvPatch::typeName_());
+
+
+    // Constructors
+
+        //- Construct from patch and internal field
+        cyclicACMIFvsPatchField
+        (
+            const fvPatch&,
+            const DimensionedField<Type, surfaceMesh>&
+        );
+
+        //- Construct from patch, internal field and dictionary
+        cyclicACMIFvsPatchField
+        (
+            const fvPatch&,
+            const DimensionedField<Type, surfaceMesh>&,
+            const dictionary&
+        );
+
+        //- Construct by mapping given cyclicACMIFvsPatchField onto a new patch
+        cyclicACMIFvsPatchField
+        (
+            const cyclicACMIFvsPatchField<Type>&,
+            const fvPatch&,
+            const DimensionedField<Type, surfaceMesh>&,
+            const fvPatchFieldMapper&
+        );
+
+        //- Construct as copy
+        cyclicACMIFvsPatchField
+        (
+            const cyclicACMIFvsPatchField<Type>&
+        );
+
+        //- Construct and return a clone
+        virtual tmp<fvsPatchField<Type> > clone() const
+        {
+            return tmp<fvsPatchField<Type> >
+            (
+                new cyclicACMIFvsPatchField<Type>(*this)
+            );
+        }
+
+        //- Construct as copy setting internal field reference
+        cyclicACMIFvsPatchField
+        (
+            const cyclicACMIFvsPatchField<Type>&,
+            const DimensionedField<Type, surfaceMesh>&
+        );
+
+        //- Construct and return a clone setting internal field reference
+        virtual tmp<fvsPatchField<Type> > clone
+        (
+            const DimensionedField<Type, surfaceMesh>& iF
+        ) const
+        {
+            return tmp<fvsPatchField<Type> >
+            (
+                new cyclicACMIFvsPatchField<Type>(*this, iF)
+            );
+        }
+
+    // Member functions
+
+        // Access
+
+            //- Return true if running parallel
+            virtual bool coupled() const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+#   include "cyclicACMIFvsPatchField.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/finiteVolume/fields/fvsPatchFields/constraint/cyclicACMI/cyclicACMIFvsPatchFields.C b/src/finiteVolume/fields/fvsPatchFields/constraint/cyclicACMI/cyclicACMIFvsPatchFields.C
new file mode 100644
index 0000000000..efe05703d9
--- /dev/null
+++ b/src/finiteVolume/fields/fvsPatchFields/constraint/cyclicACMI/cyclicACMIFvsPatchFields.C
@@ -0,0 +1,43 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 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 "cyclicACMIFvsPatchFields.H"
+#include "fvsPatchFields.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+makeFvsPatchFields(cyclicACMI);
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// ************************************************************************* //
diff --git a/src/finiteVolume/fields/fvsPatchFields/constraint/cyclicACMI/cyclicACMIFvsPatchFields.H b/src/finiteVolume/fields/fvsPatchFields/constraint/cyclicACMI/cyclicACMIFvsPatchFields.H
new file mode 100644
index 0000000000..11801d8cd2
--- /dev/null
+++ b/src/finiteVolume/fields/fvsPatchFields/constraint/cyclicACMI/cyclicACMIFvsPatchFields.H
@@ -0,0 +1,49 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef cyclicACMIFvsPatchFields_H
+#define cyclicACMIFvsPatchFields_H
+
+#include "cyclicACMIFvsPatchField.H"
+#include "fieldTypes.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+makeFvsPatchTypeFieldTypedefs(cyclicACMI);
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/finiteVolume/fields/fvsPatchFields/constraint/cyclicACMI/cyclicACMIFvsPatchFieldsFwd.H b/src/finiteVolume/fields/fvsPatchFields/constraint/cyclicACMI/cyclicACMIFvsPatchFieldsFwd.H
new file mode 100644
index 0000000000..41b42881b9
--- /dev/null
+++ b/src/finiteVolume/fields/fvsPatchFields/constraint/cyclicACMI/cyclicACMIFvsPatchFieldsFwd.H
@@ -0,0 +1,50 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef cyclicACMIFvsPatchFieldsFwd_H
+#define cyclicACMIFvsPatchFieldsFwd_H
+
+#include "fieldTypes.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+template<class Type> class cyclicACMIFvsPatchField;
+
+makeFvsPatchTypeFieldTypedefs(cyclicACMI);
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/finiteVolume/fvMatrices/solvers/GAMGSymSolver/GAMGAgglomerations/faceAreaPairGAMGAgglomeration/faceAreaPairGAMGAgglomeration.C b/src/finiteVolume/fvMatrices/solvers/GAMGSymSolver/GAMGAgglomerations/faceAreaPairGAMGAgglomeration/faceAreaPairGAMGAgglomeration.C
index 9bfcda020c..42a35f5c1b 100644
--- a/src/finiteVolume/fvMatrices/solvers/GAMGSymSolver/GAMGAgglomerations/faceAreaPairGAMGAgglomeration/faceAreaPairGAMGAgglomeration.C
+++ b/src/finiteVolume/fvMatrices/solvers/GAMGSymSolver/GAMGAgglomerations/faceAreaPairGAMGAgglomeration/faceAreaPairGAMGAgglomeration.C
@@ -90,8 +90,6 @@ Foam::faceAreaPairGAMGAgglomeration::faceAreaPairGAMGAgglomeration
 :
     pairGAMGAgglomeration(mesh, controlDict)
 {
-    vectorField n(faceAreas/mag(faceAreas));
-
     //agglomerate(mesh, sqrt(mag(faceAreas)));
     agglomerate
     (
@@ -100,7 +98,8 @@ Foam::faceAreaPairGAMGAgglomeration::faceAreaPairGAMGAgglomeration
         (
             cmptMultiply
             (
-                n,
+                faceAreas
+               /sqrt(mag(faceAreas)),
                 vector(1, 1.01, 1.02)
                 //vector::one
             )
diff --git a/src/finiteVolume/fvMesh/fvPatches/constraint/cyclicACMI/cyclicACMIFvPatch.C b/src/finiteVolume/fvMesh/fvPatches/constraint/cyclicACMI/cyclicACMIFvPatch.C
new file mode 100644
index 0000000000..fe674cf98e
--- /dev/null
+++ b/src/finiteVolume/fvMesh/fvPatches/constraint/cyclicACMI/cyclicACMIFvPatch.C
@@ -0,0 +1,202 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 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 "cyclicACMIFvPatch.H"
+#include "addToRunTimeSelectionTable.H"
+#include "fvMesh.H"
+#include "transform.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(cyclicACMIFvPatch, 0);
+    addToRunTimeSelectionTable(fvPatch, cyclicACMIFvPatch, polyPatch);
+}
+
+// * * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * //
+
+void Foam::cyclicACMIFvPatch::updateAreas() const
+{
+    if (cyclicACMIPolyPatch_.updated())
+    {
+        // Set Sf and magSf for both sides' coupled and non-overlapping patches
+
+        // owner couple
+        const_cast<vectorField&>(Sf()) = patch().faceAreas();
+        const_cast<scalarField&>(magSf()) = mag(patch().faceAreas());
+
+        // owner non-overlapping
+        const fvPatch& nonOverlapPatch = this->nonOverlapPatch();
+        const_cast<vectorField&>(nonOverlapPatch.Sf()) =
+            nonOverlapPatch.patch().faceAreas();
+        const_cast<scalarField&>(nonOverlapPatch.magSf()) =
+            mag(nonOverlapPatch.patch().faceAreas());
+
+        // neighbour couple
+        const cyclicACMIFvPatch& nbrACMI = neighbPatch();
+        const_cast<vectorField&>(nbrACMI.Sf()) =
+            nbrACMI.patch().faceAreas();
+        const_cast<scalarField&>(nbrACMI.magSf()) =
+            mag(nbrACMI.patch().faceAreas());
+
+        // neighbour non-overlapping
+        const fvPatch& nbrNonOverlapPatch = nbrACMI.nonOverlapPatch();
+        const_cast<vectorField&>(nbrNonOverlapPatch.Sf()) =
+            nbrNonOverlapPatch.patch().faceAreas();
+        const_cast<scalarField&>(nbrNonOverlapPatch.magSf()) =
+            mag(nbrNonOverlapPatch.patch().faceAreas());
+
+        // set the updated flag
+        cyclicACMIPolyPatch_.setUpdated(false);
+    }
+}
+
+
+void Foam::cyclicACMIFvPatch::makeWeights(scalarField& w) const
+{
+    if (coupled())
+    {
+        const cyclicACMIFvPatch& nbrPatch = neighbFvPatch();
+        const fvPatch& nbrPatchNonOverlap = nonOverlapPatch();
+
+        const scalarField deltas(nf() & fvPatch::delta());
+
+        const scalarField nbrDeltas
+        (
+            interpolate
+            (
+                nbrPatch.nf() & nbrPatch.fvPatch::delta(),
+                nbrPatchNonOverlap.nf() & nbrPatchNonOverlap.delta()
+            )
+        );
+
+        forAll(deltas, faceI)
+        {
+            scalar di = deltas[faceI];
+            scalar dni = nbrDeltas[faceI];
+
+            w[faceI] = dni/(di + dni);
+        }
+    }
+    else
+    {
+        // Behave as uncoupled patch
+        fvPatch::makeWeights(w);
+    }
+}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+bool Foam::cyclicACMIFvPatch::coupled() const
+{
+    return Pstream::parRun() || (this->size() && neighbFvPatch().size());
+}
+
+
+Foam::tmp<Foam::vectorField> Foam::cyclicACMIFvPatch::delta() const
+{
+    if (coupled())
+    {
+        const cyclicACMIFvPatch& nbrPatchCoupled = neighbFvPatch();
+        const fvPatch& nbrPatchNonOverlap = nonOverlapPatch();
+
+        const vectorField patchD(fvPatch::delta());
+
+        vectorField nbrPatchD
+        (
+            interpolate
+            (
+                nbrPatchCoupled.fvPatch::delta(),
+                nbrPatchNonOverlap.delta()
+            )
+        );
+
+        const vectorField nbrPatchD0
+        (
+            interpolate
+            (
+                vectorField(nbrPatchCoupled.size(), vector::zero),
+                nbrPatchNonOverlap.delta()()
+            )
+        );
+
+        nbrPatchD -= nbrPatchD0;
+
+        tmp<vectorField> tpdv(new vectorField(patchD.size()));
+        vectorField& pdv = tpdv();
+
+        // do the transformation if necessary
+        if (parallel())
+        {
+            forAll(patchD, faceI)
+            {
+                const vector& ddi = patchD[faceI];
+                const vector& dni = nbrPatchD[faceI];
+
+                pdv[faceI] = ddi - dni;
+            }
+        }
+        else
+        {
+            forAll(patchD, faceI)
+            {
+                const vector& ddi = patchD[faceI];
+                const vector& dni = nbrPatchD[faceI];
+
+                pdv[faceI] = ddi - transform(forwardT()[0], dni);
+            }
+        }
+
+        return tpdv;
+    }
+    else
+    {
+        return fvPatch::delta();
+    }
+}
+
+
+Foam::tmp<Foam::labelField> Foam::cyclicACMIFvPatch::interfaceInternalField
+(
+    const labelUList& internalData
+) const
+{
+    return patchInternalField(internalData);
+}
+
+
+Foam::tmp<Foam::labelField> Foam::cyclicACMIFvPatch::internalFieldTransfer
+(
+    const Pstream::commsTypes commsType,
+    const labelUList& iF
+) const
+{
+    return neighbFvPatch().patchInternalField(iF);
+}
+
+
+// ************************************************************************* //
diff --git a/src/finiteVolume/fvMesh/fvPatches/constraint/cyclicACMI/cyclicACMIFvPatch.H b/src/finiteVolume/fvMesh/fvPatches/constraint/cyclicACMI/cyclicACMIFvPatch.H
new file mode 100644
index 0000000000..7ed1693696
--- /dev/null
+++ b/src/finiteVolume/fvMesh/fvPatches/constraint/cyclicACMI/cyclicACMIFvPatch.H
@@ -0,0 +1,268 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 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::cyclicACMIFvPatch
+
+Description
+    Cyclic patch for Arbitrarily Coupled Mesh Interface (ACMI)
+
+SourceFiles
+    cyclicACMIFvPatch.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef cyclicACMIFvPatch_H
+#define cyclicACMIFvPatch_H
+
+#include "coupledFvPatch.H"
+#include "cyclicACMILduInterface.H"
+#include "cyclicACMIPolyPatch.H"
+#include "fvBoundaryMesh.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                      Class cyclicACMIFvPatch Declaration
+\*---------------------------------------------------------------------------*/
+
+class cyclicACMIFvPatch
+:
+    public coupledFvPatch,
+    public cyclicACMILduInterface
+{
+    // Private data
+
+        const cyclicACMIPolyPatch& cyclicACMIPolyPatch_;
+
+
+protected:
+
+    // Protected Member functions
+
+        //- Update the patch areas after AMI update
+        void updateAreas() const;
+
+        //- Make patch weighting factors
+        void makeWeights(scalarField&) const;
+
+
+public:
+
+    //- Runtime type information
+    TypeName(cyclicACMIPolyPatch::typeName_());
+
+
+    // Constructors
+
+        //- Construct from polyPatch
+        cyclicACMIFvPatch(const polyPatch& patch, const fvBoundaryMesh& bm)
+        :
+            coupledFvPatch(patch, bm),
+            cyclicACMILduInterface(),
+            cyclicACMIPolyPatch_(refCast<const cyclicACMIPolyPatch>(patch))
+        {}
+
+
+    // Member functions
+
+        // Access
+
+            //- Return local reference cast into the cyclic patch
+            const cyclicACMIPolyPatch& cyclicACMIPatch() const
+            {
+                return cyclicACMIPolyPatch_;
+            }
+
+            //- Return neighbour
+            virtual label neighbPatchID() const
+            {
+                return cyclicACMIPolyPatch_.neighbPatchID();
+            }
+
+            virtual bool owner() const
+            {
+                return cyclicACMIPolyPatch_.owner();
+            }
+
+            //- Return neighbour fvPatch
+            virtual const cyclicACMIFvPatch& neighbPatch() const
+            {
+                return refCast<const cyclicACMIFvPatch>
+                (
+                    this->boundaryMesh()[cyclicACMIPolyPatch_.neighbPatchID()]
+                );
+            }
+
+            //- Return neighbour
+            virtual label nonOverlapPatchID() const
+            {
+                return cyclicACMIPolyPatch_.nonOverlapPatchID();
+            }
+
+            //- Return non-overlapping fvPatch
+            virtual const fvPatch& nonOverlapPatch() const
+            {
+                return this->boundaryMesh()[nonOverlapPatchID()];
+            }
+
+            //- Return a reference to the AMI interpolator
+            virtual const AMIPatchToPatchInterpolation& AMI() const
+            {
+                const AMIPatchToPatchInterpolation& AMI =
+                    cyclicACMIPolyPatch_.AMI();
+
+                updateAreas();
+
+                return AMI;
+            }
+
+            //- Are the cyclic planes parallel
+            virtual bool parallel() const
+            {
+                return cyclicACMIPolyPatch_.parallel();
+            }
+
+            //- Return face transformation tensor
+            virtual const tensorField& forwardT() const
+            {
+                return cyclicACMIPolyPatch_.forwardT();
+            }
+
+            //- Return neighbour-cell transformation tensor
+            virtual const tensorField& reverseT() const
+            {
+                return cyclicACMIPolyPatch_.reverseT();
+            }
+
+            const cyclicACMIFvPatch& neighbFvPatch() const
+            {
+                return refCast<const cyclicACMIFvPatch>
+                (
+                    this->boundaryMesh()[cyclicACMIPolyPatch_.neighbPatchID()]
+                );
+            }
+
+            //- Return true if this patch is coupled. This is equivalent
+            //  to the coupledPolyPatch::coupled() if parallel running or
+            //  both sides present, false otherwise
+            virtual bool coupled() const;
+
+            //- Return delta (P to N) vectors across coupled patch
+            virtual tmp<vectorField> delta() const;
+
+            template<class Type>
+            tmp<Field<Type> > interpolate
+            (
+                const Field<Type>& fldCoupled
+            ) const
+            {
+                updateAreas();
+
+                return
+                    cyclicACMIPolyPatch_.cyclicAMIPolyPatch::interpolate
+                    (
+                        fldCoupled
+                    );
+            }
+
+            template<class Type>
+            tmp<Field<Type> > interpolate
+            (
+                const tmp<Field<Type> >& tfldCoupled
+            ) const
+            {
+                updateAreas();
+
+                return
+                    cyclicACMIPolyPatch_.cyclicAMIPolyPatch::interpolate
+                    (
+                        tfldCoupled
+                    );
+            }
+
+            template<class Type>
+            tmp<Field<Type> > interpolate
+            (
+                const Field<Type>& fldCoupled,
+                const Field<Type>& fldNonOverlap
+            ) const
+            {
+                updateAreas();
+
+                return
+                    cyclicACMIPolyPatch_.interpolate
+                    (
+                        fldCoupled,
+                        fldNonOverlap
+                    );
+            }
+
+            template<class Type>
+            tmp<Field<Type> > interpolate
+            (
+                const tmp<Field<Type> >& tFldCoupled,
+                const tmp<Field<Type> >& tFldNonOverlap
+            ) const
+            {
+                updateAreas();
+
+                return
+                    cyclicACMIPolyPatch_.interpolate
+                    (
+                        tFldCoupled,
+                        tFldNonOverlap
+                    );
+            }
+
+
+        // Interface transfer functions
+
+            //- Return the values of the given internal data adjacent to
+            //  the interface as a field
+            virtual tmp<labelField> interfaceInternalField
+            (
+                const labelUList& internalData
+            ) const;
+
+            //- Return neighbour field
+            virtual tmp<labelField> internalFieldTransfer
+            (
+                const Pstream::commsTypes commsType,
+                const labelUList& internalData
+            ) const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/fvAgglomerationMethods/MGridGenGamgAgglomeration/MGridGenGAMGAgglomeration.C b/src/fvAgglomerationMethods/MGridGenGamgAgglomeration/MGridGenGAMGAgglomeration.C
index 46bcbc8953..59c45bc11b 100644
--- a/src/fvAgglomerationMethods/MGridGenGamgAgglomeration/MGridGenGAMGAgglomeration.C
+++ b/src/fvAgglomerationMethods/MGridGenGamgAgglomeration/MGridGenGAMGAgglomeration.C
@@ -59,7 +59,11 @@ Foam::MGridGenGAMGAgglomeration::MGridGenGAMGAgglomeration
 
     // Start geometric agglomeration from the cell volumes and areas of the mesh
     scalarField* VPtr = const_cast<scalarField*>(&fvMesh_.cellVolumes());
-    vectorField* SfPtr = const_cast<vectorField*>(&fvMesh_.faceAreas());
+    SubField<vector> Sf(fvMesh_.faceAreas(), fvMesh_.nInternalFaces());
+    vectorField* SfPtr = const_cast<vectorField*>
+    (
+        &Sf.operator const vectorField&()
+    );
 
     // Create the boundary area cell field
     scalarField* SbPtr(new scalarField(fvMesh_.nCells(), 0));
diff --git a/src/fvAgglomerationMethods/pairPatchAgglomeration/pairPatchAgglomeration.C b/src/fvAgglomerationMethods/pairPatchAgglomeration/pairPatchAgglomeration.C
index 9a7462127c..9467906f15 100644
--- a/src/fvAgglomerationMethods/pairPatchAgglomeration/pairPatchAgglomeration.C
+++ b/src/fvAgglomerationMethods/pairPatchAgglomeration/pairPatchAgglomeration.C
@@ -44,9 +44,7 @@ bool Foam::pairPatchAgglomeration::continueAgglomerating
 {
     // Check the need for further agglomeration on all processors
     label localnCoarseFaces = nCoarseFaces;
-//     reduce(localnCoarseFaces, sumOp<label>());
     bool contAgg = localnCoarseFaces >= nFacesInCoarsestLevel_;
-    //reduce(contAgg, andOp<bool>());
     return contAgg;
 }
 
diff --git a/src/lagrangian/intermediate/clouds/Templates/KinematicCloud/KinematicCloud.C b/src/lagrangian/intermediate/clouds/Templates/KinematicCloud/KinematicCloud.C
index 66e54468e5..445775a928 100644
--- a/src/lagrangian/intermediate/clouds/Templates/KinematicCloud/KinematicCloud.C
+++ b/src/lagrangian/intermediate/clouds/Templates/KinematicCloud/KinematicCloud.C
@@ -566,7 +566,11 @@ void Foam::KinematicCloud<CloudType>::checkParcelProperties
 {
     const scalar carrierDt = mesh_.time().deltaTValue();
     parcel.stepFraction() = (carrierDt - lagrangianDt)/carrierDt;
-    parcel.typeId() = constProps_.parcelTypeId();
+
+    if (parcel.typeId() == -1)
+    {
+        parcel.typeId() = constProps_.parcelTypeId();
+    }
 }
 
 
diff --git a/src/lagrangian/intermediate/submodels/Kinematic/InjectionModel/ConeNozzleInjection/ConeNozzleInjection.C b/src/lagrangian/intermediate/submodels/Kinematic/InjectionModel/ConeNozzleInjection/ConeNozzleInjection.C
index cebed76580..97c3c819a0 100644
--- a/src/lagrangian/intermediate/submodels/Kinematic/InjectionModel/ConeNozzleInjection/ConeNozzleInjection.C
+++ b/src/lagrangian/intermediate/submodels/Kinematic/InjectionModel/ConeNozzleInjection/ConeNozzleInjection.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -167,7 +167,8 @@ Foam::ConeNozzleInjection<CloudType>::ConeNozzleInjection
             "Foam::ConeNozzleInjection<CloudType>::ConeNozzleInjection"
             "("
                 "const dictionary&, "
-                "CloudType&"
+                "CloudType&, "
+                "const word&"
             ")"
         )<< "innerNozzleDiameter >= outerNozzleDiameter" << nl
          << exit(FatalError);
@@ -369,6 +370,7 @@ void Foam::ConeNozzleInjection<CloudType>::setPositionAndCell
                     "const scalar, "
                     "vector&, "
                     "label&, "
+                    "label&, "
                     "label&"
                 ")"
             )<< "Unknown injectionMethod type" << nl
diff --git a/src/lagrangian/intermediate/submodels/Kinematic/InjectionModel/KinematicLookupTableInjection/KinematicLookupTableInjection.C b/src/lagrangian/intermediate/submodels/Kinematic/InjectionModel/KinematicLookupTableInjection/KinematicLookupTableInjection.C
index c40a95fbac..293fd7d740 100644
--- a/src/lagrangian/intermediate/submodels/Kinematic/InjectionModel/KinematicLookupTableInjection/KinematicLookupTableInjection.C
+++ b/src/lagrangian/intermediate/submodels/Kinematic/InjectionModel/KinematicLookupTableInjection/KinematicLookupTableInjection.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -43,6 +43,7 @@ Foam::KinematicLookupTableInjection<CloudType>::KinematicLookupTableInjection
     (
         readScalar(this->coeffDict().lookup("parcelsPerSecond"))
     ),
+    randomise_(readBool(this->coeffDict().lookup("randomise"))),
     injectors_
     (
         IOobject
@@ -87,6 +88,7 @@ Foam::KinematicLookupTableInjection<CloudType>::KinematicLookupTableInjection
     inputFileName_(im.inputFileName_),
     duration_(im.duration_),
     parcelsPerSecond_(im.parcelsPerSecond_),
+    randomise_(im.randomise_),
     injectors_(im.injectors_),
     injectorCells_(im.injectorCells_),
     injectorTetFaces_(im.injectorTetFaces_),
@@ -177,7 +179,16 @@ void Foam::KinematicLookupTableInjection<CloudType>::setPositionAndCell
     label& tetPtI
 )
 {
-    label injectorI = parcelI*injectorCells_.size()/nParcels;
+    label injectorI = 0;
+    if (randomise_)
+    {
+        cachedRandom& rnd = this->owner().rndGen();
+        injectorI = rnd.position<label>(0, injectorCells_.size() - 1);
+    }
+    else
+    {
+        injectorI = parcelI*injectorCells_.size()/nParcels;
+    }
 
     position = injectors_[injectorI].x();
     cellOwner = injectorCells_[injectorI];
diff --git a/src/lagrangian/intermediate/submodels/Kinematic/InjectionModel/KinematicLookupTableInjection/KinematicLookupTableInjection.H b/src/lagrangian/intermediate/submodels/Kinematic/InjectionModel/KinematicLookupTableInjection/KinematicLookupTableInjection.H
index d156f4793a..f17410bc1d 100644
--- a/src/lagrangian/intermediate/submodels/Kinematic/InjectionModel/KinematicLookupTableInjection/KinematicLookupTableInjection.H
+++ b/src/lagrangian/intermediate/submodels/Kinematic/InjectionModel/KinematicLookupTableInjection/KinematicLookupTableInjection.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -78,6 +78,9 @@ class KinematicLookupTableInjection
         //- Number of parcels per injector - common to all injection sources
         const scalar parcelsPerSecond_;
 
+        //- Flag to indicate to randomise injection positions
+        bool randomise_;
+
         //- List of injectors
         kinematicParcelInjectionDataIOList injectors_;
 
diff --git a/src/lagrangian/intermediate/submodels/Kinematic/ParticleForces/Lift/LiftForce/LiftForce.C b/src/lagrangian/intermediate/submodels/Kinematic/ParticleForces/Lift/LiftForce/LiftForce.C
index 290d2f3c3d..a4faceeec7 100644
--- a/src/lagrangian/intermediate/submodels/Kinematic/ParticleForces/Lift/LiftForce/LiftForce.C
+++ b/src/lagrangian/intermediate/submodels/Kinematic/ParticleForces/Lift/LiftForce/LiftForce.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2012-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -141,7 +141,7 @@ Foam::forceSuSp Foam::LiftForce<CloudType>::calcCoupled
 
     scalar Cl = this->Cl(p, curlUc, Re, muc);
 
-    value.Su() = mass/p.rho()*p.d()/2.0*p.rhoc()*Cl*((p.Uc() - p.U())^curlUc);
+    value.Su() = mass/p.rho()*p.rhoc()*Cl*((p.Uc() - p.U())^curlUc);
 
     return value;
 }
diff --git a/src/lagrangian/intermediate/submodels/Kinematic/ParticleForces/SRF/SRFForce.C b/src/lagrangian/intermediate/submodels/Kinematic/ParticleForces/SRF/SRFForce.C
index 758e58743b..eed0c800d0 100644
--- a/src/lagrangian/intermediate/submodels/Kinematic/ParticleForces/SRF/SRFForce.C
+++ b/src/lagrangian/intermediate/submodels/Kinematic/ParticleForces/SRF/SRFForce.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -95,7 +95,9 @@ Foam::forceSuSp Foam::SRFForce<CloudType>::calcNonCoupled
     const vector& r = p.position();
 
     // Coriolis and centrifugal acceleration terms
-    value.Su() = mass*(2.0*(p.U() ^ omega) + (omega ^ (r ^ omega)));
+    value.Su() =
+        mass*(1.0 - p.rhoc()/p.rho())
+       *(2.0*(p.U() ^ omega) + (omega ^ (r ^ omega)));
 
     return value;
 }
diff --git a/src/lagrangian/intermediate/submodels/Reacting/InjectionModel/ReactingLookupTableInjection/ReactingLookupTableInjection.C b/src/lagrangian/intermediate/submodels/Reacting/InjectionModel/ReactingLookupTableInjection/ReactingLookupTableInjection.C
index 711b3cec7a..1259da7e37 100644
--- a/src/lagrangian/intermediate/submodels/Reacting/InjectionModel/ReactingLookupTableInjection/ReactingLookupTableInjection.C
+++ b/src/lagrangian/intermediate/submodels/Reacting/InjectionModel/ReactingLookupTableInjection/ReactingLookupTableInjection.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -42,6 +42,7 @@ Foam::ReactingLookupTableInjection<CloudType>::ReactingLookupTableInjection
     (
         readScalar(this->coeffDict().lookup("parcelsPerSecond"))
     ),
+    randomise_(readBool(this->coeffDict().lookup("randomise"))),
     injectors_
     (
         IOobject
@@ -86,6 +87,7 @@ Foam::ReactingLookupTableInjection<CloudType>::ReactingLookupTableInjection
     inputFileName_(im.inputFileName_),
     duration_(im.duration_),
     parcelsPerSecond_(im.parcelsPerSecond_),
+    randomise_(im.randomise_),
     injectors_(im.injectors_),
     injectorCells_(im.injectorCells_),
     injectorTetFaces_(im.injectorTetFaces_),
@@ -176,7 +178,16 @@ void Foam::ReactingLookupTableInjection<CloudType>::setPositionAndCell
     label& tetPtI
 )
 {
-    label injectorI = parcelI*injectorCells_.size()/nParcels;
+    label injectorI = 0;
+    if (randomise_)
+    {
+        cachedRandom& rnd = this->owner().rndGen();
+        injectorI = rnd.position<label>(0, injectorCells_.size() - 1);
+    }
+    else
+    {
+        injectorI = parcelI*injectorCells_.size()/nParcels;
+    }
 
     position = injectors_[injectorI].x();
     cellOwner = injectorCells_[injectorI];
diff --git a/src/lagrangian/intermediate/submodels/Reacting/InjectionModel/ReactingLookupTableInjection/ReactingLookupTableInjection.H b/src/lagrangian/intermediate/submodels/Reacting/InjectionModel/ReactingLookupTableInjection/ReactingLookupTableInjection.H
index ef062fd72b..654109c509 100644
--- a/src/lagrangian/intermediate/submodels/Reacting/InjectionModel/ReactingLookupTableInjection/ReactingLookupTableInjection.H
+++ b/src/lagrangian/intermediate/submodels/Reacting/InjectionModel/ReactingLookupTableInjection/ReactingLookupTableInjection.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -81,6 +81,9 @@ class ReactingLookupTableInjection
         //- Number of parcels per injector - common to all injection sources
         const scalar parcelsPerSecond_;
 
+        //- Flag to indicate to randomise injection positions
+        bool randomise_;
+
         //- List of injectors
         reactingParcelInjectionDataIOList injectors_;
 
diff --git a/src/lagrangian/intermediate/submodels/ReactingMultiphase/InjectionModel/ReactingMultiphaseLookupTableInjection/ReactingMultiphaseLookupTableInjection.C b/src/lagrangian/intermediate/submodels/ReactingMultiphase/InjectionModel/ReactingMultiphaseLookupTableInjection/ReactingMultiphaseLookupTableInjection.C
index bd630d879d..179b846caf 100644
--- a/src/lagrangian/intermediate/submodels/ReactingMultiphase/InjectionModel/ReactingMultiphaseLookupTableInjection/ReactingMultiphaseLookupTableInjection.C
+++ b/src/lagrangian/intermediate/submodels/ReactingMultiphase/InjectionModel/ReactingMultiphaseLookupTableInjection/ReactingMultiphaseLookupTableInjection.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -43,6 +43,7 @@ ReactingMultiphaseLookupTableInjection
     (
         readScalar(this->coeffDict().lookup("parcelsPerSecond"))
     ),
+    randomise_(readBool(this->coeffDict().lookup("randomise"))),
     injectors_
     (
         IOobject
@@ -88,6 +89,7 @@ ReactingMultiphaseLookupTableInjection
     inputFileName_(im.inputFileName_),
     duration_(im.duration_),
     parcelsPerSecond_(im.parcelsPerSecond_),
+    randomise_(im.randomise_),
     injectors_(im.injectors_),
     injectorCells_(im.injectorCells_),
     injectorTetFaces_(im.injectorTetFaces_),
@@ -182,7 +184,16 @@ void Foam::ReactingMultiphaseLookupTableInjection<CloudType>::setPositionAndCell
     label& tetPtI
 )
 {
-    label injectorI = parcelI*injectorCells_.size()/nParcels;
+    label injectorI = 0;
+    if (randomise_)
+    {
+        cachedRandom& rnd = this->owner().rndGen();
+        injectorI = rnd.position<label>(0, injectorCells_.size() - 1);
+    }
+    else
+    {
+        injectorI = parcelI*injectorCells_.size()/nParcels;
+    }
 
     position = injectors_[injectorI].x();
     cellOwner = injectorCells_[injectorI];
diff --git a/src/lagrangian/intermediate/submodels/ReactingMultiphase/InjectionModel/ReactingMultiphaseLookupTableInjection/ReactingMultiphaseLookupTableInjection.H b/src/lagrangian/intermediate/submodels/ReactingMultiphase/InjectionModel/ReactingMultiphaseLookupTableInjection/ReactingMultiphaseLookupTableInjection.H
index 7e6c328558..81f41d42de 100644
--- a/src/lagrangian/intermediate/submodels/ReactingMultiphase/InjectionModel/ReactingMultiphaseLookupTableInjection/ReactingMultiphaseLookupTableInjection.H
+++ b/src/lagrangian/intermediate/submodels/ReactingMultiphase/InjectionModel/ReactingMultiphaseLookupTableInjection/ReactingMultiphaseLookupTableInjection.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -84,6 +84,9 @@ class ReactingMultiphaseLookupTableInjection
         //- Number of parcels per injector - common to all injection sources
         const scalar parcelsPerSecond_;
 
+        //- Flag to indicate to randomise injection positions
+        bool randomise_;
+
         //- List of injectors
         reactingMultiphaseParcelInjectionDataIOList injectors_;
 
diff --git a/src/lagrangian/intermediate/submodels/Thermodynamic/InjectionModel/ThermoLookupTableInjection/ThermoLookupTableInjection.C b/src/lagrangian/intermediate/submodels/Thermodynamic/InjectionModel/ThermoLookupTableInjection/ThermoLookupTableInjection.C
index fdc0a3b4a3..682fc9c3ea 100644
--- a/src/lagrangian/intermediate/submodels/Thermodynamic/InjectionModel/ThermoLookupTableInjection/ThermoLookupTableInjection.C
+++ b/src/lagrangian/intermediate/submodels/Thermodynamic/InjectionModel/ThermoLookupTableInjection/ThermoLookupTableInjection.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -43,6 +43,7 @@ Foam::ThermoLookupTableInjection<CloudType>::ThermoLookupTableInjection
     (
         readScalar(this->coeffDict().lookup("parcelsPerSecond"))
     ),
+    randomise_(readBool(this->coeffDict().lookup("randomise"))),
     injectors_
     (
         IOobject
@@ -87,6 +88,7 @@ Foam::ThermoLookupTableInjection<CloudType>::ThermoLookupTableInjection
     inputFileName_(im.inputFileName_),
     duration_(im.duration_),
     parcelsPerSecond_(im.parcelsPerSecond_),
+    randomise_(im.randomise_),
     injectors_(im.injectors_),
     injectorCells_(im.injectorCells_),
     injectorTetFaces_(im.injectorTetFaces_),
@@ -177,7 +179,16 @@ void Foam::ThermoLookupTableInjection<CloudType>::setPositionAndCell
     label& tetPtI
 )
 {
-    label injectorI = parcelI*injectorCells_.size()/nParcels;
+    label injectorI = 0;
+    if (randomise_)
+    {
+        cachedRandom& rnd = this->owner().rndGen();
+        injectorI = rnd.position<label>(0, injectorCells_.size() - 1);
+    }
+    else
+    {
+        injectorI = parcelI*injectorCells_.size()/nParcels;
+    }
 
     position = injectors_[injectorI].x();
     cellOwner = injectorCells_[injectorI];
diff --git a/src/lagrangian/intermediate/submodels/Thermodynamic/InjectionModel/ThermoLookupTableInjection/ThermoLookupTableInjection.H b/src/lagrangian/intermediate/submodels/Thermodynamic/InjectionModel/ThermoLookupTableInjection/ThermoLookupTableInjection.H
index efb83c3614..42c48f290d 100644
--- a/src/lagrangian/intermediate/submodels/Thermodynamic/InjectionModel/ThermoLookupTableInjection/ThermoLookupTableInjection.H
+++ b/src/lagrangian/intermediate/submodels/Thermodynamic/InjectionModel/ThermoLookupTableInjection/ThermoLookupTableInjection.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -80,6 +80,9 @@ class ThermoLookupTableInjection
         //- Number of parcels per injector - common to all injection sources
         const scalar parcelsPerSecond_;
 
+        //- Flag to indicate to randomise injection positions
+        bool randomise_;
+
         //- List of injectors
         kinematicParcelInjectionDataIOList injectors_;
 
diff --git a/src/mesh/autoMesh/autoHexMesh/autoHexMeshDriver/autoRefineDriver.C b/src/mesh/autoMesh/autoHexMesh/autoHexMeshDriver/autoRefineDriver.C
index 484f851c0f..d78866bcd7 100644
--- a/src/mesh/autoMesh/autoHexMesh/autoHexMeshDriver/autoRefineDriver.C
+++ b/src/mesh/autoMesh/autoHexMesh/autoHexMeshDriver/autoRefineDriver.C
@@ -46,9 +46,6 @@ defineTypeNameAndDebug(autoRefineDriver, 0);
 } // End namespace Foam
 
 
-// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
-
-
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
 // Construct from components
@@ -97,12 +94,14 @@ Foam::label Foam::autoRefineDriver::featureEdgeRefine
                 (
                     refineParams.keepPoints()[0],    // For now only use one.
                     refineParams.curvature(),
+                    refineParams.planarAngle(),
 
                     true,               // featureRefinement
                     false,              // featureDistanceRefinement
                     false,              // internalRefinement
                     false,              // surfaceRefinement
                     false,              // curvatureRefinement
+                    false,              // gapRefinement
                     refineParams.maxGlobalCells(),
                     refineParams.maxLocalCells()
                 )
@@ -208,12 +207,14 @@ Foam::label Foam::autoRefineDriver::surfaceOnlyRefine
             (
                 refineParams.keepPoints()[0],
                 refineParams.curvature(),
+                refineParams.planarAngle(),
 
                 false,              // featureRefinement
                 false,              // featureDistanceRefinement
                 false,              // internalRefinement
                 true,               // surfaceRefinement
                 true,               // curvatureRefinement
+                false,              // gapRefinement
                 refineParams.maxGlobalCells(),
                 refineParams.maxLocalCells()
             )
@@ -294,6 +295,371 @@ Foam::label Foam::autoRefineDriver::surfaceOnlyRefine
 }
 
 
+Foam::label Foam::autoRefineDriver::gapOnlyRefine
+(
+    const refinementParameters& refineParams,
+    const label maxIter
+)
+{
+    const fvMesh& mesh = meshRefiner_.mesh();
+
+    // Determine the maximum refinement level over all surfaces. This
+    // determines the minumum number of surface refinement iterations.
+
+    label maxIncrement = 0;
+    const labelList& maxLevel = meshRefiner_.surfaces().maxLevel();
+    const labelList& gapLevel = meshRefiner_.surfaces().gapLevel();
+
+    forAll(maxLevel, i)
+    {
+        maxIncrement = max(maxIncrement, gapLevel[i]-maxLevel[i]);
+    }
+
+    label iter = 0;
+
+    if (maxIncrement == 0)
+    {
+        return iter;
+    }
+
+    for (iter = 0; iter < maxIter; iter++)
+    {
+        Info<< nl
+            << "Gap refinement iteration " << iter << nl
+            << "--------------------------" << nl
+            << endl;
+
+
+        // Determine cells to refine
+        // ~~~~~~~~~~~~~~~~~~~~~~~~~
+        // Only look at surface intersections (minLevel and surface curvature),
+        // do not do internal refinement (refinementShells)
+
+        labelList candidateCells
+        (
+            meshRefiner_.refineCandidates
+            (
+                refineParams.keepPoints()[0],
+                refineParams.curvature(),
+                refineParams.planarAngle(),
+
+                false,              // featureRefinement
+                false,              // featureDistanceRefinement
+                false,              // internalRefinement
+                false,              // surfaceRefinement
+                false,              // curvatureRefinement
+                true,               // gapRefinement
+                refineParams.maxGlobalCells(),
+                refineParams.maxLocalCells()
+            )
+        );
+
+        if (debug&meshRefinement::MESH)
+        {
+            Pout<< "Dumping " << candidateCells.size()
+                << " cells to cellSet candidateCellsFromGap." << endl;
+            cellSet c(mesh, "candidateCellsFromGap", candidateCells);
+            c.instance() = meshRefiner_.timeName();
+            c.write();
+        }
+
+        // Grow by one layer to make sure we're covering the gap
+        {
+            boolList isCandidateCell(mesh.nCells(), false);
+            forAll(candidateCells, i)
+            {
+                isCandidateCell[candidateCells[i]] = true;
+            }
+
+            for (label i=0; i<1; i++)
+            {
+                boolList newIsCandidateCell(isCandidateCell);
+
+                // Internal faces
+                for (label faceI = 0; faceI < mesh.nInternalFaces(); faceI++)
+                {
+                    label own = mesh.faceOwner()[faceI];
+                    label nei = mesh.faceNeighbour()[faceI];
+
+                    if (isCandidateCell[own] != isCandidateCell[nei])
+                    {
+                        newIsCandidateCell[own] = true;
+                        newIsCandidateCell[nei] = true;
+                    }
+                }
+
+                // Get coupled boundary condition values
+                boolList neiIsCandidateCell;
+                syncTools::swapBoundaryCellList
+                (
+                    mesh,
+                    isCandidateCell,
+                    neiIsCandidateCell
+                );
+
+                // Boundary faces
+                for
+                (
+                    label faceI = mesh.nInternalFaces();
+                    faceI < mesh.nFaces();
+                    faceI++
+                )
+                {
+                    label own = mesh.faceOwner()[faceI];
+                    label bFaceI = faceI-mesh.nInternalFaces();
+
+                    if (isCandidateCell[own] != neiIsCandidateCell[bFaceI])
+                    {
+                        newIsCandidateCell[own] = true;
+                    }
+                }
+
+                isCandidateCell.transfer(newIsCandidateCell);
+            }
+
+            label n = 0;
+            forAll(isCandidateCell, cellI)
+            {
+                if (isCandidateCell[cellI])
+                {
+                    n++;
+                }
+            }
+            candidateCells.setSize(n);
+            n = 0;
+            forAll(isCandidateCell, cellI)
+            {
+                if (isCandidateCell[cellI])
+                {
+                    candidateCells[n++] = cellI;
+                }
+            }
+        }
+
+
+        if (debug&meshRefinement::MESH)
+        {
+            Pout<< "Dumping " << candidateCells.size()
+                << " cells to cellSet candidateCellsFromGapPlusBuffer." << endl;
+            cellSet c(mesh, "candidateCellsFromGapPlusBuffer", candidateCells);
+            c.instance() = meshRefiner_.timeName();
+            c.write();
+        }
+
+
+        labelList cellsToRefine
+        (
+            meshRefiner_.meshCutter().consistentRefinement
+            (
+                candidateCells,
+                true
+            )
+        );
+        Info<< "Determined cells to refine in = "
+            << mesh.time().cpuTimeIncrement() << " s" << endl;
+
+
+        label nCellsToRefine = cellsToRefine.size();
+        reduce(nCellsToRefine, sumOp<label>());
+
+        Info<< "Selected for refinement : " << nCellsToRefine
+            << " cells (out of " << mesh.globalData().nTotalCells()
+            << ')' << endl;
+
+        // Stop when no cells to refine or have done minimum necessary
+        // iterations and not enough cells to refine.
+        if
+        (
+            nCellsToRefine == 0
+         || (
+                iter >= maxIncrement
+             && nCellsToRefine <= refineParams.minRefineCells()
+            )
+        )
+        {
+            Info<< "Stopping refining since too few cells selected."
+                << nl << endl;
+            break;
+        }
+
+
+        if (debug)
+        {
+            const_cast<Time&>(mesh.time())++;
+        }
+
+
+        if
+        (
+            returnReduce
+            (
+                (mesh.nCells() >= refineParams.maxLocalCells()),
+                orOp<bool>()
+            )
+        )
+        {
+            meshRefiner_.balanceAndRefine
+            (
+                "gap refinement iteration " + name(iter),
+                decomposer_,
+                distributor_,
+                cellsToRefine,
+                refineParams.maxLoadUnbalance()
+            );
+        }
+        else
+        {
+            meshRefiner_.refineAndBalance
+            (
+                "gap refinement iteration " + name(iter),
+                decomposer_,
+                distributor_,
+                cellsToRefine,
+                refineParams.maxLoadUnbalance()
+            );
+        }
+    }
+    return iter;
+}
+
+
+Foam::label Foam::autoRefineDriver::danglingCellRefine
+(
+    const refinementParameters& refineParams,
+    const label nFaces,
+    const label maxIter
+)
+{
+    const fvMesh& mesh = meshRefiner_.mesh();
+
+    label iter;
+    for (iter = 0; iter < maxIter; iter++)
+    {
+        Info<< nl
+            << "Dangling coarse cells refinement iteration " << iter << nl
+            << "--------------------------------------------" << nl
+            << endl;
+
+
+        // Determine cells to refine
+        // ~~~~~~~~~~~~~~~~~~~~~~~~~
+
+        const cellList& cells = mesh.cells();
+        const polyBoundaryMesh& pbm = mesh.boundaryMesh();
+
+        labelList candidateCells;
+        {
+            cellSet candidateCellSet(mesh, "candidateCells", cells.size()/1000);
+
+            forAll(cells, cellI)
+            {
+                const cell& cFaces = cells[cellI];
+
+                label nIntFaces = 0;
+                forAll(cFaces, i)
+                {
+                    label bFaceI = cFaces[i]-mesh.nInternalFaces();
+                    if (bFaceI < 0)
+                    {
+                        nIntFaces++;
+                    }
+                    else
+                    {
+                        label patchI = pbm.patchID()[bFaceI];
+                        if (pbm[patchI].coupled())
+                        {
+                            nIntFaces++;
+                        }
+                    }
+                }
+
+                if (nIntFaces == nFaces)
+                {
+                    candidateCellSet.insert(cellI);
+                }
+            }
+
+            if (debug&meshRefinement::MESH)
+            {
+                Pout<< "Dumping " << candidateCellSet.size()
+                    << " cells to cellSet candidateCellSet." << endl;
+                candidateCellSet.instance() = meshRefiner_.timeName();
+                candidateCellSet.write();
+            }
+            candidateCells = candidateCellSet.toc();
+        }
+
+
+
+        labelList cellsToRefine
+        (
+            meshRefiner_.meshCutter().consistentRefinement
+            (
+                candidateCells,
+                true
+            )
+        );
+        Info<< "Determined cells to refine in = "
+            << mesh.time().cpuTimeIncrement() << " s" << endl;
+
+
+        label nCellsToRefine = cellsToRefine.size();
+        reduce(nCellsToRefine, sumOp<label>());
+
+        Info<< "Selected for refinement : " << nCellsToRefine
+            << " cells (out of " << mesh.globalData().nTotalCells()
+            << ')' << endl;
+
+        // Stop when no cells to refine. No checking of minRefineCells since
+        // too few cells
+        if (nCellsToRefine == 0)
+        {
+            Info<< "Stopping refining since too few cells selected."
+                << nl << endl;
+            break;
+        }
+
+
+        if (debug)
+        {
+            const_cast<Time&>(mesh.time())++;
+        }
+
+
+        if
+        (
+            returnReduce
+            (
+                (mesh.nCells() >= refineParams.maxLocalCells()),
+                orOp<bool>()
+            )
+        )
+        {
+            meshRefiner_.balanceAndRefine
+            (
+                "coarse cell refinement iteration " + name(iter),
+                decomposer_,
+                distributor_,
+                cellsToRefine,
+                refineParams.maxLoadUnbalance()
+            );
+        }
+        else
+        {
+            meshRefiner_.refineAndBalance
+            (
+                "coarse cell refinement iteration " + name(iter),
+                decomposer_,
+                distributor_,
+                cellsToRefine,
+                refineParams.maxLoadUnbalance()
+            );
+        }
+    }
+    return iter;
+}
+
+
 void Foam::autoRefineDriver::removeInsideCells
 (
     const refinementParameters& refineParams,
@@ -371,12 +737,14 @@ Foam::label Foam::autoRefineDriver::shellRefine
             (
                 refineParams.keepPoints()[0],
                 refineParams.curvature(),
+                refineParams.planarAngle(),
 
                 false,              // featureRefinement
                 true,               // featureDistanceRefinement
                 true,               // internalRefinement
                 false,              // surfaceRefinement
                 false,              // curvatureRefinement
+                false,              // gapRefinement
                 refineParams.maxGlobalCells(),
                 refineParams.maxLocalCells()
             )
@@ -522,6 +890,7 @@ void Foam::autoRefineDriver::baffleAndSplitMesh
         false,                          // perpendicular edge connected cells
         scalarField(0),                 // per region perpendicular angle
         !handleSnapProblems,            // merge free standing baffles?
+        refineParams.planarAngle(),
         motionDict,
         const_cast<Time&>(mesh.time()),
         globalToMasterPatch_,
@@ -606,8 +975,8 @@ void Foam::autoRefineDriver::splitAndMergeBaffles
         handleSnapProblems,
         handleSnapProblems,                 // remove perp edge connected cells
         perpAngle,                          // perp angle
-        false,                              // merge free standing baffles?
-        //true,                               // merge free standing baffles?
+        true,                               // merge free standing baffles?
+        refineParams.planarAngle(),         // planar angle
         motionDict,
         const_cast<Time&>(mesh.time()),
         globalToMasterPatch_,
@@ -652,6 +1021,16 @@ void Foam::autoRefineDriver::splitAndMergeBaffles
             // Debug:test all is still synced across proc patches
             meshRefiner_.checkData();
         }
+
+        // Remove any now dangling parts
+        meshRefiner_.splitMeshRegions(refineParams.keepPoints()[0]);
+
+        if (debug)
+        {
+            // Debug:test all is still synced across proc patches
+            meshRefiner_.checkData();
+        }
+
         Info<< "Merged free-standing baffles in = "
             << mesh.time().cpuTimeIncrement() << " s." << endl;
     }
@@ -731,6 +1110,12 @@ void Foam::autoRefineDriver::doRefine
         100     // maxIter
     );
 
+    gapOnlyRefine
+    (
+        refineParams,
+        100     // maxIter
+    );
+
     // Remove cells (a certain distance) beyond surface intersections
     removeInsideCells
     (
@@ -745,6 +1130,20 @@ void Foam::autoRefineDriver::doRefine
         100    // maxIter
     );
 
+    // Refine any hexes with 5 or 6 faces refined to make smooth edges
+    danglingCellRefine
+    (
+        refineParams,
+        21,     // 1 coarse face + 5 refined faces
+        100     // maxIter
+    );
+    danglingCellRefine
+    (
+        refineParams,
+        24,     // 0 coarse faces + 6 refined faces
+        100     // maxIter
+    );
+
     // Introduce baffles at surface intersections. Remove sections unreachable
     // from keepPoint.
     baffleAndSplitMesh(refineParams, prepareForSnapping, motionDict);
diff --git a/src/mesh/autoMesh/autoHexMesh/autoHexMeshDriver/autoRefineDriver.H b/src/mesh/autoMesh/autoHexMesh/autoHexMeshDriver/autoRefineDriver.H
index 37a0f6b102..c44a14a794 100644
--- a/src/mesh/autoMesh/autoHexMesh/autoHexMeshDriver/autoRefineDriver.H
+++ b/src/mesh/autoMesh/autoHexMesh/autoHexMeshDriver/autoRefineDriver.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -88,6 +88,21 @@ class autoRefineDriver
             const label maxIter
         );
 
+        //- Refine all cells in small gaps
+        label gapOnlyRefine
+        (
+            const refinementParameters& refineParams,
+            const label maxIter
+        );
+
+        //- Refine cells with almost all sides refined
+        label danglingCellRefine
+        (
+            const refinementParameters& refineParams,
+            const label nFaces,
+            const label maxIter
+        );
+
         //- Remove all cells within intersected region
         void removeInsideCells
         (
diff --git a/src/mesh/autoMesh/autoHexMesh/autoHexMeshDriver/refinementParameters/refinementParameters.C b/src/mesh/autoMesh/autoHexMesh/autoHexMeshDriver/refinementParameters/refinementParameters.C
index ab2140a4ec..7bf8d8cf6c 100644
--- a/src/mesh/autoMesh/autoHexMesh/autoHexMeshDriver/refinementParameters/refinementParameters.C
+++ b/src/mesh/autoMesh/autoHexMesh/autoHexMeshDriver/refinementParameters/refinementParameters.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -41,6 +41,7 @@ Foam::refinementParameters::refinementParameters
     maxLocalCells_(readLabel(dict.lookup("procCellLimit"))),
     minRefineCells_(readLabel(dict.lookup("minimumRefine"))),
     curvature_(readScalar(dict.lookup("curvature"))),
+    planarAngle_(dict.lookupOrDefault("planarAngle", curvature_)),
     nBufferLayers_(readLabel(dict.lookup("nBufferLayers"))),
     keepPoints_(dict.lookup("keepPoints")),
     allowFreeStandingZoneFaces_(dict.lookup("allowFreeStandingZoneFaces")),
@@ -53,6 +54,14 @@ Foam::refinementParameters::refinementParameters(const dictionary& dict)
     maxGlobalCells_(readLabel(dict.lookup("maxGlobalCells"))),
     maxLocalCells_(readLabel(dict.lookup("maxLocalCells"))),
     minRefineCells_(readLabel(dict.lookup("minRefinementCells"))),
+    planarAngle_
+    (
+        dict.lookupOrDefault
+        (
+            "planarAngle",
+            readScalar(dict.lookup("resolveFeatureAngle"))
+        )
+    ),
     nBufferLayers_(readLabel(dict.lookup("nCellsBetweenLevels"))),
     keepPoints_(pointField(1, dict.lookup("locationInMesh"))),
     allowFreeStandingZoneFaces_(dict.lookup("allowFreeStandingZoneFaces")),
diff --git a/src/mesh/autoMesh/autoHexMesh/autoHexMeshDriver/refinementParameters/refinementParameters.H b/src/mesh/autoMesh/autoHexMesh/autoHexMeshDriver/refinementParameters/refinementParameters.H
index 66867e7f55..4fb05644e8 100644
--- a/src/mesh/autoMesh/autoHexMesh/autoHexMeshDriver/refinementParameters/refinementParameters.H
+++ b/src/mesh/autoMesh/autoHexMesh/autoHexMeshDriver/refinementParameters/refinementParameters.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -67,6 +67,9 @@ class refinementParameters
         //- Curvature
         scalar curvature_;
 
+        //- Planarity criterion
+        scalar planarAngle_;
+
         //- Number of layers between different refinement levels
         const label nBufferLayers_;
 
@@ -129,6 +132,12 @@ public:
                 return curvature_;
             }
 
+            //- Angle when two intersections are considered to be planar
+            scalar planarAngle() const
+            {
+                return planarAngle_;
+            }
+
             //- Number of layers between different refinement levels
             label nBufferLayers() const
             {
diff --git a/src/mesh/autoMesh/autoHexMesh/meshRefinement/meshRefinement.H b/src/mesh/autoMesh/autoHexMesh/meshRefinement/meshRefinement.H
index 6ab861d8a4..7487e8a2bf 100644
--- a/src/mesh/autoMesh/autoHexMesh/meshRefinement/meshRefinement.H
+++ b/src/mesh/autoMesh/autoHexMesh/meshRefinement/meshRefinement.H
@@ -253,6 +253,14 @@ private:
                 label& nRefine
             );
 
+            //- Mark every cell with level of feature passing through it
+            //  (or -1 if not passed through). Uses tracking.
+            void markFeatureCellLevel
+            (
+                const point& keepPoint,
+                labelList& maxFeatureLevel
+            ) const;
+
             //- Calculate list of cells to refine based on intersection of
             //  features.
             label markFeatureRefinement
@@ -327,6 +335,48 @@ private:
                 label& nRefine
             ) const;
 
+            //- Is local topology a small gap?
+            bool isGap
+            (
+                const scalar,
+                const vector&,
+                const vector&,
+                const vector&,
+                const vector&
+            ) const;
+
+            //- Mark cell if local a gap topology or
+            bool checkProximity
+            (
+                const scalar planarCos,
+                const label nAllowRefine,
+
+                const label surfaceLevel,
+                const vector& surfaceLocation,
+                const vector& surfaceNormal,
+
+                const label cellI,
+
+                label& cellMaxLevel,
+                vector& cellMaxLocation,
+                vector& cellMaxNormal,
+
+                labelList& refineCell,
+                label& nRefine
+            ) const;
+
+            //- Mark cells for surface proximity based refinement.
+            label markProximityRefinement
+            (
+                const scalar curvature,
+                const label nAllowRefine,
+                const labelList& neiLevel,
+                const pointField& neiCc,
+
+                labelList& refineCell,
+                label& nRefine
+            ) const;
+
         // Baffle handling
 
             //- Get faces to repatch. Returns map from face to patch.
@@ -337,16 +387,6 @@ private:
                 const labelList& globalToSlavePatch
             ) const;
 
-            //- Geometric test on see whether face needs to be baffled:
-            //  is face boundary face and perpendicular to surface normal?
-            bool validBaffleTopology
-            (
-                const label faceI,
-                const vector& n1,
-                const vector& n2,
-                const vector& testDir
-            ) const;
-
             //- Determine patches for baffles
             void getBafflePatches
             (
@@ -435,7 +475,11 @@ private:
 
             //- Extract those baffles (duplicate) faces that are on the edge
             //  of a baffle region. These are candidates for merging.
-            List<labelPair> freeStandingBaffles(const List<labelPair>&) const;
+            List<labelPair> freeStandingBaffles
+            (
+                const List<labelPair>&,
+                const scalar freeStandingAngle
+            ) const;
 
 
         // Zone handling
@@ -489,6 +533,16 @@ private:
                 labelList& namedSurfaceIndex
             ) const;
 
+            //- Remove any loose standing cells
+            void handleSnapProblems
+            (
+                const bool removeEdgeConnectedCells,
+                const scalarField& perpendicularAngle,
+                const dictionary& motionDict,
+                Time& runTime,
+                const labelList& globalToMasterPatch,
+                const labelList& globalToSlavePatch
+            );
 
         //- Disallow default bitwise copy construct
         meshRefinement(const meshRefinement&);
@@ -664,12 +718,14 @@ public:
             (
                 const point& keepPoint,
                 const scalar curvature,
+                const scalar planarAngle,
 
                 const bool featureRefinement,
                 const bool featureDistanceRefinement,
                 const bool internalRefinement,
                 const bool surfaceRefinement,
                 const bool curvatureRefinement,
+                const bool gapRefinement,
                 const label maxGlobalCells,
                 const label maxLocalCells
             ) const;
@@ -707,6 +763,7 @@ public:
                 const bool removeEdgeConnectedCells,
                 const scalarField& perpendicularAngle,
                 const bool mergeFreeStanding,
+                const scalar freeStandingAngle,
                 const dictionary& motionDict,
                 Time& runTime,
                 const labelList& globalToMasterPatch,
diff --git a/src/mesh/autoMesh/autoHexMesh/meshRefinement/meshRefinementBaffles.C b/src/mesh/autoMesh/autoHexMesh/meshRefinement/meshRefinementBaffles.C
index 339e51cd7f..628dd7898a 100644
--- a/src/mesh/autoMesh/autoHexMesh/meshRefinement/meshRefinementBaffles.C
+++ b/src/mesh/autoMesh/autoHexMesh/meshRefinement/meshRefinementBaffles.C
@@ -44,6 +44,7 @@ License
 #include "regionSplit.H"
 #include "removeCells.H"
 #include "unitConversion.H"
+#include "OBJstream.H"
 
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 
@@ -217,43 +218,43 @@ Foam::label Foam::meshRefinement::getBafflePatch
 }
 
 
-// Check if we are a boundary face and normal of surface does
-// not align with test vector. In this case there'd probably be
-// a freestanding 'baffle' so we might as well not create it.
-// Note that since it is not a proper baffle we cannot detect it
-// afterwards so this code cannot be merged with the
-// filterDuplicateFaces code.
-bool Foam::meshRefinement::validBaffleTopology
-(
-    const label faceI,
-    const vector& n1,
-    const vector& n2,
-    const vector& testDir
-) const
-{
-
-    label patchI = mesh_.boundaryMesh().whichPatch(faceI);
-    if (patchI == -1 || mesh_.boundaryMesh()[patchI].coupled())
-    {
-        return true;
-    }
-    else if (mag(n1&n2) > cos(degToRad(30)))
-    {
-        // Both normals aligned. Check that test vector perpendicularish to
-        // surface normal
-        scalar magTestDir = mag(testDir);
-        if (magTestDir > VSMALL)
-        {
-            if (mag(n1&(testDir/magTestDir)) < cos(degToRad(45)))
-            {
-                //Pout<< "** disabling baffling face "
-                //    << mesh_.faceCentres()[faceI] << endl;
-                return false;
-            }
-        }
-    }
-    return true;
-}
+//// Check if we are a boundary face and normal of surface does
+//// not align with test vector. In this case there'd probably be
+//// a freestanding 'baffle' so we might as well not create it.
+//// Note that since it is not a proper baffle we cannot detect it
+//// afterwards so this code cannot be merged with the
+//// filterDuplicateFaces code.
+//bool Foam::meshRefinement::validBaffleTopology
+//(
+//    const label faceI,
+//    const vector& n1,
+//    const vector& n2,
+//    const vector& testDir
+//) const
+//{
+//
+//    label patchI = mesh_.boundaryMesh().whichPatch(faceI);
+//    if (patchI == -1 || mesh_.boundaryMesh()[patchI].coupled())
+//    {
+//        return true;
+//    }
+//    else if (mag(n1&n2) > cos(degToRad(30)))
+//    {
+//        // Both normals aligned. Check that test vector perpendicularish to
+//        // surface normal
+//        scalar magTestDir = mag(testDir);
+//        if (magTestDir > VSMALL)
+//        {
+//            if (mag(n1&(testDir/magTestDir)) < cos(degToRad(45)))
+//            {
+//                //Pout<< "** disabling baffling face "
+//                //    << mesh_.faceCentres()[faceI] << endl;
+//                return false;
+//            }
+//        }
+//    }
+//    return true;
+//}
 
 
 // Determine patches for baffles on all intersected unnamed faces
@@ -800,7 +801,8 @@ Foam::autoPtr<Foam::mapPolyMesh> Foam::meshRefinement::createZoneBaffles
 // region.
 Foam::List<Foam::labelPair> Foam::meshRefinement::freeStandingBaffles
 (
-    const List<labelPair>& couples
+    const List<labelPair>& couples,
+    const scalar planarAngle
 ) const
 {
     // All duplicate faces on edge of the patch are to be merged.
@@ -809,6 +811,22 @@ Foam::List<Foam::labelPair> Foam::meshRefinement::freeStandingBaffles
     labelList nBafflesPerEdge(mesh_.nEdges(), 0);
 
 
+    // This algorithm is quite tricky. We don't want to use edgeFaces and
+    // also want it to run in parallel so it is now an algorithm over
+    // all (boundary) faces instead.
+    // We want to pick up any edges that are only used by the baffle
+    // or internal faces but not by any other boundary faces. So
+    // - increment count on an edge by 1 if it is used by any (uncoupled)
+    //   boundary face.
+    // - increment count on an edge by 1000000 if it is used by a baffle face
+    // - sum in parallel
+    //
+    // So now any edge that is used by baffle faces only will have the
+    // value 2*1000000+2*1.
+
+
+    const label baffleValue = 1000000;
+
 
     // Count number of boundary faces per edge
     // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -847,18 +865,22 @@ Foam::List<Foam::labelPair> Foam::meshRefinement::freeStandingBaffles
 
     forAll(couples, i)
     {
-        const labelList& fEdges0 = mesh_.faceEdges(couples[i].first(), fe0);
-
-        forAll(fEdges0, fEdgeI)
         {
-            nBafflesPerEdge[fEdges0[fEdgeI]] += 1000000;
+            label f0 = couples[i].first();
+            const labelList& fEdges0 = mesh_.faceEdges(f0, fe0);
+            forAll(fEdges0, fEdgeI)
+            {
+                nBafflesPerEdge[fEdges0[fEdgeI]] += baffleValue;
+            }
         }
 
-        const labelList& fEdges1 = mesh_.faceEdges(couples[i].second(), fe1);
-
-        forAll(fEdges1, fEdgeI)
         {
-            nBafflesPerEdge[fEdges1[fEdgeI]] += 1000000;
+            label f1 = couples[i].second();
+            const labelList& fEdges1 = mesh_.faceEdges(f1, fe1);
+            forAll(fEdges1, fEdgeI)
+            {
+                nBafflesPerEdge[fEdges1[fEdgeI]] += baffleValue;
+            }
         }
     }
 
@@ -873,8 +895,8 @@ Foam::List<Foam::labelPair> Foam::meshRefinement::freeStandingBaffles
 
 
     // Baffles which are not next to other boundaries and baffles will have
-    // nBafflesPerEdge value 2*1000000+2*1 (from 2 boundary faces which are
-    // both baffle faces)
+    // nBafflesPerEdge value 2*baffleValue+2*1 (from 2 boundary faces which
+    // are both baffle faces)
 
     List<labelPair> filteredCouples(couples.size());
     label filterI = 0;
@@ -889,15 +911,15 @@ Foam::List<Foam::labelPair> Foam::meshRefinement::freeStandingBaffles
          == patches.whichPatch(couple.second())
         )
         {
-            const labelList& fEdges = mesh_.faceEdges(couples[i].first());
+            const labelList& fEdges = mesh_.faceEdges(couple.first());
 
             forAll(fEdges, fEdgeI)
             {
                 label edgeI = fEdges[fEdgeI];
 
-                if (nBafflesPerEdge[edgeI] == 2*1000000+2*1)
+                if (nBafflesPerEdge[edgeI] == 2*baffleValue+2*1)
                 {
-                    filteredCouples[filterI++] = couples[i];
+                    filteredCouples[filterI++] = couple;
                     break;
                 }
             }
@@ -905,111 +927,127 @@ Foam::List<Foam::labelPair> Foam::meshRefinement::freeStandingBaffles
     }
     filteredCouples.setSize(filterI);
 
-    //Info<< "freeStandingBaffles : from "
-    //    << returnReduce(couples.size(), sumOp<label>())
-    //    << " down to "
-    //    << returnReduce(filteredCouples.size(), sumOp<label>())
-    //    << " baffles." << nl << endl;
+
+    label nFiltered = returnReduce(filteredCouples.size(), sumOp<label>());
+
+    Info<< "freeStandingBaffles : detected "
+        << nFiltered
+        << " free-standing baffles out of "
+        << returnReduce(couples.size(), sumOp<label>())
+        << nl << endl;
 
 
+    if (nFiltered > 0)
+    {
+        // Collect segments
+        // ~~~~~~~~~~~~~~~~
 
-//XXXXXX
-//    {
-//        // Collect segments
-//        // ~~~~~~~~~~~~~~~~
-//
-//        pointField start(filteredCouples.size());
-//        pointField end(filteredCouples.size());
-//
-//        const pointField& cellCentres = mesh_.cellCentres();
-//
-//        forAll(filteredCouples, i)
-//        {
-//            const labelPair& couple = couples[i];
-//            start[i] = cellCentres[mesh_.faceOwner()[couple.first()]];
-//            end[i] = cellCentres[mesh_.faceOwner()[couple.second()]];
-//        }
-//
-//        // Extend segments a bit
-//        {
-//            const vectorField smallVec(Foam::sqrt(SMALL)*(end-start));
-//            start -= smallVec;
-//            end += smallVec;
-//        }
-//
-//
-//        // Do test for intersections
-//        // ~~~~~~~~~~~~~~~~~~~~~~~~~
-//        labelList surface1;
-//        List<pointIndexHit> hit1;
-//        labelList region1;
-//        vectorField normal1;
-//
-//        labelList surface2;
-//        List<pointIndexHit> hit2;
-//        labelList region2;
-//        vectorField normal2;
-//
-//        surfaces_.findNearestIntersection
-//        (
-//            surfacesToBaffle,
-//            start,
-//            end,
-//
-//            surface1,
-//            hit1,
-//            region1,
-//            normal1,
-//
-//            surface2,
-//            hit2,
-//            region2,
-//            normal2
-//        );
-//
-//        forAll(testFaces, i)
-//        {
-//            if (hit1[i].hit() && hit2[i].hit())
-//            {
-//                bool createBaffle = true;
-//
-//                label faceI = couples[i].first();
-//                label patchI = mesh_.boundaryMesh().whichPatch(faceI);
-//                if (patchI != -1 && !mesh_.boundaryMesh()[patchI].coupled())
-//                {
-//                    // Check if we are a boundary face and normal of surface
-//                    // does
-//                    // not align with test vector. In this case there'd
-//                    // probably be
-//                    // a freestanding 'baffle' so we might as well not
-//                    // create it.
-//                    // Note that since it is not a proper baffle we cannot
-//                    // detect it
-//                    // afterwards so this code cannot be merged with the
-//                    // filterDuplicateFaces code.
-//                    if (mag(normal1[i]&normal2[i]) > cos(degToRad(30)))
-//                    {
-//                        // Both normals aligned
-//                        vector n = end[i]-start[i];
-//                        scalar magN = mag(n);
-//                        if (magN > VSMALL)
-//                        {
-//                            n /= magN;
-//
-//                            if (mag(normal1[i]&n) < cos(degToRad(45)))
-//                            {
-//                                Pout<< "** disabling baffling face "
-//                                    << mesh_.faceCentres()[faceI] << endl;
-//                                createBaffle = false;
-//                            }
-//                        }
-//                    }
-//                }
-//
-//
-//        }
-//XXXXXX
+        pointField start(filteredCouples.size());
+        pointField end(filteredCouples.size());
 
+        const pointField& cellCentres = mesh_.cellCentres();
+
+        forAll(filteredCouples, i)
+        {
+            const labelPair& couple = filteredCouples[i];
+            start[i] = cellCentres[mesh_.faceOwner()[couple.first()]];
+            end[i] = cellCentres[mesh_.faceOwner()[couple.second()]];
+        }
+
+        // Extend segments a bit
+        {
+            const vectorField smallVec(Foam::sqrt(SMALL)*(end-start));
+            start -= smallVec;
+            end += smallVec;
+        }
+
+
+        // Do test for intersections
+        // ~~~~~~~~~~~~~~~~~~~~~~~~~
+        labelList surface1;
+        List<pointIndexHit> hit1;
+        labelList region1;
+        vectorField normal1;
+
+        labelList surface2;
+        List<pointIndexHit> hit2;
+        labelList region2;
+        vectorField normal2;
+
+        surfaces_.findNearestIntersection
+        (
+            identity(surfaces_.surfaces().size()),
+            start,
+            end,
+
+            surface1,
+            hit1,
+            region1,
+            normal1,
+
+            surface2,
+            hit2,
+            region2,
+            normal2
+        );
+
+        //mkDir(mesh_.time().path()/timeName());
+        //OBJstream str
+        //(
+        //    mesh_.time().path()/timeName()/"flatBaffles.obj"
+        //);
+
+        const scalar planarAngleCos = Foam::cos(degToRad(planarAngle));
+
+        label filterI = 0;
+        forAll(filteredCouples, i)
+        {
+            const labelPair& couple = filteredCouples[i];
+
+            if
+            (
+                hit1[i].hit()
+             && hit2[i].hit()
+             && (
+                    surface1[i] != surface2[i]
+                 || hit1[i].index() != hit2[i].index()
+                )
+            )
+            {
+                // Two different hits. Check angle.
+                //str.write
+                //(
+                //    linePointRef(hit1[i].hitPoint(), hit2[i].hitPoint()),
+                //    normal1[i],
+                //    normal2[i]
+                //);
+
+                if ((normal1[i]&normal2[i]) > planarAngleCos)
+                {
+                    // Both normals aligned
+                    vector n = end[i]-start[i];
+                    scalar magN = mag(n);
+                    if (magN > VSMALL)
+                    {
+                        filteredCouples[filterI++] = couple;
+                    }
+                }
+            }
+            else if (hit1[i].hit() || hit2[i].hit())
+            {
+                // Single hit. Do not include in freestanding baffles.
+            }
+        }
+
+        filteredCouples.setSize(filterI);
+
+        Info<< "freeStandingBaffles : detected "
+            << returnReduce(filterI, sumOp<label>())
+            << " planar (within " << planarAngle
+            << " degrees) free-standing baffles out of "
+            << nFiltered
+            << nl << endl;
+    }
 
     return filteredCouples;
 }
@@ -1832,15 +1870,102 @@ void Foam::meshRefinement::makeConsistentFaceIndex
 }
 
 
+void Foam::meshRefinement::handleSnapProblems
+(
+    const bool removeEdgeConnectedCells,
+    const scalarField& perpendicularAngle,
+    const dictionary& motionDict,
+    Time& runTime,
+    const labelList& globalToMasterPatch,
+    const labelList& globalToSlavePatch
+)
+{
+    Info<< nl
+        << "Introducing baffles to block off problem cells" << nl
+        << "----------------------------------------------" << nl
+        << endl;
+
+    labelList facePatch
+    (
+        markFacesOnProblemCells
+        (
+            motionDict,
+            removeEdgeConnectedCells,
+            perpendicularAngle,
+            globalToMasterPatch
+        )
+    );
+    Info<< "Analyzed problem cells in = "
+        << runTime.cpuTimeIncrement() << " s\n" << nl << endl;
+
+    if (debug&meshRefinement::MESH)
+    {
+        faceSet problemTopo(mesh_, "problemFacesTopo", 100);
+
+        const labelList facePatchTopo
+        (
+            markFacesOnProblemCells
+            (
+                motionDict,
+                removeEdgeConnectedCells,
+                perpendicularAngle,
+                globalToMasterPatch
+            )
+        );
+        forAll(facePatchTopo, faceI)
+        {
+            if (facePatchTopo[faceI] != -1)
+            {
+                problemTopo.insert(faceI);
+            }
+        }
+        problemTopo.instance() = timeName();
+        Pout<< "Dumping " << problemTopo.size()
+            << " problem faces to " << problemTopo.objectPath() << endl;
+        problemTopo.write();
+    }
+
+    Info<< "Introducing baffles to delete problem cells." << nl << endl;
+
+    if (debug)
+    {
+        runTime++;
+    }
+
+    // Create baffles with same owner and neighbour for now.
+    createBaffles(facePatch, facePatch);
+
+    if (debug)
+    {
+        // Debug:test all is still synced across proc patches
+        checkData();
+    }
+    Info<< "Created baffles in = "
+        << runTime.cpuTimeIncrement() << " s\n" << nl << endl;
+
+    printMeshInfo(debug, "After introducing baffles");
+
+    if (debug&meshRefinement::MESH)
+    {
+        Pout<< "Writing extra baffled mesh to time "
+            << timeName() << endl;
+        write(debug, runTime.path()/"extraBaffles");
+        Pout<< "Dumped debug data in = "
+            << runTime.cpuTimeIncrement() << " s\n" << nl << endl;
+    }
+}
+
+
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
 // Split off unreachable areas of mesh.
 void Foam::meshRefinement::baffleAndSplitMesh
 (
-    const bool handleSnapProblems,
+    const bool doHandleSnapProblems,
     const bool removeEdgeConnectedCells,
     const scalarField& perpendicularAngle,
     const bool mergeFreeStanding,
+    const scalar planarAngle,
     const dictionary& motionDict,
     Time& runTime,
     const labelList& globalToMasterPatch,
@@ -1902,82 +2027,92 @@ void Foam::meshRefinement::baffleAndSplitMesh
 
     // Create some additional baffles where we want surface cells removed.
 
-    if (handleSnapProblems)
+    if (doHandleSnapProblems)
     {
-        Info<< nl
-            << "Introducing baffles to block off problem cells" << nl
-            << "----------------------------------------------" << nl
-            << endl;
+        //Info<< nl
+        //    << "Introducing baffles to block off problem cells" << nl
+        //    << "----------------------------------------------" << nl
+        //    << endl;
+        //
+        //labelList facePatch
+        //(
+        //    markFacesOnProblemCells
+        //    (
+        //        motionDict,
+        //        removeEdgeConnectedCells,
+        //        perpendicularAngle,
+        //        globalToMasterPatch
+        //    )
+        //    //markFacesOnProblemCellsGeometric(motionDict)
+        //);
+        //Info<< "Analyzed problem cells in = "
+        //    << runTime.cpuTimeIncrement() << " s\n" << nl << endl;
+        //
+        //if (debug&meshRefinement::MESH)
+        //{
+        //    faceSet problemTopo(mesh_, "problemFacesTopo", 100);
+        //
+        //    const labelList facePatchTopo
+        //    (
+        //        markFacesOnProblemCells
+        //        (
+        //            motionDict,
+        //            removeEdgeConnectedCells,
+        //            perpendicularAngle,
+        //            globalToMasterPatch
+        //        )
+        //    );
+        //    forAll(facePatchTopo, faceI)
+        //    {
+        //        if (facePatchTopo[faceI] != -1)
+        //        {
+        //            problemTopo.insert(faceI);
+        //        }
+        //    }
+        //    problemTopo.instance() = timeName();
+        //    Pout<< "Dumping " << problemTopo.size()
+        //        << " problem faces to " << problemTopo.objectPath() << endl;
+        //    problemTopo.write();
+        //}
+        //
+        //Info<< "Introducing baffles to delete problem cells." << nl << endl;
+        //
+        //if (debug)
+        //{
+        //    runTime++;
+        //}
+        //
+        //// Create baffles with same owner and neighbour for now.
+        //createBaffles(facePatch, facePatch);
+        //
+        //if (debug)
+        //{
+        //    // Debug:test all is still synced across proc patches
+        //    checkData();
+        //}
+        //Info<< "Created baffles in = "
+        //    << runTime.cpuTimeIncrement() << " s\n" << nl << endl;
+        //
+        //printMeshInfo(debug, "After introducing baffles");
+        //
+        //if (debug&meshRefinement::MESH)
+        //{
+        //    Pout<< "Writing extra baffled mesh to time "
+        //        << timeName() << endl;
+        //    write(debug, runTime.path()/"extraBaffles");
+        //    Pout<< "Dumped debug data in = "
+        //        << runTime.cpuTimeIncrement() << " s\n" << nl << endl;
+        //}
 
-        labelList facePatch
+        handleSnapProblems
         (
-            markFacesOnProblemCells
-            (
-                motionDict,
-                removeEdgeConnectedCells,
-                perpendicularAngle,
-                globalToMasterPatch
-            )
-            //markFacesOnProblemCellsGeometric(motionDict)
+            removeEdgeConnectedCells,
+            perpendicularAngle,
+            motionDict,
+            runTime,
+            globalToMasterPatch,
+            globalToSlavePatch
         );
-        Info<< "Analyzed problem cells in = "
-            << runTime.cpuTimeIncrement() << " s\n" << nl << endl;
-
-        if (debug&meshRefinement::MESH)
-        {
-            faceSet problemTopo(mesh_, "problemFacesTopo", 100);
-
-            const labelList facePatchTopo
-            (
-                markFacesOnProblemCells
-                (
-                    motionDict,
-                    removeEdgeConnectedCells,
-                    perpendicularAngle,
-                    globalToMasterPatch
-                )
-            );
-            forAll(facePatchTopo, faceI)
-            {
-                if (facePatchTopo[faceI] != -1)
-                {
-                    problemTopo.insert(faceI);
-                }
-            }
-            problemTopo.instance() = timeName();
-            Pout<< "Dumping " << problemTopo.size()
-                << " problem faces to " << problemTopo.objectPath() << endl;
-            problemTopo.write();
-        }
-
-        Info<< "Introducing baffles to delete problem cells." << nl << endl;
-
-        if (debug)
-        {
-            runTime++;
-        }
-
-        // Create baffles with same owner and neighbour for now.
-        createBaffles(facePatch, facePatch);
-
-        if (debug)
-        {
-            // Debug:test all is still synced across proc patches
-            checkData();
-        }
-        Info<< "Created baffles in = "
-            << runTime.cpuTimeIncrement() << " s\n" << nl << endl;
-
-        printMeshInfo(debug, "After introducing baffles");
-
-        if (debug&meshRefinement::MESH)
-        {
-            Pout<< "Writing extra baffled mesh to time "
-                << timeName() << endl;
-            write(debug, runTime.path()/"extraBaffles");
-            Pout<< "Dumped debug data in = "
-                << runTime.cpuTimeIncrement() << " s\n" << nl << endl;
-        }
     }
 
 
@@ -2036,7 +2171,8 @@ void Foam::meshRefinement::baffleAndSplitMesh
                 (
                     identity(mesh_.nFaces()-mesh_.nInternalFaces())
                    +mesh_.nInternalFaces()
-                )
+                ),
+                planarAngle
             )
         );
 
@@ -2052,6 +2188,18 @@ void Foam::meshRefinement::baffleAndSplitMesh
             // from them.
             mergeBaffles(couples);
 
+            // Detect any problem cells resulting from merging of baffles
+            // and delete them
+            handleSnapProblems
+            (
+                removeEdgeConnectedCells,
+                perpendicularAngle,
+                motionDict,
+                runTime,
+                globalToMasterPatch,
+                globalToSlavePatch
+            );
+
             if (debug)
             {
                 // Debug:test all is still synced across proc patches
@@ -2663,18 +2811,6 @@ Foam::autoPtr<Foam::mapPolyMesh> Foam::meshRefinement::zonify
 
             if (surface1[i] != -1)
             {
-                //- Not allowed not to create baffle - is vital for regioning.
-                //  Have logic instead at erosion!
-                //bool createBaffle = validBaffleTopology
-                //(
-                //    faceI,
-                //    normal1[i],
-                //    normal2[i],
-                //    end[i]-start[i]
-                //);
-                //
-
-
                 // If both hit should probably choose 'nearest'
                 if
                 (
diff --git a/src/mesh/autoMesh/autoHexMesh/meshRefinement/meshRefinementRefine.C b/src/mesh/autoMesh/autoHexMesh/meshRefinement/meshRefinementRefine.C
index 42e7983e5a..9667750cf5 100644
--- a/src/mesh/autoMesh/autoHexMesh/meshRefinement/meshRefinementRefine.C
+++ b/src/mesh/autoMesh/autoHexMesh/meshRefinement/meshRefinementRefine.C
@@ -38,6 +38,7 @@ License
 #include "featureEdgeMesh.H"
 #include "Cloud.H"
 //#include "globalIndex.H"
+//#include "OBJstream.H"
 
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 
@@ -244,14 +245,10 @@ bool Foam::meshRefinement::markForRefine
 }
 
 
-// Calculates list of cells to refine based on intersection with feature edge.
-Foam::label Foam::meshRefinement::markFeatureRefinement
+void Foam::meshRefinement::markFeatureCellLevel
 (
     const point& keepPoint,
-    const label nAllowRefine,
-
-    labelList& refineCell,
-    label& nRefine
+    labelList& maxFeatureLevel
 ) const
 {
     // We want to refine all cells containing a feature edge.
@@ -384,7 +381,7 @@ Foam::label Foam::meshRefinement::markFeatureRefinement
 
 
     // Largest refinement level of any feature passed through
-    labelList maxFeatureLevel(mesh_.nCells(), -1);
+    maxFeatureLevel = labelList(mesh_.nCells(), -1);
 
     // Database to pass into trackedParticle::move
     trackedParticle::trackingData td(cloud, maxFeatureLevel);
@@ -467,8 +464,23 @@ Foam::label Foam::meshRefinement::markFeatureRefinement
         // Track all particles to their end position.
         cloud.move(td, GREAT);
     }
+}
 
 
+// Calculates list of cells to refine based on intersection with feature edge.
+Foam::label Foam::meshRefinement::markFeatureRefinement
+(
+    const point& keepPoint,
+    const label nAllowRefine,
+
+    labelList& refineCell,
+    label& nRefine
+) const
+{
+    // Largest refinement level of any feature passed through
+    labelList maxFeatureLevel;
+    markFeatureCellLevel(keepPoint, maxFeatureLevel);
+
     // See which cells to refine. maxFeatureLevel will hold highest level
     // of any feature edge that passed through.
 
@@ -1011,6 +1023,9 @@ Foam::label Foam::meshRefinement::markSurfaceCurvatureRefinement
             end,
             minLevel,           // max level of surface has to be bigger
                                 // than min level of neighbouring cells
+
+            surfaces_.maxLevel(),
+
             surfaceNormal,
             surfaceLevel
         );
@@ -1199,6 +1214,473 @@ Foam::label Foam::meshRefinement::markSurfaceCurvatureRefinement
 }
 
 
+// Mark small gaps
+bool Foam::meshRefinement::isGap
+(
+    const scalar planarCos,
+    const vector& point0,
+    const vector& normal0,
+
+    const vector& point1,
+    const vector& normal1
+) const
+{
+    ////- hits differ and angles are oppositeish
+    //return
+    //    (mag(point0-point1) > mergeDistance())
+    // && ((normal0 & normal1) < (-1+planarCos));
+
+
+    //- hits differ and angles are oppositeish and
+    //  hits have a normal distance
+    vector d = point1-point0;
+    scalar magD = mag(d);
+
+    if (magD > mergeDistance())
+    {
+        scalar cosAngle = (normal0 & normal1);
+
+        vector avg = vector::zero;
+        if (cosAngle < (-1+planarCos))
+        {
+            // Opposite normals
+            avg = 0.5*(normal0-normal1);
+        }
+        else if (cosAngle > (1-planarCos))
+        {
+            avg = 0.5*(normal0+normal1);
+        }
+
+        if (avg != vector::zero)
+        {
+            avg /= mag(avg);
+            d /= magD;
+
+            // Check average normal with respect to intersection locations
+            if (mag(avg&d) > Foam::cos(degToRad(45)))
+            {
+                return true;
+            }
+            else
+            {
+                return false;
+            }
+        }
+        else
+        {
+            return false;
+        }
+    }
+    else
+    {
+        return false;
+    }
+}
+
+
+bool Foam::meshRefinement::checkProximity
+(
+    const scalar planarCos,
+    const label nAllowRefine,
+
+    const label surfaceLevel,       // current intersection max level
+    const vector& surfaceLocation,  // current intersection location
+    const vector& surfaceNormal,    // current intersection normal
+
+    const label cellI,
+
+    label& cellMaxLevel,        // cached max surface level for this cell
+    vector& cellMaxLocation,    // cached surface normal for this cell
+    vector& cellMaxNormal,      // cached surface normal for this cell
+
+    labelList& refineCell,
+    label& nRefine
+) const
+{
+    const labelList& cellLevel = meshCutter_.cellLevel();
+
+    // Test if surface applicable
+    if (surfaceLevel > cellLevel[cellI])
+    {
+        if (cellMaxLevel == -1)
+        {
+            // First visit of cell. Store
+            cellMaxLevel = surfaceLevel;
+            cellMaxLocation = surfaceLocation;
+            cellMaxNormal = surfaceNormal;
+        }
+        else
+        {
+            // Second or more visit.
+            // Check if
+            //  - different location
+            //  - opposite surface
+
+            bool closeSurfaces = isGap
+            (
+                planarCos,
+                cellMaxLocation,
+                cellMaxNormal,
+                surfaceLocation,
+                surfaceNormal
+            );
+
+            // Set normal to that of highest surface. Not really necessary
+            // over here but we reuse cellMax info when doing coupled faces.
+            if (surfaceLevel > cellMaxLevel)
+            {
+                cellMaxLevel = surfaceLevel;
+                cellMaxLocation = surfaceLocation;
+                cellMaxNormal = surfaceNormal;
+            }
+
+
+            if (closeSurfaces)
+            {
+                //Pout<< "Found gap:" << nl
+                //    << "    location:" << surfaceLocation
+                //    << "\tnormal  :" << surfaceNormal << nl
+                ///    << "    location:" << cellMaxLocation
+                //    << "\tnormal  :" << cellMaxNormal << nl
+                //    << "\tcos     :" << (surfaceNormal&cellMaxNormal) << nl
+                //    << endl;
+
+                return markForRefine
+                (
+                    surfaceLevel,   // mark with any non-neg number.
+                    nAllowRefine,
+                    refineCell[cellI],
+                    nRefine
+                );
+            }
+        }
+    }
+
+    // Did not reach refinement limit.
+    return true;
+}
+
+
+Foam::label Foam::meshRefinement::markProximityRefinement
+(
+    const scalar planarCos,
+    const label nAllowRefine,
+    const labelList& neiLevel,
+    const pointField& neiCc,
+
+    labelList& refineCell,
+    label& nRefine
+) const
+{
+    const labelList& cellLevel = meshCutter_.cellLevel();
+    const pointField& cellCentres = mesh_.cellCentres();
+
+    label oldNRefine = nRefine;
+
+    // 1. local test: any cell on more than one surface gets refined
+    // (if its current level is < max of the surface max level)
+
+    // 2. 'global' test: any cell on only one surface with a neighbour
+    // on a different surface gets refined (if its current level etc.)
+
+
+    // Collect candidate faces (i.e. intersecting any surface and
+    // owner/neighbour not yet refined.
+    labelList testFaces(getRefineCandidateFaces(refineCell));
+
+    // Collect segments
+    pointField start(testFaces.size());
+    pointField end(testFaces.size());
+    labelList minLevel(testFaces.size());
+
+    forAll(testFaces, i)
+    {
+        label faceI = testFaces[i];
+
+        label own = mesh_.faceOwner()[faceI];
+
+        if (mesh_.isInternalFace(faceI))
+        {
+            label nei = mesh_.faceNeighbour()[faceI];
+
+            start[i] = cellCentres[own];
+            end[i] = cellCentres[nei];
+            minLevel[i] = min(cellLevel[own], cellLevel[nei]);
+        }
+        else
+        {
+            label bFaceI = faceI - mesh_.nInternalFaces();
+
+            start[i] = cellCentres[own];
+            end[i] = neiCc[bFaceI];
+            minLevel[i] = min(cellLevel[own], neiLevel[bFaceI]);
+        }
+    }
+
+    // Extend segments a bit
+    {
+        const vectorField smallVec(Foam::sqrt(SMALL)*(end-start));
+        start -= smallVec;
+        end += smallVec;
+    }
+
+
+    // Test for all intersections (with surfaces of higher gap level than
+    // minLevel) and cache per cell the max surface level and the local normal
+    // on that surface.
+    labelList cellMaxLevel(mesh_.nCells(), -1);
+    vectorField cellMaxNormal(mesh_.nCells(), vector::zero);
+    pointField cellMaxLocation(mesh_.nCells(), vector::zero);
+
+    {
+        // Per segment the normals of the surfaces
+        List<vectorList> surfaceLocation;
+        List<vectorList> surfaceNormal;
+        // Per segment the list of levels of the surfaces
+        labelListList surfaceLevel;
+
+        surfaces_.findAllHigherIntersections
+        (
+            start,
+            end,
+            minLevel,           // gap level of surface has to be bigger
+                                // than min level of neighbouring cells
+
+            surfaces_.gapLevel(),
+
+            surfaceLocation,
+            surfaceNormal,
+            surfaceLevel
+        );
+        // Clear out unnecessary data
+        start.clear();
+        end.clear();
+        minLevel.clear();
+
+        //// Extract per cell information on the surface with the highest max
+        //OBJstream str
+        //(
+        //    mesh_.time().path()
+        //  / "findAllHigherIntersections_"
+        //  + mesh_.time().timeName()
+        //  + ".obj"
+        //);
+        //// All intersections
+        //OBJstream str2
+        //(
+        //    mesh_.time().path()
+        //  / "findAllHigherIntersections2_"
+        //  + mesh_.time().timeName()
+        //  + ".obj"
+        //);
+
+        forAll(testFaces, i)
+        {
+            label faceI = testFaces[i];
+            label own = mesh_.faceOwner()[faceI];
+
+            const labelList& fLevels = surfaceLevel[i];
+            const vectorList& fPoints = surfaceLocation[i];
+            const vectorList& fNormals = surfaceNormal[i];
+
+            forAll(fLevels, hitI)
+            {
+                checkProximity
+                (
+                    planarCos,
+                    nAllowRefine,
+
+                    fLevels[hitI],
+                    fPoints[hitI],
+                    fNormals[hitI],
+
+                    own,
+                    cellMaxLevel[own],
+                    cellMaxLocation[own],
+                    cellMaxNormal[own],
+
+                    refineCell,
+                    nRefine
+                );
+            }
+
+            if (mesh_.isInternalFace(faceI))
+            {
+                label nei = mesh_.faceNeighbour()[faceI];
+
+                forAll(fLevels, hitI)
+                {
+                    checkProximity
+                    (
+                        planarCos,
+                        nAllowRefine,
+
+                        fLevels[hitI],
+                        fPoints[hitI],
+                        fNormals[hitI],
+
+                        nei,
+                        cellMaxLevel[nei],
+                        cellMaxLocation[nei],
+                        cellMaxNormal[nei],
+
+                        refineCell,
+                        nRefine
+                    );
+                }
+            }
+        }
+    }
+
+    // 2. Find out a measure of surface curvature and region edges.
+    // Send over surface region and surface normal to neighbour cell.
+
+    labelList neiBndMaxLevel(mesh_.nFaces()-mesh_.nInternalFaces());
+    pointField neiBndMaxLocation(mesh_.nFaces()-mesh_.nInternalFaces());
+    vectorField neiBndMaxNormal(mesh_.nFaces()-mesh_.nInternalFaces());
+
+    for (label faceI = mesh_.nInternalFaces(); faceI < mesh_.nFaces(); faceI++)
+    {
+        label bFaceI = faceI-mesh_.nInternalFaces();
+        label own = mesh_.faceOwner()[faceI];
+
+        neiBndMaxLevel[bFaceI] = cellMaxLevel[own];
+        neiBndMaxLocation[bFaceI] = cellMaxLocation[own];
+        neiBndMaxNormal[bFaceI] = cellMaxNormal[own];
+    }
+    syncTools::swapBoundaryFaceList(mesh_, neiBndMaxLevel);
+    syncTools::swapBoundaryFaceList(mesh_, neiBndMaxLocation);
+    syncTools::swapBoundaryFaceList(mesh_, neiBndMaxNormal);
+
+    // Loop over all faces. Could only be checkFaces.. except if they're coupled
+
+    // Internal faces
+    for (label faceI = 0; faceI < mesh_.nInternalFaces(); faceI++)
+    {
+        label own = mesh_.faceOwner()[faceI];
+        label nei = mesh_.faceNeighbour()[faceI];
+
+        if (cellMaxLevel[own] != -1 && cellMaxLevel[nei] != -1)
+        {
+            // Have valid data on both sides. Check planarCos.
+            if
+            (
+                isGap
+                (
+                    planarCos,
+                    cellMaxLocation[own],
+                    cellMaxNormal[own],
+                    cellMaxLocation[nei],
+                    cellMaxNormal[nei]
+                )
+            )
+            {
+                // See which side to refine
+                if (cellLevel[own] < cellMaxLevel[own])
+                {
+                    if
+                    (
+                        !markForRefine
+                        (
+                            cellMaxLevel[own],
+                            nAllowRefine,
+                            refineCell[own],
+                            nRefine
+                        )
+                    )
+                    {
+                        if (debug)
+                        {
+                            Pout<< "Stopped refining since reaching my cell"
+                                << " limit of " << mesh_.nCells()+7*nRefine
+                                << endl;
+                        }
+                        break;
+                    }
+                }
+
+                if (cellLevel[nei] < cellMaxLevel[nei])
+                {
+                    if
+                    (
+                        !markForRefine
+                        (
+                            cellMaxLevel[nei],
+                            nAllowRefine,
+                            refineCell[nei],
+                            nRefine
+                        )
+                    )
+                    {
+                        if (debug)
+                        {
+                            Pout<< "Stopped refining since reaching my cell"
+                                << " limit of " << mesh_.nCells()+7*nRefine
+                                << endl;
+                        }
+                        break;
+                    }
+                }
+            }
+        }
+    }
+    // Boundary faces
+    for (label faceI = mesh_.nInternalFaces(); faceI < mesh_.nFaces(); faceI++)
+    {
+        label own = mesh_.faceOwner()[faceI];
+        label bFaceI = faceI - mesh_.nInternalFaces();
+
+        if (cellLevel[own] < cellMaxLevel[own] && neiBndMaxLevel[bFaceI] != -1)
+        {
+            // Have valid data on both sides. Check planarCos.
+            if
+            (
+                isGap
+                (
+                    planarCos,
+                    cellMaxLocation[own],
+                    cellMaxNormal[own],
+                    neiBndMaxLocation[bFaceI],
+                    neiBndMaxNormal[bFaceI]
+                )
+            )
+            {
+                if
+                (
+                    !markForRefine
+                    (
+                        cellMaxLevel[own],
+                        nAllowRefine,
+                        refineCell[own],
+                        nRefine
+                    )
+                )
+                {
+                    if (debug)
+                    {
+                        Pout<< "Stopped refining since reaching my cell"
+                            << " limit of " << mesh_.nCells()+7*nRefine
+                            << endl;
+                    }
+                    break;
+                }
+            }
+        }
+    }
+
+    if
+    (
+        returnReduce(nRefine, sumOp<label>())
+      > returnReduce(nAllowRefine, sumOp<label>())
+    )
+    {
+        Info<< "Reached refinement limit." << endl;
+    }
+
+    return returnReduce(nRefine-oldNRefine, sumOp<label>());
+}
+
+
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
 // Calculate list of cells to refine. Gets for any edge (start - end)
@@ -1210,12 +1692,14 @@ Foam::labelList Foam::meshRefinement::refineCandidates
 (
     const point& keepPoint,
     const scalar curvature,
+    const scalar planarAngle,
 
     const bool featureRefinement,
     const bool featureDistanceRefinement,
     const bool internalRefinement,
     const bool surfaceRefinement,
     const bool curvatureRefinement,
+    const bool gapRefinement,
     const label maxGlobalCells,
     const label maxLocalCells
 ) const
@@ -1359,6 +1843,35 @@ Foam::labelList Foam::meshRefinement::refineCandidates
                 << ": " << nCurv << " cells."  << endl;
         }
 
+
+        const scalar planarCos = Foam::cos(degToRad(planarAngle));
+
+        if
+        (
+            gapRefinement
+         && (planarCos >= -1 && planarCos <= 1)
+         && (max(surfaces_.gapLevel()) > -1)
+        )
+        {
+            Info<< "Specified gap level : " << max(surfaces_.gapLevel())
+                << ", planar angle " << planarAngle << endl;
+
+            label nGap = markProximityRefinement
+            (
+                planarCos,
+                nAllowRefine,
+                neiLevel,
+                neiCc,
+
+                refineCell,
+                nRefine
+            );
+            Info<< "Marked for refinement due to close opposite surfaces       "
+                << ": " << nGap << " cells."  << endl;
+        }
+
+
+
         // Pack cells-to-refine
         // ~~~~~~~~~~~~~~~~~~~~
 
diff --git a/src/mesh/autoMesh/autoHexMesh/refinementSurfaces/refinementSurfaces.C b/src/mesh/autoMesh/autoHexMesh/refinementSurfaces/refinementSurfaces.C
index f53968532c..f1917ee6f9 100644
--- a/src/mesh/autoMesh/autoHexMesh/refinementSurfaces/refinementSurfaces.C
+++ b/src/mesh/autoMesh/autoHexMesh/refinementSurfaces/refinementSurfaces.C
@@ -116,10 +116,12 @@ Foam::refinementSurfaces::refinementSurfaces
 
     labelList globalMinLevel(surfI, 0);
     labelList globalMaxLevel(surfI, 0);
+    labelList globalLevelIncr(surfI, 0);
     scalarField globalAngle(surfI, -GREAT);
     PtrList<dictionary> globalPatchInfo(surfI);
     List<Map<label> > regionMinLevel(surfI);
     List<Map<label> > regionMaxLevel(surfI);
+    List<Map<label> > regionLevelIncr(surfI);
     List<Map<scalar> > regionAngle(surfI);
     List<Map<autoPtr<dictionary> > > regionPatchInfo(surfI);
 
@@ -138,6 +140,31 @@ Foam::refinementSurfaces::refinementSurfaces
             const labelPair refLevel(dict.lookup("level"));
             globalMinLevel[surfI] = refLevel[0];
             globalMaxLevel[surfI] = refLevel[1];
+            globalLevelIncr[surfI] = dict.lookupOrDefault
+            (
+                "gapLevelIncrement",
+                0
+            );
+
+            if
+            (
+                globalMinLevel[surfI] < 0
+             || globalMaxLevel[surfI] < globalMinLevel[surfI]
+             || globalLevelIncr[surfI] < 0
+            )
+            {
+                FatalErrorIn
+                (
+                    "refinementSurfaces::refinementSurfaces"
+                    "(const searchableSurfaces&, const dictionary>&"
+                )   << "Illegal level specification for surface "
+                    << names_[surfI]
+                    << " : minLevel:" << globalMinLevel[surfI]
+                    << " maxLevel:" << globalMaxLevel[surfI]
+                    << " levelIncrement:" << globalLevelIncr[surfI]
+                    << exit(FatalError);
+            }
+
 
             // Global zone names per surface
             if (dict.readIfPresent("faceZone", faceZoneNames_[surfI]))
@@ -244,6 +271,34 @@ Foam::refinementSurfaces::refinementSurfaces
 
                         regionMinLevel[surfI].insert(regionI, refLevel[0]);
                         regionMaxLevel[surfI].insert(regionI, refLevel[1]);
+                        label levelIncr = regionDict.lookupOrDefault
+                        (
+                            "gapLevelIncrement",
+                            0
+                        );
+                        regionLevelIncr[surfI].insert(regionI, levelIncr);
+
+                        if
+                        (
+                            refLevel[0] < 0
+                         || refLevel[1] < refLevel[0]
+                         || levelIncr < 0
+                        )
+                        {
+                            FatalErrorIn
+                            (
+                                "refinementSurfaces::refinementSurfaces"
+                                "(const searchableSurfaces&, const dictionary>&"
+                            )   << "Illegal level specification for surface "
+                                << names_[surfI] << " region "
+                                << regionNames[regionI]
+                                << " : minLevel:" << refLevel[0]
+                                << " maxLevel:" << refLevel[1]
+                                << " levelIncrement:" << levelIncr
+                                << exit(FatalError);
+                        }
+
+
 
                         if (regionDict.found("perpendicularAngle"))
                         {
@@ -286,6 +341,8 @@ Foam::refinementSurfaces::refinementSurfaces
     minLevel_ = 0;
     maxLevel_.setSize(nRegions);
     maxLevel_ = 0;
+    gapLevel_.setSize(nRegions);
+    gapLevel_ = -1;
     perpendicularAngle_.setSize(nRegions);
     perpendicularAngle_ = -GREAT;
     patchInfo_.setSize(nRegions);
@@ -301,6 +358,10 @@ Foam::refinementSurfaces::refinementSurfaces
             label globalRegionI = regionOffset_[surfI] + i;
             minLevel_[globalRegionI] = globalMinLevel[surfI];
             maxLevel_[globalRegionI] = globalMaxLevel[surfI];
+            gapLevel_[globalRegionI] =
+                maxLevel_[globalRegionI]
+              + globalLevelIncr[surfI];
+
             perpendicularAngle_[globalRegionI] = globalAngle[surfI];
             if (globalPatchInfo.set(surfI))
             {
@@ -319,24 +380,9 @@ Foam::refinementSurfaces::refinementSurfaces
 
             minLevel_[globalRegionI] = iter();
             maxLevel_[globalRegionI] = regionMaxLevel[surfI][iter.key()];
-
-            // Check validity
-            if
-            (
-                minLevel_[globalRegionI] < 0
-             || maxLevel_[globalRegionI] < minLevel_[globalRegionI]
-            )
-            {
-                FatalErrorIn
-                (
-                    "refinementSurfaces::refinementSurfaces"
-                    "(const searchableSurfaces&, const dictionary>&"
-                )   << "Illegal level or layer specification for surface "
-                    << names_[surfI]
-                    << " : minLevel:" << minLevel_[globalRegionI]
-                    << " maxLevel:" << maxLevel_[globalRegionI]
-                    << exit(FatalError);
-            }
+            gapLevel_[globalRegionI] =
+                maxLevel_[globalRegionI]
+              + regionLevelIncr[surfI][iter.key()];
         }
         forAllConstIter(Map<scalar>, regionAngle[surfI], iter)
         {
@@ -714,6 +760,8 @@ void Foam::refinementSurfaces::findAllHigherIntersections
     const pointField& end,
     const labelList& currentLevel,   // current cell refinement level
 
+    const labelList& globalRegionLevel,
+
     List<vectorList>& surfaceNormal,
     labelListList& surfaceLevel
 ) const
@@ -777,7 +825,7 @@ void Foam::refinementSurfaces::findAllHigherIntersections
             label region = globalRegion(surfI, surfRegion[i]);
             label pointI = pointMap[i];
 
-            if (maxLevel_[region] > currentLevel[pointI])
+            if (globalRegionLevel[region] > currentLevel[pointI])
             {
                 // Append to pointI info
                 label sz = surfaceNormal[pointI].size();
@@ -785,7 +833,95 @@ void Foam::refinementSurfaces::findAllHigherIntersections
                 surfaceNormal[pointI][sz] = surfNormal[i];
 
                 surfaceLevel[pointI].setSize(sz+1);
-                surfaceLevel[pointI][sz] = maxLevel_[region];
+                surfaceLevel[pointI][sz] = globalRegionLevel[region];
+            }
+        }
+    }
+}
+
+
+void Foam::refinementSurfaces::findAllHigherIntersections
+(
+    const pointField& start,
+    const pointField& end,
+    const labelList& currentLevel,   // current cell refinement level
+
+    const labelList& globalRegionLevel,
+
+    List<pointList>& surfaceLocation,
+    List<vectorList>& surfaceNormal,
+    labelListList& surfaceLevel
+) const
+{
+    surfaceLevel.setSize(start.size());
+    surfaceNormal.setSize(start.size());
+    surfaceLocation.setSize(start.size());
+
+    if (surfaces_.empty())
+    {
+        return;
+    }
+
+    // Work arrays
+    List<List<pointIndexHit> > hitInfo;
+    labelList pRegions;
+    vectorField pNormals;
+
+    forAll(surfaces_, surfI)
+    {
+        allGeometry_[surfaces_[surfI]].findLineAll(start, end, hitInfo);
+
+        // Repack hits for surface into flat list
+        // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+        // To avoid overhead of calling getRegion for every point
+
+        label n = 0;
+        forAll(hitInfo, pointI)
+        {
+            n += hitInfo[pointI].size();
+        }
+
+        List<pointIndexHit> surfInfo(n);
+        labelList pointMap(n);
+        n = 0;
+
+        forAll(hitInfo, pointI)
+        {
+            const List<pointIndexHit>& pHits = hitInfo[pointI];
+
+            forAll(pHits, i)
+            {
+                surfInfo[n] = pHits[i];
+                pointMap[n] = pointI;
+                n++;
+            }
+        }
+
+        labelList surfRegion(n);
+        vectorField surfNormal(n);
+        allGeometry_[surfaces_[surfI]].getRegion(surfInfo, surfRegion);
+        allGeometry_[surfaces_[surfI]].getNormal(surfInfo, surfNormal);
+
+        // Extract back into pointwise
+        // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+        forAll(surfRegion, i)
+        {
+            label region = globalRegion(surfI, surfRegion[i]);
+            label pointI = pointMap[i];
+
+            if (globalRegionLevel[region] > currentLevel[pointI])
+            {
+                // Append to pointI info
+                label sz = surfaceNormal[pointI].size();
+                surfaceLocation[pointI].setSize(sz+1);
+                surfaceLocation[pointI][sz] = surfInfo[i].hitPoint();
+
+                surfaceNormal[pointI].setSize(sz+1);
+                surfaceNormal[pointI][sz] = surfNormal[i];
+
+                surfaceLevel[pointI].setSize(sz+1);
+                surfaceLevel[pointI][sz] = globalRegionLevel[region];
             }
         }
     }
diff --git a/src/mesh/autoMesh/autoHexMesh/refinementSurfaces/refinementSurfaces.H b/src/mesh/autoMesh/autoHexMesh/refinementSurfaces/refinementSurfaces.H
index aed21821b5..c9773398e5 100644
--- a/src/mesh/autoMesh/autoHexMesh/refinementSurfaces/refinementSurfaces.H
+++ b/src/mesh/autoMesh/autoHexMesh/refinementSurfaces/refinementSurfaces.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -51,6 +51,8 @@ class searchableSurfaces;
 class shellSurfaces;
 class triSurfaceMesh;
 
+typedef List<point> pointList;
+
 /*---------------------------------------------------------------------------*\
                            Class refinementSurfaces Declaration
 \*---------------------------------------------------------------------------*/
@@ -120,6 +122,9 @@ private:
         //- From global region number to refinement level
         labelList maxLevel_;
 
+        //- From global region number to small-gap level
+        labelList gapLevel_;
+
         //- From global region number to perpendicular angle
         scalarField perpendicularAngle_;
 
@@ -226,6 +231,12 @@ public:
                 return maxLevel_;
             }
 
+            //- From global region number to small gap refinement level
+            const labelList& gapLevel() const
+            {
+                return gapLevel_;
+            }
+
             //- From global region number to perpendicular angle
             const scalarField& perpendicularAngle() const
             {
@@ -295,11 +306,25 @@ public:
                 const pointField& start,
                 const pointField& end,
                 const labelList& currentLevel,  // current cell refinement level
+                const labelList& globalRegionLevel, // level per surfregion
 
                 List<vectorList>& surfaceNormal,
                 labelListList& surfaceLevel
             ) const;
 
+            //- Find all intersections of edge. Unsorted order.
+            void findAllHigherIntersections
+            (
+                const pointField& start,
+                const pointField& end,
+                const labelList& currentLevel,  // current cell refinement level
+                const labelList& globalRegionLevel, // level per surfregion
+
+                List<pointList>& surfaceLocation,
+                List<vectorList>& surfaceNormal,
+                labelListList& surfaceLevel
+            ) const;
+
             //- Find intersection nearest to the endpoints. surface1,2 are
             //  not indices into surfacesToTest but refinement surface indices.
             //  Returns surface, region on surface (so not global surface)
diff --git a/src/meshTools/AMIInterpolation/AMIInterpolation/AMIInterpolation.C b/src/meshTools/AMIInterpolation/AMIInterpolation/AMIInterpolation.C
index 8bc8b86d2e..10ec0bf5d0 100644
--- a/src/meshTools/AMIInterpolation/AMIInterpolation/AMIInterpolation.C
+++ b/src/meshTools/AMIInterpolation/AMIInterpolation/AMIInterpolation.C
@@ -56,6 +56,11 @@ Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolationMethodToWord
             method = "faceAreaWeightAMI";
             break;
         }
+        case imPartialFaceAreaWeight:
+        {
+            method = "partialFaceAreaWeightAMI";
+            break;
+        }
         default:
         {
             FatalErrorIn
@@ -87,7 +92,15 @@ Foam::AMIInterpolation<SourcePatch, TargetPatch>::wordTointerpolationMethod
 
     wordList methods
     (
-        IStringStream("(directAMI mapNearestAMI faceAreaWeightAMI)")()
+        IStringStream
+        (
+            "("
+                "directAMI "
+                "mapNearestAMI "
+                "faceAreaWeightAMI "
+                "partialFaceAreaWeightAMI"
+            ")"
+        )()
     );
 
     if (im == "directAMI")
@@ -102,6 +115,10 @@ Foam::AMIInterpolation<SourcePatch, TargetPatch>::wordTointerpolationMethod
     {
         method = imFaceAreaWeight;
     }
+    else if (im == "partialFaceAreaWeightAMI")
+    {
+        method = imPartialFaceAreaWeight;
+    }
     else
     {
         FatalErrorIn
@@ -183,6 +200,7 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::normaliseWeights
     const labelListList& addr,
     scalarListList& wght,
     scalarField& wghtSum,
+    const bool conformal,
     const bool output
 )
 {
@@ -191,12 +209,19 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::normaliseWeights
     forAll(wght, faceI)
     {
         scalarList& w = wght[faceI];
+        scalar denom = patchAreas[faceI];
+
         scalar s = sum(w);
-        scalar t = s/patchAreas[faceI];
+        scalar t = s/denom;
+
+        if (conformal)
+        {
+            denom = s;
+        }
 
         forAll(w, i)
         {
-            w[i] /= s;
+            w[i] /= denom;
         }
 
         wghtSum[faceI] = t;
@@ -476,6 +501,7 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::agglomerate
         srcAddress,
         srcWeights,
         srcWeightsSum,
+        true,
         false
     );
 }
@@ -749,7 +775,6 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::update
         tgtMagSf_[faceI] = tgtPatch[faceI].mag(tgtPatch.points());
     }
 
-
     // Calculate if patches present on multiple processors
     singlePatchProc_ = calcDistribution(srcPatch, tgtPatch);
 
@@ -794,32 +819,28 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::update
                 newTgtPoints
             );
 
-
         // calculate AMI interpolation
-        {
-            autoPtr<AMIMethod<SourcePatch, TargetPatch> > AMIPtr
+        autoPtr<AMIMethod<SourcePatch, TargetPatch> > AMIPtr
+        (
+            AMIMethod<SourcePatch, TargetPatch>::New
             (
-                AMIMethod<SourcePatch, TargetPatch>::New
-                (
-                    interpolationMethodToWord(method_),
-                    srcPatch,
-                    newTgtPatch,
-                    srcMagSf_,
-                    tgtMagSf_,
-                    triMode_,
-                    reverseTarget_
-                )
-            );
-
-            AMIPtr->calculate
-            (
-                srcAddress_,
-                srcWeights_,
-                tgtAddress_,
-                tgtWeights_
-            );
-        }
+                interpolationMethodToWord(method_),
+                srcPatch,
+                newTgtPatch,
+                srcMagSf_,
+                tgtMagSf_,
+                triMode_,
+                reverseTarget_
+            )
+        );
 
+        AMIPtr->calculate
+        (
+            srcAddress_,
+            srcWeights_,
+            tgtAddress_,
+            tgtWeights_
+        );
 
         // Now
         // ~~~
@@ -886,6 +907,7 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::update
             srcAddress_,
             srcWeights_,
             srcWeightsSum_,
+            AMIPtr->conformal(),
             true
         );
         normaliseWeights
@@ -895,6 +917,7 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::update
             tgtAddress_,
             tgtWeights_,
             tgtWeightsSum_,
+            AMIPtr->conformal(),
             true
         );
 
@@ -903,7 +926,6 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::update
         srcMapPtr_.reset(new mapDistribute(globalSrcFaces, tgtAddress_, cMap));
         tgtMapPtr_.reset(new mapDistribute(globalTgtFaces, srcAddress_, cMap));
 
-
         if (debug)
         {
             writeFaceConnectivity(srcPatch, newTgtPatch, srcAddress_);
@@ -913,29 +935,27 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::update
     {
 
         // calculate AMI interpolation
-        {
-            autoPtr<AMIMethod<SourcePatch, TargetPatch> > AMIPtr
+        autoPtr<AMIMethod<SourcePatch, TargetPatch> > AMIPtr
+        (
+            AMIMethod<SourcePatch, TargetPatch>::New
             (
-                AMIMethod<SourcePatch, TargetPatch>::New
-                (
-                    interpolationMethodToWord(method_),
-                    srcPatch,
-                    tgtPatch,
-                    srcMagSf_,
-                    tgtMagSf_,
-                    triMode_,
-                    reverseTarget_
-                )
-            );
+                interpolationMethodToWord(method_),
+                srcPatch,
+                tgtPatch,
+                srcMagSf_,
+                tgtMagSf_,
+                triMode_,
+                reverseTarget_
+            )
+        );
 
-            AMIPtr->calculate
-            (
-                srcAddress_,
-                srcWeights_,
-                tgtAddress_,
-                tgtWeights_
-            );
-        }
+        AMIPtr->calculate
+        (
+            srcAddress_,
+            srcWeights_,
+            tgtAddress_,
+            tgtWeights_
+        );
 
         normaliseWeights
         (
@@ -944,6 +964,7 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::update
             srcAddress_,
             srcWeights_,
             srcWeightsSum_,
+            AMIPtr->conformal(),
             true
         );
         normaliseWeights
@@ -953,6 +974,7 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::update
             tgtAddress_,
             tgtWeights_,
             tgtWeightsSum_,
+            AMIPtr->conformal(),
             true
         );
     }
diff --git a/src/meshTools/AMIInterpolation/AMIInterpolation/AMIInterpolation.H b/src/meshTools/AMIInterpolation/AMIInterpolation/AMIInterpolation.H
index e31eb91e1c..3aea35473f 100644
--- a/src/meshTools/AMIInterpolation/AMIInterpolation/AMIInterpolation.H
+++ b/src/meshTools/AMIInterpolation/AMIInterpolation/AMIInterpolation.H
@@ -88,7 +88,8 @@ public:
         {
             imDirect,
             imMapNearest,
-            imFaceAreaWeight
+            imFaceAreaWeight,
+            imPartialFaceAreaWeight
         };
 
         //- Convert interpolationMethod to word representation
@@ -236,6 +237,7 @@ private:
                 const labelListList& addr,
                 scalarListList& wght,
                 scalarField& wghtSum,
+                const bool conformal,
                 const bool output
             );
 
diff --git a/src/meshTools/AMIInterpolation/AMIInterpolation/AMIMethod/AMIMethod/AMIMethod.C b/src/meshTools/AMIInterpolation/AMIInterpolation/AMIMethod/AMIMethod/AMIMethod.C
index b5ab236b92..bb1e61d210 100644
--- a/src/meshTools/AMIInterpolation/AMIInterpolation/AMIMethod/AMIMethod/AMIMethod.C
+++ b/src/meshTools/AMIInterpolation/AMIInterpolation/AMIMethod/AMIMethod/AMIMethod.C
@@ -41,24 +41,28 @@ void Foam::AMIMethod<SourcePatch, TargetPatch>::checkPatches() const
     }
 
 
-    const scalar maxBoundsError = 0.05;
-
-    // check bounds of source and target
-    boundBox bbSrc(srcPatch_.points(), srcPatch_.meshPoints(), true);
-    boundBox bbTgt(tgtPatch_.points(), tgtPatch_.meshPoints(), true);
-
-    boundBox bbTgtInf(bbTgt);
-    bbTgtInf.inflate(maxBoundsError);
-
-    if (!bbTgtInf.contains(bbSrc))
+    if (conformal())
     {
-        WarningIn("AMIMethod<SourcePatch, TargetPatch>::checkPatches()")
-            << "Source and target patch bounding boxes are not similar" << nl
-            << "    source box span     : " << bbSrc.span() << nl
-            << "    target box span     : " << bbTgt.span() << nl
-            << "    source box          : " << bbSrc << nl
-            << "    target box          : " << bbTgt << nl
-            << "    inflated target box : " << bbTgtInf << endl;
+        const scalar maxBoundsError = 0.05;
+
+        // check bounds of source and target
+        boundBox bbSrc(srcPatch_.points(), srcPatch_.meshPoints(), true);
+        boundBox bbTgt(tgtPatch_.points(), tgtPatch_.meshPoints(), true);
+
+        boundBox bbTgtInf(bbTgt);
+        bbTgtInf.inflate(maxBoundsError);
+
+        if (!bbTgtInf.contains(bbSrc))
+        {
+            WarningIn("AMIMethod<SourcePatch, TargetPatch>::checkPatches()")
+                << "Source and target patch bounding boxes are not similar"
+                << nl
+                << "    source box span     : " << bbSrc.span() << nl
+                << "    target box span     : " << bbTgt.span() << nl
+                << "    source box          : " << bbSrc << nl
+                << "    target box          : " << bbTgt << nl
+                << "    inflated target box : " << bbTgtInf << endl;
+        }
     }
 }
 
@@ -74,6 +78,8 @@ bool Foam::AMIMethod<SourcePatch, TargetPatch>::initialise
     label& tgtFaceI
 )
 {
+    checkPatches();
+
     // set initial sizes for weights and addressing - must be done even if
     // returns false below
     srcAddress.setSize(srcPatch_.size());
@@ -241,17 +247,16 @@ Foam::label Foam::AMIMethod<SourcePatch, TargetPatch>::findTargetFace
 
     pointIndexHit sample = treePtr_->findNearest(srcPt, 10.0*srcFaceArea);
 
-
-    if (debug)
-    {
-        Pout<< "Source point = " << srcPt << ", Sample point = "
-            << sample.hitPoint() << ", Sample index = " << sample.index()
-            << endl;
-    }
-
     if (sample.hit())
     {
         targetFaceI = sample.index();
+
+        if (debug)
+        {
+            Pout<< "Source point = " << srcPt << ", Sample point = "
+                << sample.hitPoint() << ", Sample index = " << sample.index()
+                << endl;
+        }
     }
 
     return targetFaceI;
@@ -334,8 +339,6 @@ Foam::AMIMethod<SourcePatch, TargetPatch>::AMIMethod
     srcNonOverlap_(),
     triMode_(triMode)
 {
-    checkPatches();
-
     label srcSize = returnReduce(srcPatch_.size(), sumOp<label>());
     label tgtSize = returnReduce(tgtPatch_.size(), sumOp<label>());
 
@@ -352,4 +355,13 @@ Foam::AMIMethod<SourcePatch, TargetPatch>::~AMIMethod()
 {}
 
 
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+template<class SourcePatch, class TargetPatch>
+bool Foam::AMIMethod<SourcePatch, TargetPatch>::conformal() const
+{
+    return true;
+}
+
+
 // ************************************************************************* //
diff --git a/src/meshTools/AMIInterpolation/AMIInterpolation/AMIMethod/AMIMethod/AMIMethod.H b/src/meshTools/AMIInterpolation/AMIInterpolation/AMIMethod/AMIMethod/AMIMethod.H
index 7b6482b7c6..673a695a33 100644
--- a/src/meshTools/AMIInterpolation/AMIInterpolation/AMIMethod/AMIMethod/AMIMethod.H
+++ b/src/meshTools/AMIInterpolation/AMIInterpolation/AMIMethod/AMIMethod/AMIMethod.H
@@ -207,6 +207,9 @@ public:
             //  Note: this should be empty for correct functioning
             inline const labelList& srcNonOverlap() const;
 
+            //- Flag to indicate that interpolation patches are conformal
+            virtual bool conformal() const;
+
 
         // Manipulation
 
diff --git a/src/meshTools/AMIInterpolation/AMIInterpolation/AMIMethod/faceAreaWeightAMI/faceAreaWeightAMI.C b/src/meshTools/AMIInterpolation/AMIInterpolation/AMIMethod/faceAreaWeightAMI/faceAreaWeightAMI.C
index ab47c3afb4..ed4ae2d9f0 100644
--- a/src/meshTools/AMIInterpolation/AMIInterpolation/AMIMethod/faceAreaWeightAMI/faceAreaWeightAMI.C
+++ b/src/meshTools/AMIInterpolation/AMIInterpolation/AMIMethod/faceAreaWeightAMI/faceAreaWeightAMI.C
@@ -25,7 +25,85 @@ License
 
 #include "faceAreaWeightAMI.H"
 
-// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+// * * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * //
+
+template<class SourcePatch, class TargetPatch>
+void Foam::faceAreaWeightAMI<SourcePatch, TargetPatch>::calcAddressing
+(
+    List<DynamicList<label> >& srcAddr,
+    List<DynamicList<scalar> >& srcWght,
+    List<DynamicList<label> >& tgtAddr,
+    List<DynamicList<scalar> >& tgtWght,
+    label srcFaceI,
+    label tgtFaceI
+)
+{
+    // construct weights and addressing
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    label nFacesRemaining = srcAddr.size();
+
+    // list of tgt face neighbour faces
+    DynamicList<label> nbrFaces(10);
+
+    // list of faces currently visited for srcFaceI to avoid multiple hits
+    DynamicList<label> visitedFaces(10);
+
+    // list to keep track of tgt faces used to seed src faces
+    labelList seedFaces(nFacesRemaining, -1);
+    seedFaces[srcFaceI] = tgtFaceI;
+
+    // list to keep track of whether src face can be mapped
+    boolList mapFlag(nFacesRemaining, true);
+
+    // reset starting seed
+    label startSeedI = 0;
+
+    DynamicList<label> nonOverlapFaces;
+    do
+    {
+        // Do advancing front starting from srcFaceI,tgtFaceI
+        bool faceProcessed = processSourceFace
+        (
+            srcFaceI,
+            tgtFaceI,
+
+            nbrFaces,
+            visitedFaces,
+
+            srcAddr,
+            srcWght,
+            tgtAddr,
+            tgtWght
+        );
+
+        mapFlag[srcFaceI] = false;
+
+        nFacesRemaining--;
+
+        if (!faceProcessed)
+        {
+            nonOverlapFaces.append(srcFaceI);
+        }
+
+        // choose new src face from current src face neighbour
+        if (nFacesRemaining > 0)
+        {
+            setNextFaces
+            (
+                startSeedI,
+                srcFaceI,
+                tgtFaceI,
+                mapFlag,
+                seedFaces,
+                visitedFaces
+            );
+        }
+    } while (nFacesRemaining > 0);
+
+    this->srcNonOverlap_.transfer(nonOverlapFaces);
+}
+
 
 template<class SourcePatch, class TargetPatch>
 bool Foam::faceAreaWeightAMI<SourcePatch, TargetPatch>::processSourceFace
@@ -45,6 +123,11 @@ bool Foam::faceAreaWeightAMI<SourcePatch, TargetPatch>::processSourceFace
     List<DynamicList<scalar> >& tgtWght
 )
 {
+    if (tgtStartFaceI == -1)
+    {
+        return false;
+    }
+
     nbrFaces.clear();
     visitedFaces.clear();
 
@@ -101,11 +184,15 @@ void Foam::faceAreaWeightAMI<SourcePatch, TargetPatch>::setNextFaces
     label& tgtFaceI,
     const boolList& mapFlag,
     labelList& seedFaces,
-    const DynamicList<label>& visitedFaces
+    const DynamicList<label>& visitedFaces,
+    bool errorOnNotFound
 ) const
 {
     const labelList& srcNbrFaces = this->srcPatch_.faceFaces()[srcFaceI];
 
+    // initialise tgtFaceI
+    tgtFaceI = -1;
+
     // set possible seeds for later use
     bool valuesSet = false;
     forAll(srcNbrFaces, i)
@@ -195,19 +282,23 @@ void Foam::faceAreaWeightAMI<SourcePatch, TargetPatch>::setNextFaces
             }
         }
 
-        FatalErrorIn
-        (
-            "void Foam::faceAreaWeightAMI<SourcePatch, TargetPatch>::"
-            "setNextFaces"
-            "("
-                "label&, "
-                "label&, "
-                "label&, "
-                "const boolList&, "
-                "labelList&, "
-                "const DynamicList<label>&"
-            ") const"
-        )  << "Unable to set source and target faces" << abort(FatalError);
+        if (errorOnNotFound)
+        {
+            FatalErrorIn
+            (
+                "void Foam::faceAreaWeightAMI<SourcePatch, TargetPatch>::"
+                "setNextFaces"
+                "("
+                    "label&, "
+                    "label&, "
+                    "label&, "
+                    "const boolList&, "
+                    "labelList&, "
+                    "const DynamicList<label>&, "
+                    "bool"
+                ") const"
+            )  << "Unable to set source and target faces" << abort(FatalError);
+        }
     }
 }
 
@@ -447,77 +538,21 @@ void Foam::faceAreaWeightAMI<SourcePatch, TargetPatch>::calculate
     List<DynamicList<label> > tgtAddr(this->tgtPatch_.size());
     List<DynamicList<scalar> > tgtWght(tgtAddr.size());
 
+    calcAddressing
+    (
+        srcAddr,
+        srcWght,
+        tgtAddr,
+        tgtWght,
+        srcFaceI,
+        tgtFaceI
+    );
 
-    // construct weights and addressing
-    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-    label nFacesRemaining = srcAddr.size();
-
-    // list of tgt face neighbour faces
-    DynamicList<label> nbrFaces(10);
-
-    // list of faces currently visited for srcFaceI to avoid multiple hits
-    DynamicList<label> visitedFaces(10);
-
-    // list to keep track of tgt faces used to seed src faces
-    labelList seedFaces(nFacesRemaining, -1);
-    seedFaces[srcFaceI] = tgtFaceI;
-
-    // list to keep track of whether src face can be mapped
-    boolList mapFlag(nFacesRemaining, true);
-
-    // reset starting seed
-    label startSeedI = 0;
-
-    DynamicList<label> nonOverlapFaces;
-    do
+    if (this->srcNonOverlap_.size() != 0)
     {
-        // Do advancing front starting from srcFaceI,tgtFaceI
-        bool faceProcessed = processSourceFace
-        (
-            srcFaceI,
-            tgtFaceI,
-
-            nbrFaces,
-            visitedFaces,
-
-            srcAddr,
-            srcWght,
-            tgtAddr,
-            tgtWght
-        );
-
-        mapFlag[srcFaceI] = false;
-
-        nFacesRemaining--;
-
-        if (!faceProcessed)
-        {
-            nonOverlapFaces.append(srcFaceI);
-        }
-
-        // choose new src face from current src face neighbour
-        if (nFacesRemaining > 0)
-        {
-            setNextFaces
-            (
-                startSeedI,
-                srcFaceI,
-                tgtFaceI,
-                mapFlag,
-                seedFaces,
-                visitedFaces
-            );
-        }
-    } while (nFacesRemaining > 0);
-
-    if (nonOverlapFaces.size() != 0)
-    {
-        Pout<< "    AMI: " << nonOverlapFaces.size()
+        Pout<< "    AMI: " << this->srcNonOverlap_.size()
             << " non-overlap faces identified"
             << endl;
-
-        this->srcNonOverlap_.transfer(nonOverlapFaces);
     }
 
 
diff --git a/src/meshTools/AMIInterpolation/AMIInterpolation/AMIMethod/faceAreaWeightAMI/faceAreaWeightAMI.H b/src/meshTools/AMIInterpolation/AMIInterpolation/AMIMethod/faceAreaWeightAMI/faceAreaWeightAMI.H
index 82061d2727..2aff197745 100644
--- a/src/meshTools/AMIInterpolation/AMIInterpolation/AMIMethod/faceAreaWeightAMI/faceAreaWeightAMI.H
+++ b/src/meshTools/AMIInterpolation/AMIInterpolation/AMIMethod/faceAreaWeightAMI/faceAreaWeightAMI.H
@@ -52,9 +52,9 @@ class faceAreaWeightAMI
     public AMIMethod<SourcePatch, TargetPatch>
 {
 
-private:
+protected:
 
-    // Private Member Functions
+    // Protected Member Functions
 
         //- Disallow default bitwise copy construct
         faceAreaWeightAMI(const faceAreaWeightAMI&);
@@ -64,8 +64,19 @@ private:
 
         // Marching front
 
+            //- Calculate addressing and weights using temporary storage
+            virtual void calcAddressing
+            (
+                List<DynamicList<label> >& srcAddress,
+                List<DynamicList<scalar> >& srcWeights,
+                List<DynamicList<label> >& tgtAddress,
+                List<DynamicList<scalar> >& tgtWeights,
+                label srcFaceI,
+                label tgtFaceI
+            );
+
             //- Determine overlap contributions for source face srcFaceI
-            bool processSourceFace
+            virtual bool processSourceFace
             (
                 const label srcFaceI,
                 const label tgtStartFaceI,
@@ -78,7 +89,7 @@ private:
             );
 
             //- Attempt to re-evaluate source faces that have not been included
-            void restartUncoveredSourceFace
+            virtual void restartUncoveredSourceFace
             (
                 List<DynamicList<label> >& srcAddr,
                 List<DynamicList<scalar> >& srcWght,
@@ -87,21 +98,22 @@ private:
             );
 
             //- Set the source and target seed faces
-            void setNextFaces
+            virtual void setNextFaces
             (
                 label& startSeedI,
                 label& srcFaceI,
                 label& tgtFaceI,
                 const boolList& mapFlag,
                 labelList& seedFaces,
-                const DynamicList<label>& visitedFaces
+                const DynamicList<label>& visitedFaces,
+                bool errorOnNotFound = true
             ) const;
 
 
         // Evaluation
 
             //- Area of intersection between source and target faces
-            scalar interArea
+            virtual scalar interArea
             (
                 const label srcFaceI,
                 const label tgtFaceI
diff --git a/src/meshTools/AMIInterpolation/AMIInterpolation/AMIMethod/partialFaceAreaWeightAMI/partialFaceAreaWeightAMI.C b/src/meshTools/AMIInterpolation/AMIInterpolation/AMIMethod/partialFaceAreaWeightAMI/partialFaceAreaWeightAMI.C
new file mode 100644
index 0000000000..ad0f6376b1
--- /dev/null
+++ b/src/meshTools/AMIInterpolation/AMIInterpolation/AMIMethod/partialFaceAreaWeightAMI/partialFaceAreaWeightAMI.C
@@ -0,0 +1,155 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 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 "partialFaceAreaWeightAMI.H"
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+template<class SourcePatch, class TargetPatch>
+void Foam::partialFaceAreaWeightAMI<SourcePatch, TargetPatch>::setNextFaces
+(
+    label& startSeedI,
+    label& srcFaceI,
+    label& tgtFaceI,
+    const boolList& mapFlag,
+    labelList& seedFaces,
+    const DynamicList<label>& visitedFaces,
+    const bool errorOnNotFound
+) const
+{
+    faceAreaWeightAMI<SourcePatch, TargetPatch>::setNextFaces
+    (
+        startSeedI,
+        srcFaceI,
+        tgtFaceI,
+        mapFlag,
+        seedFaces,
+        visitedFaces,
+        false // no error on not found
+    );
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+template<class SourcePatch, class TargetPatch>
+Foam::partialFaceAreaWeightAMI<SourcePatch, TargetPatch>::
+partialFaceAreaWeightAMI
+(
+    const SourcePatch& srcPatch,
+    const TargetPatch& tgtPatch,
+    const scalarField& srcMagSf,
+    const scalarField& tgtMagSf,
+    const faceAreaIntersect::triangulationMode& triMode,
+    const bool reverseTarget
+)
+:
+    faceAreaWeightAMI<SourcePatch, TargetPatch>
+    (
+        srcPatch,
+        tgtPatch,
+        srcMagSf,
+        tgtMagSf,
+        triMode,
+        reverseTarget
+    )
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
+
+template<class SourcePatch, class TargetPatch>
+Foam::partialFaceAreaWeightAMI<SourcePatch, TargetPatch>::
+~partialFaceAreaWeightAMI()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+template<class SourcePatch, class TargetPatch>
+bool Foam::partialFaceAreaWeightAMI<SourcePatch, TargetPatch>::conformal() const
+{
+    return false;
+}
+
+
+template<class SourcePatch, class TargetPatch>
+void Foam::partialFaceAreaWeightAMI<SourcePatch, TargetPatch>::calculate
+(
+    labelListList& srcAddress,
+    scalarListList& srcWeights,
+    labelListList& tgtAddress,
+    scalarListList& tgtWeights,
+    label srcFaceI,
+    label tgtFaceI
+)
+{
+    bool ok =
+        this->initialise
+        (
+            srcAddress,
+            srcWeights,
+            tgtAddress,
+            tgtWeights,
+            srcFaceI,
+            tgtFaceI
+        );
+
+    if (!ok)
+    {
+        return;
+    }
+
+    // temporary storage for addressing and weights
+    List<DynamicList<label> > srcAddr(this->srcPatch_.size());
+    List<DynamicList<scalar> > srcWght(srcAddr.size());
+    List<DynamicList<label> > tgtAddr(this->tgtPatch_.size());
+    List<DynamicList<scalar> > tgtWght(tgtAddr.size());
+
+    faceAreaWeightAMI<SourcePatch, TargetPatch>::calcAddressing
+    (
+        srcAddr,
+        srcWght,
+        tgtAddr,
+        tgtWght,
+        srcFaceI,
+        tgtFaceI
+    );
+
+    // transfer data to persistent storage
+    forAll(srcAddr, i)
+    {
+        srcAddress[i].transfer(srcAddr[i]);
+        srcWeights[i].transfer(srcWght[i]);
+    }
+    forAll(tgtAddr, i)
+    {
+        tgtAddress[i].transfer(tgtAddr[i]);
+        tgtWeights[i].transfer(tgtWght[i]);
+    }
+}
+
+
+// ************************************************************************* //
diff --git a/src/meshTools/AMIInterpolation/AMIInterpolation/AMIMethod/partialFaceAreaWeightAMI/partialFaceAreaWeightAMI.H b/src/meshTools/AMIInterpolation/AMIInterpolation/AMIMethod/partialFaceAreaWeightAMI/partialFaceAreaWeightAMI.H
new file mode 100644
index 0000000000..4fd0ea2494
--- /dev/null
+++ b/src/meshTools/AMIInterpolation/AMIInterpolation/AMIMethod/partialFaceAreaWeightAMI/partialFaceAreaWeightAMI.H
@@ -0,0 +1,141 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 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::partialFaceAreaWeightAMI
+
+Description
+    Partial face area weighted Arbitrary Mesh Interface (AMI) method
+
+SourceFiles
+    partialFaceAreaWeightAMI.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef partialFaceAreaWeightAMI_H
+#define partialFaceAreaWeightAMI_H
+
+#include "faceAreaWeightAMI.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                  Class partialFaceAreaWeightAMI Declaration
+\*---------------------------------------------------------------------------*/
+
+template<class SourcePatch, class TargetPatch>
+class partialFaceAreaWeightAMI
+:
+    public faceAreaWeightAMI<SourcePatch, TargetPatch>
+{
+
+private:
+
+    // Private Member Functions
+
+        //- Disallow default bitwise copy construct
+        partialFaceAreaWeightAMI(const partialFaceAreaWeightAMI&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const partialFaceAreaWeightAMI&);
+
+        // Marching front
+
+            //- Set the source and target seed faces
+            virtual void setNextFaces
+            (
+                label& startSeedI,
+                label& srcFaceI,
+                label& tgtFaceI,
+                const boolList& mapFlag,
+                labelList& seedFaces,
+                const DynamicList<label>& visitedFaces,
+                bool errorOnNotFound = true
+            ) const;
+
+
+public:
+
+    //- Runtime type information
+    TypeName("partialFaceAreaWeightAMI");
+
+
+    // Constructors
+
+        //- Construct from components
+        partialFaceAreaWeightAMI
+        (
+            const SourcePatch& srcPatch,
+            const TargetPatch& tgtPatch,
+            const scalarField& srcMagSf,
+            const scalarField& tgtMagSf,
+            const faceAreaIntersect::triangulationMode& triMode,
+            const bool reverseTarget = false
+        );
+
+
+    //- Destructor
+    virtual ~partialFaceAreaWeightAMI();
+
+
+    // Member Functions
+
+        // Access
+
+            //- Flag to indicate that interpolation patches are conformal
+            virtual bool conformal() const;
+
+
+        // Manipulation
+
+            //- Update addressing and weights
+            virtual void calculate
+            (
+                labelListList& srcAddress,
+                scalarListList& srcWeights,
+                labelListList& tgtAddress,
+                scalarListList& tgtWeights,
+                label srcFaceI = -1,
+                label tgtFaceI = -1
+            );
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+#   include "partialFaceAreaWeightAMI.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/meshTools/AMIInterpolation/AMIInterpolation/AMIPatchToPatchInterpolation.C b/src/meshTools/AMIInterpolation/AMIInterpolation/AMIPatchToPatchInterpolation.C
index 6cb5678aaf..319f837593 100644
--- a/src/meshTools/AMIInterpolation/AMIInterpolation/AMIPatchToPatchInterpolation.C
+++ b/src/meshTools/AMIInterpolation/AMIInterpolation/AMIPatchToPatchInterpolation.C
@@ -28,6 +28,7 @@ License
 #include "directAMI.H"
 #include "mapNearestAMI.H"
 #include "faceAreaWeightAMI.H"
+#include "partialFaceAreaWeightAMI.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -38,6 +39,7 @@ namespace Foam
     makeAMIMethodType(AMIPatchToPatchInterpolation, directAMI);
     makeAMIMethodType(AMIPatchToPatchInterpolation, mapNearestAMI);
     makeAMIMethodType(AMIPatchToPatchInterpolation, faceAreaWeightAMI);
+    makeAMIMethodType(AMIPatchToPatchInterpolation, partialFaceAreaWeightAMI);
 }
 
 
diff --git a/src/meshTools/AMIInterpolation/GAMG/interfaceFields/cyclicACMIGAMGInterfaceField/cyclicACMIGAMGInterfaceField.C b/src/meshTools/AMIInterpolation/GAMG/interfaceFields/cyclicACMIGAMGInterfaceField/cyclicACMIGAMGInterfaceField.C
new file mode 100644
index 0000000000..4963d926cd
--- /dev/null
+++ b/src/meshTools/AMIInterpolation/GAMG/interfaceFields/cyclicACMIGAMGInterfaceField/cyclicACMIGAMGInterfaceField.C
@@ -0,0 +1,129 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 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 "cyclicACMIGAMGInterfaceField.H"
+#include "addToRunTimeSelectionTable.H"
+#include "lduMatrix.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(cyclicACMIGAMGInterfaceField, 0);
+    addToRunTimeSelectionTable
+    (
+        GAMGInterfaceField,
+        cyclicACMIGAMGInterfaceField,
+        lduInterface
+    );
+    addToRunTimeSelectionTable
+    (
+        GAMGInterfaceField,
+        cyclicACMIGAMGInterfaceField,
+        lduInterfaceField
+    );
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::cyclicACMIGAMGInterfaceField::cyclicACMIGAMGInterfaceField
+(
+    const GAMGInterface& GAMGCp,
+    const lduInterfaceField& fineInterface
+)
+:
+    GAMGInterfaceField(GAMGCp, fineInterface),
+    cyclicACMIInterface_(refCast<const cyclicACMIGAMGInterface>(GAMGCp)),
+    doTransform_(false),
+    rank_(0)
+{
+    const cyclicAMILduInterfaceField& p =
+        refCast<const cyclicAMILduInterfaceField>(fineInterface);
+
+    doTransform_ = p.doTransform();
+    rank_ = p.rank();
+}
+
+
+Foam::cyclicACMIGAMGInterfaceField::cyclicACMIGAMGInterfaceField
+(
+    const GAMGInterface& GAMGCp,
+    const bool doTransform,
+    const int rank
+)
+:
+    GAMGInterfaceField(GAMGCp, doTransform, rank),
+    cyclicACMIInterface_(refCast<const cyclicACMIGAMGInterface>(GAMGCp)),
+    doTransform_(doTransform),
+    rank_(rank)
+{}
+
+
+// * * * * * * * * * * * * * * * * Desstructor * * * * * * * * * * * * * * * //
+
+Foam::cyclicACMIGAMGInterfaceField::~cyclicACMIGAMGInterfaceField()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+void Foam::cyclicACMIGAMGInterfaceField::updateInterfaceMatrix
+(
+    scalarField& result,
+    const scalarField& psiInternal,
+    const scalarField& coeffs,
+    const direction cmpt,
+    const Pstream::commsTypes
+) const
+{
+    // Get neighbouring field
+    scalarField pnf
+    (
+        cyclicACMIInterface_.neighbPatch().interfaceInternalField(psiInternal)
+    );
+
+    // Transform according to the transformation tensors
+    transformCoupleField(pnf, cmpt);
+
+    if (cyclicACMIInterface_.owner())
+    {
+        pnf = cyclicACMIInterface_.AMI().interpolateToSource(pnf);
+    }
+    else
+    {
+        pnf = cyclicACMIInterface_.neighbPatch().AMI().interpolateToTarget(pnf);
+    }
+
+    const labelUList& faceCells = cyclicACMIInterface_.faceCells();
+
+    forAll(faceCells, elemI)
+    {
+        result[faceCells[elemI]] -= coeffs[elemI]*pnf[elemI];
+    }
+}
+
+
+// ************************************************************************* //
diff --git a/src/meshTools/AMIInterpolation/GAMG/interfaceFields/cyclicACMIGAMGInterfaceField/cyclicACMIGAMGInterfaceField.H b/src/meshTools/AMIInterpolation/GAMG/interfaceFields/cyclicACMIGAMGInterfaceField/cyclicACMIGAMGInterfaceField.H
new file mode 100644
index 0000000000..e06d76328d
--- /dev/null
+++ b/src/meshTools/AMIInterpolation/GAMG/interfaceFields/cyclicACMIGAMGInterfaceField/cyclicACMIGAMGInterfaceField.H
@@ -0,0 +1,166 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 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::cyclicACMIGAMGInterfaceField
+
+Description
+    GAMG agglomerated cyclic interface for Arbitrarily Coupled Mesh Interface
+    (ACMI) fields.
+
+SourceFiles
+    cyclicACMIGAMGInterfaceField.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef cyclicACMIGAMGInterfaceField_H
+#define cyclicACMIGAMGInterfaceField_H
+
+#include "GAMGInterfaceField.H"
+#include "cyclicACMIGAMGInterface.H"
+#include "cyclicACMILduInterfaceField.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                 Class cyclicACMIGAMGInterfaceField Declaration
+\*---------------------------------------------------------------------------*/
+
+class cyclicACMIGAMGInterfaceField
+:
+    public GAMGInterfaceField,
+    virtual public cyclicACMILduInterfaceField
+{
+    // Private data
+
+        //- Local reference cast into the cyclic interface
+        const cyclicACMIGAMGInterface& cyclicACMIInterface_;
+
+        //- Is the transform required
+        bool doTransform_;
+
+        //- Rank of component for transformation
+        int rank_;
+
+
+    // Private Member Functions
+
+        //- Disallow default bitwise copy construct
+        cyclicACMIGAMGInterfaceField(const cyclicACMIGAMGInterfaceField&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const cyclicACMIGAMGInterfaceField&);
+
+
+public:
+
+    //- Runtime type information
+    TypeName("cyclicACMI");
+
+
+    // Constructors
+
+        //- Construct from GAMG interface and fine level interface field
+        cyclicACMIGAMGInterfaceField
+        (
+            const GAMGInterface& GAMGCp,
+            const lduInterfaceField& fineInterfaceField
+        );
+
+        //- Construct from GAMG interface and fine level interface field
+        cyclicACMIGAMGInterfaceField
+        (
+            const GAMGInterface& GAMGCp,
+            const bool doTransform,
+            const int rank
+        );
+
+
+    //- Destructor
+    virtual ~cyclicACMIGAMGInterfaceField();
+
+
+    // Member Functions
+
+        // Access
+
+            //- Return size
+            label size() const
+            {
+                return cyclicACMIInterface_.size();
+            }
+
+
+        // Interface matrix update
+
+            //- Update result field based on interface functionality
+            virtual void updateInterfaceMatrix
+            (
+                scalarField& result,
+                const scalarField& psiInternal,
+                const scalarField& coeffs,
+                const direction cmpt,
+                const Pstream::commsTypes commsType
+            ) const;
+
+
+        //- Cyclic interface functions
+
+            //- Does the interface field perform the transfromation
+            virtual bool doTransform() const
+            {
+                return doTransform_;
+            }
+
+            //- Return face transformation tensor
+            virtual const tensorField& forwardT() const
+            {
+                return cyclicACMIInterface_.forwardT();
+            }
+
+            //- Return neighbour-cell transformation tensor
+            virtual const tensorField& reverseT() const
+            {
+                return cyclicACMIInterface_.reverseT();
+            }
+
+            //- Return rank of component for transform
+            virtual int rank() const
+            {
+                return rank_;
+            }
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/meshTools/AMIInterpolation/GAMG/interfaces/cyclicACMIGAMGInterface/cyclicACMIGAMGInterface.C b/src/meshTools/AMIInterpolation/GAMG/interfaces/cyclicACMIGAMGInterface/cyclicACMIGAMGInterface.C
new file mode 100644
index 0000000000..d9e3a0fb77
--- /dev/null
+++ b/src/meshTools/AMIInterpolation/GAMG/interfaces/cyclicACMIGAMGInterface/cyclicACMIGAMGInterface.C
@@ -0,0 +1,198 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 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 "AMIInterpolation.H"
+#include "cyclicACMIGAMGInterface.H"
+#include "addToRunTimeSelectionTable.H"
+#include "Map.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(cyclicACMIGAMGInterface, 0);
+    addToRunTimeSelectionTable
+    (
+        GAMGInterface,
+        cyclicACMIGAMGInterface,
+        lduInterface
+    );
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::cyclicACMIGAMGInterface::cyclicACMIGAMGInterface
+(
+    const label index,
+    const lduInterfacePtrsList& coarseInterfaces,
+    const lduInterface& fineInterface,
+    const labelField& localRestrictAddressing,
+    const labelField& neighbourRestrictAddressing,
+    const label fineLevelIndex,
+    const label coarseComm
+)
+:
+    GAMGInterface
+    (
+        index,
+        coarseInterfaces
+    ),
+    fineCyclicACMIInterface_
+    (
+        refCast<const cyclicACMILduInterface>(fineInterface)
+    )
+{
+    // Construct face agglomeration from cell agglomeration
+    {
+        // From coarse face to cell
+        DynamicList<label> dynFaceCells(localRestrictAddressing.size());
+
+        // From face to coarse face
+        DynamicList<label> dynFaceRestrictAddressing
+        (
+            localRestrictAddressing.size()
+        );
+
+        Map<label> masterToCoarseFace(localRestrictAddressing.size());
+
+        forAll(localRestrictAddressing, ffi)
+        {
+            label curMaster = localRestrictAddressing[ffi];
+
+            Map<label>::const_iterator fnd = masterToCoarseFace.find
+            (
+                curMaster
+            );
+
+            if (fnd == masterToCoarseFace.end())
+            {
+                // New coarse face
+                label coarseI = dynFaceCells.size();
+                dynFaceRestrictAddressing.append(coarseI);
+                dynFaceCells.append(curMaster);
+                masterToCoarseFace.insert(curMaster, coarseI);
+            }
+            else
+            {
+                // Already have coarse face
+                dynFaceRestrictAddressing.append(fnd());
+            }
+        }
+
+        faceCells_.transfer(dynFaceCells);
+        faceRestrictAddressing_.transfer(dynFaceRestrictAddressing);
+    }
+
+
+    // On the owner side construct the AMI
+
+    if (fineCyclicACMIInterface_.owner())
+    {
+        // Construct the neighbour side agglomeration (as the neighbour would
+        // do it so it the exact loop above using neighbourRestrictAddressing
+        // instead of localRestrictAddressing)
+
+        labelList nbrFaceRestrictAddressing;
+        {
+            // From face to coarse face
+            DynamicList<label> dynNbrFaceRestrictAddressing
+            (
+                neighbourRestrictAddressing.size()
+            );
+
+            Map<label> masterToCoarseFace(neighbourRestrictAddressing.size());
+
+            forAll(neighbourRestrictAddressing, ffi)
+            {
+                label curMaster = neighbourRestrictAddressing[ffi];
+
+                Map<label>::const_iterator fnd = masterToCoarseFace.find
+                (
+                    curMaster
+                );
+
+                if (fnd == masterToCoarseFace.end())
+                {
+                    // New coarse face
+                    label coarseI = masterToCoarseFace.size();
+                    dynNbrFaceRestrictAddressing.append(coarseI);
+                    masterToCoarseFace.insert(curMaster, coarseI);
+                }
+                else
+                {
+                    // Already have coarse face
+                    dynNbrFaceRestrictAddressing.append(fnd());
+                }
+            }
+
+            nbrFaceRestrictAddressing.transfer(dynNbrFaceRestrictAddressing);
+        }
+
+        amiPtr_.reset
+        (
+            new AMIPatchToPatchInterpolation
+            (
+                fineCyclicACMIInterface_.AMI(),
+                faceRestrictAddressing_,
+                nbrFaceRestrictAddressing
+            )
+        );
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * Desstructor * * * * * * * * * * * * * * * //
+
+Foam::cyclicACMIGAMGInterface::~cyclicACMIGAMGInterface()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+Foam::tmp<Foam::labelField>
+Foam::cyclicACMIGAMGInterface::internalFieldTransfer
+(
+    const Pstream::commsTypes,
+    const labelUList& iF
+) const
+{
+    const cyclicACMIGAMGInterface& nbr =
+        dynamic_cast<const cyclicACMIGAMGInterface&>(neighbPatch());
+    const labelUList& nbrFaceCells = nbr.faceCells();
+
+    tmp<labelField> tpnf(new labelField(nbrFaceCells.size()));
+    labelField& pnf = tpnf();
+
+    forAll(pnf, facei)
+    {
+        pnf[facei] = iF[nbrFaceCells[facei]];
+    }
+
+    return tpnf;
+}
+
+
+// ************************************************************************* //
diff --git a/src/meshTools/AMIInterpolation/GAMG/interfaces/cyclicACMIGAMGInterface/cyclicACMIGAMGInterface.H b/src/meshTools/AMIInterpolation/GAMG/interfaces/cyclicACMIGAMGInterface/cyclicACMIGAMGInterface.H
new file mode 100644
index 0000000000..3bf7bb3410
--- /dev/null
+++ b/src/meshTools/AMIInterpolation/GAMG/interfaces/cyclicACMIGAMGInterface/cyclicACMIGAMGInterface.H
@@ -0,0 +1,174 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 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::cyclicACMIGAMGInterface
+
+Description
+    GAMG agglomerated cyclic ACMI interface.
+
+SourceFiles
+    cyclicACMIGAMGInterface.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef cyclicACMIGAMGInterface_H
+#define cyclicACMIGAMGInterface_H
+
+#include "GAMGInterface.H"
+#include "cyclicACMILduInterface.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                   Class cyclicACMIGAMGInterface Declaration
+\*---------------------------------------------------------------------------*/
+
+class cyclicACMIGAMGInterface
+:
+    public GAMGInterface,
+    virtual public cyclicACMILduInterface
+{
+    // Private data
+
+        //- Reference for the cyclicLduInterface from which this is
+        //  agglomerated
+        const cyclicACMILduInterface& fineCyclicACMIInterface_;
+
+        //- AMI interface
+        autoPtr<AMIPatchToPatchInterpolation> amiPtr_;
+
+
+    // Private Member Functions
+
+        //- Disallow default bitwise copy construct
+        cyclicACMIGAMGInterface(const cyclicACMIGAMGInterface&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const cyclicACMIGAMGInterface&);
+
+
+public:
+
+    //- Runtime type information
+    TypeName("cyclicACMI");
+
+
+    // Constructors
+
+        //- Construct from fine level interface,
+        //  local and neighbour restrict addressing
+        cyclicACMIGAMGInterface
+        (
+            const label index,
+            const lduInterfacePtrsList& coarseInterfaces,
+            const lduInterface& fineInterface,
+            const labelField& restrictAddressing,
+            const labelField& neighbourRestrictAddressing,
+            const label fineLevelIndex,
+            const label coarseComm
+        );
+
+
+    //- Destructor
+    virtual ~cyclicACMIGAMGInterface();
+
+
+    // Member Functions
+
+        // Interface transfer functions
+
+            //- Transfer and return internal field adjacent to the interface
+            virtual tmp<labelField> internalFieldTransfer
+            (
+                const Pstream::commsTypes commsType,
+                const labelUList& iF
+            ) const;
+
+
+        //- Cyclic interface functions
+
+            //- Return neigbour processor number
+            virtual label neighbPatchID() const
+            {
+                return fineCyclicACMIInterface_.neighbPatchID();
+            }
+
+            virtual bool owner() const
+            {
+                return fineCyclicACMIInterface_.owner();
+            }
+
+            virtual const cyclicACMIGAMGInterface& neighbPatch() const
+            {
+                return dynamic_cast<const cyclicACMIGAMGInterface&>
+                (
+                    coarseInterfaces_[neighbPatchID()]
+                );
+            }
+
+            virtual const AMIPatchToPatchInterpolation& AMI() const
+            {
+                return amiPtr_();
+            }
+
+            //- Return face transformation tensor
+            virtual const tensorField& forwardT() const
+            {
+                return fineCyclicACMIInterface_.forwardT();
+            }
+
+            //- Return neighbour-cell transformation tensor
+            virtual const tensorField& reverseT() const
+            {
+                return fineCyclicACMIInterface_.reverseT();
+            }
+
+
+        // I/O
+
+            //- Write to stream
+            virtual void write(Ostream&) const
+            {
+                //TBD. How to serialise the AMI such that we can stream
+                // cyclicACMIGAMGInterface.
+                notImplemented
+                (
+                    "cyclicACMIGAMGInterface::write(Ostream&) const"
+                );
+            }
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/meshTools/AMIInterpolation/patches/cyclicACMI/cyclicACMILduInterfaceField/cyclicACMILduInterface.C b/src/meshTools/AMIInterpolation/patches/cyclicACMI/cyclicACMILduInterfaceField/cyclicACMILduInterface.C
new file mode 100644
index 0000000000..08c5c570a3
--- /dev/null
+++ b/src/meshTools/AMIInterpolation/patches/cyclicACMI/cyclicACMILduInterfaceField/cyclicACMILduInterface.C
@@ -0,0 +1,42 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 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 "cyclicACMILduInterface.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+defineTypeNameAndDebug(cyclicACMILduInterface, 0);
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::cyclicACMILduInterface::~cyclicACMILduInterface()
+{}
+
+
+// ************************************************************************* //
diff --git a/src/meshTools/AMIInterpolation/patches/cyclicACMI/cyclicACMILduInterfaceField/cyclicACMILduInterface.H b/src/meshTools/AMIInterpolation/patches/cyclicACMI/cyclicACMILduInterfaceField/cyclicACMILduInterface.H
new file mode 100644
index 0000000000..3d25637ce6
--- /dev/null
+++ b/src/meshTools/AMIInterpolation/patches/cyclicACMI/cyclicACMILduInterfaceField/cyclicACMILduInterface.H
@@ -0,0 +1,80 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 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::cyclicACMILduInterface
+
+Description
+    An abstract base class for cyclic ACMI coupled interfaces
+
+SourceFiles
+    cyclicACMILduInterface.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef cyclicACMILduInterface_H
+#define cyclicACMILduInterface_H
+
+#include "cyclicAMILduInterface.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                   Class cyclicACMILduInterface Declaration
+\*---------------------------------------------------------------------------*/
+
+class cyclicACMILduInterface
+:
+    public cyclicAMILduInterface
+{
+
+public:
+
+    //- Runtime type information
+    TypeName("cyclicACMILduInterface");
+
+
+    // Constructors
+
+        //- Construct null
+        cyclicACMILduInterface()
+        {}
+
+
+    //- Destructor
+    virtual ~cyclicACMILduInterface();
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/meshTools/AMIInterpolation/patches/cyclicACMI/cyclicACMILduInterfaceField/cyclicACMILduInterfaceField.C b/src/meshTools/AMIInterpolation/patches/cyclicACMI/cyclicACMILduInterfaceField/cyclicACMILduInterfaceField.C
new file mode 100644
index 0000000000..b823235255
--- /dev/null
+++ b/src/meshTools/AMIInterpolation/patches/cyclicACMI/cyclicACMILduInterfaceField/cyclicACMILduInterfaceField.C
@@ -0,0 +1,55 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 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 "cyclicACMILduInterfaceField.H"
+#include "diagTensorField.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+defineTypeNameAndDebug(cyclicACMILduInterfaceField, 0);
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::cyclicACMILduInterfaceField::~cyclicACMILduInterfaceField()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+void Foam::cyclicACMILduInterfaceField::transformCoupleField
+(
+    scalarField& f,
+    const direction cmpt
+) const
+{
+    cyclicAMILduInterfaceField::transformCoupleField(f, cmpt);
+}
+
+
+// ************************************************************************* //
diff --git a/src/meshTools/AMIInterpolation/patches/cyclicACMI/cyclicACMILduInterfaceField/cyclicACMILduInterfaceField.H b/src/meshTools/AMIInterpolation/patches/cyclicACMI/cyclicACMILduInterfaceField/cyclicACMILduInterfaceField.H
new file mode 100644
index 0000000000..5d0ec6e6e4
--- /dev/null
+++ b/src/meshTools/AMIInterpolation/patches/cyclicACMI/cyclicACMILduInterfaceField/cyclicACMILduInterfaceField.H
@@ -0,0 +1,108 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 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::cyclicACMILduInterfaceField
+
+Description
+    Abstract base class for cyclic ACMI coupled interfaces
+
+SourceFiles
+    cyclicACMILduInterfaceField.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef cyclicACMILduInterfaceField_H
+#define cyclicACMILduInterfaceField_H
+
+#include "cyclicAMILduInterfaceField.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                 Class cyclicACMILduInterfaceField Declaration
+\*---------------------------------------------------------------------------*/
+
+class cyclicACMILduInterfaceField
+:
+    public cyclicAMILduInterfaceField
+{
+
+public:
+
+    //- Runtime type information
+    TypeName("cyclicACMILduInterfaceField");
+
+
+    // Constructors
+
+        //- Construct null
+        cyclicACMILduInterfaceField()
+        {}
+
+
+    //- Destructor
+    virtual ~cyclicACMILduInterfaceField();
+
+
+    // Member Functions
+
+        //- Transform given patch field
+        template<class Type>
+        void transformCoupleField(Field<Type>& f) const;
+
+        //- Transform given patch internal field
+        void transformCoupleField
+        (
+            scalarField& psiInternal,
+            const direction cmpt
+        ) const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#include "tensorField.H"
+
+template<class Type>
+void Foam::cyclicACMILduInterfaceField::transformCoupleField
+(
+    Field<Type>& f
+) const
+{
+    cyclicAMILduInterfaceField::transformCoupleField(f);
+}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/meshTools/AMIInterpolation/patches/cyclicACMI/cyclicACMIPointPatch/cyclicACMIPointPatch.C b/src/meshTools/AMIInterpolation/patches/cyclicACMI/cyclicACMIPointPatch/cyclicACMIPointPatch.C
new file mode 100644
index 0000000000..d7feb7f231
--- /dev/null
+++ b/src/meshTools/AMIInterpolation/patches/cyclicACMI/cyclicACMIPointPatch/cyclicACMIPointPatch.C
@@ -0,0 +1,99 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 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 "cyclicACMIPointPatch.H"
+#include "pointBoundaryMesh.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(cyclicACMIPointPatch, 0);
+    addToRunTimeSelectionTable
+    (
+        facePointPatch,
+        cyclicACMIPointPatch,
+        polyPatch
+    );
+}
+
+
+// * * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * //
+
+void Foam::cyclicACMIPointPatch::initGeometry(PstreamBuffers&)
+{}
+
+
+void Foam::cyclicACMIPointPatch::calcGeometry(PstreamBuffers&)
+{}
+
+
+void Foam::cyclicACMIPointPatch::initMovePoints
+(
+    PstreamBuffers&,
+    const pointField&
+)
+{}
+
+
+void Foam::cyclicACMIPointPatch::movePoints(PstreamBuffers&, const pointField&)
+{}
+
+
+void Foam::cyclicACMIPointPatch::initUpdateMesh(PstreamBuffers& pBufs)
+{
+    facePointPatch::initUpdateMesh(pBufs);
+//    cyclicACMIPointPatch::initGeometry(pBufs);
+}
+
+
+void Foam::cyclicACMIPointPatch::updateMesh(PstreamBuffers& pBufs)
+{
+    facePointPatch::updateMesh(pBufs);
+//    cyclicACMIPointPatch::calcGeometry(pBufs);
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::cyclicACMIPointPatch::cyclicACMIPointPatch
+(
+    const polyPatch& patch,
+    const pointBoundaryMesh& bm
+)
+:
+    coupledFacePointPatch(patch, bm),
+    cyclicACMIPolyPatch_(refCast<const cyclicACMIPolyPatch>(patch))
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::cyclicACMIPointPatch::~cyclicACMIPointPatch()
+{}
+
+
+// ************************************************************************* //
diff --git a/src/meshTools/AMIInterpolation/patches/cyclicACMI/cyclicACMIPointPatch/cyclicACMIPointPatch.H b/src/meshTools/AMIInterpolation/patches/cyclicACMI/cyclicACMIPointPatch/cyclicACMIPointPatch.H
new file mode 100644
index 0000000000..1ed4f26cdb
--- /dev/null
+++ b/src/meshTools/AMIInterpolation/patches/cyclicACMI/cyclicACMIPointPatch/cyclicACMIPointPatch.H
@@ -0,0 +1,170 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 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::cyclicACMIPointPatch
+
+Description
+    Cyclic AMI point patch - place holder only
+
+SourceFiles
+    cyclicACMIPointPatch.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef cyclicACMIPointPatch_H
+#define cyclicACMIPointPatch_H
+
+#include "coupledFacePointPatch.H"
+#include "cyclicACMIPolyPatch.H"
+#include "pointBoundaryMesh.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                    Class cyclicACMIPointPatch Declaration
+\*---------------------------------------------------------------------------*/
+
+class cyclicACMIPointPatch
+:
+    public coupledFacePointPatch
+{
+    // Private data
+
+        //- Local reference cast into the cyclic AMI patch
+        const cyclicACMIPolyPatch& cyclicACMIPolyPatch_;
+
+
+    // Private Member Functions
+
+        //- Disallow default construct as copy
+        cyclicACMIPointPatch(const cyclicACMIPointPatch&);
+
+        //- Disallow default assignment
+        void operator=(const cyclicACMIPointPatch&);
+
+
+protected:
+
+    // Protected Member Functions
+
+        //- Initialise the calculation of the patch geometry
+        virtual void initGeometry(PstreamBuffers&);
+
+        //- Calculate the patch geometry
+        virtual void calcGeometry(PstreamBuffers&);
+
+        //- Initialise the patches for moving points
+        virtual void initMovePoints(PstreamBuffers&, const pointField&);
+
+        //- Correct patches after moving points
+        virtual void movePoints(PstreamBuffers&, const pointField&);
+
+        //- Initialise the update of the patch topology
+        virtual void initUpdateMesh(PstreamBuffers&);
+
+        //- Update of the patch topology
+        virtual void updateMesh(PstreamBuffers&);
+
+
+public:
+
+    //- Runtime type information
+    TypeName(cyclicACMIPolyPatch::typeName_());
+
+
+    // Constructors
+
+        //- Construct from components
+        cyclicACMIPointPatch
+        (
+            const polyPatch& patch,
+            const pointBoundaryMesh& bm
+        );
+
+
+    //- Destructor
+    virtual ~cyclicACMIPointPatch();
+
+
+    // Member Functions
+
+        //- Is patch 'coupled'. Note that on AMI the geometry is not
+        //  coupled but the fields are!
+        virtual bool coupled() const
+        {
+            return false;
+        }
+
+        //- Return the constraint type this pointPatch implements.
+        virtual const word& constraintType() const
+        {
+            return type();
+        }
+
+        //- Return the underlying cyclicAMIPolyPatch
+        const cyclicACMIPolyPatch& cyclicACMIPatch() const
+        {
+            return cyclicACMIPolyPatch_;
+        }
+
+        //- Return neighbour point patch
+        const cyclicACMIPointPatch& neighbPatch() const
+        {
+            label patchI = cyclicACMIPolyPatch_.neighbPatchID();
+            const pointPatch& pp = this->boundaryMesh()[patchI];
+            return refCast<const cyclicACMIPointPatch>(pp);
+        }
+
+        //- Are the cyclic planes parallel
+        bool parallel() const
+        {
+            return cyclicACMIPolyPatch_.parallel();
+        }
+
+        //- Return face transformation tensor
+        const tensorField& forwardT() const
+        {
+            return cyclicACMIPolyPatch_.forwardT();
+        }
+
+        //- Return neighbour-cell transformation tensor
+        const tensorField& reverseT() const
+        {
+            return cyclicACMIPolyPatch_.reverseT();
+        }
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/meshTools/AMIInterpolation/patches/cyclicACMI/cyclicACMIPointPatchField/cyclicACMIPointPatchField.C b/src/meshTools/AMIInterpolation/patches/cyclicACMI/cyclicACMIPointPatchField/cyclicACMIPointPatchField.C
new file mode 100644
index 0000000000..cc15eaf02f
--- /dev/null
+++ b/src/meshTools/AMIInterpolation/patches/cyclicACMI/cyclicACMIPointPatchField/cyclicACMIPointPatchField.C
@@ -0,0 +1,210 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 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 "cyclicACMIPointPatchField.H"
+#include "Swap.H"
+#include "transformField.H"
+#include "pointFields.H"
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+template<class Type>
+Foam::cyclicACMIPointPatchField<Type>::cyclicACMIPointPatchField
+(
+    const pointPatch& p,
+    const DimensionedField<Type, pointMesh>& iF
+)
+:
+    coupledPointPatchField<Type>(p, iF),
+    cyclicACMIPatch_(refCast<const cyclicACMIPointPatch>(p)),
+    ppiPtr_(NULL),
+    nbrPpiPtr_(NULL)
+{}
+
+
+template<class Type>
+Foam::cyclicACMIPointPatchField<Type>::cyclicACMIPointPatchField
+(
+    const pointPatch& p,
+    const DimensionedField<Type, pointMesh>& iF,
+    const dictionary& dict
+)
+:
+    coupledPointPatchField<Type>(p, iF, dict),
+    cyclicACMIPatch_(refCast<const cyclicACMIPointPatch>(p)),
+    ppiPtr_(NULL),
+    nbrPpiPtr_(NULL)
+{
+    if (!isType<cyclicACMIPointPatch>(p))
+    {
+        FatalIOErrorIn
+        (
+            "cyclicACMIPointPatchField<Type>::cyclicACMIPointPatchField\n"
+            "(\n"
+            "    const pointPatch&,\n"
+            "    const DimensionedField<Type, pointMesh>&,\n"
+            "    const dictionary&\n"
+            ")\n",
+            dict
+        )   << "patch " << this->patch().index() << " not cyclicACMI type. "
+            << "Patch type = " << p.type()
+            << exit(FatalIOError);
+    }
+}
+
+
+template<class Type>
+Foam::cyclicACMIPointPatchField<Type>::cyclicACMIPointPatchField
+(
+    const cyclicACMIPointPatchField<Type>& ptf,
+    const pointPatch& p,
+    const DimensionedField<Type, pointMesh>& iF,
+    const pointPatchFieldMapper& mapper
+)
+:
+    coupledPointPatchField<Type>(ptf, p, iF, mapper),
+    cyclicACMIPatch_(refCast<const cyclicACMIPointPatch>(p)),
+    ppiPtr_(NULL),
+    nbrPpiPtr_(NULL)
+{
+    if (!isType<cyclicACMIPointPatch>(this->patch()))
+    {
+        FatalErrorIn
+        (
+            "cyclicACMIPointPatchField<Type>::cyclicACMIPointPatchField\n"
+            "(\n"
+            "    const cyclicACMIPointPatchField<Type>&,\n"
+            "    const pointPatch&,\n"
+            "    const DimensionedField<Type, pointMesh>&,\n"
+            "    const pointPatchFieldMapper&\n"
+            ")\n"
+        )   << "Field type does not correspond to patch type for patch "
+            << this->patch().index() << "." << endl
+            << "Field type: " << typeName << endl
+            << "Patch type: " << this->patch().type()
+            << exit(FatalError);
+    }
+}
+
+
+template<class Type>
+Foam::cyclicACMIPointPatchField<Type>::cyclicACMIPointPatchField
+(
+    const cyclicACMIPointPatchField<Type>& ptf,
+    const DimensionedField<Type, pointMesh>& iF
+)
+:
+    coupledPointPatchField<Type>(ptf, iF),
+    cyclicACMIPatch_(ptf.cyclicACMIPatch_),
+    ppiPtr_(NULL),
+    nbrPpiPtr_(NULL)
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+template<class Type>
+void Foam::cyclicACMIPointPatchField<Type>::swapAddSeparated
+(
+    const Pstream::commsTypes,
+    Field<Type>& pField
+) const
+{
+    if (cyclicACMIPatch_.cyclicACMIPatch().owner())
+    {
+        // We inplace modify pField. To prevent the other side (which gets
+        // evaluated at a later date) using already changed values we do
+        // all swaps on the side that gets evaluated first.
+
+        // Get neighbouring pointPatch
+        const cyclicACMIPointPatch& nbrPatch = cyclicACMIPatch_.neighbPatch();
+
+        // Get neighbouring pointPatchField
+        const GeometricField<Type, pointPatchField, pointMesh>& fld =
+            refCast<const GeometricField<Type, pointPatchField, pointMesh> >
+            (
+                this->dimensionedInternalField()
+            );
+
+        const cyclicACMIPointPatchField<Type>& nbr =
+            refCast<const cyclicACMIPointPatchField<Type> >
+            (
+                fld.boundaryField()[nbrPatch.index()]
+            );
+
+
+        Field<Type> ptFld(this->patchInternalField(pField));
+        Field<Type> nbrPtFld(nbr.patchInternalField(pField));
+
+
+        if (doTransform())
+        {
+            const tensor& forwardT = this->forwardT()[0];
+            const tensor& reverseT = this->reverseT()[0];
+
+            transform(ptFld, reverseT, ptFld);
+            transform(nbrPtFld, forwardT, nbrPtFld);
+        }
+
+        // convert point field to face field, AMI interpolate, then
+        // face back to point
+        {
+            // add neighbour side contribution to owner
+            Field<Type> nbrFcFld(nbrPpi().pointToFaceInterpolate(nbrPtFld));
+
+            const cyclicAMIPolyPatch& cami = cyclicACMIPatch_.cyclicACMIPatch();
+
+            // interpolate to owner
+            nbrFcFld = cami.interpolate(nbrFcFld);
+
+            // add to internal field
+            this->addToInternalField
+            (
+                pField,
+                ppi().faceToPointInterpolate(nbrFcFld)()
+            );
+        }
+
+        {
+            // add owner side contribution to neighbour
+            Field<Type> fcFld(ppi().pointToFaceInterpolate(ptFld));
+
+            const cyclicAMIPolyPatch& cami = cyclicACMIPatch_.cyclicACMIPatch();
+
+            // interpolate to neighbour
+            fcFld = cami.neighbPatch().cyclicAMIPolyPatch::interpolate(fcFld);
+
+            // add to internal field
+            nbr.addToInternalField
+            (
+                pField,
+                nbrPpi().faceToPointInterpolate(fcFld)()
+            );
+        }
+    }
+}
+
+
+// ************************************************************************* //
diff --git a/src/meshTools/AMIInterpolation/patches/cyclicACMI/cyclicACMIPointPatchField/cyclicACMIPointPatchField.H b/src/meshTools/AMIInterpolation/patches/cyclicACMI/cyclicACMIPointPatchField/cyclicACMIPointPatchField.H
new file mode 100644
index 0000000000..7d490280bf
--- /dev/null
+++ b/src/meshTools/AMIInterpolation/patches/cyclicACMI/cyclicACMIPointPatchField/cyclicACMIPointPatchField.H
@@ -0,0 +1,241 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 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::cyclicACMIPointPatchField
+
+Description
+    Cyclic ACMI front and back plane patch field
+
+SourceFiles
+    cyclicACMIPointPatchField.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef cyclicACMIPointPatchField_H
+#define cyclicACMIPointPatchField_H
+
+#include "coupledPointPatchField.H"
+#include "cyclicACMIPointPatch.H"
+#include "PrimitivePatchInterpolation.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                  Class cyclicACMIPointPatchField Declaration
+\*---------------------------------------------------------------------------*/
+
+template<class Type>
+class cyclicACMIPointPatchField
+:
+    public coupledPointPatchField<Type>
+{
+    // Private data
+
+        //- Local reference cast into the cyclicACMI patch
+        const cyclicACMIPointPatch& cyclicACMIPatch_;
+
+        //- Owner side patch interpolation pointer
+        mutable autoPtr<PrimitivePatchInterpolation<primitivePatch> > ppiPtr_;
+
+        //- Neighbour side patch interpolation pointer
+        mutable autoPtr<PrimitivePatchInterpolation<primitivePatch> >
+            nbrPpiPtr_;
+
+
+    // Private Member Functions
+
+        //- Owner side patch interpolation
+        const PrimitivePatchInterpolation<primitivePatch>& ppi() const
+        {
+            if (!ppiPtr_.valid())
+            {
+                ppiPtr_.reset
+                (
+                    new PrimitivePatchInterpolation<primitivePatch>
+                    (
+                        cyclicACMIPatch_.cyclicACMIPatch()
+                    )
+                );
+            }
+
+            return ppiPtr_();
+        }
+
+        //- Neighbour side patch interpolation
+        const PrimitivePatchInterpolation<primitivePatch>& nbrPpi() const
+        {
+            if (!nbrPpiPtr_.valid())
+            {
+                nbrPpiPtr_.reset
+                (
+                    new PrimitivePatchInterpolation<primitivePatch>
+                    (
+                        cyclicACMIPatch_.cyclicACMIPatch().neighbPatch()
+                    )
+                );
+            }
+
+            return nbrPpiPtr_();
+        }
+
+
+public:
+
+    //- Runtime type information
+    TypeName(cyclicACMIPointPatch::typeName_());
+
+
+    // Constructors
+
+        //- Construct from patch and internal field
+        cyclicACMIPointPatchField
+        (
+            const pointPatch&,
+            const DimensionedField<Type, pointMesh>&
+        );
+
+        //- Construct from patch, internal field and dictionary
+        cyclicACMIPointPatchField
+        (
+            const pointPatch&,
+            const DimensionedField<Type, pointMesh>&,
+            const dictionary&
+        );
+
+        //- Construct by mapping given patchField<Type> onto a new patch
+        cyclicACMIPointPatchField
+        (
+            const cyclicACMIPointPatchField<Type>&,
+            const pointPatch&,
+            const DimensionedField<Type, pointMesh>&,
+            const pointPatchFieldMapper&
+        );
+
+        //- Construct and return a clone
+        virtual autoPtr<pointPatchField<Type> > clone() const
+        {
+            return autoPtr<pointPatchField<Type> >
+            (
+                new cyclicACMIPointPatchField<Type>
+                (
+                    *this
+                )
+            );
+        }
+
+        //- Construct as copy setting internal field reference
+        cyclicACMIPointPatchField
+        (
+            const cyclicACMIPointPatchField<Type>&,
+            const DimensionedField<Type, pointMesh>&
+        );
+
+        //- Construct and return a clone setting internal field reference
+        virtual autoPtr<pointPatchField<Type> > clone
+        (
+            const DimensionedField<Type, pointMesh>& iF
+        ) const
+        {
+            return autoPtr<pointPatchField<Type> >
+            (
+                new cyclicACMIPointPatchField<Type>
+                (
+                    *this, iF
+                )
+            );
+        }
+
+
+    // Member functions
+
+        // Constraint handling
+
+            //- Return the constraint type this pointPatchField implements
+            virtual const word& constraintType() const
+            {
+                return cyclicACMIPointPatch::typeName;
+            }
+
+
+        // Cyclic AMI coupled interface functions
+
+            //- Does the patch field perform the transfromation
+            virtual bool doTransform() const
+            {
+                return
+                   !(
+                        cyclicACMIPatch_.parallel()
+                     || pTraits<Type>::rank == 0
+                    );
+            }
+
+            //- Return face transformation tensor
+            virtual const tensorField& forwardT() const
+            {
+                return cyclicACMIPatch_.forwardT();
+            }
+
+            //- Return neighbour-cell transformation tensor
+            virtual const tensorField& reverseT() const
+            {
+                return cyclicACMIPatch_.reverseT();
+            }
+
+
+        // Evaluation functions
+
+            //- Evaluate the patch field
+            virtual void evaluate
+            (
+                const Pstream::commsTypes commsType=Pstream::blocking
+            )
+            {}
+
+            //- Complete swap of patch point values and add to local values
+            virtual void swapAddSeparated
+            (
+                const Pstream::commsTypes commsType,
+                Field<Type>&
+            ) const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+#    include "cyclicACMIPointPatchField.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/meshTools/AMIInterpolation/patches/cyclicACMI/cyclicACMIPointPatchField/cyclicACMIPointPatchFields.C b/src/meshTools/AMIInterpolation/patches/cyclicACMI/cyclicACMIPointPatchField/cyclicACMIPointPatchFields.C
new file mode 100644
index 0000000000..e2d743bb4e
--- /dev/null
+++ b/src/meshTools/AMIInterpolation/patches/cyclicACMI/cyclicACMIPointPatchField/cyclicACMIPointPatchFields.C
@@ -0,0 +1,43 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 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 "cyclicACMIPointPatchFields.H"
+#include "pointPatchFields.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+makePointPatchFields(cyclicACMI);
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// ************************************************************************* //
diff --git a/src/meshTools/AMIInterpolation/patches/cyclicACMI/cyclicACMIPointPatchField/cyclicACMIPointPatchFields.H b/src/meshTools/AMIInterpolation/patches/cyclicACMI/cyclicACMIPointPatchField/cyclicACMIPointPatchFields.H
new file mode 100644
index 0000000000..e36f1ef9ed
--- /dev/null
+++ b/src/meshTools/AMIInterpolation/patches/cyclicACMI/cyclicACMIPointPatchField/cyclicACMIPointPatchFields.H
@@ -0,0 +1,49 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef cyclicACMIPointPatchFields_H
+#define cyclicACMIPointPatchFields_H
+
+#include "cyclicACMIPointPatchField.H"
+#include "fieldTypes.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+makePointPatchFieldTypedefs(cyclicACMI);
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/meshTools/AMIInterpolation/patches/cyclicACMI/cyclicACMIPolyPatch/cyclicACMIPolyPatch.C b/src/meshTools/AMIInterpolation/patches/cyclicACMI/cyclicACMIPolyPatch/cyclicACMIPolyPatch.C
new file mode 100644
index 0000000000..6e249d876f
--- /dev/null
+++ b/src/meshTools/AMIInterpolation/patches/cyclicACMI/cyclicACMIPolyPatch/cyclicACMIPolyPatch.C
@@ -0,0 +1,441 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 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 "cyclicACMIPolyPatch.H"
+#include "transformField.H"
+#include "SubField.H"
+#include "polyMesh.H"
+#include "Time.H"
+#include "faceAreaIntersect.H"
+#include "ops.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(cyclicACMIPolyPatch, 0);
+
+    addToRunTimeSelectionTable(polyPatch, cyclicACMIPolyPatch, word);
+    addToRunTimeSelectionTable(polyPatch, cyclicACMIPolyPatch, dictionary);
+}
+
+const Foam::scalar Foam::cyclicACMIPolyPatch::tolerance_ = 1e-6;
+
+// * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
+
+void Foam::cyclicACMIPolyPatch::initPatchFaceAreas() const
+{
+    if (!empty() && faceAreas0_.empty())
+    {
+        faceAreas0_ = faceAreas();
+    }
+
+    const cyclicACMIPolyPatch& nbrACMI =
+        refCast<const cyclicACMIPolyPatch>(this->neighbPatch());
+
+    if (!nbrACMI.empty() && nbrACMI.faceAreas0().empty())
+    {
+        nbrACMI.initPatchFaceAreas();
+    }
+}
+
+
+void Foam::cyclicACMIPolyPatch::resetAMI
+(
+    const AMIPatchToPatchInterpolation::interpolationMethod&
+) const
+{
+    if (owner())
+    {
+        const polyPatch& nonOverlapPatch = this->nonOverlapPatch();
+
+        initPatchFaceAreas();
+
+        // reset patch face areas based on original patch for AMI calculation
+        vectorField::subField Sf = faceAreas();
+        vectorField::subField noSf = nonOverlapPatch.faceAreas();
+
+        forAll(Sf, faceI)
+        {
+            Sf[faceI] = faceAreas0_[faceI];
+            noSf[faceI] = faceAreas0_[faceI];
+        }
+
+        // calculate the AMI using partial face-area-weighted
+        cyclicAMIPolyPatch::resetAMI
+        (
+            AMIPatchToPatchInterpolation::imPartialFaceAreaWeight
+        );
+
+        const scalarField& srcWeightSum = AMI().srcWeightsSum();
+
+        // set patch face areas based on sum of AMI weights per face
+        forAll(Sf, faceI)
+        {
+            scalar w = srcWeightSum[faceI];
+            w = min(1.0 - tolerance_, max(tolerance_, w));
+
+            Sf[faceI] *= w;
+            noSf[faceI] *= 1.0 - w;
+        }
+
+        setNeighbourFaceAreas();
+
+        // set the updated flag
+        updated_ = true;
+    }
+}
+
+
+void Foam::cyclicACMIPolyPatch::setNeighbourFaceAreas() const
+{
+    const cyclicACMIPolyPatch& cp =
+        refCast<const cyclicACMIPolyPatch>(this->neighbPatch());
+    const polyPatch& pp = cp.nonOverlapPatch();
+
+    const scalarField& tgtWeightSum = AMI().tgtWeightsSum();
+
+    const vectorField& faceAreas0 = cp.faceAreas0();
+
+    vectorField::subField Sf = cp.faceAreas();
+    vectorField::subField noSf = pp.faceAreas();
+
+    forAll(Sf, faceI)
+    {
+        scalar w = tgtWeightSum[faceI];
+        w = min(1.0 - tolerance_, max(tolerance_, w));
+
+        Sf[faceI] = w*faceAreas0[faceI];
+        noSf[faceI] = (1.0 - w)*faceAreas0[faceI];
+    }
+}
+
+
+void Foam::cyclicACMIPolyPatch::initGeometry(PstreamBuffers& pBufs)
+{
+    cyclicAMIPolyPatch::initGeometry(pBufs);
+}
+
+
+void Foam::cyclicACMIPolyPatch::calcGeometry(PstreamBuffers& pBufs)
+{
+    cyclicAMIPolyPatch::calcGeometry(pBufs);
+}
+
+
+void Foam::cyclicACMIPolyPatch::initMovePoints
+(
+    PstreamBuffers& pBufs,
+    const pointField& p
+)
+{
+    cyclicAMIPolyPatch::initMovePoints(pBufs, p);
+}
+
+
+void Foam::cyclicACMIPolyPatch::movePoints
+(
+    PstreamBuffers& pBufs,
+    const pointField& p
+)
+{
+    cyclicAMIPolyPatch::movePoints(pBufs, p);
+}
+
+
+void Foam::cyclicACMIPolyPatch::initUpdateMesh(PstreamBuffers& pBufs)
+{
+    cyclicAMIPolyPatch::initUpdateMesh(pBufs);
+}
+
+
+void Foam::cyclicACMIPolyPatch::updateMesh(PstreamBuffers& pBufs)
+{
+    cyclicAMIPolyPatch::updateMesh(pBufs);
+}
+
+
+void Foam::cyclicACMIPolyPatch::clearGeom()
+{
+    cyclicAMIPolyPatch::clearGeom();
+}
+
+
+// * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * * * //
+
+Foam::cyclicACMIPolyPatch::cyclicACMIPolyPatch
+(
+    const word& name,
+    const label size,
+    const label start,
+    const label index,
+    const polyBoundaryMesh& bm,
+    const word& patchType,
+    const transformType transform
+)
+:
+    cyclicAMIPolyPatch(name, size, start, index, bm, patchType, transform),
+    faceAreas0_(),
+    nonOverlapPatchName_(word::null),
+    nonOverlapPatchID_(-1),
+    updated_(false)
+{
+    // Non-overlapping patch might not be valid yet so cannot determine
+    // associated patchID
+}
+
+
+Foam::cyclicACMIPolyPatch::cyclicACMIPolyPatch
+(
+    const word& name,
+    const dictionary& dict,
+    const label index,
+    const polyBoundaryMesh& bm,
+    const word& patchType
+)
+:
+    cyclicAMIPolyPatch(name, dict, index, bm, patchType),
+    faceAreas0_(),
+    nonOverlapPatchName_(dict.lookup("nonOverlapPatch")),
+    nonOverlapPatchID_(-1),
+    updated_(false)
+{
+    if (nonOverlapPatchName_ == name)
+    {
+        FatalIOErrorIn
+        (
+            "cyclicACMIPolyPatch::cyclicACMIPolyPatch"
+            "("
+                "const word&, "
+                "const dictionary&, "
+                "const label, "
+                "const polyBoundaryMesh&, "
+                "const word&"
+            ")",
+            dict
+        )   << "Non-overlapping patch name " << nonOverlapPatchName_
+            << " cannot be the same as this patch " << name
+            << exit(FatalIOError);
+    }
+
+    // Non-overlapping patch might not be valid yet so cannot determine
+    // associated patchID
+}
+
+
+Foam::cyclicACMIPolyPatch::cyclicACMIPolyPatch
+(
+    const cyclicACMIPolyPatch& pp,
+    const polyBoundaryMesh& bm
+)
+:
+    cyclicAMIPolyPatch(pp, bm),
+    faceAreas0_(),
+    nonOverlapPatchName_(pp.nonOverlapPatchName_),
+    nonOverlapPatchID_(-1),
+    updated_(false)
+{
+    // Non-overlapping patch might not be valid yet so cannot determine
+    // associated patchID
+}
+
+
+Foam::cyclicACMIPolyPatch::cyclicACMIPolyPatch
+(
+    const cyclicACMIPolyPatch& pp,
+    const polyBoundaryMesh& bm,
+    const label index,
+    const label newSize,
+    const label newStart,
+    const word& nbrPatchName,
+    const word& nonOverlapPatchName
+)
+:
+    cyclicAMIPolyPatch(pp, bm, index, newSize, newStart, nbrPatchName),
+    faceAreas0_(),
+    nonOverlapPatchName_(nonOverlapPatchName),
+    nonOverlapPatchID_(-1),
+    updated_(false)
+{
+    if (nonOverlapPatchName_ == name())
+    {
+        FatalErrorIn
+        (
+            "const cyclicACMIPolyPatch& "
+            "const polyBoundaryMesh&, "
+            "const label, "
+            "const label, "
+            "const label, "
+            "const word&, "
+            "const word&"
+        )   << "Non-overlapping patch name " << nonOverlapPatchName_
+            << " cannot be the same as this patch " << name()
+            << exit(FatalError);
+    }
+
+    // Non-overlapping patch might not be valid yet so cannot determine
+    // associated patchID
+}
+
+
+Foam::cyclicACMIPolyPatch::cyclicACMIPolyPatch
+(
+    const cyclicACMIPolyPatch& pp,
+    const polyBoundaryMesh& bm,
+    const label index,
+    const labelUList& mapAddressing,
+    const label newStart
+)
+:
+    cyclicAMIPolyPatch(pp, bm, index, mapAddressing, newStart),
+    faceAreas0_(),
+    nonOverlapPatchName_(pp.nonOverlapPatchName_),
+    nonOverlapPatchID_(-1),
+    updated_(false)
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::cyclicACMIPolyPatch::~cyclicACMIPolyPatch()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+Foam::label Foam::cyclicACMIPolyPatch::nonOverlapPatchID() const
+{
+    if (nonOverlapPatchID_ == -1)
+    {
+        nonOverlapPatchID_ =
+            this->boundaryMesh().findPatchID(nonOverlapPatchName_);
+
+        if (nonOverlapPatchID_ == -1)
+        {
+            FatalErrorIn("cyclicPolyAMIPatch::neighbPatchID() const")
+                << "Illegal non-overlapping patch name " << nonOverlapPatchName_
+                << nl << "Valid patch names are "
+                << this->boundaryMesh().names()
+                << exit(FatalError);
+        }
+
+        const polyPatch& noPp = this->boundaryMesh()[nonOverlapPatchID_];
+
+        bool ok = true;
+
+        if (size() == noPp.size())
+        {
+            const scalarField magSf(mag(faceAreas()));
+            const scalarField noMagSf(mag(noPp.faceAreas()));
+
+            forAll(magSf, faceI)
+            {
+                scalar ratio = mag(magSf[faceI]/(noMagSf[faceI] + ROOTVSMALL));
+
+                if (ratio - 1 > tolerance_)
+                {
+                    ok = false;
+                    break;
+                }
+            }
+        }
+        else
+        {
+            ok = false;
+        }
+
+        if (!ok)
+        {
+            FatalErrorIn
+            (
+                "Foam::label "
+                "Foam::cyclicACMIPolyPatch::nonOverlapPatchID() const"
+            )   << "Inconsistent ACMI patches " << name() << " and "
+                << noPp.name() << ".  Patches should have identical topology"
+                << exit(FatalError);
+        }
+    }
+
+    return nonOverlapPatchID_;
+}
+
+
+void Foam::cyclicACMIPolyPatch::calcGeometry
+(
+    const primitivePatch& referPatch,
+    const pointField& thisCtrs,
+    const vectorField& thisAreas,
+    const pointField& thisCc,
+    const pointField& nbrCtrs,
+    const vectorField& nbrAreas,
+    const pointField& nbrCc
+)
+{
+    cyclicAMIPolyPatch::calcGeometry
+    (
+        referPatch,
+        thisCtrs,
+        thisAreas,
+        thisCc,
+        nbrCtrs,
+        nbrAreas,
+        nbrCc
+    );
+}
+
+
+void Foam::cyclicACMIPolyPatch::initOrder
+(
+    PstreamBuffers& pBufs,
+    const primitivePatch& pp
+) const
+{
+    cyclicAMIPolyPatch::initOrder(pBufs, pp);
+}
+
+
+bool Foam::cyclicACMIPolyPatch::order
+(
+    PstreamBuffers& pBufs,
+    const primitivePatch& pp,
+    labelList& faceMap,
+    labelList& rotation
+) const
+{
+    return cyclicAMIPolyPatch::order(pBufs, pp, faceMap, rotation);
+}
+
+
+void Foam::cyclicACMIPolyPatch::write(Ostream& os) const
+{
+    cyclicAMIPolyPatch::write(os);
+
+    os.writeKeyword("nonOverlapPatch") << nonOverlapPatchName_
+        << token::END_STATEMENT << nl;
+}
+
+
+// ************************************************************************* //
diff --git a/src/meshTools/AMIInterpolation/patches/cyclicACMI/cyclicACMIPolyPatch/cyclicACMIPolyPatch.H b/src/meshTools/AMIInterpolation/patches/cyclicACMI/cyclicACMIPolyPatch/cyclicACMIPolyPatch.H
new file mode 100644
index 0000000000..b092c14f04
--- /dev/null
+++ b/src/meshTools/AMIInterpolation/patches/cyclicACMI/cyclicACMIPolyPatch/cyclicACMIPolyPatch.H
@@ -0,0 +1,349 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 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::cyclicACMIPolyPatch
+
+Description
+    Cyclic patch for Arbitrarily Coupled Mesh Interface (ACMI)
+
+SourceFiles
+    cyclicACMIPolyPatch.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef cyclicACMIPolyPatch_H
+#define cyclicACMIPolyPatch_H
+
+#include "cyclicAMIPolyPatch.H"
+#include "AMIPatchToPatchInterpolation.H"
+#include "polyBoundaryMesh.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                     Class cyclicACMIPolyPatch Declaration
+\*---------------------------------------------------------------------------*/
+
+class cyclicACMIPolyPatch
+:
+    public cyclicAMIPolyPatch
+{
+
+private:
+
+    // Private data
+
+        //- Copy of the original patch face areas
+        mutable vectorField faceAreas0_;
+
+        //- Name of non-overlapping patch
+        const word nonOverlapPatchName_;
+
+        //- Index of non-overlapping patch
+        mutable label nonOverlapPatchID_;
+
+        //- Flag to indicate that AMI has been updated
+        mutable bool updated_;
+
+
+protected:
+
+        static const scalar tolerance_;
+
+
+    // Protected Member Functions
+
+        //- Initialise patch face areas
+        virtual void initPatchFaceAreas() const;
+
+        //- Reset the AMI interpolator
+        virtual void resetAMI
+        (
+            const AMIPatchToPatchInterpolation::interpolationMethod& AMIMethod =
+                AMIPatchToPatchInterpolation::imFaceAreaWeight
+        ) const;
+
+        //- Set neighbour ACMI patch areas
+        virtual void setNeighbourFaceAreas() const;
+
+        //- Initialise the calculation of the patch geometry
+        virtual void initGeometry(PstreamBuffers&);
+
+        //- Calculate the patch geometry
+        virtual void calcGeometry(PstreamBuffers&);
+
+        //- Initialise the patches for moving points
+        virtual void initMovePoints(PstreamBuffers& pBufs, const pointField&);
+
+        //- Correct patches after moving points
+        virtual void movePoints(PstreamBuffers& pBufs, const pointField&);
+
+        //- Initialise the update of the patch topology
+        virtual void initUpdateMesh(PstreamBuffers&);
+
+        //- Update of the patch topology
+        virtual void updateMesh(PstreamBuffers&);
+
+        //- Clear geometry
+        virtual void clearGeom();
+
+
+public:
+
+    //- Runtime type information
+    TypeName("cyclicACMI");
+
+
+    // Constructors
+
+        //- Construct from (base couped patch) components
+        cyclicACMIPolyPatch
+        (
+            const word& name,
+            const label size,
+            const label start,
+            const label index,
+            const polyBoundaryMesh& bm,
+            const word& patchType,
+            const transformType transform = UNKNOWN
+        );
+
+        //- Construct from dictionary
+        cyclicACMIPolyPatch
+        (
+            const word& name,
+            const dictionary& dict,
+            const label index,
+            const polyBoundaryMesh& bm,
+            const word& patchType
+        );
+
+        //- Construct as copy, resetting the boundary mesh
+        cyclicACMIPolyPatch
+        (
+            const cyclicACMIPolyPatch&,
+            const polyBoundaryMesh&
+        );
+
+        //- Construct given the original patch and resetting the
+        //  face list and boundary mesh information
+        cyclicACMIPolyPatch
+        (
+            const cyclicACMIPolyPatch& pp,
+            const polyBoundaryMesh& bm,
+            const label index,
+            const label newSize,
+            const label newStart,
+            const word& nbrPatchName,
+            const word& nonOverlapPatchName
+        );
+
+        //- Construct given the original patch and a map
+        cyclicACMIPolyPatch
+        (
+            const cyclicACMIPolyPatch& pp,
+            const polyBoundaryMesh& bm,
+            const label index,
+            const labelUList& mapAddressing,
+            const label newStart
+        );
+
+
+        //- Construct and return a clone, resetting the boundary mesh
+        virtual autoPtr<polyPatch> clone(const polyBoundaryMesh& bm) const
+        {
+            return autoPtr<polyPatch>(new cyclicACMIPolyPatch(*this, bm));
+        }
+
+        //- Construct and return a clone, resetting the face list
+        //  and boundary mesh
+        virtual autoPtr<polyPatch> clone
+        (
+            const polyBoundaryMesh& bm,
+            const label index,
+            const label newSize,
+            const label newStart
+        ) const
+        {
+            return autoPtr<polyPatch>
+            (
+                new cyclicACMIPolyPatch
+                (
+                    *this,
+                    bm,
+                    index,
+                    newSize,
+                    newStart,
+                    neighbPatchName(),
+                    nonOverlapPatchName_
+                )
+            );
+        }
+
+        //- Construct and return a clone, resetting the face list
+        //  and boundary mesh
+        virtual autoPtr<polyPatch> clone
+        (
+            const polyBoundaryMesh& bm,
+            const label index,
+            const labelUList& mapAddressing,
+            const label newStart
+        ) const
+        {
+            return autoPtr<polyPatch>
+            (
+                new cyclicACMIPolyPatch
+                (
+                    *this,
+                    bm,
+                    index,
+                    mapAddressing,
+                    newStart
+                )
+            );
+        }
+
+
+    //- Destructor
+    virtual ~cyclicACMIPolyPatch();
+
+
+    // Member Functions
+
+        // Access
+
+            //- Reset the updated flag
+            inline void setUpdated(bool flag) const;
+
+            //- Return access to the updated flag
+            inline bool updated() const;
+
+            //- Return access to the original patch face areas
+            inline const vectorField& faceAreas0() const;
+
+            //- Non-overlapping patch name
+            inline const word& nonOverlapPatchName() const;
+
+            //- Non-overlapping patch ID
+            virtual label nonOverlapPatchID() const;
+
+            //- Return a const reference to the non-overlapping patch
+            inline const polyPatch& nonOverlapPatch() const;
+
+            //- Return a reference to the non-overlapping patch
+            inline polyPatch& nonOverlapPatch();
+
+            //- Mask field where 1 = overlap, 0 = no-overlap
+            inline const scalarField& mask() const;
+
+
+            // Interpolations
+
+                //- Interpolate field
+                template<class Type>
+                tmp<Field<Type> > interpolate
+                (
+                    const Field<Type>& fldCouple,
+                    const Field<Type>& fldNonOverlap
+                ) const;
+
+                //- Interpolate tmp field
+                template<class Type>
+                tmp<Field<Type> > interpolate
+                (
+                    const tmp<Field<Type> >& tFldCouple,
+                    const tmp<Field<Type> >& tFldNonOverlap
+                ) const;
+
+                //- Low-level interpolate List
+                template<class Type, class CombineOp>
+                void interpolate
+                (
+                    const UList<Type>& fldCouple,
+                    const UList<Type>& fldNonOverlap,
+                    const CombineOp& cop,
+                    List<Type>& result
+                ) const;
+
+
+        //- Calculate the patch geometry
+        virtual void calcGeometry
+        (
+            const primitivePatch& referPatch,
+            const pointField& thisCtrs,
+            const vectorField& thisAreas,
+            const pointField& thisCc,
+            const pointField& nbrCtrs,
+            const vectorField& nbrAreas,
+            const pointField& nbrCc
+        );
+
+        //- Initialize ordering for primitivePatch. Does not
+        //  refer to *this (except for name() and type() etc.)
+        virtual void initOrder
+        (
+            PstreamBuffers&,
+            const primitivePatch&
+        ) const;
+
+        //- Return new ordering for primitivePatch.
+        //  Ordering is -faceMap: for every face
+        //  index of the new face -rotation:for every new face the clockwise
+        //  shift of the original face. Return false if nothing changes
+        //  (faceMap is identity, rotation is 0), true otherwise.
+        virtual bool order
+        (
+            PstreamBuffers&,
+            const primitivePatch&,
+            labelList& faceMap,
+            labelList& rotation
+        ) const;
+
+        //- Write the polyPatch data as a dictionary
+        virtual void write(Ostream&) const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#include "cyclicACMIPolyPatchI.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+    #include "cyclicACMIPolyPatchTemplates.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/meshTools/AMIInterpolation/patches/cyclicACMI/cyclicACMIPolyPatch/cyclicACMIPolyPatchI.H b/src/meshTools/AMIInterpolation/patches/cyclicACMI/cyclicACMIPolyPatch/cyclicACMIPolyPatchI.H
new file mode 100644
index 0000000000..a245f779c0
--- /dev/null
+++ b/src/meshTools/AMIInterpolation/patches/cyclicACMI/cyclicACMIPolyPatch/cyclicACMIPolyPatchI.H
@@ -0,0 +1,83 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+inline void Foam::cyclicACMIPolyPatch::setUpdated(const bool flag) const
+{
+    updated_ = flag;
+}
+
+
+inline bool Foam::cyclicACMIPolyPatch::updated() const
+{
+    return updated_;
+}
+
+
+inline const Foam::vectorField& Foam::cyclicACMIPolyPatch::faceAreas0() const
+{
+    return faceAreas0_;
+}
+
+
+inline const Foam::word& Foam::cyclicACMIPolyPatch::nonOverlapPatchName() const
+{
+    return nonOverlapPatchName_;
+}
+
+
+inline const Foam::polyPatch& Foam::cyclicACMIPolyPatch::nonOverlapPatch() const
+{
+    // note: use nonOverlapPatchID() as opposed to patch name to initialise
+    // demand-driven data
+
+    return this->boundaryMesh()[nonOverlapPatchID()];
+}
+
+
+inline Foam::polyPatch& Foam::cyclicACMIPolyPatch::nonOverlapPatch()
+{
+    // note: use nonOverlapPatchID() as opposed to patch name to initialise
+    // demand-driven data
+
+    return const_cast<polyPatch&>(this->boundaryMesh()[nonOverlapPatchID()]);
+}
+
+
+inline const Foam::scalarField& Foam::cyclicACMIPolyPatch::mask() const
+{
+    if (owner())
+    {
+        return AMI().srcWeightsSum();
+    }
+    else
+    {
+        return neighbPatch().AMI().tgtWeightsSum();
+    }
+}
+
+
+// ************************************************************************* //
diff --git a/src/meshTools/AMIInterpolation/patches/cyclicACMI/cyclicACMIPolyPatch/cyclicACMIPolyPatchTemplates.C b/src/meshTools/AMIInterpolation/patches/cyclicACMI/cyclicACMIPolyPatch/cyclicACMIPolyPatchTemplates.C
new file mode 100644
index 0000000000..127085ac44
--- /dev/null
+++ b/src/meshTools/AMIInterpolation/patches/cyclicACMI/cyclicACMIPolyPatch/cyclicACMIPolyPatchTemplates.C
@@ -0,0 +1,91 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+template<class Type>
+Foam::tmp<Foam::Field<Type> > Foam::cyclicACMIPolyPatch::interpolate
+(
+    const Field<Type>& fldCouple,
+    const Field<Type>& fldNonOverlap
+) const
+{
+    if (owner())
+    {
+        const scalarField& w = AMI().srcWeightsSum();
+
+        return
+            w*AMI().interpolateToSource(fldCouple)
+          + (1.0 - w)*fldNonOverlap;
+    }
+    else
+    {
+        const scalarField& w = neighbPatch().AMI().tgtWeightsSum();
+
+        return
+            w*neighbPatch().AMI().interpolateToTarget(fldCouple)
+          + (1.0 - w)*fldNonOverlap;
+    }
+}
+
+
+template<class Type>
+Foam::tmp<Foam::Field<Type> > Foam::cyclicACMIPolyPatch::interpolate
+(
+    const tmp<Field<Type> >& tFldCouple,
+    const tmp<Field<Type> >& tFldNonOverlap
+) const
+{
+    return interpolate(tFldCouple(), tFldNonOverlap());
+}
+
+
+template<class Type, class CombineOp>
+void Foam::cyclicACMIPolyPatch::interpolate
+(
+    const UList<Type>& fldCouple,
+    const UList<Type>& fldNonOverlap,
+    const CombineOp& cop,
+    List<Type>& result
+) const
+{
+    if (owner())
+    {
+        const scalarField& w = AMI().srcWeightsSum();
+
+        AMI().interpolateToSource(fldCouple, cop, result);
+        result = w*result + (1.0 - w)*fldNonOverlap;
+    }
+    else
+    {
+        const scalarField& w = neighbPatch().AMI().tgtWeightsSum();
+
+        neighbPatch().AMI().interpolateToTarget(fldCouple, cop, result);
+        result = w*result + (1.0 - w)*fldNonOverlap;
+    }
+}
+
+
+// ************************************************************************* //
diff --git a/src/meshTools/AMIInterpolation/patches/cyclic/cyclicAMILduInterfaceField/cyclicAMILduInterface.C b/src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMILduInterfaceField/cyclicAMILduInterface.C
similarity index 95%
rename from src/meshTools/AMIInterpolation/patches/cyclic/cyclicAMILduInterfaceField/cyclicAMILduInterface.C
rename to src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMILduInterfaceField/cyclicAMILduInterface.C
index 863013080f..19afeced63 100644
--- a/src/meshTools/AMIInterpolation/patches/cyclic/cyclicAMILduInterfaceField/cyclicAMILduInterface.C
+++ b/src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMILduInterfaceField/cyclicAMILduInterface.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
diff --git a/src/meshTools/AMIInterpolation/patches/cyclic/cyclicAMILduInterfaceField/cyclicAMILduInterface.H b/src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMILduInterfaceField/cyclicAMILduInterface.H
similarity index 97%
rename from src/meshTools/AMIInterpolation/patches/cyclic/cyclicAMILduInterfaceField/cyclicAMILduInterface.H
rename to src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMILduInterfaceField/cyclicAMILduInterface.H
index 0bcbf3a4ef..55ecbf5514 100644
--- a/src/meshTools/AMIInterpolation/patches/cyclic/cyclicAMILduInterfaceField/cyclicAMILduInterface.H
+++ b/src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMILduInterfaceField/cyclicAMILduInterface.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
diff --git a/src/meshTools/AMIInterpolation/patches/cyclic/cyclicAMILduInterfaceField/cyclicAMILduInterfaceField.C b/src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMILduInterfaceField/cyclicAMILduInterfaceField.C
similarity index 96%
rename from src/meshTools/AMIInterpolation/patches/cyclic/cyclicAMILduInterfaceField/cyclicAMILduInterfaceField.C
rename to src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMILduInterfaceField/cyclicAMILduInterfaceField.C
index 0752825b56..d3b5a52b6b 100644
--- a/src/meshTools/AMIInterpolation/patches/cyclic/cyclicAMILduInterfaceField/cyclicAMILduInterfaceField.C
+++ b/src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMILduInterfaceField/cyclicAMILduInterfaceField.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
diff --git a/src/meshTools/AMIInterpolation/patches/cyclic/cyclicAMILduInterfaceField/cyclicAMILduInterfaceField.H b/src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMILduInterfaceField/cyclicAMILduInterfaceField.H
similarity index 98%
rename from src/meshTools/AMIInterpolation/patches/cyclic/cyclicAMILduInterfaceField/cyclicAMILduInterfaceField.H
rename to src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMILduInterfaceField/cyclicAMILduInterfaceField.H
index 533437df08..ad0a4e66ac 100644
--- a/src/meshTools/AMIInterpolation/patches/cyclic/cyclicAMILduInterfaceField/cyclicAMILduInterfaceField.H
+++ b/src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMILduInterfaceField/cyclicAMILduInterfaceField.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
diff --git a/src/meshTools/AMIInterpolation/patches/cyclic/cyclicAMIPointPatch/cyclicAMIPointPatch.C b/src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMIPointPatch/cyclicAMIPointPatch.C
similarity index 97%
rename from src/meshTools/AMIInterpolation/patches/cyclic/cyclicAMIPointPatch/cyclicAMIPointPatch.C
rename to src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMIPointPatch/cyclicAMIPointPatch.C
index fec146018d..2b4e6b8ad3 100644
--- a/src/meshTools/AMIInterpolation/patches/cyclic/cyclicAMIPointPatch/cyclicAMIPointPatch.C
+++ b/src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMIPointPatch/cyclicAMIPointPatch.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
diff --git a/src/meshTools/AMIInterpolation/patches/cyclic/cyclicAMIPointPatch/cyclicAMIPointPatch.H b/src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMIPointPatch/cyclicAMIPointPatch.H
similarity index 98%
rename from src/meshTools/AMIInterpolation/patches/cyclic/cyclicAMIPointPatch/cyclicAMIPointPatch.H
rename to src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMIPointPatch/cyclicAMIPointPatch.H
index 477892745e..3cbe4c29f6 100644
--- a/src/meshTools/AMIInterpolation/patches/cyclic/cyclicAMIPointPatch/cyclicAMIPointPatch.H
+++ b/src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMIPointPatch/cyclicAMIPointPatch.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
diff --git a/src/meshTools/AMIInterpolation/patches/cyclic/cyclicAMIPointPatchField/cyclicAMIPointPatchField.C b/src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMIPointPatchField/cyclicAMIPointPatchField.C
similarity index 98%
rename from src/meshTools/AMIInterpolation/patches/cyclic/cyclicAMIPointPatchField/cyclicAMIPointPatchField.C
rename to src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMIPointPatchField/cyclicAMIPointPatchField.C
index 8aa29db5cb..1bf86bea35 100644
--- a/src/meshTools/AMIInterpolation/patches/cyclic/cyclicAMIPointPatchField/cyclicAMIPointPatchField.C
+++ b/src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMIPointPatchField/cyclicAMIPointPatchField.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
diff --git a/src/meshTools/AMIInterpolation/patches/cyclic/cyclicAMIPointPatchField/cyclicAMIPointPatchField.H b/src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMIPointPatchField/cyclicAMIPointPatchField.H
similarity index 98%
rename from src/meshTools/AMIInterpolation/patches/cyclic/cyclicAMIPointPatchField/cyclicAMIPointPatchField.H
rename to src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMIPointPatchField/cyclicAMIPointPatchField.H
index 845ecb46a2..e9f9212eab 100644
--- a/src/meshTools/AMIInterpolation/patches/cyclic/cyclicAMIPointPatchField/cyclicAMIPointPatchField.H
+++ b/src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMIPointPatchField/cyclicAMIPointPatchField.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
diff --git a/src/meshTools/AMIInterpolation/patches/cyclic/cyclicAMIPointPatchField/cyclicAMIPointPatchFields.C b/src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMIPointPatchField/cyclicAMIPointPatchFields.C
similarity index 95%
rename from src/meshTools/AMIInterpolation/patches/cyclic/cyclicAMIPointPatchField/cyclicAMIPointPatchFields.C
rename to src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMIPointPatchField/cyclicAMIPointPatchFields.C
index 56e1aef405..889d4f73a3 100644
--- a/src/meshTools/AMIInterpolation/patches/cyclic/cyclicAMIPointPatchField/cyclicAMIPointPatchFields.C
+++ b/src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMIPointPatchField/cyclicAMIPointPatchFields.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
diff --git a/src/meshTools/AMIInterpolation/patches/cyclic/cyclicAMIPointPatchField/cyclicAMIPointPatchFields.H b/src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMIPointPatchField/cyclicAMIPointPatchFields.H
similarity index 95%
rename from src/meshTools/AMIInterpolation/patches/cyclic/cyclicAMIPointPatchField/cyclicAMIPointPatchFields.H
rename to src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMIPointPatchField/cyclicAMIPointPatchFields.H
index 0fb94a64c7..e85dfa4d3d 100644
--- a/src/meshTools/AMIInterpolation/patches/cyclic/cyclicAMIPointPatchField/cyclicAMIPointPatchFields.H
+++ b/src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMIPointPatchField/cyclicAMIPointPatchFields.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
diff --git a/src/meshTools/AMIInterpolation/patches/cyclic/cyclicAMIPolyPatch/cyclicAMIPolyPatch.C b/src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMIPolyPatch/cyclicAMIPolyPatch.C
similarity index 99%
rename from src/meshTools/AMIInterpolation/patches/cyclic/cyclicAMIPolyPatch/cyclicAMIPolyPatch.C
rename to src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMIPolyPatch/cyclicAMIPolyPatch.C
index 0458dad9de..6632fdb6d2 100644
--- a/src/meshTools/AMIInterpolation/patches/cyclic/cyclicAMIPolyPatch/cyclicAMIPolyPatch.C
+++ b/src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMIPolyPatch/cyclicAMIPolyPatch.C
@@ -232,7 +232,12 @@ void Foam::cyclicAMIPolyPatch::calcTransforms
 }
 
 
-void Foam::cyclicAMIPolyPatch::resetAMI() const
+// * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
+
+void Foam::cyclicAMIPolyPatch::resetAMI
+(
+    const AMIPatchToPatchInterpolation::interpolationMethod& AMIMethod
+) const
 {
     if (owner())
     {
@@ -283,7 +288,7 @@ void Foam::cyclicAMIPolyPatch::resetAMI() const
                 nbrPatch0,
                 surfPtr(),
                 faceAreaIntersect::tmMesh,
-                AMIPatchToPatchInterpolation::imFaceAreaWeight,
+                AMIMethod,
                 AMIReverse_
             )
         );
@@ -301,8 +306,6 @@ void Foam::cyclicAMIPolyPatch::resetAMI() const
 }
 
 
-// * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
-
 void Foam::cyclicAMIPolyPatch::initGeometry(PstreamBuffers& pBufs)
 {
     polyPatch::initGeometry(pBufs);
diff --git a/src/meshTools/AMIInterpolation/patches/cyclic/cyclicAMIPolyPatch/cyclicAMIPolyPatch.H b/src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMIPolyPatch/cyclicAMIPolyPatch.H
similarity index 97%
rename from src/meshTools/AMIInterpolation/patches/cyclic/cyclicAMIPolyPatch/cyclicAMIPolyPatch.H
rename to src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMIPolyPatch/cyclicAMIPolyPatch.H
index 45aef51952..51a9c1dc0d 100644
--- a/src/meshTools/AMIInterpolation/patches/cyclic/cyclicAMIPolyPatch/cyclicAMIPolyPatch.H
+++ b/src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMIPolyPatch/cyclicAMIPolyPatch.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -108,14 +108,18 @@ private:
             const vectorField& half1Areas
         );
 
-        //- Reset the AMI interpolator
-        void resetAMI() const;
-
 
 protected:
 
     // Protected Member Functions
 
+        //- Reset the AMI interpolator
+        virtual void resetAMI
+        (
+            const AMIPatchToPatchInterpolation::interpolationMethod& AMIMethod =
+                AMIPatchToPatchInterpolation::imFaceAreaWeight
+        ) const;
+
         //- Recalculate the transformation tensors
         virtual void calcTransforms();
 
diff --git a/src/meshTools/AMIInterpolation/patches/cyclic/cyclicAMIPolyPatch/cyclicAMIPolyPatchI.H b/src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMIPolyPatch/cyclicAMIPolyPatchI.H
similarity index 96%
rename from src/meshTools/AMIInterpolation/patches/cyclic/cyclicAMIPolyPatch/cyclicAMIPolyPatchI.H
rename to src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMIPolyPatch/cyclicAMIPolyPatchI.H
index 6d726e9df7..66a273e0c7 100644
--- a/src/meshTools/AMIInterpolation/patches/cyclic/cyclicAMIPolyPatch/cyclicAMIPolyPatchI.H
+++ b/src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMIPolyPatch/cyclicAMIPolyPatchI.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
diff --git a/src/meshTools/AMIInterpolation/patches/cyclic/cyclicAMIPolyPatch/cyclicAMIPolyPatchTemplates.C b/src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMIPolyPatch/cyclicAMIPolyPatchTemplates.C
similarity index 97%
rename from src/meshTools/AMIInterpolation/patches/cyclic/cyclicAMIPolyPatch/cyclicAMIPolyPatchTemplates.C
rename to src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMIPolyPatch/cyclicAMIPolyPatchTemplates.C
index bf4507ff8e..3c5fc6e027 100644
--- a/src/meshTools/AMIInterpolation/patches/cyclic/cyclicAMIPolyPatch/cyclicAMIPolyPatchTemplates.C
+++ b/src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMIPolyPatch/cyclicAMIPolyPatchTemplates.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
diff --git a/src/meshTools/Make/files b/src/meshTools/Make/files
index 91bbbc11fd..ab78000ffc 100644
--- a/src/meshTools/Make/files
+++ b/src/meshTools/Make/files
@@ -43,6 +43,9 @@ patchWave = $(algorithms)/PatchEdgeFaceWave
 $(patchWave)/PatchEdgeFaceWaveName.C
 $(patchWave)/patchEdgeFaceInfo.C
 $(patchWave)/patchPatchDist.C
+$(patchWave)/patchEdgeFaceRegion.C
+$(patchWave)/patchEdgeFaceRegions.C
+
 
 meshWave = $(algorithms)/MeshWave
 $(meshWave)/MeshWaveName.C
@@ -113,7 +116,6 @@ $(faceSources)/boundaryToFace/boundaryToFace.C
 $(faceSources)/zoneToFace/zoneToFace.C
 $(faceSources)/boxToFace/boxToFace.C
 $(faceSources)/regionToFace/regionToFace.C
-$(faceSources)/regionToFace/patchEdgeFaceRegion.C
 
 pointSources = sets/pointSources
 $(pointSources)/labelToPoint/labelToPoint.C
@@ -175,14 +177,23 @@ $(AMI)/AMIInterpolation/AMIPatchToPatchInterpolation.C
 $(AMI)/faceAreaIntersect/faceAreaIntersect.C
 $(AMI)/GAMG/interfaces/cyclicAMIGAMGInterface/cyclicAMIGAMGInterface.C
 $(AMI)/GAMG/interfaceFields/cyclicAMIGAMGInterfaceField/cyclicAMIGAMGInterfaceField.C
+$(AMI)/GAMG/interfaces/cyclicACMIGAMGInterface/cyclicACMIGAMGInterface.C
+$(AMI)/GAMG/interfaceFields/cyclicACMIGAMGInterfaceField/cyclicACMIGAMGInterfaceField.C
 
-AMICycPatches=$(AMI)/patches/cyclic
+AMICycPatches=$(AMI)/patches/cyclicAMI
 $(AMICycPatches)/cyclicAMILduInterfaceField/cyclicAMILduInterface.C
 $(AMICycPatches)/cyclicAMILduInterfaceField/cyclicAMILduInterfaceField.C
 $(AMICycPatches)/cyclicAMIPolyPatch/cyclicAMIPolyPatch.C
 $(AMICycPatches)/cyclicAMIPointPatch/cyclicAMIPointPatch.C
 $(AMICycPatches)/cyclicAMIPointPatchField/cyclicAMIPointPatchFields.C
 
+ACMICycPatches=$(AMI)/patches/cyclicACMI
+$(ACMICycPatches)/cyclicACMILduInterfaceField/cyclicACMILduInterface.C
+$(ACMICycPatches)/cyclicACMILduInterfaceField/cyclicACMILduInterfaceField.C
+$(ACMICycPatches)/cyclicACMIPolyPatch/cyclicACMIPolyPatch.C
+$(ACMICycPatches)/cyclicACMIPointPatch/cyclicACMIPointPatch.C
+$(ACMICycPatches)/cyclicACMIPointPatchField/cyclicACMIPointPatchFields.C
+
 mappedPatches/mappedPolyPatch/mappedPatchBase.C
 mappedPatches/mappedPolyPatch/mappedPolyPatch.C
 mappedPatches/mappedPolyPatch/mappedWallPolyPatch.C
diff --git a/src/meshTools/sets/faceSources/regionToFace/patchEdgeFaceRegion.C b/src/meshTools/algorithms/PatchEdgeFaceWave/patchEdgeFaceRegion.C
similarity index 95%
rename from src/meshTools/sets/faceSources/regionToFace/patchEdgeFaceRegion.C
rename to src/meshTools/algorithms/PatchEdgeFaceWave/patchEdgeFaceRegion.C
index 91e9b4c331..eaac9a864a 100644
--- a/src/meshTools/sets/faceSources/regionToFace/patchEdgeFaceRegion.C
+++ b/src/meshTools/algorithms/PatchEdgeFaceWave/patchEdgeFaceRegion.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2012-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
diff --git a/src/meshTools/sets/faceSources/regionToFace/patchEdgeFaceRegion.H b/src/meshTools/algorithms/PatchEdgeFaceWave/patchEdgeFaceRegion.H
similarity index 98%
rename from src/meshTools/sets/faceSources/regionToFace/patchEdgeFaceRegion.H
rename to src/meshTools/algorithms/PatchEdgeFaceWave/patchEdgeFaceRegion.H
index 6c0b65f2d7..48ced2899b 100644
--- a/src/meshTools/sets/faceSources/regionToFace/patchEdgeFaceRegion.H
+++ b/src/meshTools/algorithms/PatchEdgeFaceWave/patchEdgeFaceRegion.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2012-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
diff --git a/src/meshTools/sets/faceSources/regionToFace/patchEdgeFaceRegionI.H b/src/meshTools/algorithms/PatchEdgeFaceWave/patchEdgeFaceRegionI.H
similarity index 100%
rename from src/meshTools/sets/faceSources/regionToFace/patchEdgeFaceRegionI.H
rename to src/meshTools/algorithms/PatchEdgeFaceWave/patchEdgeFaceRegionI.H
diff --git a/src/meshTools/algorithms/PatchEdgeFaceWave/patchEdgeFaceRegions.C b/src/meshTools/algorithms/PatchEdgeFaceWave/patchEdgeFaceRegions.C
new file mode 100644
index 0000000000..72050034aa
--- /dev/null
+++ b/src/meshTools/algorithms/PatchEdgeFaceWave/patchEdgeFaceRegions.C
@@ -0,0 +1,50 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012-2013 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 "patchEdgeFaceRegions.H"
+
+// * * * * * * * * * * * * * * * Friend Operators  * * * * * * * * * * * * * //
+
+Foam::Ostream& Foam::operator<<
+(
+    Foam::Ostream& os,
+    const Foam::patchEdgeFaceRegions& wDist
+)
+{
+    return os << wDist.regions_;
+}
+
+
+Foam::Istream& Foam::operator>>
+(
+    Foam::Istream& is,
+    Foam::patchEdgeFaceRegions& wDist
+)
+{
+    return is >> wDist.regions_;
+}
+
+
+// ************************************************************************* //
diff --git a/src/meshTools/algorithms/PatchEdgeFaceWave/patchEdgeFaceRegions.H b/src/meshTools/algorithms/PatchEdgeFaceWave/patchEdgeFaceRegions.H
new file mode 100644
index 0000000000..a60a38ce45
--- /dev/null
+++ b/src/meshTools/algorithms/PatchEdgeFaceWave/patchEdgeFaceRegions.H
@@ -0,0 +1,173 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 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::patchEdgeFaceRegions
+
+Description
+    Transport of regions for use in PatchEdgeFaceWave.
+
+    Set element to -1 to denote blocked.
+
+SourceFiles
+    patchEdgeFaceRegionsI.H
+    patchEdgeFaceRegions.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef patchEdgeFaceRegions_H
+#define patchEdgeFaceRegions_H
+
+#include "labelList.H"
+#include "scalar.H"
+#include "tensor.H"
+#include "labelPair.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// Forward declaration of classes
+class polyMesh;
+
+/*---------------------------------------------------------------------------*\
+                           Class patchEdgeFaceRegions Declaration
+\*---------------------------------------------------------------------------*/
+
+class patchEdgeFaceRegions
+{
+    // Private data
+
+        //- region per point
+        labelList regions_;
+
+public:
+
+    // Constructors
+
+        //- Construct null
+        inline patchEdgeFaceRegions();
+
+        //- Construct from regions
+        inline patchEdgeFaceRegions(const labelList&);
+
+        //- Construct from regions (on edge)
+        inline patchEdgeFaceRegions(const labelPair&);
+
+
+    // Member Functions
+
+        // Access
+
+            inline const labelList& regions() const;
+
+
+        // Needed by meshWave
+
+            //- Check whether origin has been changed at all or
+            //  still contains original (invalid) value.
+            template<class TrackingData>
+            inline bool valid(TrackingData& td) const;
+
+            //- Apply rotation matrix
+            template<class Patch, class TrackingData>
+            inline void transform
+            (
+                const polyMesh& mesh,
+                const Patch& patch,
+                const tensor& rotTensor,
+                const scalar tol,
+                TrackingData& td
+            );
+
+            //- Influence of face on edge
+            template<class Patch, class TrackingData>
+            inline bool updateEdge
+            (
+                const polyMesh& mesh,
+                const Patch& patch,
+                const label edgeI,
+                const label faceI,
+                const patchEdgeFaceRegions& faceInfo,
+                const scalar tol,
+                TrackingData& td
+            );
+
+            //- New information for edge (from e.g. coupled edge)
+            template<class Patch, class TrackingData>
+            inline bool updateEdge
+            (
+                const polyMesh& mesh,
+                const Patch& patch,
+                const patchEdgeFaceRegions& edgeInfo,
+                const bool sameOrientation,
+                const scalar tol,
+                TrackingData& td
+            );
+
+            //- Influence of edge on face.
+            template<class Patch, class TrackingData>
+            inline bool updateFace
+            (
+                const polyMesh& mesh,
+                const Patch& patch,
+                const label faceI,
+                const label edgeI,
+                const patchEdgeFaceRegions& edgeInfo,
+                const scalar tol,
+                TrackingData& td
+            );
+
+            //- Same (like operator==)
+            template<class TrackingData>
+            inline bool equal(const patchEdgeFaceRegions&, TrackingData&) const;
+
+
+    // Member Operators
+
+        // Needed for List IO
+        inline bool operator==(const patchEdgeFaceRegions&) const;
+        inline bool operator!=(const patchEdgeFaceRegions&) const;
+
+
+    // IOstream Operators
+
+        friend Ostream& operator<<(Ostream&, const patchEdgeFaceRegions&);
+        friend Istream& operator>>(Istream&, patchEdgeFaceRegions&);
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#include "patchEdgeFaceRegionsI.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/meshTools/algorithms/PatchEdgeFaceWave/patchEdgeFaceRegionsI.H b/src/meshTools/algorithms/PatchEdgeFaceWave/patchEdgeFaceRegionsI.H
new file mode 100644
index 0000000000..f39488a018
--- /dev/null
+++ b/src/meshTools/algorithms/PatchEdgeFaceWave/patchEdgeFaceRegionsI.H
@@ -0,0 +1,282 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 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 "polyMesh.H"
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+inline Foam::patchEdgeFaceRegions::patchEdgeFaceRegions()
+{}
+
+
+inline Foam::patchEdgeFaceRegions::patchEdgeFaceRegions
+(
+    const labelList& regions
+)
+:
+    regions_(regions)
+{}
+
+
+inline Foam::patchEdgeFaceRegions::patchEdgeFaceRegions
+(
+    const labelPair& regions
+)
+:
+    regions_(2)
+{
+    regions_[0] = regions[0];
+    regions_[1] = regions[1];
+}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+inline const Foam::labelList& Foam::patchEdgeFaceRegions::regions() const
+{
+    return regions_;
+}
+
+
+template<class TrackingData>
+inline bool Foam::patchEdgeFaceRegions::valid(TrackingData& td) const
+{
+    return regions_.size() && (findIndex(regions_, labelMax) == -1);
+}
+
+
+template<class Patch, class TrackingData>
+inline void Foam::patchEdgeFaceRegions::transform
+(
+    const polyMesh& mesh,
+    const Patch& patch,
+    const tensor& rotTensor,
+    const scalar tol,
+    TrackingData& td
+)
+{}
+
+
+template<class Patch, class TrackingData>
+inline bool Foam::patchEdgeFaceRegions::updateEdge
+(
+    const polyMesh& mesh,
+    const Patch& patch,
+    const label edgeI,
+    const label faceI,
+    const patchEdgeFaceRegions& faceInfo,
+    const scalar tol,
+    TrackingData& td
+)
+{
+    const face& f = patch.localFaces()[faceI];
+    const edge& e = patch.edges()[edgeI];
+
+    label index = findIndex(patch.faceEdges()[faceI], edgeI);
+    bool sameOrientation = (f[index] == e.start());
+
+    // Get information in edge-order
+    edge orientedInfo
+    (
+        faceInfo.regions_[index],
+        faceInfo.regions_[f.fcIndex(index)]
+    );
+    if (!sameOrientation)
+    {
+        orientedInfo.flip();
+    }
+
+    if (!faceInfo.valid(td))
+    {
+        FatalErrorIn("patchEdgeFaceRegions::updateEdge(..)")
+            << "problem." << abort(FatalError);
+    }
+
+    if ((findIndex(orientedInfo, -1) != -1) || (findIndex(regions_, -1) != -1))
+    {
+        // Blocked edge/face
+        return false;
+    }
+
+
+    bool changed = false;
+
+    regions_.setSize(orientedInfo.size(), labelMax);
+    forAll(orientedInfo, i)
+    {
+        if (orientedInfo[i] != -1 && orientedInfo[i] < regions_[i])
+        {
+            regions_[i] = orientedInfo[i];
+            changed = true;
+        }
+    }
+    return changed;
+}
+
+
+template<class Patch, class TrackingData>
+inline bool Foam::patchEdgeFaceRegions::updateEdge
+(
+    const polyMesh& mesh,
+    const Patch& patch,
+    const patchEdgeFaceRegions& edgeInfo,
+    const bool sameOrientation,
+    const scalar tol,
+    TrackingData& td
+)
+{
+    // Get information in edge-order
+    edge orientedInfo(edgeInfo.regions_[0], edgeInfo.regions_[1]);
+    if (!sameOrientation)
+    {
+        orientedInfo.flip();
+    }
+
+
+    if (!edgeInfo.valid(td))
+    {
+        FatalErrorIn("patchEdgeFaceRegions::updateEdge(..)")
+            << "problem." << abort(FatalError);
+    }
+
+    if ((findIndex(orientedInfo, -1) != -1) || (findIndex(regions_, -1) != -1))
+    {
+        // Blocked edge/face
+        return false;
+    }
+
+
+    bool changed = false;
+
+    regions_.setSize(orientedInfo.size(), labelMax);
+    forAll(orientedInfo, i)
+    {
+        if (orientedInfo[i] != -1 && orientedInfo[i] < regions_[i])
+        {
+            regions_[i] = orientedInfo[i];
+            changed = true;
+        }
+    }
+    return changed;
+}
+
+
+template<class Patch, class TrackingData>
+inline bool Foam::patchEdgeFaceRegions::updateFace
+(
+    const polyMesh& mesh,
+    const Patch& patch,
+    const label faceI,
+    const label edgeI,
+    const patchEdgeFaceRegions& edgeInfo,
+    const scalar tol,
+    TrackingData& td
+)
+{
+    const face& f = patch.localFaces()[faceI];
+    const edge& e = patch.edges()[edgeI];
+
+    // Find starting point of edge on face.
+    label index0 = findIndex(patch.faceEdges()[faceI], edgeI);
+    label index1 = f.fcIndex(index0);
+    bool sameOrientation = (f[index0] == e.start());
+
+
+    // Get information in face-order
+    edge orientedInfo
+    (
+        edgeInfo.regions_[0],
+        edgeInfo.regions_[1]
+    );
+    if (!sameOrientation)
+    {
+        orientedInfo.flip();
+    }
+
+    if (!edgeInfo.valid(td))
+    {
+        FatalErrorIn("patchEdgeFaceRegions::updateFace(..)")
+            << "problem." << abort(FatalError);
+    }
+
+    if ((findIndex(orientedInfo, -1) != -1) || (findIndex(regions_, -1) != -1))
+    {
+        // Blocked edge/face
+        return false;
+    }
+
+
+    bool changed = false;
+
+    // Scale if needed
+    regions_.setSize(f.size(), labelMax);
+
+    if (orientedInfo[0] < regions_[index0])
+    {
+        regions_[index0] = orientedInfo[0];
+        changed = true;
+    }
+    if (orientedInfo[1] < regions_[index1])
+    {
+        regions_[index1] = orientedInfo[1];
+        changed = true;
+    }
+
+    return changed;
+}
+
+
+template<class TrackingData>
+inline bool Foam::patchEdgeFaceRegions::equal
+(
+    const patchEdgeFaceRegions& rhs,
+    TrackingData& td
+) const
+{
+    return operator==(rhs);
+}
+
+
+// * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
+
+inline bool Foam::patchEdgeFaceRegions::operator==
+(
+    const Foam::patchEdgeFaceRegions& rhs
+) const
+{
+    return regions() == rhs.regions();
+}
+
+
+inline bool Foam::patchEdgeFaceRegions::operator!=
+(
+    const Foam::patchEdgeFaceRegions& rhs
+) const
+{
+    return !(*this == rhs);
+}
+
+
+// ************************************************************************* //
diff --git a/src/meshTools/searchableSurface/triSurfaceMesh.C b/src/meshTools/searchableSurface/triSurfaceMesh.C
index 21cec14657..125450603b 100644
--- a/src/meshTools/searchableSurface/triSurfaceMesh.C
+++ b/src/meshTools/searchableSurface/triSurfaceMesh.C
@@ -433,24 +433,28 @@ Foam::triSurfaceMesh::edgeTree() const
           + nInternalEdges()
         );
 
-        treeBoundBox bb;
-        label nPoints;
-        PatchTools::calcBounds
-        (
-            static_cast<const triSurface&>(*this),
-            bb,
-            nPoints
-        );
+        treeBoundBox bb(vector::zero, vector::zero);
 
-        // Random number generator. Bit dodgy since not exactly random ;-)
-        Random rndGen(65431);
+        if (bEdges.size())
+        {
+            label nPoints;
+            PatchTools::calcBounds
+            (
+                static_cast<const triSurface&>(*this),
+                bb,
+                nPoints
+            );
 
-        // Slightly extended bb. Slightly off-centred just so on symmetric
-        // geometry there are less face/edge aligned items.
+            // Random number generator. Bit dodgy since not exactly random ;-)
+            Random rndGen(65431);
 
-        bb = bb.extend(rndGen, 1e-4);
-        bb.min() -= point(ROOTVSMALL, ROOTVSMALL, ROOTVSMALL);
-        bb.max() += point(ROOTVSMALL, ROOTVSMALL, ROOTVSMALL);
+            // Slightly extended bb. Slightly off-centred just so on symmetric
+            // geometry there are less face/edge aligned items.
+
+            bb = bb.extend(rndGen, 1e-4);
+            bb.min() -= point(ROOTVSMALL, ROOTVSMALL, ROOTVSMALL);
+            bb.max() += point(ROOTVSMALL, ROOTVSMALL, ROOTVSMALL);
+        }
 
         scalar oldTol = indexedOctree<treeDataEdge>::perturbTol();
         indexedOctree<treeDataEdge>::perturbTol() = tolerance();
diff --git a/src/meshTools/triSurface/triSurfaceSearch/triSurfaceRegionSearch.C b/src/meshTools/triSurface/triSurfaceSearch/triSurfaceRegionSearch.C
index 738cb8dcdd..34dc89f920 100644
--- a/src/meshTools/triSurface/triSurfaceSearch/triSurfaceRegionSearch.C
+++ b/src/meshTools/triSurface/triSurfaceSearch/triSurfaceRegionSearch.C
@@ -121,33 +121,40 @@ Foam::triSurfaceRegionSearch::treeByRegion() const
             );
 
             // Calculate bb without constructing local point numbering.
-            treeBoundBox bb;
-            label nPoints;
-            PatchTools::calcBounds
-            (
-                indirectRegionPatches_[regionI],
-                bb,
-                nPoints
-            );
+            treeBoundBox bb(vector::zero, vector::zero);
 
-//            if (nPoints != surface().points().size())
-//            {
-//                WarningIn("triSurfaceRegionSearch::treeByRegion() const")
-//                    << "Surface does not have compact point numbering. "
-//                    << "Of " << surface().points().size()
-//                    << " only " << nPoints
-//                    << " are used. This might give problems in some routines."
-//                    << endl;
-//            }
+            if (indirectRegionPatches_[regionI].size())
+            {
+                label nPoints;
+                PatchTools::calcBounds
+                (
+                    indirectRegionPatches_[regionI],
+                    bb,
+                    nPoints
+                );
 
-            // Random number generator. Bit dodgy since not exactly random ;-)
-            Random rndGen(65431);
+    //            if (nPoints != surface().points().size())
+    //            {
+    //                WarningIn("triSurfaceRegionSearch::treeByRegion() const")
+    //                    << "Surface does not have compact point numbering. "
+    //                    << "Of " << surface().points().size()
+    //                    << " only " << nPoints
+    //                    << " are used."
+    //                    << " This might give problems in some routines."
+    //                    << endl;
+    //            }
 
-            // Slightly extended bb. Slightly off-centred just so on symmetric
-            // geometry there are fewer face/edge aligned items.
-            bb = bb.extend(rndGen, 1e-4);
-            bb.min() -= point(ROOTVSMALL, ROOTVSMALL, ROOTVSMALL);
-            bb.max() += point(ROOTVSMALL, ROOTVSMALL, ROOTVSMALL);
+                // Random number generator. Bit dodgy since not exactly
+                // random ;-)
+                Random rndGen(65431);
+
+                // Slightly extended bb. Slightly off-centred just so
+                // on symmetric geometry there are fewer face/edge
+                // aligned items.
+                bb = bb.extend(rndGen, 1e-4);
+                bb.min() -= point(ROOTVSMALL, ROOTVSMALL, ROOTVSMALL);
+                bb.max() += point(ROOTVSMALL, ROOTVSMALL, ROOTVSMALL);
+            }
 
             treeByRegion_.set
             (
diff --git a/src/meshTools/triSurface/triSurfaceSearch/triSurfaceSearch.C b/src/meshTools/triSurface/triSurfaceSearch/triSurfaceSearch.C
index 91188f1e36..5d78faff69 100644
--- a/src/meshTools/triSurface/triSurfaceSearch/triSurfaceSearch.C
+++ b/src/meshTools/triSurface/triSurfaceSearch/triSurfaceSearch.C
@@ -200,28 +200,33 @@ Foam::triSurfaceSearch::tree() const
     if (treePtr_.empty())
     {
         // Calculate bb without constructing local point numbering.
-        treeBoundBox bb;
-        label nPoints;
-        PatchTools::calcBounds(surface(), bb, nPoints);
+        treeBoundBox bb(vector::zero, vector::zero);
 
-        if (nPoints != surface().points().size())
+        if (surface().size())
         {
-            WarningIn("triSurfaceSearch::tree() const")
-                << "Surface does not have compact point numbering."
-                << " Of " << surface().points().size() << " only " << nPoints
-                << " are used. This might give problems in some routines."
-                << endl;
+            label nPoints;
+            PatchTools::calcBounds(surface(), bb, nPoints);
+
+            if (nPoints != surface().points().size())
+            {
+                WarningIn("triSurfaceSearch::tree() const")
+                    << "Surface does not have compact point numbering."
+                    << " Of " << surface().points().size()
+                    << " only " << nPoints
+                    << " are used. This might give problems in some routines."
+                    << endl;
+            }
+
+            // Random number generator. Bit dodgy since not exactly random ;-)
+            Random rndGen(65431);
+
+            // Slightly extended bb. Slightly off-centred just so on symmetric
+            // geometry there are less face/edge aligned items.
+            bb = bb.extend(rndGen, 1e-4);
+            bb.min() -= point(ROOTVSMALL, ROOTVSMALL, ROOTVSMALL);
+            bb.max() += point(ROOTVSMALL, ROOTVSMALL, ROOTVSMALL);
         }
 
-        // Random number generator. Bit dodgy since not exactly random ;-)
-        Random rndGen(65431);
-
-        // Slightly extended bb. Slightly off-centred just so on symmetric
-        // geometry there are less face/edge aligned items.
-        bb = bb.extend(rndGen, 1e-4);
-        bb.min() -= point(ROOTVSMALL, ROOTVSMALL, ROOTVSMALL);
-        bb.max() += point(ROOTVSMALL, ROOTVSMALL, ROOTVSMALL);
-
         scalar oldTol = indexedOctree<treeDataTriSurface>::perturbTol();
         indexedOctree<treeDataTriSurface>::perturbTol() = tolerance_;
 
diff --git a/src/parallel/decompose/decompositionMethods/noDecomp/noDecomp.H b/src/parallel/decompose/decompositionMethods/noDecomp/noDecomp.H
index 13368c9970..154838d35c 100644
--- a/src/parallel/decompose/decompositionMethods/noDecomp/noDecomp.H
+++ b/src/parallel/decompose/decompositionMethods/noDecomp/noDecomp.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2012-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -78,7 +78,7 @@ public:
         //  up to the user.
         virtual bool parallelAware() const
         {
-            return false;
+            return true;
         }
 
         //- Return for every coordinate the wanted processor number. Use the
@@ -90,12 +90,7 @@ public:
             const scalarField& cWeights
         )
         {
-            notImplemented
-            (
-                "decompose(const polyMesh&, const pointField&"
-                ", const scalarField&)"
-            );
-            return labelList(0);
+            return labelList(cc.size(), Pstream::myProcNo());
         }
 
         //- Return for every coordinate the wanted processor number. Explicitly
@@ -112,12 +107,7 @@ public:
             const scalarField& cWeights
         )
         {
-            notImplemented
-            (
-                "decompose(const labelListList&, const pointField&"
-                ", const scalarField&)"
-            );
-            return labelList(0);
+            return labelList(globalCellCells.size(), Pstream::myProcNo());
         }
 
 };
diff --git a/src/parallel/distributed/distributedTriSurfaceMesh/distributedTriSurfaceMesh.C b/src/parallel/distributed/distributedTriSurfaceMesh/distributedTriSurfaceMesh.C
index 80308fac5e..7c80bd1a56 100644
--- a/src/parallel/distributed/distributedTriSurfaceMesh/distributedTriSurfaceMesh.C
+++ b/src/parallel/distributed/distributedTriSurfaceMesh/distributedTriSurfaceMesh.C
@@ -2360,10 +2360,28 @@ bool Foam::distributedTriSurfaceMesh::writeObject
     // Make sure dictionary goes to same directory as surface
     const_cast<fileName&>(dict_.instance()) = searchableSurface::instance();
 
+    // Copy of triSurfaceMesh::writeObject except for the sorting of
+    // triangles by region. This is done so we preserve region names,
+    // even if locally we have zero triangles.
+    {
+        fileName fullPath(searchableSurface::objectPath());
+
+        if (!mkDir(fullPath.path()))
+        {
+            return false;
+        }
+
+        // Important: preserve any zero-sized patches
+        triSurface::write(fullPath, true);
+
+        if (!isFile(fullPath))
+        {
+            return false;
+        }
+    }
+
     // Dictionary needs to be written in ascii - binary output not supported.
-    return
-        triSurfaceMesh::writeObject(fmt, ver, cmp)
-     && dict_.writeObject(IOstream::ASCII, ver, cmp);
+    return dict_.writeObject(IOstream::ASCII, ver, cmp);
 }
 
 
diff --git a/src/parallel/distributed/distributedTriSurfaceMesh/distributedTriSurfaceMesh.H b/src/parallel/distributed/distributedTriSurfaceMesh/distributedTriSurfaceMesh.H
index 32a062a573..7e4d27ef0c 100644
--- a/src/parallel/distributed/distributedTriSurfaceMesh/distributedTriSurfaceMesh.H
+++ b/src/parallel/distributed/distributedTriSurfaceMesh/distributedTriSurfaceMesh.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -446,6 +446,10 @@ public:
         // regIOobject implementation
 
             //- Write using given format, version and compression
+            //  Do not use the triSurfaceMesh::writeObject since it
+            //  would filter out empty regions. These need to be preserved
+            //  in case we want to make decisions based on the number of
+            //  regions.
             virtual bool writeObject
             (
                 IOstream::streamFormat fmt,
diff --git a/src/postProcessing/functionObjects/IO/writeRegisteredObject/writeRegisteredObject.H b/src/postProcessing/functionObjects/IO/writeRegisteredObject/writeRegisteredObject.H
index f4bd97bd36..014d4ce90c 100644
--- a/src/postProcessing/functionObjects/IO/writeRegisteredObject/writeRegisteredObject.H
+++ b/src/postProcessing/functionObjects/IO/writeRegisteredObject/writeRegisteredObject.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -38,7 +38,7 @@ Description
         type        writeRegisteredObject;
         functionObjectLibs ("libIOFunctionObjects.so");
         ...
-        objectNames (obj1 obj2);   
+        objectNames (obj1 obj2);
     }
     \endverbatim
 
diff --git a/src/postProcessing/functionObjects/field/fieldAverage/fieldAverage/fieldAverage.C b/src/postProcessing/functionObjects/field/fieldAverage/fieldAverage/fieldAverage.C
index d714747310..5a73765f93 100644
--- a/src/postProcessing/functionObjects/field/fieldAverage/fieldAverage/fieldAverage.C
+++ b/src/postProcessing/functionObjects/field/fieldAverage/fieldAverage/fieldAverage.C
@@ -68,12 +68,6 @@ void Foam::fieldAverage::initialize()
     resetFields(prime2MeanScalarFields_);
     resetFields(prime2MeanSymmTensorFields_);
 
-    totalIter_.clear();
-    totalIter_.setSize(faItems_.size(), 1);
-
-    totalTime_.clear();
-    totalTime_.setSize(faItems_.size(), obr_.time().deltaTValue());
-
 
     // Add mean fields to the field lists
     forAll(faItems_, fieldI)
@@ -150,11 +144,21 @@ void Foam::fieldAverage::initialize()
             }
         }
     }
+
+    // ensure first averaging works unconditionally
+    prevTimeIndex_ = -1;
+
+    initialised_ = true;
 }
 
 
 void Foam::fieldAverage::calcAverages()
 {
+    if (!initialised_)
+    {
+        initialize();
+    }
+
     const label currentTimeIndex =
         static_cast<const fvMesh&>(obr_).time().timeIndex();
 
@@ -248,6 +252,12 @@ void Foam::fieldAverage::writeAveragingProperties() const
 
 void Foam::fieldAverage::readAveragingProperties()
 {
+    totalIter_.clear();
+    totalIter_.setSize(faItems_.size(), 1);
+
+    totalTime_.clear();
+    totalTime_.setSize(faItems_.size(), obr_.time().deltaTValue());
+
     if (resetOnRestart_)
     {
         Info<< "fieldAverage: starting averaging at time "
@@ -258,7 +268,7 @@ void Foam::fieldAverage::readAveragingProperties()
         IOobject propsDictHeader
         (
             "fieldAveragingProperties",
-            obr_.time().timeName(),
+            obr_.time().timeName(obr_.time().startTime().value()),
             "uniform",
             obr_,
             IOobject::MUST_READ_IF_MODIFIED,
@@ -290,6 +300,7 @@ void Foam::fieldAverage::readAveragingProperties()
                     << " time = " << totalTime_[fieldI] << endl;
             }
         }
+
         Info<< endl;
     }
 }
@@ -311,6 +322,7 @@ Foam::fieldAverage::fieldAverage
     prevTimeIndex_(-1),
     resetOnRestart_(false),
     resetOnOutput_(false),
+    initialised_(false),
     faItems_(),
     meanScalarFields_(),
     meanVectorFields_(),
@@ -357,15 +369,13 @@ void Foam::fieldAverage::read(const dictionary& dict)
 {
     if (active_)
     {
+        initialised_ = false;
+
         dict.readIfPresent("resetOnRestart", resetOnRestart_);
         dict.readIfPresent("resetOnOutput", resetOnOutput_);
         dict.lookup("fields") >> faItems_;
 
-        initialize();
         readAveragingProperties();
-
-        // ensure first averaging works unconditionally
-        prevTimeIndex_ = -1;
     }
 }
 
diff --git a/src/postProcessing/functionObjects/field/fieldAverage/fieldAverage/fieldAverage.H b/src/postProcessing/functionObjects/field/fieldAverage/fieldAverage/fieldAverage.H
index f8b689757d..4a6d75e06b 100644
--- a/src/postProcessing/functionObjects/field/fieldAverage/fieldAverage/fieldAverage.H
+++ b/src/postProcessing/functionObjects/field/fieldAverage/fieldAverage/fieldAverage.H
@@ -171,6 +171,9 @@ protected:
         //- Reset the averaging process on output flag
         Switch resetOnOutput_;
 
+        //- Initialised flag
+        bool initialised_;
+
         //- List of field average items, describing what averages to be
         //  calculated and output
         List<fieldAverageItem> faItems_;
diff --git a/src/postProcessing/functionObjects/field/fieldValues/cellSource/cellSource.C b/src/postProcessing/functionObjects/field/fieldValues/cellSource/cellSource.C
index 3d7977c488..595c16084d 100644
--- a/src/postProcessing/functionObjects/field/fieldValues/cellSource/cellSource.C
+++ b/src/postProcessing/functionObjects/field/fieldValues/cellSource/cellSource.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -222,11 +222,22 @@ void Foam::fieldValues::cellSource::write()
 
         forAll(fields_, i)
         {
-            writeValues<scalar>(fields_[i]);
-            writeValues<vector>(fields_[i]);
-            writeValues<sphericalTensor>(fields_[i]);
-            writeValues<symmTensor>(fields_[i]);
-            writeValues<tensor>(fields_[i]);
+            const word& fieldName = fields_[i];
+            bool processed = false;
+
+            processed = processed || writeValues<scalar>(fieldName);
+            processed = processed || writeValues<vector>(fieldName);
+            processed = processed || writeValues<sphericalTensor>(fieldName);
+            processed = processed || writeValues<symmTensor>(fieldName);
+            processed = processed || writeValues<tensor>(fieldName);
+
+            if (!processed)
+            {
+                WarningIn("void Foam::fieldValues::cellSource::write()")
+                    << "Requested field " << fieldName
+                    << " not found in database and not processed"
+                    << endl;
+            }
         }
 
         if (Pstream::master())
diff --git a/src/postProcessing/functionObjects/field/fieldValues/faceSource/faceSource.C b/src/postProcessing/functionObjects/field/fieldValues/faceSource/faceSource.C
index dd54de718a..ee3b626562 100644
--- a/src/postProcessing/functionObjects/field/fieldValues/faceSource/faceSource.C
+++ b/src/postProcessing/functionObjects/field/fieldValues/faceSource/faceSource.C
@@ -630,11 +630,22 @@ void Foam::fieldValues::faceSource::write()
 
         forAll(fields_, i)
         {
-            writeValues<scalar>(fields_[i]);
-            writeValues<vector>(fields_[i]);
-            writeValues<sphericalTensor>(fields_[i]);
-            writeValues<symmTensor>(fields_[i]);
-            writeValues<tensor>(fields_[i]);
+            const word& fieldName = fields_[i];
+            bool processed = false;
+
+            processed = processed || writeValues<scalar>(fieldName);
+            processed = processed || writeValues<vector>(fieldName);
+            processed = processed || writeValues<sphericalTensor>(fieldName);
+            processed = processed || writeValues<symmTensor>(fieldName);
+            processed = processed || writeValues<tensor>(fieldName);
+
+            if (!processed)
+            {
+                WarningIn("void Foam::fieldValues::faceSource::write()")
+                    << "Requested field " << fieldName
+                    << " not found in database and not processed"
+                    << endl;
+            }
         }
 
         if (Pstream::master())
diff --git a/src/postProcessing/functionObjects/forces/forces/forces.C b/src/postProcessing/functionObjects/forces/forces/forces.C
index c159b652e8..e38208963b 100644
--- a/src/postProcessing/functionObjects/forces/forces/forces.C
+++ b/src/postProcessing/functionObjects/forces/forces/forces.C
@@ -28,16 +28,12 @@ License
 #include "dictionary.H"
 #include "Time.H"
 #include "wordReList.H"
-
-#include "incompressible/singlePhaseTransportModel/singlePhaseTransportModel.H"
-#include "incompressible/RAS/RASModel/RASModel.H"
-#include "incompressible/LES/LESModel/LESModel.H"
-
-#include "fluidThermo.H"
-#include "compressible/RAS/RASModel/RASModel.H"
-#include "compressible/LES/LESModel/LESModel.H"
-
+#include "fvcGrad.H"
 #include "porosityModel.H"
+#include "fluidThermo.H"
+#include "incompressible/turbulenceModel/turbulenceModel.H"
+#include "compressible/turbulenceModel/turbulenceModel.H"
+#include "incompressible/singlePhaseTransportModel/singlePhaseTransportModel.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
@@ -70,38 +66,27 @@ void Foam::forces::writeFileHeader(const label i)
 
 Foam::tmp<Foam::volSymmTensorField> Foam::forces::devRhoReff() const
 {
-    if (obr_.foundObject<compressible::RASModel>("RASProperties"))
-    {
-        const compressible::RASModel& ras
-            = obr_.lookupObject<compressible::RASModel>("RASProperties");
+    typedef compressible::turbulenceModel cmpTurbModel;
+    typedef incompressible::turbulenceModel icoTurbModel;
 
-        return ras.devRhoReff();
-    }
-    else if (obr_.foundObject<incompressible::RASModel>("RASProperties"))
+    if (obr_.foundObject<cmpTurbModel>(cmpTurbModel::typeName))
     {
-        const incompressible::RASModel& ras
-            = obr_.lookupObject<incompressible::RASModel>("RASProperties");
+        const cmpTurbModel& turb =
+            obr_.lookupObject<cmpTurbModel>(cmpTurbModel::typeName);
 
-        return rho()*ras.devReff();
+        return turb.devRhoReff();
     }
-    else if (obr_.foundObject<compressible::LESModel>("LESProperties"))
+    else if (obr_.foundObject<icoTurbModel>(icoTurbModel::typeName))
     {
-        const compressible::LESModel& les =
-        obr_.lookupObject<compressible::LESModel>("LESProperties");
+        const incompressible::turbulenceModel& turb =
+            obr_.lookupObject<icoTurbModel>(icoTurbModel::typeName);
 
-        return les.devRhoReff();
+        return rho()*turb.devReff();
     }
-    else if (obr_.foundObject<incompressible::LESModel>("LESProperties"))
-    {
-        const incompressible::LESModel& les
-            = obr_.lookupObject<incompressible::LESModel>("LESProperties");
-
-        return rho()*les.devReff();
-    }
-    else if (obr_.foundObject<fluidThermo>("thermophysicalProperties"))
+    else if (obr_.foundObject<fluidThermo>(fluidThermo::typeName))
     {
         const fluidThermo& thermo =
-             obr_.lookupObject<fluidThermo>("thermophysicalProperties");
+            obr_.lookupObject<fluidThermo>(fluidThermo::typeName);
 
         const volVectorField& U = obr_.lookupObject<volVectorField>(UName_);
 
@@ -438,7 +423,13 @@ Foam::forces::forces
     binPoints_(),
     binFormat_("undefined"),
     binCumulative_(true)
-{}
+{
+    forAll(force_, i)
+    {
+        force_[i].setSize(nBin_);
+        moment_[i].setSize(nBin_);
+    }
+}
 
 
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
diff --git a/src/postProcessing/functionObjects/utilities/pressureTools/pressureTools.C b/src/postProcessing/functionObjects/utilities/pressureTools/pressureTools.C
index 607d52e503..014aefd8a0 100644
--- a/src/postProcessing/functionObjects/utilities/pressureTools/pressureTools.C
+++ b/src/postProcessing/functionObjects/utilities/pressureTools/pressureTools.C
@@ -70,7 +70,7 @@ Foam::dimensionedScalar Foam::pressureTools::rhoScale
     }
     else
     {
-        return dimensionedScalar("rhoRef", dimDensity, rhoRef_);
+        return dimensionedScalar("rhoRef", dimDensity, rhoInf_);
     }
 }
 
@@ -100,7 +100,7 @@ Foam::tmp<Foam::volScalarField> Foam::pressureTools::rho
                         IOobject::NO_WRITE
                     ),
                     p.mesh(),
-                    dimensionedScalar("zero", dimDensity, rhoRef_)
+                    dimensionedScalar("zero", dimDensity, rhoInf_)
                 )
             );
     }
@@ -193,7 +193,6 @@ Foam::pressureTools::pressureTools
     pName_("p"),
     UName_("U"),
     rhoName_("rho"),
-    rhoRef_(1.0),
     calcTotal_(false),
     pRef_(0.0),
     calcCoeff_(false),
@@ -219,6 +218,37 @@ Foam::pressureTools::pressureTools
     }
 
     read(dict);
+
+    if (active_)
+    {
+        dimensionSet pDims(dimPressure);
+
+        if (calcCoeff_)
+        {
+            pDims /= dimPressure;
+        }
+
+        const fvMesh& mesh = refCast<const fvMesh>(obr_);
+
+        volScalarField* pPtr
+        (
+            new volScalarField
+            (
+                IOobject
+                (
+                    pName(),
+                    mesh.time().timeName(),
+                    mesh,
+                    IOobject::NO_READ,
+                    IOobject::NO_WRITE
+                ),
+                mesh,
+                dimensionedScalar("0", pDims, 0.0)
+            )
+        );
+
+        mesh.objectRegistry::store(pPtr);
+    }
 }
 
 
@@ -242,7 +272,7 @@ void Foam::pressureTools::read(const dictionary& dict)
 
         if (p.dimensions() != dimPressure)
         {
-            dict.lookup("rhoRef") >> rhoRef_;
+            dict.lookup("rhoRef") >> rhoInf_;
         } 
 
         dict.lookup("calcTotal") >> calcTotal_;
@@ -280,17 +310,13 @@ void Foam::pressureTools::write()
     {
         const volScalarField& p = obr_.lookupObject<volScalarField>(pName_);
 
-        volScalarField pResult
-        (
-            IOobject
+        volScalarField& pResult =
+            const_cast<volScalarField&>
             (
-                pName(),
-                obr_.time().timeName(),
-                obr_,
-                IOobject::NO_READ
-            ),
-            convertToCoeff(rhoScale(p)*p + pDyn(p) + pRef())
-        );
+                obr_.lookupObject<volScalarField>(pName())
+            );
+
+        pResult == convertToCoeff(rhoScale(p)*p + pDyn(p) + pRef());
 
         pResult.write();
     }
diff --git a/src/postProcessing/functionObjects/utilities/pressureTools/pressureTools.H b/src/postProcessing/functionObjects/utilities/pressureTools/pressureTools.H
index 11f490429d..82a44921ed 100644
--- a/src/postProcessing/functionObjects/utilities/pressureTools/pressureTools.H
+++ b/src/postProcessing/functionObjects/utilities/pressureTools/pressureTools.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2012-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -92,7 +92,6 @@ Description
     \table
         Property     | Description             | Required    | Default value
         type         | type name: pressureTools| yes         |
-        rhoRef       | Reference density for incompressible cases | no | 1
         calcTotal    | Calculate total coefficient | yes     |
         pRef         | Reference pressure for total pressure | no | 0.0
         calcCoeff    | Calculate pressure coefficient | yes  |
@@ -150,9 +149,6 @@ class pressureTools
         //- Name of density field, default is "rho"
         word rhoName_;
 
-        //- Reference density employed for incompressible cases
-        scalar rhoRef_;
-
 
         // Total pressure calculation
 
diff --git a/src/regionModels/surfaceFilmModels/Make/files b/src/regionModels/surfaceFilmModels/Make/files
index 1151e2f7fd..f14a789338 100644
--- a/src/regionModels/surfaceFilmModels/Make/files
+++ b/src/regionModels/surfaceFilmModels/Make/files
@@ -24,6 +24,10 @@ $(KINEMATICMODELS)/injectionModel/drippingInjection/drippingInjection.C
 $(KINEMATICMODELS)/injectionModel/removeInjection/removeInjection.C
 $(KINEMATICMODELS)/injectionModel/curvatureSeparation/curvatureSeparation.C
 
+$(KINEMATICMODELS)/filmTurbulenceModel/filmTurbulenceModel/filmTurbulenceModel.C
+$(KINEMATICMODELS)/filmTurbulenceModel/filmTurbulenceModel/filmTurbulenceModelNew.C
+$(KINEMATICMODELS)/filmTurbulenceModel/laminar/laminar.C
+
 THERMOMODELS=submodels/thermo
 $(THERMOMODELS)/phaseChangeModel/phaseChangeModel/phaseChangeModel.C
 $(THERMOMODELS)/phaseChangeModel/phaseChangeModel/phaseChangeModelNew.C
diff --git a/src/regionModels/surfaceFilmModels/kinematicSingleLayer/kinematicSingleLayer.C b/src/regionModels/surfaceFilmModels/kinematicSingleLayer/kinematicSingleLayer.C
index fecefcd2e3..00a3ac39af 100644
--- a/src/regionModels/surfaceFilmModels/kinematicSingleLayer/kinematicSingleLayer.C
+++ b/src/regionModels/surfaceFilmModels/kinematicSingleLayer/kinematicSingleLayer.C
@@ -163,7 +163,7 @@ tmp<volScalarField> kinematicSingleLayer::pu()
         (
             IOobject
             (
-                "pu",
+                typeName + ":pu",
                 time_.timeName(),
                 regionMesh(),
                 IOobject::NO_READ,
@@ -185,7 +185,7 @@ tmp<volScalarField> kinematicSingleLayer::pp()
         (
             IOobject
             (
-                "pp",
+                typeName + ":pp",
                 time_.timeName(),
                 regionMesh(),
                 IOobject::NO_READ,
@@ -216,6 +216,8 @@ void kinematicSingleLayer::updateSubmodels()
     // Update source fields
     const dimensionedScalar deltaT = time().deltaT();
     rhoSp_ += cloudMassTrans_/magSf()/deltaT;
+
+    turbulence_->correct();
 }
 
 
@@ -282,9 +284,7 @@ void kinematicSingleLayer::updateSurfaceVelocities()
     Uw_ -= nHat()*(Uw_ & nHat());
     Uw_.correctBoundaryConditions();
 
-    // apply quadratic profile to surface velocity (scale by sqrt(2))
-    Us_ = 1.414*U_;
-    Us_.correctBoundaryConditions();
+    Us_ = turbulence_->Us();
 }
 
 
@@ -309,6 +309,7 @@ tmp<Foam::fvVectorMatrix> kinematicSingleLayer::solveMomentum
 //      - fvm::SuSp(rhoSp_, U_)
       - rhoSp_*U_
       + forces_.correct(U_)
+      + turbulence_->Su(U_)
     );
 
     fvVectorMatrix& UEqn = tUEqn();
@@ -779,6 +780,8 @@ kinematicSingleLayer::kinematicSingleLayer
 
     injection_(*this, coeffs_),
 
+    turbulence_(filmTurbulenceModel::New(*this, coeffs_)),
+
     forces_(*this, coeffs_),
 
     addedMassTotal_(0.0)
@@ -1020,7 +1023,7 @@ tmp<volScalarField> kinematicSingleLayer::primaryMassTrans() const
         (
             IOobject
             (
-                "kinematicSingleLayer::primaryMassTrans",
+                typeName + ":primaryMassTrans",
                 time().timeName(),
                 primaryMesh(),
                 IOobject::NO_READ,
@@ -1075,7 +1078,7 @@ tmp<DimensionedField<scalar, volMesh> > kinematicSingleLayer::Srho() const
         (
             IOobject
             (
-                "kinematicSingleLayer::Srho",
+                typeName + ":Srho",
                 time().timeName(),
                 primaryMesh(),
                 IOobject::NO_READ,
@@ -1100,7 +1103,7 @@ tmp<DimensionedField<scalar, volMesh> > kinematicSingleLayer::Srho
         (
             IOobject
             (
-                "kinematicSingleLayer::Srho(" + Foam::name(i) + ")",
+                typeName + ":Srho(" + Foam::name(i) + ")",
                 time().timeName(),
                 primaryMesh(),
                 IOobject::NO_READ,
@@ -1122,7 +1125,7 @@ tmp<DimensionedField<scalar, volMesh> > kinematicSingleLayer::Sh() const
         (
             IOobject
             (
-                "kinematicSingleLayer::Sh",
+                typeName + ":Sh",
                 time().timeName(),
                 primaryMesh(),
                 IOobject::NO_READ,
diff --git a/src/regionModels/surfaceFilmModels/kinematicSingleLayer/kinematicSingleLayer.H b/src/regionModels/surfaceFilmModels/kinematicSingleLayer/kinematicSingleLayer.H
index 079999d0cd..2c9e1020a3 100644
--- a/src/regionModels/surfaceFilmModels/kinematicSingleLayer/kinematicSingleLayer.H
+++ b/src/regionModels/surfaceFilmModels/kinematicSingleLayer/kinematicSingleLayer.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -43,6 +43,7 @@ SourceFiles
 
 #include "injectionModelList.H"
 #include "forceList.H"
+#include "filmTurbulenceModel.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -197,6 +198,9 @@ protected:
             //- Cloud injection
             injectionModelList injection_;
 
+            //- Turbulence model
+            autoPtr<filmTurbulenceModel> turbulence_;
+
             //- List of film forces
             forceList forces_;
 
@@ -444,6 +448,9 @@ public:
             //- Injection
             inline injectionModelList& injection();
 
+            //- Turbulence
+            inline const filmTurbulenceModel& turbulence() const;
+
 
         // Helper functions
 
diff --git a/src/regionModels/surfaceFilmModels/kinematicSingleLayer/kinematicSingleLayerI.H b/src/regionModels/surfaceFilmModels/kinematicSingleLayer/kinematicSingleLayerI.H
index 6a77b614bc..15f6398ad8 100644
--- a/src/regionModels/surfaceFilmModels/kinematicSingleLayer/kinematicSingleLayerI.H
+++ b/src/regionModels/surfaceFilmModels/kinematicSingleLayer/kinematicSingleLayerI.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -169,6 +169,12 @@ inline injectionModelList& kinematicSingleLayer::injection()
 }
 
 
+inline const filmTurbulenceModel& kinematicSingleLayer::turbulence() const
+{
+    return turbulence_();
+}
+
+
 inline tmp<volScalarField> kinematicSingleLayer::mass() const
 {
     return rho_*delta_*magSf();
diff --git a/src/regionModels/surfaceFilmModels/submodels/kinematic/filmTurbulenceModel/filmTurbulenceModel/filmTurbulenceModel.C b/src/regionModels/surfaceFilmModels/submodels/kinematic/filmTurbulenceModel/filmTurbulenceModel/filmTurbulenceModel.C
new file mode 100644
index 0000000000..a77307e881
--- /dev/null
+++ b/src/regionModels/surfaceFilmModels/submodels/kinematic/filmTurbulenceModel/filmTurbulenceModel/filmTurbulenceModel.C
@@ -0,0 +1,73 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 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 "filmTurbulenceModel.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace regionModels
+{
+namespace surfaceFilmModels
+{
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+defineTypeNameAndDebug(filmTurbulenceModel, 0);
+defineRunTimeSelectionTable(filmTurbulenceModel, dictionary);
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+filmTurbulenceModel::filmTurbulenceModel(const surfaceFilmModel& owner)
+:
+    subModelBase(owner)
+{}
+
+
+filmTurbulenceModel::filmTurbulenceModel
+(
+    const word& type,
+    const surfaceFilmModel& owner,
+    const dictionary& dict
+)
+:
+    subModelBase(type, owner, dict)
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+filmTurbulenceModel::~filmTurbulenceModel()
+{}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace surfaceFilmModels
+} // End namespace regionModels
+} // End namespace Foam
+
+// ************************************************************************* //
diff --git a/src/regionModels/surfaceFilmModels/submodels/kinematic/filmTurbulenceModel/filmTurbulenceModel/filmTurbulenceModel.H b/src/regionModels/surfaceFilmModels/submodels/kinematic/filmTurbulenceModel/filmTurbulenceModel/filmTurbulenceModel.H
new file mode 100644
index 0000000000..571bf83e8d
--- /dev/null
+++ b/src/regionModels/surfaceFilmModels/submodels/kinematic/filmTurbulenceModel/filmTurbulenceModel/filmTurbulenceModel.H
@@ -0,0 +1,148 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 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::regionModels::surfaceFilmModels::filmTurbulenceModel
+
+Description
+    Base class for film turbulence models
+
+SourceFiles
+    filmTurbulenceModel.C
+    filmTurbulenceModelNew.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef filmTurbulenceModel_H
+#define filmTurbulenceModel_H
+
+#include "subModelBase.H"
+#include "runTimeSelectionTables.H"
+#include "fvMatricesFwd.H"
+#include "volFieldsFwd.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace regionModels
+{
+namespace surfaceFilmModels
+{
+
+/*---------------------------------------------------------------------------*\
+                       Class filmTurbulenceModel Declaration
+\*---------------------------------------------------------------------------*/
+
+class filmTurbulenceModel
+:
+    public subModelBase
+{
+private:
+
+    // Private Member Functions
+
+        //- Disallow default bitwise copy construct
+        filmTurbulenceModel(const filmTurbulenceModel&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const filmTurbulenceModel&);
+
+
+public:
+
+    //- Runtime type information
+    TypeName("filmTurbulenceModel");
+
+
+    // Declare runtime constructor selection table
+
+         declareRunTimeSelectionTable
+         (
+             autoPtr,
+             filmTurbulenceModel,
+             dictionary,
+             (
+                const surfaceFilmModel& owner,
+                const dictionary& dict
+             ),
+             (owner, dict)
+         );
+
+    // Constructors
+
+        //- Construct null
+        filmTurbulenceModel(const surfaceFilmModel& owner);
+
+        //- Construct from type name, dictionary and surface film model
+        filmTurbulenceModel
+        (
+            const word& type,
+            const surfaceFilmModel& owner,
+            const dictionary& dict
+        );
+
+
+    // Selectors
+
+        //- Return a reference to the selected injection model
+        static autoPtr<filmTurbulenceModel> New
+        (
+            const surfaceFilmModel& owner,
+            const dictionary& dict
+        );
+
+
+    //- Destructor
+    virtual ~filmTurbulenceModel();
+
+
+    // Member Functions
+
+        // Evolution
+
+            //- Return the film surface velocity
+            virtual tmp<volVectorField> Us() const = 0;
+
+            //- Return the film turbulence viscosity
+            virtual tmp<volScalarField> mut() const = 0;
+
+            //- Correct/update the model
+            virtual void correct() = 0;
+
+            //- Return the source for the film momentum equation
+            virtual tmp<fvVectorMatrix> Su(volVectorField& U) const = 0;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace surfaceFilmModels
+} // End namespace regionModels
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/regionModels/surfaceFilmModels/submodels/kinematic/filmTurbulenceModel/filmTurbulenceModel/filmTurbulenceModelNew.C b/src/regionModels/surfaceFilmModels/submodels/kinematic/filmTurbulenceModel/filmTurbulenceModel/filmTurbulenceModelNew.C
new file mode 100644
index 0000000000..ba939ef798
--- /dev/null
+++ b/src/regionModels/surfaceFilmModels/submodels/kinematic/filmTurbulenceModel/filmTurbulenceModel/filmTurbulenceModelNew.C
@@ -0,0 +1,77 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 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 "filmTurbulenceModel.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace regionModels
+{
+namespace surfaceFilmModels
+{
+
+// * * * * * * * * * * * * * * * * Selectors * * * * * * * * * * * * * * * * //
+
+autoPtr<filmTurbulenceModel> filmTurbulenceModel::New
+(
+    const surfaceFilmModel& model,
+    const dictionary& dict
+)
+{
+    const word modelType(dict.lookup("turbulence"));
+
+    Info<< "        " << modelType << endl;
+
+    dictionaryConstructorTable::iterator cstrIter =
+        dictionaryConstructorTablePtr_->find(modelType);
+
+    if (cstrIter == dictionaryConstructorTablePtr_->end())
+    {
+        FatalErrorIn
+        (
+            "filmTurbulenceModel::New"
+            "("
+                "const surfaceFilmModel&, "
+                "const dictionary&"
+            ")"
+        )   << "Unknown filmTurbulenceModel type " << modelType
+            << nl << nl << "Valid filmTurbulenceModel types are:" << nl
+            << dictionaryConstructorTablePtr_->toc()
+            << exit(FatalError);
+    }
+
+    return autoPtr<filmTurbulenceModel>(cstrIter()(model, dict));
+}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace surfaceFilmModels
+} // End namespace regionModels
+} // End namespace Foam
+
+// ************************************************************************* //
diff --git a/src/regionModels/surfaceFilmModels/submodels/kinematic/filmTurbulenceModel/laminar/laminar.C b/src/regionModels/surfaceFilmModels/submodels/kinematic/filmTurbulenceModel/laminar/laminar.C
new file mode 100644
index 0000000000..108109702b
--- /dev/null
+++ b/src/regionModels/surfaceFilmModels/submodels/kinematic/filmTurbulenceModel/laminar/laminar.C
@@ -0,0 +1,160 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2013 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 "laminar.H"
+#include "addToRunTimeSelectionTable.H"
+#include "fvMesh.H"
+#include "fvMatrices.H"
+#include "Time.H"
+#include "volFields.H"
+#include "fvmSup.H"
+#include "kinematicSingleLayer.H"
+#include "zeroGradientFvPatchFields.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace regionModels
+{
+namespace surfaceFilmModels
+{
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+defineTypeNameAndDebug(laminar, 0);
+addToRunTimeSelectionTable(filmTurbulenceModel, laminar, dictionary);
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+laminar::laminar
+(
+    const surfaceFilmModel& owner,
+    const dictionary& dict
+)
+:
+    filmTurbulenceModel(type(), owner, dict),
+    Cf_(readScalar(coeffs_.lookup("Cf")))
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+laminar::~laminar()
+{}
+
+
+// * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
+
+tmp<volVectorField> laminar::Us() const
+{
+    tmp<volVectorField> tUs
+    (
+        new volVectorField
+        (
+            IOobject
+            (
+                typeName + ".Us",
+                owner_.regionMesh().time().timeName(),
+                owner_.regionMesh(),
+                IOobject::NO_READ,
+                IOobject::NO_WRITE
+            ),
+            owner_.regionMesh(),
+            dimensionedVector("zero", dimVelocity, vector::zero),
+            zeroGradientFvPatchVectorField::typeName
+        )
+    );
+
+    // apply quadratic profile
+    tUs() = Foam::sqrt(2.0)*owner_.U();
+    tUs().correctBoundaryConditions();
+
+    return tUs;
+}
+
+
+tmp<volScalarField> laminar::mut() const
+{
+    return tmp<volScalarField>
+    (
+        new volScalarField
+        (
+            IOobject
+            (
+                typeName + ".mut",
+                owner_.regionMesh().time().timeName(),
+                owner_.regionMesh(),
+                IOobject::NO_READ,
+                IOobject::NO_WRITE
+            ),
+            owner_.regionMesh(),
+            dimensionedScalar("zero", dimMass/dimLength/dimTime, 0.0)
+        )
+    );
+}
+
+
+void laminar::correct()
+{
+    // do nothing
+}
+
+tmp<fvVectorMatrix> laminar::Su(volVectorField& U) const
+{
+    // local reference to film model
+    const kinematicSingleLayer& film =
+        static_cast<const kinematicSingleLayer&>(owner_);
+
+    // local references to film fields
+    const volScalarField& mu = film.mu();
+    const volVectorField& Uw = film.Uw();
+    const volVectorField& Us = film.Us();
+    const volScalarField& delta = film.delta();
+    const volVectorField& Up = film.UPrimary();
+    const volScalarField& rhop = film.rhoPrimary();
+
+    // employ simple coeff-based model
+    volScalarField Cs("Cs", Cf_*rhop*mag(Up - Us));
+
+    dimensionedScalar d0("SMALL", delta.dimensions(), SMALL);
+    volScalarField Cw("Cw", mu/(0.3333*(delta + d0)));
+    Cw.min(5000.0);
+
+    return
+    (
+       - fvm::Sp(Cs, U) + Cs*Us // surface contribution
+       - fvm::Sp(Cw, U) + Cw*Uw // wall contribution
+    );
+}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace surfaceFilmModels
+} // End namespace regionModels
+} // End namespace Foam
+
+// ************************************************************************* //
diff --git a/src/regionModels/surfaceFilmModels/submodels/kinematic/filmTurbulenceModel/laminar/laminar.H b/src/regionModels/surfaceFilmModels/submodels/kinematic/filmTurbulenceModel/laminar/laminar.H
new file mode 100644
index 0000000000..397030efff
--- /dev/null
+++ b/src/regionModels/surfaceFilmModels/submodels/kinematic/filmTurbulenceModel/laminar/laminar.H
@@ -0,0 +1,118 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 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::regionModels::surfaceFilmModels::laminar
+
+Description
+    Film laminar turbulence model.
+
+SourceFiles
+    laminar.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef laminar_H
+#define laminar_H
+
+#include "filmTurbulenceModel.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace regionModels
+{
+namespace surfaceFilmModels
+{
+
+/*---------------------------------------------------------------------------*\
+                           Class laminar Declaration
+\*---------------------------------------------------------------------------*/
+
+class laminar
+:
+    public filmTurbulenceModel
+{
+private:
+
+    // Private Data
+
+        //- Surface roughness coefficient
+        scalar Cf_;
+
+
+    // Private member functions
+
+        //- Disallow default bitwise copy construct
+        laminar(const laminar&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const laminar&);
+
+
+public:
+
+    //- Runtime type information
+    TypeName("laminar");
+
+
+    // Constructors
+
+        //- Construct from surface film model
+        laminar(const surfaceFilmModel& owner, const dictionary& dict);
+
+
+    //- Destructor
+    virtual ~laminar();
+
+
+    // Member Functions
+
+        // Evolution
+
+            //- Return the film surface velocity
+            virtual tmp<volVectorField> Us() const;
+
+            //- Return the film turbulence viscosity
+            virtual tmp<volScalarField> mut() const;
+
+            //- Correct/update the model
+            virtual void correct();
+
+            //- Return the source for the film momentum equation
+            virtual tmp<fvVectorMatrix> Su(volVectorField& U) const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace surfaceFilmModels
+} // End namespace regionModels
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/regionModels/surfaceFilmModels/thermoSingleLayer/thermoSingleLayerI.H b/src/regionModels/surfaceFilmModels/thermoSingleLayer/thermoSingleLayerI.H
index 659a315f49..0905176adf 100644
--- a/src/regionModels/surfaceFilmModels/thermoSingleLayer/thermoSingleLayerI.H
+++ b/src/regionModels/surfaceFilmModels/thermoSingleLayer/thermoSingleLayerI.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -25,6 +25,7 @@ License
 
 #include "thermoSingleLayer.H"
 #include "heatTransferModel.H"
+#include "filmRadiationModel.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
diff --git a/src/renumber/renumberMethods/structuredRenumber/structuredRenumber.C b/src/renumber/renumberMethods/structuredRenumber/structuredRenumber.C
index b0a13a8399..289adba5c9 100644
--- a/src/renumber/renumberMethods/structuredRenumber/structuredRenumber.C
+++ b/src/renumber/renumberMethods/structuredRenumber/structuredRenumber.C
@@ -202,7 +202,7 @@ Foam::labelList Foam::structuredRenumber::renumber
             if (depthFirst_)
             {
                 orderedToOld[nLayers*cellData[cellI].data()+layerI] = cellI;
-                                }
+            }
             else
             {
                 orderedToOld[cellData[cellI].data()+nLayers*layerI] = cellI;
diff --git a/src/thermophysicalModels/radiationModels/derivedFvPatchFields/greyDiffusiveRadiation/greyDiffusiveRadiationMixedFvPatchScalarField.C b/src/thermophysicalModels/radiationModels/derivedFvPatchFields/greyDiffusiveRadiation/greyDiffusiveRadiationMixedFvPatchScalarField.C
index 5817279076..52b3192c6d 100644
--- a/src/thermophysicalModels/radiationModels/derivedFvPatchFields/greyDiffusiveRadiation/greyDiffusiveRadiationMixedFvPatchScalarField.C
+++ b/src/thermophysicalModels/radiationModels/derivedFvPatchFields/greyDiffusiveRadiation/greyDiffusiveRadiationMixedFvPatchScalarField.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -189,51 +189,40 @@ updateCoeffs()
     }
 
     scalarField& Iw = *this;
-    const vectorField n(patch().Sf()/patch().magSf());
+    const vectorField n(patch().nf());
 
     radiativeIntensityRay& ray =
         const_cast<radiativeIntensityRay&>(dom.IRay(rayId));
 
-    ray.Qr().boundaryField()[patchI] += Iw*(n & ray.dAve());
+    const scalarField nAve(n & ray.dAve());
 
-    scalarField temissivity = emissivity();
+    ray.Qr().boundaryField()[patchI] += Iw*nAve;
+
+    const scalarField temissivity = emissivity();
+
+    scalarField& Qem = ray.Qem().boundaryField()[patchI];
+    scalarField& Qin = ray.Qin().boundaryField()[patchI];
+
+    const vector& myRayId = dom.IRay(rayId).d();
+
+    const scalarField& Ir = dom.Qin();
 
     forAll(Iw, faceI)
     {
-        scalar Ir = 0.0;
-
-        for (label rayI=0; rayI < dom.nRay(); rayI++)
-        {
-            const vector& d = dom.IRay(rayI).d();
-
-            const scalarField& IFace =
-                dom.IRay(rayI).ILambda(lambdaId).boundaryField()[patchI];
-
-            if ((-n[faceI] & d) < 0.0)
-            {
-                // q into the wall
-                const vector& dAve = dom.IRay(rayI).dAve();
-                Ir += IFace[faceI]*mag(n[faceI] & dAve);
-            }
-        }
-
-        const vector& d = dom.IRay(rayId).d();
-
-        if ((-n[faceI] & d) > 0.0)
+        if ((-n[faceI] & myRayId) > 0.0)
         {
             // direction out of the wall
             refGrad()[faceI] = 0.0;
             valueFraction()[faceI] = 1.0;
             refValue()[faceI] =
                 (
-                    Ir*(scalar(1.0) - temissivity[faceI])
+                    Ir[faceI]*(scalar(1.0) - temissivity[faceI])
                   + temissivity[faceI]*physicoChemical::sigma.value()
                   * pow4(Tp[faceI])
                 )/pi;
 
-             // Emmited heat flux from this ray direction
-            ray.Qem().boundaryField()[patchI][faceI] =
-                refValue()[faceI]*(n[faceI] & ray.dAve());
+            // Emmited heat flux from this ray direction
+            Qem[faceI] = refValue()[faceI]*nAve[faceI];
         }
         else
         {
@@ -242,9 +231,8 @@ updateCoeffs()
             refGrad()[faceI] = 0.0;
             refValue()[faceI] = 0.0; //not used
 
-             // Incident heat flux on this ray direction
-            ray.Qin().boundaryField()[patchI][faceI] =
-                Iw[faceI]*(n[faceI] & ray.dAve());
+            // Incident heat flux on this ray direction
+            Qin[faceI] = Iw[faceI]*nAve[faceI];
         }
     }
 
diff --git a/src/thermophysicalModels/radiationModels/derivedFvPatchFields/greyDiffusiveRadiation/greyDiffusiveRadiationMixedFvPatchScalarField.H b/src/thermophysicalModels/radiationModels/derivedFvPatchFields/greyDiffusiveRadiation/greyDiffusiveRadiationMixedFvPatchScalarField.H
index f1a38077e0..8f8b1aef17 100644
--- a/src/thermophysicalModels/radiationModels/derivedFvPatchFields/greyDiffusiveRadiation/greyDiffusiveRadiationMixedFvPatchScalarField.H
+++ b/src/thermophysicalModels/radiationModels/derivedFvPatchFields/greyDiffusiveRadiation/greyDiffusiveRadiationMixedFvPatchScalarField.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
diff --git a/src/thermophysicalModels/radiationModels/radiationModel/fvDOM/fvDOM/fvDOM.C b/src/thermophysicalModels/radiationModels/radiationModel/fvDOM/fvDOM/fvDOM.C
index 10961db032..4217231ce8 100644
--- a/src/thermophysicalModels/radiationModels/radiationModel/fvDOM/fvDOM/fvDOM.C
+++ b/src/thermophysicalModels/radiationModels/radiationModel/fvDOM/fvDOM/fvDOM.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -27,6 +27,7 @@ License
 #include "absorptionEmissionModel.H"
 #include "scatterModel.H"
 #include "constants.H"
+#include "fvm.H"
 
 using namespace Foam::constant;
 using namespace Foam::constant::mathematical;
@@ -172,10 +173,39 @@ void Foam::radiation::fvDOM::initialise()
     Info<< "fvDOM : Allocated " << IRay_.size()
         << " rays with average orientation:" << nl;
 
-    forAll(IRay_, i)
+    if (cacheDiv_)
     {
-        Info<< '\t' << IRay_[i].I().name()
-            << '\t' << IRay_[i].dAve() << nl;
+        Info<< "Caching div fvMatrix..."<< endl;
+        for (label lambdaI = 0; lambdaI < nLambda_; lambdaI++)
+        {
+            fvRayDiv_[lambdaI].setSize(nRay_);
+
+            forAll(IRay_, rayId)
+            {
+                const surfaceScalarField Ji(IRay_[rayId].dAve() & mesh_.Sf());
+                const volScalarField& iRayLambdaI =
+                    IRay_[rayId].ILambda(lambdaI);
+
+                fvRayDiv_[lambdaI].set
+                (
+                    rayId,
+                    new fvScalarMatrix
+                    (
+                        fvm::div(Ji, iRayLambdaI, "div(Ji,Ii_h)")
+                    )
+                );
+            }
+        }
+    }
+
+    forAll(IRay_, rayId)
+    {
+        if (omegaMax_ <  IRay_[rayId].omega())
+        {
+            omegaMax_ = IRay_[rayId].omega();
+        }
+        Info<< '\t' << IRay_[rayId].I().name() << " : " << "omega : "
+            << '\t' << IRay_[rayId].omega() << nl;
     }
 
     Info<< endl;
@@ -194,7 +224,7 @@ Foam::radiation::fvDOM::fvDOM(const volScalarField& T)
             "G",
             mesh_.time().timeName(),
             mesh_,
-            IOobject::READ_IF_PRESENT,
+            IOobject::NO_READ,
             IOobject::AUTO_WRITE
         ),
         mesh_,
@@ -247,7 +277,7 @@ Foam::radiation::fvDOM::fvDOM(const volScalarField& T)
             mesh_.time().timeName(),
             mesh_,
             IOobject::NO_READ,
-            IOobject::NO_WRITE
+            IOobject::AUTO_WRITE
         ),
         mesh_,
         dimensionedScalar("a", dimless/dimLength, 0.0)
@@ -260,7 +290,10 @@ Foam::radiation::fvDOM::fvDOM(const volScalarField& T)
     blackBody_(nLambda_, T),
     IRay_(0),
     convergence_(coeffs_.lookupOrDefault<scalar>("convergence", 0.0)),
-    maxIter_(coeffs_.lookupOrDefault<label>("maxIter", 50))
+    maxIter_(coeffs_.lookupOrDefault<label>("maxIter", 50)),
+    fvRayDiv_(nLambda_),
+    cacheDiv_(coeffs_.lookupOrDefault<bool>("cacheDiv", false)),
+    omegaMax_(0)
 {
     initialise();
 }
@@ -346,7 +379,10 @@ Foam::radiation::fvDOM::fvDOM
     blackBody_(nLambda_, T),
     IRay_(0),
     convergence_(coeffs_.lookupOrDefault<scalar>("convergence", 0.0)),
-    maxIter_(coeffs_.lookupOrDefault<label>("maxIter", 50))
+    maxIter_(coeffs_.lookupOrDefault<label>("maxIter", 50)),
+    fvRayDiv_(nLambda_),
+    cacheDiv_(coeffs_.lookupOrDefault<bool>("cacheDiv", false)),
+    omegaMax_(0)
 {
     initialise();
 }
@@ -364,7 +400,6 @@ bool Foam::radiation::fvDOM::read()
     if (radiationModel::read())
     {
         // Only reading solution parameters - not changing ray geometry
-
         coeffs_.readIfPresent("convergence", convergence_);
         coeffs_.readIfPresent("maxIter", maxIter_);
 
@@ -383,19 +418,30 @@ void Foam::radiation::fvDOM::calculate()
 
     updateBlackBodyEmission();
 
+    // Set rays convergence false
+    List<bool> rayIdConv(nRay_, false);
+
     scalar maxResidual = 0.0;
     label radIter = 0;
     do
     {
+        Info<< "Radiation solver iter: " << radIter << endl;
+
         radIter++;
+        maxResidual = 0.0;
         forAll(IRay_, rayI)
         {
-            maxResidual = 0.0;
-            scalar maxBandResidual = IRay_[rayI].correct();
-            maxResidual = max(maxBandResidual, maxResidual);
-        }
+            if (!rayIdConv[rayI])
+            {
+                scalar maxBandResidual = IRay_[rayI].correct();
+                maxResidual = max(maxBandResidual, maxResidual);
 
-        Info<< "Radiation solver iter: " << radIter << endl;
+                if (maxBandResidual < convergence_)
+                {
+                    rayIdConv[rayI] = true;
+                }
+            }
+        }
 
     } while (maxResidual > convergence_ && radIter < maxIter_);
 
@@ -433,7 +479,7 @@ Foam::radiation::fvDOM::Ru() const
     const DimensionedField<scalar, volMesh> E =
         absorptionEmission_->ECont()().dimensionedInternalField();
     const DimensionedField<scalar, volMesh> a =
-        a_.dimensionedInternalField(); //absorptionEmission_->aCont()()
+        a_.dimensionedInternalField();
 
     return  a*G - E;
 }
diff --git a/src/thermophysicalModels/radiationModels/radiationModel/fvDOM/fvDOM/fvDOM.H b/src/thermophysicalModels/radiationModels/radiationModel/fvDOM/fvDOM/fvDOM.H
index 48efae9ee6..3d9950db4c 100644
--- a/src/thermophysicalModels/radiationModels/radiationModel/fvDOM/fvDOM/fvDOM.H
+++ b/src/thermophysicalModels/radiationModels/radiationModel/fvDOM/fvDOM/fvDOM.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -30,6 +30,7 @@ Description
     directions in a participating media, not including scatter.
 
     Available absorption models:
+        constantAbsorptionEmission
         greyMeanAbsoprtionEmission
         wideBandAbsorptionEmission
 
@@ -37,9 +38,15 @@ Description
     \verbatim
         fvDOMCoeffs
         {
-            nPhi    1;          // azimuthal angles in PI/2 on X-Y.(from Y to X)
-            nTheta  2;          // polar angles in PI (from Z to X-Y plane)
-            convergence 1e-4;   // convergence criteria for radiation iteration
+            nPhi        4;          // azimuthal angles in PI/2 on X-Y.
+                                    //(from Y to X)
+            nTheta      0;          // polar angles in PI (from Z to X-Y plane)
+            convergence 1e-3;       // convergence criteria for radiation
+                                    //iteration
+            maxIter     4;          // maximum number of iterations
+            cacheDiv    true;       // cache the div of the RTE equation.
+            //NOTE: Caching div is "only" accurate if the upwind scheme is used
+            //in div(Ji,Ii_h)
         }
 
         solverFreq   1; // Number of flow iterations per radiation iteration
@@ -61,6 +68,7 @@ SourceFiles
 
 #include "radiativeIntensityRay.H"
 #include "radiationModel.H"
+#include "fvMatrices.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -79,6 +87,7 @@ class fvDOM
 {
     // Private data
 
+
         //- Incident radiation  [W/m2]
         volScalarField G_;
 
@@ -121,6 +130,15 @@ class fvDOM
         //- Maximum number of iterations
         scalar maxIter_;
 
+        //- List of cached fvMatrices for rays
+        List<PtrList<fvScalarMatrix> >fvRayDiv_;
+
+        //- Cache convection div matrix
+        bool cacheDiv_;
+
+        //- Maximum omega weight
+        scalar omegaMax_;
+
 
     // Private Member Functions
 
@@ -229,6 +247,19 @@ public:
 
             //- Const access to black body
             inline const blackBodyEmission& blackBody() const;
+
+            //- Const access to cached fvMatrix
+            inline const fvScalarMatrix& fvRayDiv
+            (
+                const label lambdaI,
+                const label rayId
+            ) const;
+
+            //- Caching div(Ji, Ilamda)
+            inline bool cacheDiv() const;
+
+            //- Return omegaMax
+            inline scalar omegaMax() const;
 };
 
 
diff --git a/src/thermophysicalModels/radiationModels/radiationModel/fvDOM/fvDOM/fvDOMI.H b/src/thermophysicalModels/radiationModels/radiationModel/fvDOM/fvDOM/fvDOMI.H
index de6e44f523..8bc9c6425e 100644
--- a/src/thermophysicalModels/radiationModels/radiationModel/fvDOM/fvDOM/fvDOMI.H
+++ b/src/thermophysicalModels/radiationModels/radiationModel/fvDOM/fvDOM/fvDOMI.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -102,6 +102,7 @@ inline const Foam::volScalarField& Foam::radiation::fvDOM::Qem() const
     return Qem_;
 }
 
+
 inline const Foam::radiation::blackBodyEmission&
 Foam::radiation::fvDOM::blackBody() const
 {
@@ -109,4 +110,26 @@ Foam::radiation::fvDOM::blackBody() const
 }
 
 
+inline const Foam::fvScalarMatrix& Foam::radiation::fvDOM::fvRayDiv
+(
+    const label rayId,
+    const label lambdaI
+) const
+{
+    return fvRayDiv_[lambdaI][rayId];
+}
+
+
+inline bool Foam::radiation::fvDOM::cacheDiv() const
+{
+    return cacheDiv_;
+}
+
+
+inline Foam::scalar Foam::radiation::fvDOM::omegaMax() const
+{
+    return omegaMax_;
+}
+
+
 // ************************************************************************* //
diff --git a/src/thermophysicalModels/radiationModels/radiationModel/fvDOM/radiativeIntensityRay/radiativeIntensityRay.C b/src/thermophysicalModels/radiationModels/radiationModel/fvDOM/radiativeIntensityRay/radiativeIntensityRay.C
index 947e3e5030..28644026a4 100644
--- a/src/thermophysicalModels/radiationModels/radiationModel/fvDOM/radiativeIntensityRay/radiativeIntensityRay.C
+++ b/src/thermophysicalModels/radiationModels/radiationModel/fvDOM/radiativeIntensityRay/radiativeIntensityRay.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -113,7 +113,8 @@ Foam::radiation::radiativeIntensityRay::radiativeIntensityRay
     phi_(phi),
     omega_(0.0),
     nLambda_(nLambda),
-    ILambda_(nLambda)
+    ILambda_(nLambda),
+    myRayId_(rayId)
 {
     scalar sinTheta = Foam::sin(theta);
     scalar cosTheta = Foam::cos(theta);
@@ -135,7 +136,6 @@ Foam::radiation::radiativeIntensityRay::radiativeIntensityRay
         0.5*deltaPhi*Foam::sin(2.0*theta)*Foam::sin(deltaTheta)
     );
 
-
     autoPtr<volScalarField> IDefaultPtr;
 
     forAll(ILambda_, lambdaI)
@@ -213,29 +213,51 @@ Foam::scalar Foam::radiation::radiativeIntensityRay::correct()
     {
         const volScalarField& k = dom_.aLambda(lambdaI);
 
-        const surfaceScalarField Ji(dAve_ & mesh_.Sf());
+        tmp<fvScalarMatrix> IiEq;
 
-        fvScalarMatrix IiEq
+        if (!dom_.cacheDiv())
+        {
+            const surfaceScalarField Ji(dAve_ & mesh_.Sf());
+
+            IiEq =
+            (
+                fvm::div(Ji, ILambda_[lambdaI], "div(Ji,Ii_h)")
+              + fvm::Sp(k*omega_, ILambda_[lambdaI])
+            ==
+                1.0/constant::mathematical::pi*omega_
+              * (
+                    k*blackBody_.bLambda(lambdaI)
+                  + absorptionEmission_.ECont(lambdaI)/4
+                )
+            );
+        }
+        else
+        {
+            IiEq =
+            (
+               dom_.fvRayDiv(myRayId_, lambdaI)
+             + fvm::Sp(k*omega_, ILambda_[lambdaI])
+           ==
+               1.0/constant::mathematical::pi*omega_
+             * (
+                   k*blackBody_.bLambda(lambdaI)
+                 + absorptionEmission_.ECont(lambdaI)/4
+               )
+            );
+        }
+
+        IiEq().relax();
+
+        const solverPerformance ILambdaSol = solve
         (
-            fvm::div(Ji, ILambda_[lambdaI], "div(Ji,Ii_h)")
-          + fvm::Sp(k*omega_, ILambda_[lambdaI])
-         ==
-            1.0/constant::mathematical::pi*omega_
-           *(
-                k*blackBody_.bLambda(lambdaI)
-              + absorptionEmission_.ECont(lambdaI)/4
-            )
+            IiEq(),
+            mesh_.solver("Ii")
         );
 
-        IiEq.relax();
+        const scalar initialRes =
+            ILambdaSol.initialResidual()*omega_/dom_.omegaMax();
 
-        scalar eqnResidual = solve
-        (
-            IiEq,
-            mesh_.solver("Ii")
-        ).initialResidual();
-
-        maxResidual = max(eqnResidual, maxResidual);
+        maxResidual = max(initialRes, maxResidual);
     }
 
     return maxResidual;
diff --git a/src/thermophysicalModels/radiationModels/radiationModel/fvDOM/radiativeIntensityRay/radiativeIntensityRay.H b/src/thermophysicalModels/radiationModels/radiationModel/fvDOM/radiativeIntensityRay/radiativeIntensityRay.H
index 83eed35d99..25f363044e 100644
--- a/src/thermophysicalModels/radiationModels/radiationModel/fvDOM/radiativeIntensityRay/radiativeIntensityRay.H
+++ b/src/thermophysicalModels/radiationModels/radiationModel/fvDOM/radiativeIntensityRay/radiativeIntensityRay.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -38,6 +38,7 @@ SourceFiles
 #include "absorptionEmissionModel.H"
 #include "blackBodyEmission.H"
 
+
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 namespace Foam
@@ -111,6 +112,9 @@ private:
         //- Global ray id - incremented in constructor
         static label rayId;
 
+        //- My ray Id
+        label myRayId_;
+
 
     // Private Member Functions
 
@@ -209,6 +213,7 @@ public:
 
             //- Return the radiative intensity for a given wavelength
             inline const volScalarField& ILambda(const label lambdaI) const;
+
 };
 
 
diff --git a/src/thermophysicalModels/radiationModels/submodels/absorptionEmissionModel/absorptionEmissionModel/absorptionEmissionModel.C b/src/thermophysicalModels/radiationModels/submodels/absorptionEmissionModel/absorptionEmissionModel/absorptionEmissionModel.C
index 982c7e3137..563b46727f 100644
--- a/src/thermophysicalModels/radiationModels/submodels/absorptionEmissionModel/absorptionEmissionModel/absorptionEmissionModel.C
+++ b/src/thermophysicalModels/radiationModels/submodels/absorptionEmissionModel/absorptionEmissionModel/absorptionEmissionModel.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -252,8 +252,8 @@ void Foam::radiation::absorptionEmissionModel::correct
     PtrList<volScalarField>& aj
 ) const
 {
-    a.internalField() = this->a();
-    aj[0].internalField() =  a.internalField();
+    a = this->a();
+    aj[0] =  a;
 }
 
 
diff --git a/src/turbulenceModels/compressible/LES/SpalartAllmaras/SpalartAllmaras.C b/src/turbulenceModels/compressible/LES/SpalartAllmaras/SpalartAllmaras.C
index 6994f926e3..324d857a31 100644
--- a/src/turbulenceModels/compressible/LES/SpalartAllmaras/SpalartAllmaras.C
+++ b/src/turbulenceModels/compressible/LES/SpalartAllmaras/SpalartAllmaras.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -63,20 +63,51 @@ tmp<volScalarField> SpalartAllmaras::fv1() const
 
 tmp<volScalarField> SpalartAllmaras::fv2() const
 {
-    return 1.0/pow3(scalar(1) + rho()*nuTilda_/(mu()*Cv2_));
+    if (ashfordCorrection_)
+    {
+        return 1.0/pow3(scalar(1) + rho()*nuTilda_/(mu()*Cv2_));
+    }
+    else
+    {
+        const volScalarField chi("chi", rho()*nuTilda_/mu());
+        return 1.0 - chi/(1.0 + chi*fv1());
+    }
 }
 
 
 tmp<volScalarField> SpalartAllmaras::fv3() const
 {
-    volScalarField chi(rho()*nuTilda_/mu());
-    volScalarField chiByCv2((1/Cv2_)*chi);
+    if (ashfordCorrection_)
+    {
+        volScalarField chi(rho()*nuTilda_/mu());
+        volScalarField chiByCv2((1/Cv2_)*chi);
 
-    return
-        (scalar(1) + chi*fv1())
-       *(1/Cv2_)
-       *(3*(scalar(1) + chiByCv2) + sqr(chiByCv2))
-       /pow3(scalar(1) + chiByCv2);
+        return
+            (scalar(1) + chi*fv1())
+           *(1/Cv2_)
+           *(3*(scalar(1) + chiByCv2) + sqr(chiByCv2))
+           /pow3(scalar(1) + chiByCv2);
+    }
+    else
+    {
+        return tmp<volScalarField>
+        (
+            new volScalarField
+            (
+                IOobject
+                (
+                    "fv3",
+                    mesh_.time().timeName(),
+                    mesh_,
+                    IOobject::NO_READ,
+                    IOobject::NO_WRITE
+                ),
+                mesh_,
+                dimensionedScalar("fv3", dimless, 1),
+                zeroGradientFvPatchScalarField::typeName
+            )
+        );
+    }
 }
 
 
@@ -222,6 +253,8 @@ SpalartAllmaras::SpalartAllmaras
         )
     ),
 
+    ashfordCorrection_(coeffDict_.lookupOrDefault("ashfordCorrection", true)),
+
     nuTilda_
     (
         IOobject
@@ -265,6 +298,11 @@ SpalartAllmaras::SpalartAllmaras
     updateSubGridScaleFields();
 
     printCoeffs();
+
+    if (ashfordCorrection_)
+    {
+        Info<< "    Employing Ashford correction" << endl;
+    }
 }
 
 
@@ -344,16 +382,19 @@ bool SpalartAllmaras::read()
     {
         sigmaNut_.readIfPresent(coeffDict());
         Prt_.readIfPresent(coeffDict());
+
         Cb1_.readIfPresent(coeffDict());
         Cb2_.readIfPresent(coeffDict());
-        Cw1_ = Cb1_/sqr(kappa_) + (1.0 + Cb2_)/sigmaNut_;
-        Cw2_.readIfPresent(coeffDict());
-        Cw3_.readIfPresent(coeffDict());
         Cv1_.readIfPresent(coeffDict());
         Cv2_.readIfPresent(coeffDict());
         CDES_.readIfPresent(coeffDict());
         ck_.readIfPresent(coeffDict());
         kappa_.readIfPresent(*this);
+        Cw1_ = Cb1_/sqr(kappa_) + (1.0 + Cb2_)/sigmaNut_;
+        Cw2_.readIfPresent(coeffDict());
+        Cw3_.readIfPresent(coeffDict());
+
+        ashfordCorrection_.readIfPresent("ashfordCorrection", coeffDict());
 
         return true;
     }
diff --git a/src/turbulenceModels/compressible/LES/SpalartAllmaras/SpalartAllmaras.H b/src/turbulenceModels/compressible/LES/SpalartAllmaras/SpalartAllmaras.H
index 1897578942..11d24d3388 100644
--- a/src/turbulenceModels/compressible/LES/SpalartAllmaras/SpalartAllmaras.H
+++ b/src/turbulenceModels/compressible/LES/SpalartAllmaras/SpalartAllmaras.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -30,6 +30,15 @@ Group
 Description
     SpalartAllmaras for compressible flows
 
+    Extended according to
+    \verbatim
+        "An Unstructured Grid Generation and Adaptive Solution Technique
+        for High Reynolds Number Compressible Flows"
+        G.A. Ashford,
+        Ph.D. thesis, University of Michigan, 1996.
+    \endverbatim
+    by using the optional flag \c ashfordCorrection
+
 SourceFiles
     SpalartAllmaras.C
 
@@ -77,12 +86,16 @@ class SpalartAllmaras
             dimensionedScalar Cw3_;
 
 
-    // Fields
+        //- Optional flag to activate the Ashford correction
+        Switch ashfordCorrection_;
 
-        volScalarField nuTilda_;
-        volScalarField dTilda_;
-        volScalarField muSgs_;
-        volScalarField alphaSgs_;
+
+        // Fields
+
+            volScalarField nuTilda_;
+            volScalarField dTilda_;
+            volScalarField muSgs_;
+            volScalarField alphaSgs_;
 
 
     // Private Member Functions
diff --git a/src/turbulenceModels/compressible/RAS/SpalartAllmaras/SpalartAllmaras.C b/src/turbulenceModels/compressible/RAS/SpalartAllmaras/SpalartAllmaras.C
index 6c5f3aae0c..9e5cf2d11f 100644
--- a/src/turbulenceModels/compressible/RAS/SpalartAllmaras/SpalartAllmaras.C
+++ b/src/turbulenceModels/compressible/RAS/SpalartAllmaras/SpalartAllmaras.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -63,7 +63,14 @@ tmp<volScalarField> SpalartAllmaras::fv2
     const volScalarField& fv1
 ) const
 {
-    return 1.0/pow3(scalar(1) + chi/Cv2_);
+    if (ashfordCorrection_)
+    {
+        return 1.0/pow3(scalar(1) + chi/Cv2_);
+    }
+    else
+    {
+        return 1.0 - chi/(1.0 + chi*fv1);
+    }
 }
 
 
@@ -73,13 +80,36 @@ tmp<volScalarField> SpalartAllmaras::fv3
     const volScalarField& fv1
 ) const
 {
-    const volScalarField chiByCv2((1/Cv2_)*chi);
+    if (ashfordCorrection_)
+    {
+        const volScalarField chiByCv2((1/Cv2_)*chi);
 
-    return
-        (scalar(1) + chi*fv1)
-       *(1/Cv2_)
-       *(3*(scalar(1) + chiByCv2) + sqr(chiByCv2))
-       /pow3(scalar(1) + chiByCv2);
+        return
+            (scalar(1) + chi*fv1)
+           *(1/Cv2_)
+           *(3*(scalar(1) + chiByCv2) + sqr(chiByCv2))
+           /pow3(scalar(1) + chiByCv2);
+    }
+    else
+    {
+        return tmp<volScalarField>
+        (
+            new volScalarField
+            (
+                IOobject
+                (
+                    "fv3",
+                    mesh_.time().timeName(),
+                    mesh_,
+                    IOobject::NO_READ,
+                    IOobject::NO_WRITE
+                ),
+                mesh_,
+                dimensionedScalar("fv3", dimless, 1),
+                zeroGradientFvPatchScalarField::typeName
+            )
+        );
+    }
 }
 
 
@@ -252,6 +282,11 @@ SpalartAllmaras::SpalartAllmaras
     alphat_.correctBoundaryConditions();
 
     printCoeffs();
+
+    if (ashfordCorrection_)
+    {
+        Info<< "    Employing Ashford correction" << endl;
+    }
 }
 
 
@@ -372,6 +407,8 @@ bool SpalartAllmaras::read()
         Cv1_.readIfPresent(coeffDict());
         Cv2_.readIfPresent(coeffDict());
 
+        ashfordCorrection_.readIfPresent("ashfordCorrection", coeffDict());
+
         return true;
     }
     else
diff --git a/src/turbulenceModels/compressible/RAS/SpalartAllmaras/SpalartAllmaras.H b/src/turbulenceModels/compressible/RAS/SpalartAllmaras/SpalartAllmaras.H
index ea829fc88d..ce1054c482 100644
--- a/src/turbulenceModels/compressible/RAS/SpalartAllmaras/SpalartAllmaras.H
+++ b/src/turbulenceModels/compressible/RAS/SpalartAllmaras/SpalartAllmaras.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -37,14 +37,16 @@ Description
         P.R. Spalart,
         S.R. Allmaras,
         La Recherche Aerospatiale, No. 1, 1994, pp. 5-21.
+    \endverbatim
 
-        Extended according to:
-
+    Extended according to:
+    \verbatim
         "An Unstructured Grid Generation and Adaptive Solution Technique
         for High Reynolds Number Compressible Flows"
         G.A. Ashford,
         Ph.D. thesis, University of Michigan, 1996.
     \endverbatim
+    by using the optional flag \c ashfordCorrection
 
     The default model coefficients correspond to the following:
     \verbatim
@@ -110,6 +112,10 @@ protected:
             dimensionedScalar Cv2_;
 
 
+        //- Optional flag to activate the Ashford correction
+        Switch ashfordCorrection_;
+
+
         // Fields
 
             volScalarField nuTilda_;
diff --git a/src/turbulenceModels/derivedFvPatchFields/porousBafflePressure/porousBafflePressureFvPatchField.H b/src/turbulenceModels/derivedFvPatchFields/porousBafflePressure/porousBafflePressureFvPatchField.H
index a52e8e5b34..ed22575785 100644
--- a/src/turbulenceModels/derivedFvPatchFields/porousBafflePressure/porousBafflePressureFvPatchField.H
+++ b/src/turbulenceModels/derivedFvPatchFields/porousBafflePressure/porousBafflePressureFvPatchField.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -34,7 +34,7 @@ Description
     The porous baffle introduces a pressure jump defined by:
 
         \f[
-            \Delta p = -(I \mu U + 0.5 D \rho |U|^2 L)
+            \Delta p = -(I \mu U + 0.5 D \rho |U|^2 )L
         \f]
 
     where
diff --git a/src/turbulenceModels/derivedFvPatchFields/porousBafflePressure/porousBafflePressureFvPatchFields.C b/src/turbulenceModels/derivedFvPatchFields/porousBafflePressure/porousBafflePressureFvPatchFields.C
index 08855fa7fb..32317c0ad1 100644
--- a/src/turbulenceModels/derivedFvPatchFields/porousBafflePressure/porousBafflePressureFvPatchFields.C
+++ b/src/turbulenceModels/derivedFvPatchFields/porousBafflePressure/porousBafflePressureFvPatchFields.C
@@ -78,7 +78,7 @@ void Foam::porousBafflePressureFvPatchField<Foam::scalar>::updateCoeffs()
 
         const scalarField nuEffw = turbModel.nuEff()().boundaryField()[patchI];
 
-        jump_ = -sign(Un)*(I_*nuEffw + D_*0.5*magUn*length_)*magUn;
+        jump_ = -sign(Un)*(I_*nuEffw + D_*0.5*magUn)*magUn*length_;
     }
     else
     {
@@ -95,7 +95,7 @@ void Foam::porousBafflePressureFvPatchField<Foam::scalar>::updateCoeffs()
 
         Un /= rhow;
 
-        jump_ = -sign(Un)*(I_*muEffw + D_*0.5*rhow*magUn*length_)*magUn;
+        jump_ = -sign(Un)*(I_*muEffw + D_*0.5*rhow*magUn)*magUn*length_;
     }
 
     if (debug)
diff --git a/src/turbulenceModels/incompressible/LES/SpalartAllmaras/SpalartAllmaras.C b/src/turbulenceModels/incompressible/LES/SpalartAllmaras/SpalartAllmaras.C
index 4bbf67702a..39afb02f30 100644
--- a/src/turbulenceModels/incompressible/LES/SpalartAllmaras/SpalartAllmaras.C
+++ b/src/turbulenceModels/incompressible/LES/SpalartAllmaras/SpalartAllmaras.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -60,20 +60,51 @@ tmp<volScalarField> SpalartAllmaras::fv1() const
 
 tmp<volScalarField> SpalartAllmaras::fv2() const
 {
-    return 1/pow3(scalar(1) + nuTilda_/(Cv2_*nu()));
+    if (ashfordCorrection_)
+    {
+        return 1/pow3(scalar(1) + nuTilda_/(Cv2_*nu()));
+    }
+    else
+    {
+        const volScalarField chi("chi", nuTilda_/nu());
+        return 1.0 - chi/(1.0 + chi*fv1());
+    }
 }
 
 
 tmp<volScalarField> SpalartAllmaras::fv3() const
 {
-    const volScalarField chi("chi", nuTilda_/nu());
-    const volScalarField chiByCv2(chi/Cv2_);
+    if (ashfordCorrection_)
+    {
+        const volScalarField chi("chi", nuTilda_/nu());
+        const volScalarField chiByCv2(chi/Cv2_);
 
-    return
-        (scalar(1) + chi*fv1())
-       *(1/Cv2_)
-       *(3*(scalar(1) + chiByCv2) + sqr(chiByCv2))
-       /pow3(scalar(1) + chiByCv2);
+        return
+            (scalar(1) + chi*fv1())
+           *(1/Cv2_)
+           *(3*(scalar(1) + chiByCv2) + sqr(chiByCv2))
+           /pow3(scalar(1) + chiByCv2);
+    }
+    else
+    {
+        return tmp<volScalarField>
+        (
+            new volScalarField
+            (
+                IOobject
+                (
+                    "fv3",
+                    mesh_.time().timeName(),
+                    mesh_,
+                    IOobject::NO_READ,
+                    IOobject::NO_WRITE
+                ),
+                mesh_,
+                dimensionedScalar("fv3", dimless, 1),
+                zeroGradientFvPatchScalarField::typeName
+            )
+        );
+    }
 }
 
 
@@ -246,6 +277,8 @@ SpalartAllmaras::SpalartAllmaras
         )
     ),
 
+    ashfordCorrection_(coeffDict_.lookupOrDefault("ashfordCorrection", true)),
+
     y_(mesh_),
 
     nuTilda_
@@ -275,6 +308,11 @@ SpalartAllmaras::SpalartAllmaras
     )
 {
     updateSubGridScaleFields();
+
+    if (ashfordCorrection_)
+    {
+        Info<< "    Employing Ashford correction" << endl;
+    }
 }
 
 
@@ -376,6 +414,7 @@ bool SpalartAllmaras::read()
     {
         sigmaNut_.readIfPresent(coeffDict());
         kappa_.readIfPresent(*this);
+
         Cb1_.readIfPresent(coeffDict());
         Cb2_.readIfPresent(coeffDict());
         Cv1_.readIfPresent(coeffDict());
@@ -386,6 +425,8 @@ bool SpalartAllmaras::read()
         Cw2_.readIfPresent(coeffDict());
         Cw3_.readIfPresent(coeffDict());
 
+        ashfordCorrection_.readIfPresent("ashfordCorrection", coeffDict());
+
         return true;
     }
     else
diff --git a/src/turbulenceModels/incompressible/LES/SpalartAllmaras/SpalartAllmaras.H b/src/turbulenceModels/incompressible/LES/SpalartAllmaras/SpalartAllmaras.H
index fe4fe280f3..3f3b39e12b 100644
--- a/src/turbulenceModels/incompressible/LES/SpalartAllmaras/SpalartAllmaras.H
+++ b/src/turbulenceModels/incompressible/LES/SpalartAllmaras/SpalartAllmaras.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -30,6 +30,15 @@ Group
 Description
     SpalartAllmaras DES (SA + LES) turbulence model for incompressible flows
 
+    Extended according to
+    \verbatim
+        "An Unstructured Grid Generation and Adaptive Solution Technique
+        for High Reynolds Number Compressible Flows"
+        G.A. Ashford,
+        Ph.D. thesis, University of Michigan, 1996.
+    \endverbatim
+    by using the optional flag \c ashfordCorrection
+
 SourceFiles
     SpalartAllmaras.C
 
@@ -90,6 +99,10 @@ protected:
             dimensionedScalar Cw3_;
 
 
+        //- Optional flag to activate the Ashford correction
+        Switch ashfordCorrection_;
+
+
         // Fields
 
             wallDist y_;
diff --git a/src/turbulenceModels/incompressible/RAS/SpalartAllmaras/SpalartAllmaras.C b/src/turbulenceModels/incompressible/RAS/SpalartAllmaras/SpalartAllmaras.C
index 76046a80e2..999978f3c9 100644
--- a/src/turbulenceModels/incompressible/RAS/SpalartAllmaras/SpalartAllmaras.C
+++ b/src/turbulenceModels/incompressible/RAS/SpalartAllmaras/SpalartAllmaras.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -61,7 +61,14 @@ tmp<volScalarField> SpalartAllmaras::fv2
     const volScalarField& fv1
 ) const
 {
-    return 1.0/pow3(scalar(1) + chi/Cv2_);
+    if (ashfordCorrection_)
+    {
+        return 1.0/pow3(scalar(1) + chi/Cv2_);
+    }
+    else
+    {
+        return 1.0 - chi/(1.0 + chi*fv1);
+    }
 }
 
 
@@ -71,13 +78,36 @@ tmp<volScalarField> SpalartAllmaras::fv3
     const volScalarField& fv1
 ) const
 {
-    const volScalarField chiByCv2((1/Cv2_)*chi);
+    if (ashfordCorrection_)
+    {
+        const volScalarField chiByCv2((1/Cv2_)*chi);
 
-    return
-        (scalar(1) + chi*fv1)
-       *(1/Cv2_)
-       *(3*(scalar(1) + chiByCv2) + sqr(chiByCv2))
-       /pow3(scalar(1) + chiByCv2);
+        return
+            (scalar(1) + chi*fv1)
+           *(1/Cv2_)
+           *(3*(scalar(1) + chiByCv2) + sqr(chiByCv2))
+           /pow3(scalar(1) + chiByCv2);
+    }
+    else
+    {
+        return tmp<volScalarField>
+        (
+            new volScalarField
+            (
+                IOobject
+                (
+                    "fv3",
+                    mesh_.time().timeName(),
+                    mesh_,
+                    IOobject::NO_READ,
+                    IOobject::NO_WRITE
+                ),
+                mesh_,
+                dimensionedScalar("fv3", dimless, 1),
+                zeroGradientFvPatchScalarField::typeName
+            )
+        );
+    }
 }
 
 
@@ -195,6 +225,8 @@ SpalartAllmaras::SpalartAllmaras
         )
     ),
 
+    ashfordCorrection_(coeffDict_.lookupOrDefault("ashfordCorrection", true)),
+
     nuTilda_
     (
         IOobject
@@ -224,6 +256,11 @@ SpalartAllmaras::SpalartAllmaras
     d_(mesh_)
 {
     printCoeffs();
+
+    if (ashfordCorrection_)
+    {
+        Info<< "    Employing Ashford correction" << endl;
+    }
 }
 
 
@@ -368,6 +405,8 @@ bool SpalartAllmaras::read()
         Cv1_.readIfPresent(coeffDict());
         Cv2_.readIfPresent(coeffDict());
 
+        ashfordCorrection_.readIfPresent("ashfordCorrection", coeffDict());
+
         return true;
     }
     else
diff --git a/src/turbulenceModels/incompressible/RAS/SpalartAllmaras/SpalartAllmaras.H b/src/turbulenceModels/incompressible/RAS/SpalartAllmaras/SpalartAllmaras.H
index d7479c2dd5..597b0859c4 100644
--- a/src/turbulenceModels/incompressible/RAS/SpalartAllmaras/SpalartAllmaras.H
+++ b/src/turbulenceModels/incompressible/RAS/SpalartAllmaras/SpalartAllmaras.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -37,14 +37,16 @@ Description
         P.R. Spalart,
         S.R. Allmaras,
         La Recherche Aerospatiale, No. 1, 1994, pp. 5-21.
+    \endverbatim
 
-        Extended according to:
-
+    Extended according to
+    \verbatim
         "An Unstructured Grid Generation and Adaptive Solution Technique
         for High Reynolds Number Compressible Flows"
         G.A. Ashford,
         Ph.D. thesis, University of Michigan, 1996.
     \endverbatim
+    using the optional flag \c ashfordCorrection
 
     The default model coefficients correspond to the following:
     \verbatim
@@ -82,7 +84,7 @@ namespace RASModels
 {
 
 /*---------------------------------------------------------------------------*\
-                           Class SpalartAllmaras Declaration
+                       Class SpalartAllmaras Declaration
 \*---------------------------------------------------------------------------*/
 
 class SpalartAllmaras
@@ -108,6 +110,10 @@ protected:
             dimensionedScalar Cv2_;
 
 
+        //- Optional flag to activate the Ashford correction
+        Switch ashfordCorrection_;
+
+
         // Fields
 
             volScalarField nuTilda_;
diff --git a/tutorials/combustion/fireFoam/les/oppositeBurningPanels/0/G b/tutorials/combustion/fireFoam/les/oppositeBurningPanels/0/G
new file mode 100644
index 0000000000..fd53ea0248
--- /dev/null
+++ b/tutorials/combustion/fireFoam/les/oppositeBurningPanels/0/G
@@ -0,0 +1,41 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  dev                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       volScalarField;
+    object      G;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+dimensions      [1 0 -3 0 0 0 0];
+
+internalField   uniform 0;
+
+boundaryField
+{
+    ".*"
+    {
+        type            MarshakRadiation;
+        T               T;
+        emissivityMode  lookup;
+        emissivity      uniform 1.0;
+        value           uniform 0;
+    }
+
+    "(region0_to.*)"
+    {
+        type            MarshakRadiation;
+        T               T;
+        emissivityMode  solidRadiation;
+        value           uniform 0;
+    }
+}
+
+// ************************************************************************* //
diff --git a/tutorials/combustion/fireFoam/les/oppositeBurningPanels/constant/radiationProperties b/tutorials/combustion/fireFoam/les/oppositeBurningPanels/constant/radiationProperties
index 89ee652071..ae6091de4d 100644
--- a/tutorials/combustion/fireFoam/les/oppositeBurningPanels/constant/radiationProperties
+++ b/tutorials/combustion/fireFoam/les/oppositeBurningPanels/constant/radiationProperties
@@ -24,21 +24,24 @@ fvDOMCoeffs
 {
     nPhi    3;          // azimuthal angles in PI/2 on X-Y.(from Y to X)
     nTheta  6;          // polar angles in PI (from Z to X-Y plane)
-    convergence 1e-4;   // convergence criteria for radiation iteration
-    maxIter 2;         // maximum number of iterations
+    convergence 0.05;   // convergence criteria for radiation iteration
+    maxIter 3;          // maximum number of iterations
+    cacheDiv    true;   // cache the div of the RTE equation.
+
+// NOTE: Caching div is "only" accurate if the upwind scheme is used in
+// div(Ji,Ii_h)
 }
 
 // Number of flow iterations per radiation iteration
 solverFreq 10;
 
 absorptionEmissionModel constantAbsorptionEmission;
-//absorptionEmissionModel greyMeanAbsorptionEmission;
 
 constantAbsorptionEmissionCoeffs
 {
-    absorptivity    absorptivity [ 0 -1 0 0 0 0 0 ] 0.01;
-    emissivity      emissivity [ 0 -1 0 0 0 0 0 ] 0.01;
-    E               E [ 1 -1 -3 0 0 0 0 ] 0;
+    absorptivity    absorptivity    [ m^-1 ]       0.01;
+    emissivity      emissivity      [ m^-1 ]       0.01;
+    E               E               [ kg m^-1 s^-3 ]  0;
 }
 
 greyMeanAbsorptionEmissionCoeffs
@@ -49,7 +52,7 @@ greyMeanAbsorptionEmissionCoeffs
 
     CO2
     {
-        Tcommon         300;   //Common Temp
+        Tcommon         200;   //Common Temp
         invTemp         true;   //Is the polynomio using inverse temperature.
         Tlow            200;   //Low Temp
         Thigh           2500;  //High Temp
@@ -77,7 +80,7 @@ greyMeanAbsorptionEmissionCoeffs
 
     H2O
     {
-        Tcommon         300;
+        Tcommon         200;
         invTemp         true;
         Tlow            200;
         Thigh           2500;
@@ -104,7 +107,7 @@ greyMeanAbsorptionEmissionCoeffs
 
     C3H8//CH4
     {
-        Tcommon         300;
+        Tcommon         200;
         Tlow            200;
         Thigh           2000;
         invTemp         false;
@@ -131,7 +134,7 @@ greyMeanAbsorptionEmissionCoeffs
 
     O2
     {
-        Tcommon         300;
+        Tcommon         200;
         invTemp         true;
         Tlow            200;
         Thigh           2500;
@@ -159,7 +162,7 @@ greyMeanAbsorptionEmissionCoeffs
 
     N2
     {
-        Tcommon         300;
+        Tcommon         200;
         invTemp         true;
         Tlow            200;
         Thigh           2500;
diff --git a/tutorials/combustion/fireFoam/les/oppositeBurningPanels/system/controlDict b/tutorials/combustion/fireFoam/les/oppositeBurningPanels/system/controlDict
index 3efab07aeb..eb03206ed1 100644
--- a/tutorials/combustion/fireFoam/les/oppositeBurningPanels/system/controlDict
+++ b/tutorials/combustion/fireFoam/les/oppositeBurningPanels/system/controlDict
@@ -16,7 +16,7 @@ FoamFile
 
 application     fireFoam;
 
-startFrom       startTime;
+startFrom       latestTime;
 
 startTime       0;
 
@@ -28,11 +28,11 @@ deltaT          0.03;
 
 writeControl    adjustableRunTime;
 
-writeInterval   1;
+writeInterval   0.5;
 
 purgeWrite      0;
 
-writeFormat     ascii;
+writeFormat     binary;
 
 writePrecision  12;
 
diff --git a/tutorials/combustion/fireFoam/les/oppositeBurningPanels/system/fvSolution b/tutorials/combustion/fireFoam/les/oppositeBurningPanels/system/fvSolution
index 3a3bd03c73..7345991f71 100644
--- a/tutorials/combustion/fireFoam/les/oppositeBurningPanels/system/fvSolution
+++ b/tutorials/combustion/fireFoam/les/oppositeBurningPanels/system/fvSolution
@@ -34,7 +34,7 @@ solvers
     p_rgh
     {
         solver              GAMG;
-        tolerance           1e-5;
+        tolerance           1e-7;
         relTol              0.01;
         smoother            GaussSeidel;
         cacheAgglomeration  true;
@@ -45,28 +45,25 @@ solvers
 
     p_rghFinal
     {
-        solver              GAMG;
-        tolerance           1e-6;
+        $p_rgh;
+        tolerance           1e-7;
         relTol              0;
-        smoother            GaussSeidel;
-        cacheAgglomeration  true;
-        nCellsInCoarsestLevel 10;
-        agglomerator     faceAreaPair;
-        mergeLevels      1;
     };
 
 
-    "(U|k)"
+    "(U|Yi|k|h|omega)"
     {
         solver          PBiCG;
         preconditioner  DILU;
-        tolerance       1e-6;
-        relTol          0.01;
+        tolerance       1e-7;
+        relTol          0.1;
+        nSweeps         1;
     };
 
-    "(U|k)Final"
+    "(U|Yi|k|h|omega)Final"
     {
         $U;
+        tolerance       1e-7;
         relTol          0;
     };
 
@@ -84,18 +81,21 @@ solvers
         solver              GAMG;
         tolerance           1e-4;
         relTol              0;
-        smoother            DILU;
+        smoother            symGaussSeidel;
         cacheAgglomeration  true;
         nCellsInCoarsestLevel   10;
         agglomerator    faceAreaPair;
-        mergeLevels     1;
+        mergeLevels         1;
+        maxIter             1;
+        nPreSweeps          0;
+        nPostSweeps         1;
     }
 
-    G
+    "(G)Final"
     {
         solver          PCG;
         preconditioner  DIC;
-        tolerance       1e-06;
+        tolerance       1e-04;
         relTol          0;
     }
 
@@ -104,8 +104,8 @@ solvers
 PIMPLE
 {
     momentumPredictor yes;
-    nOuterCorrectors  2;
-    nCorrectors       1;
+    nOuterCorrectors  1;
+    nCorrectors       3;
     nNonOrthogonalCorrectors 0;
 }
 
@@ -117,7 +117,7 @@ relaxationFactors
     equations
     {
         "(U|k).*"                   1;
-        "(C3H8|O2|H2O|CO2|h).*"    1;
+        "(C3H8|O2|H2O|CO2|h).*"     1;
     }
 }
 
diff --git a/tutorials/combustion/fireFoam/les/smallPoolFire2D/constant/radiationProperties b/tutorials/combustion/fireFoam/les/smallPoolFire2D/constant/radiationProperties
index 9ff932edc9..62b677bd77 100644
--- a/tutorials/combustion/fireFoam/les/smallPoolFire2D/constant/radiationProperties
+++ b/tutorials/combustion/fireFoam/les/smallPoolFire2D/constant/radiationProperties
@@ -19,10 +19,14 @@ radiationModel  fvDOM;
 
 fvDOMCoeffs
 {
-    nPhi    4;          // azimuthal angles in PI/2 on X-Y.(from Y to X)
-    nTheta  0;          // polar angles in PI (from Z to X-Y plane)
-    convergence 1e-3;   // convergence criteria for radiation iteration
-    maxIter 1;          // maximum number of iterations
+    nPhi        4;          // azimuthal angles in PI/2 on X-Y.(from Y to X)
+    nTheta      0;          // polar angles in PI (from Z to X-Y plane)
+    convergence 1e-2;       // convergence criteria for radiation iteration
+    maxIter     4;          // maximum number of iterations
+    cacheDiv    true;       // cache the div of the RTE equation.
+
+// NOTE: Caching div is "only" accurate if the upwind scheme is used in
+// div(Ji,Ii_h)
 }
 
 // Number of flow iterations per radiation iteration
@@ -32,9 +36,9 @@ absorptionEmissionModel greyMeanAbsorptionEmission;
 
 constantAbsorptionEmissionCoeffs
 {
-   absorptivity    absorptivity    [ 0 -1 0 0 0 0 0 ] 0.1;
-   emissivity      emissivity      [ 0 -1 0 0 0 0 0 ] 0.1;
-   E               E   [ 1 -1 -3 0 0 0 0 ] 0;
+    absorptivity    absorptivity    [ m^-1 ]       0.01;
+    emissivity      emissivity      [ m^-1 ]       0.01;
+    E               E               [ kg m^-1 s^-3 ]  0;
 }
 
 greyMeanAbsorptionEmissionCoeffs
@@ -45,7 +49,7 @@ greyMeanAbsorptionEmissionCoeffs
 
     CO2
     {
-        Tcommon         300;   //Common Temp
+        Tcommon         200;   //Common Temp
         invTemp         true;   //Is the polynomio using inverse temperature.
         Tlow            200;   //Low Temp
         Thigh           2500;  //High Temp
@@ -73,7 +77,7 @@ greyMeanAbsorptionEmissionCoeffs
 
     H2O
     {
-        Tcommon         300;
+        Tcommon         200;
         invTemp         true;
         Tlow            200;
         Thigh           2500;
@@ -100,7 +104,7 @@ greyMeanAbsorptionEmissionCoeffs
 
     CH4
     {
-        Tcommon         300;
+        Tcommon         200;
         Tlow            200;
         Thigh           2500;
         invTemp         false;
@@ -127,7 +131,7 @@ greyMeanAbsorptionEmissionCoeffs
 
     O2
     {
-        Tcommon         300;
+        Tcommon         200;
         invTemp         true;
         Tlow            200;
         Thigh           2500;
@@ -155,7 +159,7 @@ greyMeanAbsorptionEmissionCoeffs
 
     N2
     {
-        Tcommon         300;
+        Tcommon         200;
         invTemp         true;
         Tlow            200;
         Thigh           2500;
diff --git a/tutorials/combustion/fireFoam/les/smallPoolFire2D/system/controlDict b/tutorials/combustion/fireFoam/les/smallPoolFire2D/system/controlDict
index 8420fc7598..689f2a866c 100644
--- a/tutorials/combustion/fireFoam/les/smallPoolFire2D/system/controlDict
+++ b/tutorials/combustion/fireFoam/les/smallPoolFire2D/system/controlDict
@@ -48,8 +48,6 @@ runTimeModifiable yes;
 
 adjustTimeStep  yes;
 
-maxCo           0.25;
-
-maxDeltaT       0.1;
+maxCo           0.5;
 
 // ************************************************************************* //
diff --git a/tutorials/combustion/fireFoam/les/smallPoolFire2D/system/fvSolution b/tutorials/combustion/fireFoam/les/smallPoolFire2D/system/fvSolution
index d7bebcf0bb..fba625916d 100644
--- a/tutorials/combustion/fireFoam/les/smallPoolFire2D/system/fvSolution
+++ b/tutorials/combustion/fireFoam/les/smallPoolFire2D/system/fvSolution
@@ -72,21 +72,24 @@ solvers
 
     Ii
     {
-        solver              GAMG;
+         solver              GAMG;
         tolerance           1e-4;
-        relTol              0;
-        smoother            DILU;
+        relTol              0.1;
+        smoother            symGaussSeidel;
         cacheAgglomeration  true;
         nCellsInCoarsestLevel   10;
-        agglomerator    faceAreaPair;
-        mergeLevels     1;
+        agglomerator      faceAreaPair;
+        mergeLevels         1;
+        maxIter             3;
+        nPreSweeps          0;
+        nPostSweeps         1;
     }
 
     G
     {
         solver          PCG;
         preconditioner  DIC;
-        tolerance       1e-06;
+        tolerance       1e-04;
         relTol          0;
     }
 
@@ -108,7 +111,7 @@ relaxationFactors
     equations
     {
         "(U|k).*"                   1;
-        "(C3H8|O2|H2O|CO2|h).*"    0.9;
+        "(C3H8|O2|H2O|CO2|h).*"     1;
     }
 }
 
diff --git a/tutorials/combustion/fireFoam/les/smallPoolFire3D/0/IDefault b/tutorials/combustion/fireFoam/les/smallPoolFire3D/0/IDefault
index e70bf3dec0..1da0ef50b9 100644
--- a/tutorials/combustion/fireFoam/les/smallPoolFire3D/0/IDefault
+++ b/tutorials/combustion/fireFoam/les/smallPoolFire3D/0/IDefault
@@ -25,7 +25,7 @@ boundaryField
         type            greyDiffusiveRadiation;
         T               T;
         emissivityMode  lookup;
-        emissivity      uniform 1.0;
+        emissivity      uniform 1;
         value           uniform 0;
     }
 }
diff --git a/tutorials/combustion/fireFoam/les/smallPoolFire3D/constant/radiationProperties b/tutorials/combustion/fireFoam/les/smallPoolFire3D/constant/radiationProperties
index 513c11e7db..63e3de884c 100644
--- a/tutorials/combustion/fireFoam/les/smallPoolFire3D/constant/radiationProperties
+++ b/tutorials/combustion/fireFoam/les/smallPoolFire3D/constant/radiationProperties
@@ -20,10 +20,14 @@ radiationModel  fvDOM;
 
 fvDOMCoeffs
 {
-    nPhi    2;          // azimuthal angles in PI/2 on X-Y.(from Y to X)
-    nTheta  2;          // polar angles in PI (from Z to X-Y plane)
-    convergence 1e-3;   // convergence criteria for radiation iteration
-    maxIter 10;         // maximum number of iterations
+    nPhi        2;          // azimuthal angles in PI/2 on X-Y.(from Y to X)
+    nTheta      2;          // polar angles in PI (from Z to X-Y plane)
+    convergence 1e-1;       // convergence criteria for radiation iteration
+    maxIter     1;          // maximum number of iterations
+    cacheDiv    true;       // cache the div of the RTE equation.
+
+//  NOTE: Caching div is "only" accurate if the upwind scheme is used in
+//  div(Ji,Ii_h)
 }
 
 // Number of flow iterations per radiation iteration
@@ -33,9 +37,9 @@ absorptionEmissionModel greyMeanAbsorptionEmission;
 
 constantAbsorptionEmissionCoeffs
 {
-    absorptivity    absorptivity    [ 0 -1 0 0 0 0 0 ] 0.01;
-    emissivity      emissivity      [ 0 -1 0 0 0 0 0 ] 0.01;
-    E               E   [ 1 -1 -3 0 0 0 0 ] 0;
+    absorptivity    absorptivity    [ m^-1 ]       0.01;
+    emissivity      emissivity      [ m^-1 ]       0.01;
+    E               E               [ kg m^-1 s^-3 ]  0;
 }
 
 greyMeanAbsorptionEmissionCoeffs
@@ -46,7 +50,7 @@ greyMeanAbsorptionEmissionCoeffs
 
     CO2
     {
-        Tcommon         300;   //Common Temp
+        Tcommon         200;   //Common Temp
         invTemp         true;   //Is the polynomio using inverse temperature.
         Tlow            200;   //Low Temp
         Thigh           2500;  //High Temp
@@ -74,7 +78,7 @@ greyMeanAbsorptionEmissionCoeffs
 
     H2O
     {
-        Tcommon         300;
+        Tcommon         200;
         invTemp         true;
         Tlow            200;
         Thigh           2500;
@@ -101,7 +105,7 @@ greyMeanAbsorptionEmissionCoeffs
 
     CH4
     {
-        Tcommon         300;
+        Tcommon         200;
         Tlow            200;
         Thigh           2500;
         invTemp         false;
@@ -128,7 +132,7 @@ greyMeanAbsorptionEmissionCoeffs
 
     O2
     {
-        Tcommon         300;
+        Tcommon         200;
         invTemp         true;
         Tlow            200;
         Thigh           2500;
@@ -156,7 +160,7 @@ greyMeanAbsorptionEmissionCoeffs
 
     N2
     {
-        Tcommon         300;
+        Tcommon         200;
         invTemp         true;
         Tlow            200;
         Thigh           2500;
diff --git a/tutorials/combustion/fireFoam/les/smallPoolFire3D/system/controlDict b/tutorials/combustion/fireFoam/les/smallPoolFire3D/system/controlDict
index 6a45d3a30f..6f9c9cf1e6 100644
--- a/tutorials/combustion/fireFoam/les/smallPoolFire3D/system/controlDict
+++ b/tutorials/combustion/fireFoam/les/smallPoolFire3D/system/controlDict
@@ -22,13 +22,13 @@ startTime       0.0;
 
 stopAt          endTime;
 
-endTime         2.75;
+endTime         0.75;
 
 deltaT          0.001;
 
 writeControl    adjustableRunTime;
 
-writeInterval   0.05;
+writeInterval   0.5;
 
 purgeWrite      0;
 
@@ -48,7 +48,7 @@ runTimeModifiable yes;
 
 adjustTimeStep  yes;
 
-maxCo           0.2;
+maxCo           0.5;
 
 maxDeltaT       0.1;
 
diff --git a/tutorials/combustion/fireFoam/les/smallPoolFire3D/system/fvSolution b/tutorials/combustion/fireFoam/les/smallPoolFire3D/system/fvSolution
index 829f7a4a7a..11cfaf95bd 100644
--- a/tutorials/combustion/fireFoam/les/smallPoolFire3D/system/fvSolution
+++ b/tutorials/combustion/fireFoam/les/smallPoolFire3D/system/fvSolution
@@ -66,12 +66,14 @@ solvers
         solver              GAMG;
         tolerance           1e-4;
         relTol              0;
-        smoother            DILU;
+        smoother            symGaussSeidel;
         cacheAgglomeration  true;
         nCellsInCoarsestLevel   10;
-        agglomerator    faceAreaPair;
-        mergeLevels     1;
-        maxIter         20;
+        agglomerator        faceAreaPair;
+        mergeLevels         1;
+        maxIter             1;
+        nPreSweeps          0;
+        nPostSweeps         1;
     }
 
     G
@@ -88,7 +90,7 @@ PIMPLE
 {
     momentumPredictor yes;
     nOuterCorrectors  1;
-    nCorrectors       2;
+    nCorrectors       3;
     nNonOrthogonalCorrectors 0;
 }
 
diff --git a/tutorials/discreteMethods/dsmcFoam/freeSpacePeriodic/system/controlDict b/tutorials/discreteMethods/dsmcFoam/freeSpacePeriodic/system/controlDict
index 6ec3573318..28634ee885 100644
--- a/tutorials/discreteMethods/dsmcFoam/freeSpacePeriodic/system/controlDict
+++ b/tutorials/discreteMethods/dsmcFoam/freeSpacePeriodic/system/controlDict
@@ -49,13 +49,6 @@ adjustTimeStep  no;
 
 functions
 {
-    dsmcFields1
-    {
-        type            dsmcFields;
-        functionObjectLibs ( "libutilityFunctionObjects.so" );
-        enabled         true;
-        outputControl   outputTime;
-    }
     fieldAverage1
     {
         type            fieldAverage;
@@ -121,6 +114,13 @@ functions
             }
         );
     }
+    dsmcFields1
+    {
+        type            dsmcFields;
+        functionObjectLibs ( "libutilityFunctionObjects.so" );
+        enabled         true;
+        outputControl   outputTime;
+    }
 }
 
 // ************************************************************************* //
diff --git a/tutorials/discreteMethods/dsmcFoam/freeSpaceStream/system/controlDict b/tutorials/discreteMethods/dsmcFoam/freeSpaceStream/system/controlDict
index 9cd736a161..2f17c188c0 100644
--- a/tutorials/discreteMethods/dsmcFoam/freeSpaceStream/system/controlDict
+++ b/tutorials/discreteMethods/dsmcFoam/freeSpaceStream/system/controlDict
@@ -49,13 +49,6 @@ adjustTimeStep  no;
 
 functions
 {
-    dsmcFields1
-    {
-        type            dsmcFields;
-        functionObjectLibs ( "libutilityFunctionObjects.so" );
-        enabled         true;
-        outputControl   outputTime;
-    }
     fieldAverage1
     {
         type            fieldAverage;
@@ -121,6 +114,13 @@ functions
             }
         );
     }
+    dsmcFields1
+    {
+        type            dsmcFields;
+        functionObjectLibs ( "libutilityFunctionObjects.so" );
+        enabled         true;
+        outputControl   outputTime;
+    }
 }
 
 // ************************************************************************* //
diff --git a/tutorials/discreteMethods/dsmcFoam/supersonicCorner/system/controlDict b/tutorials/discreteMethods/dsmcFoam/supersonicCorner/system/controlDict
index f87019fc7a..8045c73096 100644
--- a/tutorials/discreteMethods/dsmcFoam/supersonicCorner/system/controlDict
+++ b/tutorials/discreteMethods/dsmcFoam/supersonicCorner/system/controlDict
@@ -49,13 +49,6 @@ adjustTimeStep  no;
 
 functions
 {
-    dsmcFields1
-    {
-        type            dsmcFields;
-        functionObjectLibs ( "libutilityFunctionObjects.so" );
-        enabled         true;
-        outputControl   outputTime;
-    }
     fieldAverage1
     {
         type            fieldAverage;
@@ -121,6 +114,13 @@ functions
             }
         );
     }
+    dsmcFields1
+    {
+        type            dsmcFields;
+        functionObjectLibs ( "libutilityFunctionObjects.so" );
+        enabled         true;
+        outputControl   outputTime;
+    }
 }
 
 // ************************************************************************* //
diff --git a/tutorials/discreteMethods/dsmcFoam/wedge15Ma5/system/controlDict b/tutorials/discreteMethods/dsmcFoam/wedge15Ma5/system/controlDict
index ebbcdcf9a6..00dd9e1e85 100644
--- a/tutorials/discreteMethods/dsmcFoam/wedge15Ma5/system/controlDict
+++ b/tutorials/discreteMethods/dsmcFoam/wedge15Ma5/system/controlDict
@@ -49,14 +49,6 @@ adjustTimeStep  no;
 
 functions
 {
-    dsmcFields1
-    {
-        type            dsmcFields;
-        functionObjectLibs ( "libutilityFunctionObjects.so" );
-        enabled         true;
-        outputControl   outputTime;
-    }
-
     fieldAverage1
     {
         type            fieldAverage;
@@ -123,6 +115,14 @@ functions
         );
     }
 
+    dsmcFields1
+    {
+        type            dsmcFields;
+        functionObjectLibs ( "libutilityFunctionObjects.so" );
+        enabled         true;
+        outputControl   outputTime;
+    }
+
     forces1
     {
         type            forces;
diff --git a/tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D/0.org/U b/tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D/0.org/U
new file mode 100644
index 0000000000..72f38fd6dd
--- /dev/null
+++ b/tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D/0.org/U
@@ -0,0 +1,67 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  dev                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       volVectorField;
+    location    "0";
+    object      U;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+dimensions      [0 1 -1 0 0 0 0];
+
+internalField   uniform (0 0 0);
+
+boundaryField
+{
+    inlet
+    {
+        type            fixedValue;
+        value           uniform (1 0 0);
+    }
+    outlet
+    {
+        type            pressureInletOutletVelocity;
+        value           uniform (0 0 0);
+    }
+    walls
+    {
+//        type            fixedValue;
+        type            movingWallVelocity;
+        value           uniform (0 0 0);
+    }
+    defaultFaces
+    {
+        type            empty;
+    }
+    ACMI1_blockage
+    {
+        type            fixedValue;
+        value           uniform (0 0 0);
+    }
+    ACMI1_couple
+    {
+        type            cyclicACMI;
+        value           uniform (0 0 0);
+    }
+    ACMI2_blockage
+    {
+        type            fixedValue;
+        value           uniform (0 0 0);
+    }
+    ACMI2_couple
+    {
+        type            cyclicACMI;
+        value           uniform (0 0 0);
+    }
+}
+
+
+// ************************************************************************* //
diff --git a/tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D/0.org/epsilon b/tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D/0.org/epsilon
new file mode 100644
index 0000000000..36447c1079
--- /dev/null
+++ b/tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D/0.org/epsilon
@@ -0,0 +1,67 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  dev                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       volScalarField;
+    location    "0";
+    object      epsilon;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+dimensions      [0 2 -3 0 0 0 0];
+
+internalField   uniform 1.8e-3;
+
+boundaryField
+{
+    inlet
+    {
+        type            fixedValue;
+        value           $internalField;
+    }
+    outlet
+    {
+        type            inletOutlet;
+        inletValue      $internalField;
+        value           $internalField;
+    }
+    walls
+    {
+        type            epsilonWallFunction;
+        value           $internalField;
+    }
+    defaultFaces
+    {
+        type            empty;
+    }
+    ACMI1_blockage
+    {
+        type            epsilonWallFunction;
+        value           $internalField;
+    }
+    ACMI1_couple
+    {
+        type            cyclicACMI;
+        value           $internalField;
+    }
+    ACMI2_blockage
+    {
+        type            epsilonWallFunction;
+        value           $internalField;
+    }
+    ACMI2_couple
+    {
+        type            cyclicACMI;
+        value           $internalField;
+    }
+}
+
+
+// ************************************************************************* //
diff --git a/tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D/0.org/k b/tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D/0.org/k
new file mode 100644
index 0000000000..286cdf4e26
--- /dev/null
+++ b/tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D/0.org/k
@@ -0,0 +1,67 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  dev                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       volScalarField;
+    location    "0";
+    object      k;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+dimensions      [0 2 -2 0 0 0 0];
+
+internalField   uniform 3.75e-3;
+
+boundaryField
+{
+    inlet
+    {
+        type            fixedValue;
+        value           $internalField;
+    }
+    outlet
+    {
+        type            inletOutlet;
+        inletValue      $internalField;
+        value           $internalField;
+    }
+    walls
+    {
+        type            kqRWallFunction;
+        value           $internalField;
+    }
+    defaultFaces
+    {
+        type            empty;
+    }
+    ACMI1_blockage
+    {
+        type            kqRWallFunction;
+        value           $internalField;
+    }
+    ACMI1_couple
+    {
+        type            cyclicACMI;
+        value           $internalField;
+    }
+    ACMI2_blockage
+    {
+        type            kqRWallFunction;
+        value           $internalField;
+    }
+    ACMI2_couple
+    {
+        type            cyclicACMI;
+        value           $internalField;
+    }
+}
+
+
+// ************************************************************************* //
diff --git a/tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D/0.org/p b/tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D/0.org/p
new file mode 100644
index 0000000000..6a9c955b27
--- /dev/null
+++ b/tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D/0.org/p
@@ -0,0 +1,70 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  dev                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       volScalarField;
+    location    "0";
+    object      p;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+dimensions      [0 2 -2 0 0 0 0];
+
+internalField   uniform 0;
+
+boundaryField
+{
+    inlet
+    {
+        type            zeroGradient;
+    }
+    outlet
+    {
+        type            fixedValue;
+        value           uniform 0;
+    }
+    walls
+    {
+        type            zeroGradient;
+    }
+    couple1
+    {
+        type            zeroGradient;
+    }
+    couple2
+    {
+        type            zeroGradient;
+    }
+    defaultFaces
+    {
+        type            empty;
+    }
+    ACMI1_blockage
+    {
+        type            zeroGradient;
+    }
+    ACMI1_couple
+    {
+        type            cyclicACMI;
+        value           uniform 0;
+    }
+    ACMI2_blockage
+    {
+        type            zeroGradient;
+    }
+    ACMI2_couple
+    {
+        type            cyclicACMI;
+        value           uniform 0;
+    }
+}
+
+
+// ************************************************************************* //
diff --git a/tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D/Allclean b/tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D/Allclean
new file mode 100755
index 0000000000..fa0925adb5
--- /dev/null
+++ b/tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D/Allclean
@@ -0,0 +1,9 @@
+#!/bin/sh
+cd ${0%/*} || exit 1    # run from this directory
+
+# Source tutorial clean functions
+. $WM_PROJECT_DIR/bin/tools/CleanFunctions
+
+cleanCase
+
+rm -rf 0
diff --git a/tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D/Allrun b/tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D/Allrun
new file mode 100755
index 0000000000..26008d23c0
--- /dev/null
+++ b/tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D/Allrun
@@ -0,0 +1,9 @@
+#!/bin/sh
+cd ${0%/*} || exit 1    # run from this directory
+
+# Source tutorial run functions
+. $WM_PROJECT_DIR/bin/tools/RunFunctions
+
+./Allrun.pre
+
+runApplication $(getApplication)
diff --git a/tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D/Allrun-parallel b/tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D/Allrun-parallel
new file mode 100755
index 0000000000..ef154f057d
--- /dev/null
+++ b/tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D/Allrun-parallel
@@ -0,0 +1,13 @@
+#!/bin/sh
+cd ${0%/*} || exit 1    # run from this directory
+
+# Source tutorial run functions
+. $WM_PROJECT_DIR/bin/tools/RunFunctions
+
+./Allrun.pre
+
+runApplication decomposePar
+
+runParallel $(getApplication) 4
+
+runApplication reconstructPar
diff --git a/tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D/Allrun.pre b/tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D/Allrun.pre
new file mode 100755
index 0000000000..07707e4495
--- /dev/null
+++ b/tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D/Allrun.pre
@@ -0,0 +1,17 @@
+#!/bin/sh
+cd ${0%/*} || exit 1    # run from this directory
+
+# Source tutorial run functions
+. $WM_PROJECT_DIR/bin/tools/RunFunctions
+
+runApplication blockMesh
+
+runApplication topoSet -constant
+
+# split the mesh to generate the ACMI coupled patches
+runApplication createBaffles -overwrite
+
+# remove zero-sized patches
+runApplication createPatch -overwrite
+
+cp -rf 0.org 0
diff --git a/tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D/README b/tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D/README
new file mode 100644
index 0000000000..7871c1303e
--- /dev/null
+++ b/tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D/README
@@ -0,0 +1,104 @@
+oscillatingInletACMI2D
+
+This tutorial case gives an example of the Arbitrarily Coupled Mesh Interface
+(ACMI) usage.  The mesh is composed of two mesh regions: an inlet channel which
+oscillates in the +/- Y-direction, and a fixed mesh region.
+
+Each ACMI patch requires the specification of a 'non-overlapping' patch.  In
+this example, the non-overlapping patches are described as walls, e.g. taken
+from the constant/polyMesh/boundary file:
+
+    1. First ACMI poatch pair applied to the inlet channel outlet
+
+        ACMI1_blockage
+        {
+            type            wall;
+            nFaces          40;
+            startFace       43680;
+        }
+        ACMI1_couple
+        {
+            type            cyclicACMI;
+            nFaces          40;
+            startFace       43720;
+            matchTolerance  0.0001;
+            transform       noOrdering;
+            neighbourPatch  ACMI2_couple;
+            nonOverlapPatch ACMI1_blockage;
+        }
+
+
+    1. Second ACMI poatch pair applied to the fixed mesh region inlet
+
+        ACMI2_blockage
+        {
+            type            wall;
+            nFaces          96;
+            startFace       43760;
+        }
+        ACMI2_couple
+        {
+            type            cyclicACMI;
+            nFaces          96;
+            startFace       43856;
+            matchTolerance  0.0001;
+            transform       noOrdering;
+            neighbourPatch  ACMI1_couple;
+            nonOverlapPatch ACMI2_blockage;
+        }
+
+
+In the above, the ACMI1_blockage and ACMI1_couple patches occupy the same space,
+with duplicate points, edges and faces.  The ACMI2_blockage and ACMI2_couple
+patches are created similarly.
+
+The duplicate patches are initially created using the createBaffles utility.
+Firstly, the original (non-duplicated) patch faces are collected into zones
+using the topoSet utility.
+
+Each ACMI/no-overlapping patch pair is specified using a master-slave approach.
+However, since we are generating boundary patches (which are always master
+patches) the slave patches are simply defined using 'dummy' entries, e.g.:
+
+    type        faceZone;
+    zoneName    couple1Faces;
+
+    patches
+    {
+        // create blockage patch
+        master
+        {
+            //- Master side patch
+            name            ACMI1_blockage;
+            type            wall;
+        }
+        slave1 // dummy entries only
+        {
+            //- Slave side patch
+            name            ACMI1_blockage;
+            type            wall;
+        }
+
+        // create cyclic ACMI patch
+        master2
+        {
+            //- Master side patch
+            name            ACMI1_couple;
+            type            cyclicACMI;
+            matchTolerance  0.0001;
+            neighbourPatch  ACMI2_couple;
+            nonOverlapPatch ACMI1_blockage;
+            transform       noOrdering;
+        }
+        slave2 // dummy entries only
+        {
+            //- Slave side patch
+            name            ACMI1_couple;
+            type            patch;
+        }
+    }
+
+Boundary conditions must then be applied to all geometric patches in the usual,
+manner, and the cases can be executed in parallel (as shown when running the
+Allrun-parallel script) without any speacial treatment, i.e. the case set-up is
+the same as when operating in serial mode.
diff --git a/tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D/constant/RASProperties b/tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D/constant/RASProperties
new file mode 100644
index 0000000000..a4937b503a
--- /dev/null
+++ b/tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D/constant/RASProperties
@@ -0,0 +1,25 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  dev                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    location    "constant";
+    object      RASProperties;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+RASModel        kEpsilon;
+
+turbulence      on;
+
+printCoeffs     on;
+
+
+// ************************************************************************* //
diff --git a/tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D/constant/dynamicMeshDict b/tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D/constant/dynamicMeshDict
new file mode 100644
index 0000000000..ae204c40bc
--- /dev/null
+++ b/tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D/constant/dynamicMeshDict
@@ -0,0 +1,36 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  dev                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    location    "constant";
+    object      dynamicMeshDict;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+dynamicFvMesh   solidBodyMotionFvMesh;
+
+motionSolverLibs ( "libfvMotionSolvers.so" );
+
+solidBodyMotionFvMeshCoeffs
+{
+    cellZone        inletChannel;
+
+    solidBodyMotionFunction  oscillatingLinearMotion;
+
+    oscillatingLinearMotionCoeffs
+    {
+        amplitude       (0 0.5 0);
+        omega           3.14; // rad/s  (.5 rps)
+    }
+}
+
+
+// ************************************************************************* //
diff --git a/tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D/constant/polyMesh/blockMeshDict b/tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D/constant/polyMesh/blockMeshDict
new file mode 100644
index 0000000000..638f674947
--- /dev/null
+++ b/tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D/constant/polyMesh/blockMeshDict
@@ -0,0 +1,103 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  dev                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    object      blockMeshDict;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+convertToMeters 1;
+
+vertices
+(
+    (0 0.3 0)
+    (1 0.3 0)
+    (1 0.7 0)
+    (0 0.7 0)
+    (0 0.3 0.1)
+    (1 0.3 0.1)
+    (1 0.7 0.1)
+    (0 0.7 0.1)
+
+    (1 0 0)
+    (3 0 0)
+    (3 1 0)
+    (1 1 0)
+    (1 0 0.1)
+    (3 0 0.1)
+    (3 1 0.1)
+    (1 1 0.1)
+);
+
+blocks
+(
+//    hex (0 1 2 3 4 5 6 7) (20 20 1) simpleGrading (1 1 1)
+//    hex (8 9 10 11 12 13 14 15) (40 48 1) simpleGrading (1 1 1)
+    hex (0 1 2 3 4 5 6 7) (80 40 1) simpleGrading (1 1 1)
+    hex (8 9 10 11 12 13 14 15) (80 96 1) simpleGrading (1 1 1)
+);
+
+edges
+(
+);
+
+boundary
+(
+    inlet
+    {
+        type patch;
+        faces
+        (
+            (0 4 7 3)
+        );
+    }
+    outlet
+    {
+        type patch;
+        faces
+        (
+            (10 14 13 9)
+        );
+    }
+    walls
+    {
+        type wall;
+        faces
+        (
+            (3 7 6 2)
+            (1 5 4 0)
+            (11 15 14 10)
+            (9 13 12 8)
+        );
+    }
+    couple1
+    {
+        type patch;
+        faces
+        (
+            (2 6 5 1)
+        );
+    }
+    couple2
+    {
+        type patch;
+        faces
+        (
+            (8 12 15 11)
+        );
+    }
+);
+
+mergePatchPairs
+(
+);
+
+// ************************************************************************* //
diff --git a/tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D/constant/polyMesh/boundary b/tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D/constant/polyMesh/boundary
new file mode 100644
index 0000000000..f6e6726c6b
--- /dev/null
+++ b/tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D/constant/polyMesh/boundary
@@ -0,0 +1,81 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  dev                              |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       polyBoundaryMesh;
+    location    "constant/polyMesh";
+    object      boundary;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+8
+(
+    inlet
+    {
+        type            patch;
+        nFaces          40;
+        startFace       21464;
+    }
+    outlet
+    {
+        type            patch;
+        nFaces          96;
+        startFace       21504;
+    }
+    walls
+    {
+        type            wall;
+        nFaces          320;
+        startFace       21600;
+    }
+    defaultFaces
+    {
+        type            empty;
+        inGroups        1(empty);
+        nFaces          21760;
+        startFace       21920;
+    }
+    ACMI1_blockage
+    {
+        type            wall;
+        nFaces          40;
+        startFace       43680;
+    }
+    ACMI1_couple
+    {
+        type            cyclicACMI;
+        inGroups        1(cyclicACMI);
+        nFaces          40;
+        startFace       43720;
+        matchTolerance  0.0001;
+        transform       noOrdering;
+        neighbourPatch  ACMI2_couple;
+        nonOverlapPatch ACMI1_blockage;
+    }
+    ACMI2_blockage
+    {
+        type            wall;
+        nFaces          96;
+        startFace       43760;
+    }
+    ACMI2_couple
+    {
+        type            cyclicACMI;
+        inGroups        1(cyclicACMI);
+        nFaces          96;
+        startFace       43856;
+        matchTolerance  0.0001;
+        transform       noOrdering;
+        neighbourPatch  ACMI1_couple;
+        nonOverlapPatch ACMI2_blockage;
+    }
+)
+
+// ************************************************************************* //
diff --git a/tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D/constant/transportProperties b/tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D/constant/transportProperties
new file mode 100644
index 0000000000..5f2e87ebef
--- /dev/null
+++ b/tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D/constant/transportProperties
@@ -0,0 +1,22 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  dev                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    location    "constant";
+    object      transportProperties;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+transportModel  Newtonian;
+
+nu              nu [ 0 2 -1 0 0 0 0 ] 1e-6;
+
+// ************************************************************************* //
diff --git a/tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D/constant/turbulenceProperties b/tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D/constant/turbulenceProperties
new file mode 100644
index 0000000000..3721a46a2e
--- /dev/null
+++ b/tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D/constant/turbulenceProperties
@@ -0,0 +1,21 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  dev                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    location    "constant";
+    object      turbulenceProperties;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+simulationType  RASModel;
+
+
+// ************************************************************************* //
diff --git a/tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D/system/controlDict b/tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D/system/controlDict
new file mode 100644
index 0000000000..3521d07583
--- /dev/null
+++ b/tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D/system/controlDict
@@ -0,0 +1,53 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  dev                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    location    "system";
+    object      controlDict;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+application     pimpleDyMFoam;
+
+startFrom       latestTime;
+
+startTime       0;
+
+stopAt          endTime;
+
+endTime         5;
+
+deltaT          0.005;
+
+writeControl    adjustableRunTime;
+
+writeInterval   0.05;
+
+purgeWrite      0;
+
+writeFormat     ascii;
+
+writePrecision  6;
+
+writeCompression off;
+
+timeFormat      general;
+
+timePrecision   6;
+
+runTimeModifiable true;
+
+adjustTimeStep  true;
+
+maxCo           0.5;
+
+
+// ************************************************************************* //
diff --git a/tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D/system/createBafflesDict b/tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D/system/createBafflesDict
new file mode 100644
index 0000000000..c3cf5971da
--- /dev/null
+++ b/tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D/system/createBafflesDict
@@ -0,0 +1,107 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  dev                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    object      createBafflesDict;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+// Whether to convert internal faces only (so leave boundary faces intact).
+// This is only relevant if your face selection type can pick up boundary
+// faces.
+internalFacesOnly false;
+
+
+// Baffles to create.
+baffles
+{
+    ACMI1
+    {
+        //- Use predefined faceZone to select faces and orientation.
+        type        faceZone;
+        zoneName    couple1Faces;
+
+        patches
+        {
+            master
+            {
+                //- Master side patch
+                name            ACMI1_blockage;
+                type            wall;
+            }
+            slave // not used since we're manipulating a boundary patch
+            {
+                //- Slave side patch
+                name            ACMI1_blockage;
+                type            wall;
+            }
+
+            master2
+            {
+                //- Master side patch
+                name            ACMI1_couple;
+                type            cyclicACMI;
+                matchTolerance  0.0001;
+                neighbourPatch  ACMI2_couple;
+                nonOverlapPatch ACMI1_blockage;
+                transform       noOrdering;
+            }
+            slave2 // not used since we're manipulating a boundary patch
+            {
+                //- Slave side patch
+                name            ACMI1_couple;
+                type            patch;
+            }
+        }
+    }
+    ACMI2
+    {
+        //- Use predefined faceZone to select faces and orientation.
+        type        faceZone;
+        zoneName    couple2Faces;
+
+        patches
+        {
+            master
+            {
+                //- Master side patch
+                name            ACMI2_blockage;
+                type            wall;
+            }
+            slave // not used since we're manipulating a boundary patch
+            {
+                //- Slave side patch
+                name            ACMI2_blockage;
+                type            wall;
+            }
+
+            master2
+            {
+                //- Master side patch
+                name            ACMI2_couple;
+                type            cyclicACMI;
+                matchTolerance  0.0001;
+                neighbourPatch  ACMI1_couple;
+                nonOverlapPatch ACMI2_blockage;
+                transform       noOrdering;
+            }
+            slave2 // not used since we're manipulating a boundary patch
+            {
+                //- Slave side patch
+                name            ACMI2_couple;
+                type            patch;
+            }
+        }
+    }
+}
+
+
+// ************************************************************************* //
diff --git a/tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D/system/createPatchDict b/tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D/system/createPatchDict
new file mode 100644
index 0000000000..cbfab2fa08
--- /dev/null
+++ b/tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D/system/createPatchDict
@@ -0,0 +1,54 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  dev                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    object      createPatchDict;
+}
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+// This application/dictionary controls:
+// - optional: create new patches from boundary faces (either given as
+//   a set of patches or as a faceSet)
+// - always: order faces on coupled patches such that they are opposite. This
+//   is done for all coupled faces, not just for any patches created.
+// - optional: synchronise points on coupled patches.
+
+// 1. Create cyclic:
+// - specify where the faces should come from
+// - specify the type of cyclic. If a rotational specify the rotationAxis
+//   and centre to make matching easier
+// - always create both halves in one invocation with correct 'neighbourPatch'
+//   setting.
+// - optionally pointSync true to guarantee points to line up.
+
+// 2. Correct incorrect cyclic:
+// This will usually fail upon loading:
+//  "face 0 area does not match neighbour 2 by 0.0100005%"
+//  " -- possible face ordering problem."
+// - in polyMesh/boundary file:
+//      - loosen matchTolerance of all cyclics to get case to load
+//      - or change patch type from 'cyclic' to 'patch'
+//        and regenerate cyclic as above
+
+
+// Do a synchronisation of coupled points after creation of any patches.
+// Note: this does not work with points that are on multiple coupled patches
+//       with transformations (i.e. cyclics).
+pointSync false;
+
+// Patches to create.
+patches
+(
+    // none
+);
+
+// ************************************************************************* //
diff --git a/tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D/system/decomposeParDict b/tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D/system/decomposeParDict
new file mode 100644
index 0000000000..8b22fc9971
--- /dev/null
+++ b/tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D/system/decomposeParDict
@@ -0,0 +1,30 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  dev                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    object      decomposeParDict;
+}
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+numberOfSubdomains 4;
+
+method          scotch;
+
+hierarchicalCoeffs
+{
+    n               (1 4 1);
+    delta           0.001;
+    order           xyz;
+}
+
+
+// ************************************************************************* //
diff --git a/tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D/system/fvSchemes b/tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D/system/fvSchemes
new file mode 100644
index 0000000000..b6ae74a4e9
--- /dev/null
+++ b/tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D/system/fvSchemes
@@ -0,0 +1,63 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  dev                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    location    "system";
+    object      fvSchemes;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+ddtSchemes
+{
+    default         Euler;
+}
+
+gradSchemes
+{
+    default         Gauss linear;
+    grad(p)         Gauss linear;
+    grad(U)         cellLimited Gauss linear 1;
+}
+
+divSchemes
+{
+    default         none;
+//    div(phi,U)      Gauss upwind;
+    div(phi,U)      Gauss linearUpwind grad(U);
+    div(phi,k)      Gauss upwind;
+    div(phi,epsilon) Gauss upwind;
+    div((nuEff*dev(T(grad(U))))) Gauss linear;
+}
+
+laplacianSchemes
+{
+    default         Gauss linear limited corrected 0.33;
+}
+
+interpolationSchemes
+{
+    default         linear;
+}
+
+snGradSchemes
+{
+    default         limited corrected 0.33;
+}
+
+fluxRequired
+{
+    default         no;
+    pcorr           ;
+    p               ;
+}
+
+
+// ************************************************************************* //
diff --git a/tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D/system/fvSolution b/tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D/system/fvSolution
new file mode 100644
index 0000000000..61da672625
--- /dev/null
+++ b/tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D/system/fvSolution
@@ -0,0 +1,80 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  dev                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    object      fvSolution;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+solvers
+{
+    pcorr
+    {
+        solver          GAMG;
+        tolerance       1e-2;
+        relTol          0;
+        smoother        GaussSeidel;
+        cacheAgglomeration no;
+        nCellsInCoarsestLevel 10;
+        agglomerator    faceAreaPair;
+        mergeLevels     1;
+        maxIter         50;
+    }
+
+    p
+    {
+        $pcorr;
+        tolerance       1e-5;
+        relTol          0.01;
+    }
+
+    pFinal
+    {
+        $p;
+        tolerance       1e-6;
+        relTol          0;
+    }
+
+    "(U|k|epsilon)"
+    {
+        solver          smoothSolver;
+        smoother        symGaussSeidel;
+        tolerance       1e-6;
+        relTol          0.1;
+    }
+
+    "(U|k|epsilon)Final"
+    {
+        $U;
+        tolerance       1e-6;
+        relTol          0;
+    }
+}
+
+PIMPLE
+{
+    correctPhi          no;
+    nOuterCorrectors    1;
+    nCorrectors         2;
+    nNonOrthogonalCorrectors 0;
+}
+
+relaxationFactors
+{
+//    "(U|k|epsilon).*"   1;
+}
+
+cache
+{
+    grad(U);
+}
+
+// ************************************************************************* //
diff --git a/tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D/system/topoSetDict b/tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D/system/topoSetDict
new file mode 100644
index 0000000000..814bded7d0
--- /dev/null
+++ b/tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D/system/topoSetDict
@@ -0,0 +1,89 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  dev                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    object      topoSetDict;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+actions
+(
+    // Get both sides of ami
+    // ~~~~~~~~~~~~~~~~~~~~~
+
+    // Create faceZone for patch couple1
+    {
+        name    couple1Faces;
+        type    faceSet;
+        action  new;
+        source  patchToFace;
+        sourceInfo
+        {
+            name    couple1;
+        }
+    }
+    {
+        name    couple1Faces;
+        type    faceZoneSet;
+        action  new;
+        source  setToFaceZone;
+        sourceInfo
+        {
+            faceSet couple1Faces;
+        }
+    }
+
+    // Create faceZone for patch couple2
+    {
+        name    couple2Faces;
+        type    faceSet;
+        action  new;
+        source  patchToFace;
+        sourceInfo
+        {
+            name    couple2;
+        }
+    }
+    {
+        name    couple2Faces;
+        type    faceZoneSet;
+        action  new;
+        source  setToFaceZone;
+        sourceInfo
+        {
+            faceSet couple2Faces;
+        }
+    }
+
+    // Create cellZone for moving cells in inlet channel
+    {
+        name    inletChannel;
+        type    cellSet;
+        action  new;
+        source  boxToCell;
+        sourceInfo
+        {
+            box     (-100 -100 -100) (1.0001 100 100);
+        }
+    }
+    {
+        name    inletChannel;
+        type    cellZoneSet;
+        action  new;
+        source  setToCellZone;
+        sourceInfo
+        {
+            set     inletChannel;
+        }
+    }
+);
+
+// ************************************************************************* //
diff --git a/tutorials/incompressible/simpleFoam/turbineSiting/constant/RASProperties b/tutorials/incompressible/simpleFoam/turbineSiting/constant/RASProperties
index 4e7382cf5e..e8f2fd5022 100644
--- a/tutorials/incompressible/simpleFoam/turbineSiting/constant/RASProperties
+++ b/tutorials/incompressible/simpleFoam/turbineSiting/constant/RASProperties
@@ -25,10 +25,11 @@ kEpsilonCoeffs
     Cmu         0.09;
     C1          1.44;
     C2          1.92;
-    C3          -0.33;
-    sigmak      1.0;
     sigmaEps    1.11; //Original value:1.44
-    Prt         1.0;
+    //NOTE: See "On the use of the k-Epsilon model in commercial CFD software
+    // to model the neutral atmospheric boundary layer". J. of wind engineering
+    // and inductrial aerodymanics 95(2007) 355-269 by
+    // D.M. Hargreaves and N.G. Wright
 }
 
 // ************************************************************************* //
diff --git a/tutorials/lagrangian/reactingParcelFilmFoam/cylinder/constant/reactingCloud1Properties b/tutorials/lagrangian/reactingParcelFilmFoam/cylinder/constant/reactingCloud1Properties
index 45ae8875b7..b0104d35d2 100644
--- a/tutorials/lagrangian/reactingParcelFilmFoam/cylinder/constant/reactingCloud1Properties
+++ b/tutorials/lagrangian/reactingParcelFilmFoam/cylinder/constant/reactingCloud1Properties
@@ -88,6 +88,7 @@ subModels
             inputFile       "parcelInjectionProperties";
             duration        20.0;
             parcelsPerSecond 50;
+            randomise       true;
         }
     }
 
diff --git a/tutorials/lagrangian/reactingParcelFilmFoam/cylinder/constant/surfaceFilmProperties b/tutorials/lagrangian/reactingParcelFilmFoam/cylinder/constant/surfaceFilmProperties
index e327a82959..407db73fc3 100644
--- a/tutorials/lagrangian/reactingParcelFilmFoam/cylinder/constant/surfaceFilmProperties
+++ b/tutorials/lagrangian/reactingParcelFilmFoam/cylinder/constant/surfaceFilmProperties
@@ -29,17 +29,17 @@ thermoSingleLayerCoeffs
     deltaWet    1e-4;
     hydrophilic no;
 
-    forces
-    (
-        surfaceShear
-        thermocapillary
-    );
-
-    surfaceShearCoeffs
+    turbulence  laminar;
+    laminarCoeffs
     {
         Cf          0.005;
     }
 
+    forces
+    (
+        thermocapillary
+    );
+
     injectionModels ();
 
     phaseChangeModel none;
diff --git a/tutorials/lagrangian/reactingParcelFilmFoam/hotBoxes/constant/surfaceFilmProperties b/tutorials/lagrangian/reactingParcelFilmFoam/hotBoxes/constant/surfaceFilmProperties
index c6a1bcbfc1..40b719099c 100644
--- a/tutorials/lagrangian/reactingParcelFilmFoam/hotBoxes/constant/surfaceFilmProperties
+++ b/tutorials/lagrangian/reactingParcelFilmFoam/hotBoxes/constant/surfaceFilmProperties
@@ -33,6 +33,12 @@ thermoSingleLayerCoeffs
 
     radiationModel  none;
 
+    turbulence  laminar;
+    laminarCoeffs
+    {
+        Cf          0.005;
+    }
+
     upperSurfaceModels
     {
 /*
@@ -56,16 +62,10 @@ thermoSingleLayerCoeffs
 
     forces
     (
-        surfaceShear
         thermocapillary
         contactAngle
     );
 
-    surfaceShearCoeffs
-    {
-        Cf          0.005;
-    }
-
     contactAngleCoeffs
     {
         Ccf             0.085;
diff --git a/tutorials/lagrangian/reactingParcelFilmFoam/rivuletPanel/constant/surfaceFilmProperties b/tutorials/lagrangian/reactingParcelFilmFoam/rivuletPanel/constant/surfaceFilmProperties
index 90792e87a6..01e2f58fef 100644
--- a/tutorials/lagrangian/reactingParcelFilmFoam/rivuletPanel/constant/surfaceFilmProperties
+++ b/tutorials/lagrangian/reactingParcelFilmFoam/rivuletPanel/constant/surfaceFilmProperties
@@ -33,14 +33,18 @@ kinematicSingleLayerCoeffs
 
     injectionModels ();
 
+    turbulence      laminar;
+    laminarCoeffs
+    {
+        Cf          0.001;
+    }
+
     forces
     (
         contactAngle
-        surfaceShear
         thermocapillary
     );
 
-
     contactAngleCoeffs
     {
         Ccf             1;
@@ -58,9 +62,4 @@ kinematicSingleLayerCoeffs
 
         zeroForcePatches    ();
     }
-
-    surfaceShearCoeffs
-    {
-        Cf          0.001;
-    }
 }
diff --git a/tutorials/lagrangian/reactingParcelFilmFoam/splashPanel/constant/reactingCloud1Properties b/tutorials/lagrangian/reactingParcelFilmFoam/splashPanel/constant/reactingCloud1Properties
index c25468b554..9c0d5fdcac 100644
--- a/tutorials/lagrangian/reactingParcelFilmFoam/splashPanel/constant/reactingCloud1Properties
+++ b/tutorials/lagrangian/reactingParcelFilmFoam/splashPanel/constant/reactingCloud1Properties
@@ -88,6 +88,7 @@ subModels
             inputFile       "parcelInjectionProperties";
             duration        10.0;
             parcelsPerSecond 200;
+            randomise       true;
         }
     }
 
diff --git a/tutorials/lagrangian/reactingParcelFilmFoam/splashPanel/constant/surfaceFilmProperties b/tutorials/lagrangian/reactingParcelFilmFoam/splashPanel/constant/surfaceFilmProperties
index 8335fadfc2..c6b9dd1841 100644
--- a/tutorials/lagrangian/reactingParcelFilmFoam/splashPanel/constant/surfaceFilmProperties
+++ b/tutorials/lagrangian/reactingParcelFilmFoam/splashPanel/constant/surfaceFilmProperties
@@ -30,17 +30,17 @@ thermoSingleLayerCoeffs
     deltaWet    1e-4;
     hydrophilic no;
 
-    forces
-    (
-        surfaceShear
-        thermocapillary
-    );
-
-    surfaceShearCoeffs
+    turbulence  laminar;
+    laminarCoeffs
     {
         Cf          0.005;
     }
 
+    forces
+    (
+        thermocapillary
+    );
+
     injectionModels
     ();
 
diff --git a/tutorials/lagrangian/reactingParcelFoam/filter/constant/reactingCloud1Properties b/tutorials/lagrangian/reactingParcelFoam/filter/constant/reactingCloud1Properties
index 5a1582cead..47aa8cf33c 100644
--- a/tutorials/lagrangian/reactingParcelFoam/filter/constant/reactingCloud1Properties
+++ b/tutorials/lagrangian/reactingParcelFoam/filter/constant/reactingCloud1Properties
@@ -93,6 +93,7 @@ subModels
             inputFile       "parcelInjectionProperties";
             duration        1.0;
             parcelsPerSecond 250;
+            randomise       true;
         }
     }
 
diff --git a/tutorials/lagrangian/sprayFoam/aachenBomb/constant/sprayCloudProperties b/tutorials/lagrangian/sprayFoam/aachenBomb/constant/sprayCloudProperties
index dc08a39d09..62775863df 100644
--- a/tutorials/lagrangian/sprayFoam/aachenBomb/constant/sprayCloudProperties
+++ b/tutorials/lagrangian/sprayFoam/aachenBomb/constant/sprayCloudProperties
@@ -56,9 +56,11 @@ constantProperties
 {
     T0              320;
 
-    // place holders for rho0 and Cp0 - reset from liquid props using T0
+    // place holders for rho0, Cp0 and sigma0
+    // - reset from liquid props using T0
     rho0            1000;
     Cp0             4187;
+    sigma0          0.02;
 
     youngsModulus   1e9;
     poissonsRatio   0.35;
diff --git a/wmake/wmake b/wmake/wmake
index ced70188cc..ebcd38cb6e 100755
--- a/wmake/wmake
+++ b/wmake/wmake
@@ -3,7 +3,7 @@
 # =========                 |
 # \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
 #  \\    /   O peration     |
-#   \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+#   \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
 #    \\/     M anipulation  |
 #-------------------------------------------------------------------------------
 # License
@@ -202,9 +202,9 @@ fi
     exit 1
 }
 
-# transform "all" option to "libso" if that looks appropriate or remove it
+# transform "all" or no option to "libso" if that looks appropriate or remove it
 # so that the call to make builds the application
-if [ "$makeType" = all ]
+if [ "$makeType" = all -o "$makeType" = "" ]
 then
     unset makeType
     if grep -e '^ *LIB *=' "$MakeDir/files" >/dev/null 2>&1