From 8dbb3a7ab17aaf4327c665de0976e7dfa72a6ac3 Mon Sep 17 00:00:00 2001
From: andy <andy>
Date: Mon, 18 Jul 2011 11:22:13 +0100
Subject: [PATCH 01/45] STYLE: Minor code clean-up

---
 .../PatchToPatchInterpolation.C                      |  6 +-----
 src/OpenFOAM/meshes/meshTools/matchPoints.H          |  4 ++--
 src/meshTools/searchableSurface/searchableSurface.H  | 12 ++++++------
 3 files changed, 9 insertions(+), 13 deletions(-)

diff --git a/src/OpenFOAM/interpolations/patchToPatchInterpolation/PatchToPatchInterpolation.C b/src/OpenFOAM/interpolations/patchToPatchInterpolation/PatchToPatchInterpolation.C
index fd6ca0ebb7..95a98ffcb1 100644
--- a/src/OpenFOAM/interpolations/patchToPatchInterpolation/PatchToPatchInterpolation.C
+++ b/src/OpenFOAM/interpolations/patchToPatchInterpolation/PatchToPatchInterpolation.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2004-2010 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2004-2011 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -21,10 +21,6 @@ License
     You should have received a copy of the GNU General Public License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
-Description
-    Interpolation class dealing with transfer of data between two
-    primitivePatches
-
 \*---------------------------------------------------------------------------*/
 
 #include "PatchToPatchInterpolation.H"
diff --git a/src/OpenFOAM/meshes/meshTools/matchPoints.H b/src/OpenFOAM/meshes/meshTools/matchPoints.H
index 30650c6475..63a489ad30 100644
--- a/src/OpenFOAM/meshes/meshTools/matchPoints.H
+++ b/src/OpenFOAM/meshes/meshTools/matchPoints.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2004-2010 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2004-2011 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -41,7 +41,7 @@ namespace Foam
 {
 
 /*---------------------------------------------------------------------------*\
-                           Function matchPoints Declaration
+                      Function matchPoints Declaration
 \*---------------------------------------------------------------------------*/
 
 //- Determine correspondence between pointFields. Gets passed
diff --git a/src/meshTools/searchableSurface/searchableSurface.H b/src/meshTools/searchableSurface/searchableSurface.H
index c1026b1dce..c242f5d3f2 100644
--- a/src/meshTools/searchableSurface/searchableSurface.H
+++ b/src/meshTools/searchableSurface/searchableSurface.H
@@ -71,7 +71,7 @@ public:
 
     // Data types
 
-        //- volume types
+        //- Volume types
         enum volumeType
         {
             UNKNOWN = 0,
@@ -83,6 +83,7 @@ public:
 
         static const NamedEnum<volumeType, 4> volumeTypeNames;
 
+
 private:
 
     // Private data
@@ -188,16 +189,16 @@ public:
             return bounds_;
         }
 
-        //- Names of regions.
+        //- Names of regions
         virtual const wordList& regions() const = 0;
 
-        //- Whether supports volume type below.
+        //- Whether supports volume type below
         virtual bool hasVolumeType() const = 0;
 
-        //- Range of local indices that can be returned.
+        //- Range of local indices that can be returned
         virtual label size() const = 0;
 
-        //- Range of global indices that can be returned.
+        //- Range of global indices that can be returned
         virtual label globalSize() const
         {
             return size();
@@ -350,7 +351,6 @@ public:
             {
                 values.clear();
             }
-
 };
 
 

From 81d380ddac4f0b1102b4c7e2b8a44a0670c51d4a Mon Sep 17 00:00:00 2001
From: andy <andy>
Date: Mon, 18 Jul 2011 11:24:22 +0100
Subject: [PATCH 02/45] ENH: Initial commit of arbitrary mesh interface (AMI)
 functionality

---
 src/AMIInterpolation/AMIInterpolation.C       | 793 ++++++++++++++++++
 src/AMIInterpolation/AMIInterpolation.H       | 258 ++++++
 src/AMIInterpolation/AMIInterpolationName.C   |  32 +
 .../AMIPatchToPatchInterpolation.H            |  50 ++
 src/AMIInterpolation/Make/files               |   4 +
 src/AMIInterpolation/Make/options             |   6 +
 .../faceAreaIntersect/faceAreaIntersect.C     | 277 ++++++
 .../faceAreaIntersect/faceAreaIntersect.H     | 161 ++++
 .../faceAreaIntersect/faceAreaIntersectI.H    | 109 +++
 src/OpenFOAM/meshes/boundBox/boundBox.C       |  17 +-
 src/OpenFOAM/meshes/boundBox/boundBox.H       |   9 +-
 11 files changed, 1714 insertions(+), 2 deletions(-)
 create mode 100644 src/AMIInterpolation/AMIInterpolation.C
 create mode 100644 src/AMIInterpolation/AMIInterpolation.H
 create mode 100644 src/AMIInterpolation/AMIInterpolationName.C
 create mode 100644 src/AMIInterpolation/AMIPatchToPatchInterpolation.H
 create mode 100644 src/AMIInterpolation/Make/files
 create mode 100644 src/AMIInterpolation/Make/options
 create mode 100644 src/AMIInterpolation/faceAreaIntersect/faceAreaIntersect.C
 create mode 100644 src/AMIInterpolation/faceAreaIntersect/faceAreaIntersect.H
 create mode 100644 src/AMIInterpolation/faceAreaIntersect/faceAreaIntersectI.H

diff --git a/src/AMIInterpolation/AMIInterpolation.C b/src/AMIInterpolation/AMIInterpolation.C
new file mode 100644
index 0000000000..0e5c6348e5
--- /dev/null
+++ b/src/AMIInterpolation/AMIInterpolation.C
@@ -0,0 +1,793 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2011 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "AMIInterpolation.H"
+#include "faceAreaIntersect.H"
+#include "Random.H"
+#include "treeDataPrimitivePatch.H"
+#include "indexedOctree.H"
+#include "primitivePatch.H"
+#include "meshTools.H"
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+template<class SourcePatch, class TargetPatch>
+void Foam::AMIInterpolation<SourcePatch, TargetPatch>::writeIntersectionOBJ
+(
+    const scalar area,
+    const face& f1,
+    const face& f2,
+    const pointField& f1Points,
+    const pointField& f2Points
+) const
+{
+    static label count = 1;
+
+    const pointField f1pts = f1.points(f1Points);
+    const pointField f2pts = f2.points(f2Points);
+
+    Info<< "Face intersection area (" << count <<  "):" << nl
+        << "    f1 face = " << f1 << nl
+        << "    f1 pts  = " << f1pts << nl
+        << "    f2 face = " << f2 << nl
+        << "    f2 pts  = " << f2pts << nl
+        << "    area    = " << area
+        << endl;
+
+    OFstream os("areas" + name(count) + ".obj");
+
+    forAll(f1pts, i)
+    {
+        meshTools::writeOBJ(os, f1pts[i]);
+    }
+    os<< "l";
+    forAll(f1pts, i)
+    {
+        os<< " " << i + 1;
+    }
+    os<< " 1" << endl;
+
+
+    forAll(f2pts, i)
+    {
+        meshTools::writeOBJ(os, f2pts[i]);
+    }
+    os<< "l";
+    forAll(f2pts, i)
+    {
+        os<< " " << f1pts.size() + i + 1;
+    }
+    os<< " " << f1pts.size() + 1 << endl;
+
+    count++;
+}
+
+
+template<class SourcePatch, class TargetPatch>
+void Foam::AMIInterpolation<SourcePatch, TargetPatch>::checkPatches
+(
+    const primitivePatch& srcPatch,
+    const primitivePatch& tgtPatch
+)
+{
+    const scalar maxBoundsError = 0.05;
+
+    // sanity checks
+    boundBox bbSrc(srcPatch.points());
+    boundBox bbTgt(tgtPatch.points());
+    boundBox bbSurf(srcPatch.points());
+
+
+    // projection surface bounds - check against bounds of source and target
+
+    bbSurf.inflate(maxBoundsError);
+
+    if (!bbSurf.contains(bbSrc))
+    {
+        WarningIn
+        (
+            "AMIInterpolation<SourcePatch, TargetPatch>::checkPatches"
+            "("
+                "const primitivePatch&, "
+                "const primitivePatch&"
+            ")"
+        )   << "Source patch is larger than, or misaligned with the "
+            << "projection surface" << endl;
+    }
+
+    if (!bbSurf.contains(bbTgt))
+    {
+        WarningIn
+        (
+            "AMIInterpolation<SourcePatch, TargetPatch>::checkPatches"
+            "("
+                "const primitivePatch&, "
+                "const primitivePatch&"
+            ")"
+        )   << "Target patch is larger than, or misaligned with the "
+            << "projection surface" << endl;
+    }
+
+
+    // check bounds of source and target
+
+    bbTgt.inflate(maxBoundsError);
+
+    if (!bbTgt.contains(bbSrc))
+    {
+        WarningIn
+        (
+            "AMIInterpolation<SourcePatch, TargetPatch>::checkPatches"
+            "("
+                "const primitivePatch&, "
+                "const primitivePatch&"
+            ")"
+        )   << "Source and target patch bounding boxes are not similar"
+            << endl;
+    }
+}
+
+
+template<class SourcePatch, class TargetPatch>
+void Foam::AMIInterpolation<SourcePatch, TargetPatch>::projectPointsToSurface
+(
+    const searchableSurface& surf,
+    pointField& pts
+) const
+{
+    List<pointIndexHit> nearInfo;
+
+    surf.findNearest(pts, scalarField(pts.size(), GREAT), nearInfo);
+
+    label nMiss = 0;
+    forAll(nearInfo, i)
+    {
+        const pointIndexHit& pi = nearInfo[i];
+
+        if (pi.hit())
+        {
+            pts[i] = pi.hitPoint();
+        }
+        else
+        {
+            pts[i] = pts[i];
+            nMiss++;
+        }
+    }
+
+    if (nMiss > 0)
+    {
+        FatalErrorIn
+        (
+            "void Foam::projectPointsToSurface"
+            "("
+                "const searchableSurface&, "
+                "pointField&"
+            ") const"
+        )
+            << "Error projecting points to surface: "
+            << nMiss << " faces could not be determined"
+            << abort(FatalError);
+    }
+}
+
+
+template<class SourcePatch, class TargetPatch>
+Foam::label Foam::AMIInterpolation<SourcePatch, TargetPatch>::findTargetFace
+(
+    const label srcFaceI,
+    const primitivePatch& srcPatch,
+    const primitivePatch& tgtPatch
+) const
+{
+    label targetFaceI = -1;
+
+    Random rndGen(123456);
+
+    treeBoundBox bb(tgtPatch.points());
+
+    typedef treeDataPrimitivePatch<face, SubList, const pointField&> treeType;
+
+    indexedOctree<treeType> tree
+    (
+        treeType(false, tgtPatch),
+        bb.extend(rndGen, 1E-4),                // overall search domain
+        8,                                      // maxLevel
+        10,                                     // leafsize
+        3.0                                     // duplicity
+    );
+
+    const pointField& srcPts = srcPatch.points();
+    const face& srcFace = srcPatch[srcFaceI];
+    const point& srcPt = srcFace.centre(srcPts);
+    const scalar srcFaceArea = srcFace.mag(srcPts);
+
+//    pointIndexHit sample = tree.findNearest(srcPt, sqr(0.1*bb.mag()));
+    pointIndexHit sample = tree.findNearest(srcPt, 10.0*srcFaceArea);
+
+
+    if (debug)
+    {
+        Info<< "Source point = " << srcPt << ", Sample point = "
+            << sample.hitPoint() << ", Sample index = " << sample.index()
+            << endl;
+    }
+
+    if (sample.hit())
+    {
+        targetFaceI = sample.index();
+    }
+    else
+    {
+        FatalErrorIn
+        (
+            "Foam::label Foam::cyclicAMIPolyPatch::findTargetFace"
+            "("
+                "const label, "
+                "const primitivePatch&"
+                "const primitivePatch&"
+            ") const"
+        )   << "Unable to find target face for source face" << srcFaceI
+            << abort(FatalError);
+    }
+
+    return targetFaceI;
+}
+
+
+template<class SourcePatch, class TargetPatch>
+void Foam::AMIInterpolation<SourcePatch, TargetPatch>::appendNbrFaces
+(
+    const label faceI,
+    const primitivePatch& patch,
+    const DynamicList<label>& visitedFaces,
+    DynamicList<label>& faceIDs
+) const
+{
+//    const labelList& nbrFaces = patch.pointFaces()[faceI];
+    const labelList& nbrFaces = patch.faceFaces()[faceI];
+
+    // filter out faces already visited from src face neighbours
+    forAll(nbrFaces, i)
+    {
+        label nbrFaceI = nbrFaces[i];
+        bool valid = true;
+        forAll(visitedFaces, j)
+        {
+            if (nbrFaceI == visitedFaces[j])
+            {
+                valid = false;
+                break;
+            }
+        }
+
+        if (valid)
+        {
+            forAll(faceIDs, j)
+            {
+                if (nbrFaceI == faceIDs[j])
+                {
+                    valid = false;
+                    break;
+                }
+            }
+        }
+
+        if (valid)
+        {
+            faceIDs.append(nbrFaceI);
+        }
+    }
+}
+
+
+template<class SourcePatch, class TargetPatch>
+void Foam::AMIInterpolation<SourcePatch, TargetPatch>::setNextFaces
+(
+    label& srcFaceI,
+    label& tgtFaceI,
+    const primitivePatch& srcPatch0,
+    const primitivePatch& tgtPatch0,
+    const boolList& mapFlag,
+    labelList& seedFaces,
+    const DynamicList<label>& visitedFaces
+) const
+{
+//    const labelList& srcNbrFaces = srcPatch0.pointFaces()[srcFaceI];
+    const labelList& srcNbrFaces = srcPatch0.faceFaces()[srcFaceI];
+
+    // set possible seeds for later use
+    bool valuesSet = false;
+    forAll(srcNbrFaces, i)
+    {
+        label faceS = srcNbrFaces[i];
+
+        if (mapFlag[faceS] && seedFaces[faceS] == -1)
+        {
+            forAll(visitedFaces, j)
+            {
+                label faceT = visitedFaces[j];
+                scalar area = interArea(faceS, faceT, srcPatch0, tgtPatch0);
+
+                if (area > 0)
+                {
+                    // TODO - throwing area away - re-use in next iteration?
+
+                    seedFaces[faceS] = faceT;
+
+                    if (!valuesSet)
+                    {
+                        srcFaceI = faceS;
+                        tgtFaceI = faceT;
+                        valuesSet = true;
+                    }
+                }
+            }
+        }
+    }
+
+    // set next src and tgt faces if not set above
+    if (valuesSet)
+    {
+        return;
+    }
+    else
+    {
+        // try to use existing seed
+        forAll(mapFlag, faceI)
+        {
+            if (mapFlag[faceI] && seedFaces[faceI] != -1)
+            {
+                srcFaceI = faceI;
+                tgtFaceI = seedFaces[faceI];
+
+                return;
+            }
+        }
+
+        // perform new search to find match
+        if (debug)
+        {
+            Info<< "Advancing front stalled: searching for new "
+                << "target face" << endl;
+        }
+
+        forAll(mapFlag, faceI)
+        {
+            if (mapFlag[faceI])
+            {
+                srcFaceI = faceI;
+                tgtFaceI = findTargetFace(srcFaceI, srcPatch0, tgtPatch0);
+
+                return;
+            }
+        }
+
+        FatalErrorIn
+        (
+            "void Foam::cyclicAMIPolyPatch::setNextFaces"
+            "("
+                "label&, "
+                "label&, "
+                "const primitivePatch&, "
+                "const primitivePatch&, "
+                "const boolList&, "
+                "const labelList&, "
+                "const DynamicList<label>&"
+            ") const"
+        )  << "Unable to set source and target faces" << abort(FatalError);
+    }
+}
+
+
+template<class SourcePatch, class TargetPatch>
+Foam::scalar Foam::AMIInterpolation<SourcePatch, TargetPatch>::interArea
+(
+    const label srcFaceI,
+    const label tgtFaceI,
+    const primitivePatch& srcPatch,
+    const primitivePatch& tgtPatch
+) const
+{
+    const pointField& srcPoints = srcPatch.points();
+    const pointField& tgtPoints = tgtPatch.points();
+
+    const face& src = srcPatch[srcFaceI];
+    const face& tgt = tgtPatch[tgtFaceI];
+
+    // quick reject if either face has zero area
+    if ((src.mag(srcPoints) < ROOTVSMALL) || (tgt.mag(tgtPoints) < ROOTVSMALL))
+    {
+        return 0.0;
+    }
+
+    // create intersection object
+    faceAreaIntersect inter(srcPoints, tgtPoints);
+
+    // crude resultant norm
+    const vector n = 0.5*(tgt.normal(tgtPoints) - src.normal(srcPoints));
+
+    scalar area = inter.calc(src, tgt, n);
+
+    if ((debug > 1) && (area > 0))
+    {
+        writeIntersectionOBJ(area, src, tgt, srcPoints, tgtPoints);
+    }
+
+    return area;
+}
+
+
+template<class SourcePatch, class TargetPatch>
+void Foam::AMIInterpolation<SourcePatch, TargetPatch>::normaliseWeights
+(
+    const word& patchType,
+    const primitivePatch& patch,
+    const pointField& points,
+    const List<DynamicList<label> >& addr,
+    List<DynamicList<scalar> >& wght
+)
+{
+    scalarList wghtSum(patch.size(), 0.0);
+
+    // normalise weights by face areas
+    forAll(wght, faceI)
+    {
+        const DynamicList<label>& addressing = addr[faceI];
+        forAll(addressing, addrI)
+        {
+            const scalar faceArea = patch[faceI].mag(points);
+            wght[faceI][addrI] /= faceArea;
+            wghtSum[faceI] += wght[faceI][addrI];
+        }
+    }
+
+    Info<< "Cumulative " << patchType <<  "source weights min/max = "
+        << min(wghtSum) << ", " << max(wghtSum) << endl;
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+template<class SourcePatch, class TargetPatch>
+Foam::AMIInterpolation<SourcePatch, TargetPatch>::AMIInterpolation
+(
+    const SourcePatch& srcPatch,
+    const TargetPatch& tgtPatch,
+    const searchableSurface& surf
+)
+:
+    srcAddress_(),
+    srcWeights_(),
+    tgtAddress_(),
+    tgtWeights_()
+{
+    checkPatches(srcPatch, tgtPatch);
+
+    calcAddressing(srcPatch, tgtPatch, surf);
+}
+
+
+
+// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
+
+template<class SourcePatch, class TargetPatch>
+Foam::AMIInterpolation<SourcePatch, TargetPatch>::~AMIInterpolation()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+template<class SourcePatch, class TargetPatch>
+void Foam::AMIInterpolation<SourcePatch, TargetPatch>::calcAddressing
+(
+    const primitivePatch& srcPatch,
+    const primitivePatch& tgtPatch,
+    const searchableSurface& surf
+)
+{
+    if (debug)
+    {
+        Info<< "AMI: calcAddressing" << endl;
+    }
+
+    // temporary storage for addressing and weights
+    List<DynamicList<label> > srcAddr(srcPatch.size());
+    List<DynamicList<scalar> > srcWght(srcPatch.size());
+    List<DynamicList<label> > tgtAddr(tgtPatch.size());
+    List<DynamicList<scalar> > tgtWght(tgtPatch.size());
+
+
+    // create new patches for source and target
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    pointField srcPoints = srcPatch.points();
+    primitivePatch srcPatch0
+    (
+        SubList<face>
+        (
+            srcPatch,
+            srcPatch.size(),
+            0
+        ),
+        srcPoints
+    );
+
+    if (debug)
+    {
+        OFstream os("amiSrcPoints.obj");
+        forAll(srcPoints, i)
+        {
+            meshTools::writeOBJ(os, srcPoints[i]);
+        }
+    }
+
+    pointField tgtPoints = tgtPatch.points();
+    primitivePatch tgtPatch0
+    (
+        SubList<face>
+        (
+            tgtPatch,
+            tgtPatch.size(),
+            0
+        ),
+        tgtPoints
+    );
+
+    if (debug)
+    {
+        OFstream os("osTgtPoints.obj");
+        forAll(tgtPoints, i)
+        {
+            meshTools::writeOBJ(os, tgtPoints[i]);
+        }
+    }
+
+
+    if (debug)
+    {
+        Info<< "AMI: projecting points to surface" << endl;
+    }
+
+    // map source and target patches onto projection surface
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    projectPointsToSurface(surf, srcPoints);
+    projectPointsToSurface(surf, tgtPoints);
+
+
+    // find initial face match using brute force/octree search
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    label srcFaceI = 0;
+    label tgtFaceI = findTargetFace(srcFaceI, srcPatch0, tgtPatch0);
+
+    if (debug)
+    {
+        Info<< "AMI: initial target face = " << tgtFaceI << endl;
+    }
+
+
+    // construct weights and addressing
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    label facesRemaining = srcPatch0.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(facesRemaining, -1);
+    seedFaces[srcFaceI] = tgtFaceI;
+
+    // list to keep track of whether src face can be mapped
+    boolList mapFlag(facesRemaining, true);
+
+    do
+    {
+        nbrFaces.clear();
+        visitedFaces.clear();
+
+        // append initial target face and neighbours
+        nbrFaces.append(tgtFaceI);
+        appendNbrFaces(tgtFaceI, tgtPatch0, visitedFaces, nbrFaces);
+
+        do
+        {
+            // process new target face
+            tgtFaceI = nbrFaces.remove();
+            visitedFaces.append(tgtFaceI);
+            scalar area = interArea(srcFaceI, tgtFaceI, srcPatch0, tgtPatch0);
+
+            // store when intersection area > 0
+            if (area > 0)
+            {
+                srcAddr[srcFaceI].append(tgtFaceI);
+                srcWght[srcFaceI].append(area);
+
+                tgtAddr[tgtFaceI].append(srcFaceI);
+                tgtWght[tgtFaceI].append(area);
+
+                appendNbrFaces(tgtFaceI, tgtPatch0, visitedFaces, nbrFaces);
+            }
+
+        } while (nbrFaces.size() > 0);
+
+        mapFlag[srcFaceI] = false;
+
+        facesRemaining--;
+
+        // choose new src face from current src face neighbour
+        if (facesRemaining > 0)
+        {
+            setNextFaces
+            (
+                srcFaceI,
+                tgtFaceI,
+                srcPatch0,
+                tgtPatch0,
+                mapFlag,
+                seedFaces,
+                visitedFaces
+            );
+        }
+    } while (facesRemaining > 0);
+
+
+    // weights normalisation
+    normaliseWeights("source", srcPatch0, srcPoints, srcAddr, srcWght);
+    normaliseWeights("target", tgtPatch0, tgtPoints, tgtAddr, tgtWght);
+
+    // transfer data to persistent storage
+    srcAddress_.setSize(srcAddr.size());
+    srcWeights_.setSize(srcWght.size());
+    forAll(srcAddr, i)
+    {
+        srcAddress_[i].transfer(srcAddr[i]);
+        srcWeights_[i].transfer(srcWght[i]);
+    }
+
+    tgtAddress_.setSize(tgtAddr.size());
+    tgtWeights_.setSize(tgtWght.size());
+    forAll(tgtAddr, i)
+    {
+        tgtAddress_[i].transfer(tgtAddr[i]);
+        tgtWeights_[i].transfer(tgtWght[i]);
+    }
+}
+
+
+template<class SourcePatch, class TargetPatch>
+bool Foam::AMIInterpolation<SourcePatch, TargetPatch>::movePoints()
+{
+    return true;
+}
+
+
+template<class SourcePatch, class TargetPatch>
+template<class Type>
+Foam::tmp<Foam::Field<Type> >
+Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolateToSource
+(
+    const Field<Type>& fld
+) const
+{
+    if (fld.size() != tgtAddress_.size())
+    {
+        FatalErrorIn
+        (
+            "AMIInterpolation::interpolateToSource(const Field<Type>)"
+        )   << "Supplied field size is not equal to target patch size. "
+            << "Target patch = " << tgtAddress_.size() << ", supplied field: "
+            << fld.size() << abort(FatalError);
+    }
+
+    tmp<Field<Type> > tresult
+    (
+        new Field<Type>(srcAddress_.size(), pTraits<Type>::zero)
+    );
+
+    Field<Type>& result = tresult();
+
+    forAll(result, faceI)
+    {
+        const labelList& faces = srcAddress_[faceI];
+        const scalarList& weights = srcWeights_[faceI];
+
+        forAll(faces, i)
+        {
+            result[faceI] += fld[faces[i]]*weights[i];
+        }
+    }
+
+    return tresult;
+}
+
+
+template<class SourcePatch, class TargetPatch>
+template<class Type>
+Foam::tmp<Foam::Field<Type> >
+Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolateToSource
+(
+    const tmp<Field<Type> >& tFld
+) const
+{
+    return interpolateToSource(tFld());
+}
+
+
+
+template<class SourcePatch, class TargetPatch>
+template<class Type>
+Foam::tmp<Foam::Field<Type> >
+Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolateToTarget
+(
+    const Field<Type>& fld
+) const
+{
+    if (fld.size() != srcAddress_.size())
+    {
+        FatalErrorIn
+        (
+            "AMIInterpolation::interpolateToSource(const Field<Type>)"
+        )   << "Supplied field size is not equal to source patch size. "
+            << "Source patch = " << srcAddress_.size() << ", supplied field: "
+            << fld.size() << abort(FatalError);
+    }
+
+    tmp<Field<Type> > tresult
+    (
+        new Field<Type>(tgtAddress_.size(), pTraits<Type>::zero)
+    );
+
+    Field<Type>& result = tresult();
+
+    forAll(result, faceI)
+    {
+        const labelList& faces = tgtAddress_[faceI];
+        const scalarList& weights = tgtWeights_[faceI];
+
+        forAll(faces, i)
+        {
+            result[faceI] += fld[faces[i]]*weights[i];
+        }
+    }
+
+    return tresult;
+}
+
+
+template<class SourcePatch, class TargetPatch>
+template<class Type>
+Foam::tmp<Foam::Field<Type> >
+Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolateToTarget
+(
+    const tmp<Field<Type> >& tFld
+) const
+{
+    return interpolateToTarget(tFld());
+}
+
+
+// ************************************************************************* //
diff --git a/src/AMIInterpolation/AMIInterpolation.H b/src/AMIInterpolation/AMIInterpolation.H
new file mode 100644
index 0000000000..246c1660a6
--- /dev/null
+++ b/src/AMIInterpolation/AMIInterpolation.H
@@ -0,0 +1,258 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2011 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::AMIInterpolation
+
+Description
+    Interpolation class dealing with transfer of data between two
+    primitive patches with an arbitrary mesh interface (AMI)
+
+SourceFiles
+    AMIInterpolation.C
+    AMIInterpolationName.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef AMIInterpolation_H
+#define AMIInterpolation_H
+
+#include "className.H"
+#include "DynamicList.H"
+#include "searchableSurface.H"
+#include "boolList.H"
+#include "primitivePatch.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                    Class AMIInterpolationName Declaration
+\*---------------------------------------------------------------------------*/
+
+TemplateName(AMIInterpolation);
+
+
+/*---------------------------------------------------------------------------*\
+                      Class AMIInterpolation Declaration
+\*---------------------------------------------------------------------------*/
+
+template<class SourcePatch, class TargetPatch>
+class AMIInterpolation
+:
+    public AMIInterpolationName
+{
+    // Static data
+
+        // Source patch
+
+            //- Addressing
+            labelListList srcAddress_;
+
+            //- Weighting factors
+            scalarListList srcWeights_;
+
+
+        // Target patch
+
+            //- Addressing
+            labelListList tgtAddress_;
+
+            //- Weighting factors
+            scalarListList tgtWeights_;
+
+
+    // Private Member Functions
+
+        //- Disallow default bitwise copy construct
+        AMIInterpolation(const AMIInterpolation&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const AMIInterpolation&);
+
+        //- Write triangle intersection to OBJ file
+        void writeIntersectionOBJ
+        (
+            const scalar area,
+            const face& f1,
+            const face& f2,
+            const pointField& f1Points,
+            const pointField& f2Points
+        ) const;
+
+        void checkPatches
+        (
+            const primitivePatch& srcPatch,
+            const primitivePatch& tgtPatch
+        );
+
+        void projectPointsToSurface
+        (
+            const searchableSurface& surf,
+            pointField& pts
+        ) const;
+
+        label findTargetFace
+        (
+            const label srcFaceI,
+            const primitivePatch& srcPatch,
+            const primitivePatch& tgtPatch
+        ) const;
+
+        void appendNbrFaces
+        (
+            const label faceI,
+            const primitivePatch& patch,
+            const DynamicList<label>& visitedFaces,
+            DynamicList<label>& faceIDs
+        ) const;
+
+        void setNextFaces
+        (
+            label& srcFaceI,
+            label& tgtFaceI,
+            const primitivePatch& srcPatch0,
+            const primitivePatch& tgtPatch0,
+            const boolList& mapFlag,
+            labelList& seedFaces,
+            const DynamicList<label>& visitedFaces
+        ) const;
+
+        scalar interArea
+        (
+            const label srcFaceI,
+            const label tgtFaceI,
+            const primitivePatch& srcPatch,
+            const primitivePatch& tgtPatch
+        ) const;
+
+        void normaliseWeights
+        (
+            const word& patchType,
+            const primitivePatch& patch,
+            const pointField& points,
+            const List<DynamicList<label> >& addr,
+            List<DynamicList<scalar> >& wght
+        );
+
+
+public:
+
+    // Constructors
+
+        //- Construct from components
+        AMIInterpolation
+        (
+            const SourcePatch& srcPatch,
+            const TargetPatch& tgtPatch,
+            const searchableSurface& surf
+        );
+
+
+    //- Destructor
+    ~AMIInterpolation();
+
+
+    // Member Functions
+
+        // Access
+
+            // Source patch
+
+                //- Return const access to source patch addressing
+                inline const labelListList& srcAddress();
+
+                //- Return const access to source patch weights
+                inline const scalarListList& srcWeights();
+
+
+            // Target patch
+
+                //- Return const access to target patch addressing
+                inline const labelListList& tgtAddress();
+
+                //- Return const access to target patch weights
+                inline const scalarListList& tgtWeights();
+
+
+        // Manipulation
+
+            //- Calculate addressing
+            void calcAddressing
+            (
+                const primitivePatch& srcPatch,
+                const primitivePatch& tgtPatch,
+                const searchableSurface& surf
+            );
+
+            //- Correct weighting factors for moving mesh
+            bool movePoints();
+
+
+        // Evaluation
+
+            //- Interpolate from target to source
+            template<class Type>
+            tmp<Field<Type> > interpolateToSource(const Field<Type>& fld) const;
+
+            //- Interpolate from target tmp field to source
+            template<class Type>
+            tmp<Field<Type> > interpolateToSource
+            (
+                const tmp<Field<Type> >& tFld
+            ) const;
+
+            //- Interpolate from source to target
+            template<class Type>
+            tmp<Field<Type> > interpolateToTarget(const Field<Type>& fld) const;
+
+            //- Interpolate from source tmp field to target
+            template<class Type>
+            tmp<Field<Type> > interpolateToTarget
+            (
+                const tmp<Field<Type> >& tFld
+            ) const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#include "AMIInterpolationI.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+#   include "AMIInterpolation.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/AMIInterpolation/AMIInterpolationName.C b/src/AMIInterpolation/AMIInterpolationName.C
new file mode 100644
index 0000000000..064f5604dc
--- /dev/null
+++ b/src/AMIInterpolation/AMIInterpolationName.C
@@ -0,0 +1,32 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2011 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "AMIInterpolation.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+defineTypeNameAndDebug(Foam::AMIInterpolationName, 0);
+
+// ************************************************************************* //
diff --git a/src/AMIInterpolation/AMIPatchToPatchInterpolation.H b/src/AMIInterpolation/AMIPatchToPatchInterpolation.H
new file mode 100644
index 0000000000..bf9d082762
--- /dev/null
+++ b/src/AMIInterpolation/AMIPatchToPatchInterpolation.H
@@ -0,0 +1,50 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2011 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef AMIPatchToPatchInterpolation_H
+#define AMIPatchToPatchInterpolation_H
+
+#include "AMIInterpolation.H"
+#include "PrimitivePatch.H"
+#include "face.H"
+#include "SubList.H"
+#include "pointField.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    typedef AMIInterpolation
+    <
+        PrimitivePatch<face, SubList, const pointField&>,
+        PrimitivePatch<face, SubList, const pointField&>
+    >   AMIPatchToPatchInterpolation;
+}
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/AMIInterpolation/Make/files b/src/AMIInterpolation/Make/files
new file mode 100644
index 0000000000..76d2ff7f43
--- /dev/null
+++ b/src/AMIInterpolation/Make/files
@@ -0,0 +1,4 @@
+AMIInterpolationName.C
+faceAreaIntersect/faceAreaIntersect.C
+
+LIB = $(FOAM_USER_LIBBIN)/libAMIInterpolation
diff --git a/src/AMIInterpolation/Make/options b/src/AMIInterpolation/Make/options
new file mode 100644
index 0000000000..1b3eff5f59
--- /dev/null
+++ b/src/AMIInterpolation/Make/options
@@ -0,0 +1,6 @@
+EXE_INC = \
+    -DFULLDEBUG -g -O0 \
+    -I$(LIB_SRC)/meshTools/lnInclude
+
+LIB_LIBS = \
+    -lmeshTools
diff --git a/src/AMIInterpolation/faceAreaIntersect/faceAreaIntersect.C b/src/AMIInterpolation/faceAreaIntersect/faceAreaIntersect.C
new file mode 100644
index 0000000000..174fcdd461
--- /dev/null
+++ b/src/AMIInterpolation/faceAreaIntersect/faceAreaIntersect.C
@@ -0,0 +1,277 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2011 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "faceAreaIntersect.H"
+
+// * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * * //
+
+void Foam::faceAreaIntersect::triSliceWithPlane
+(
+    const triPoints& tri,
+    const plane& p,
+    FixedList<triPoints, 10>& tris,
+    label& nTris
+)
+{
+    // distance to cutting plane
+    FixedList<scalar, 3> d;
+
+    // determine how many of the points are above the cutting plane
+    label nCoPlanar = 0;
+    label nPos = 0;
+    label posI = -1;
+    label negI = -1;
+    bool coPlanar;
+    forAll(tri, i)
+    {
+        d[i] = ((tri[i] - p.refPoint()) & p.normal());
+
+        if (mag(d[i]) < 1e-10)
+        {
+            coPlanar = true;
+            nCoPlanar++;
+        }
+        else
+        {
+            coPlanar = false;
+        }
+
+        if (!coPlanar)
+        {
+            if (d[i] > 0)
+            {
+                nPos++;
+                posI = i;
+            }
+            else
+            {
+                negI = i;
+            }
+        }
+    }
+
+    if ((nPos == 3) || ((nPos == 2) && (nCoPlanar == 1)))
+    {
+        // all points above cutting plane - add triangle to list
+        tris[nTris++] = tri;
+    }
+    else if ((nPos == 2) || ((nPos == 1) && (nCoPlanar == 1)))
+    {
+        // 2 points above plane, 1 below
+        // resulting quad above plane split into 2 triangles
+
+        // point under the plane
+        label i0 = negI;
+
+        // indices of remaining points
+        label i1 = d.fcIndex(i0);
+        label i2 = d.fcIndex(i1);
+
+        // determine the two intersection points
+        point p01 = planeIntersection(d, tri, i0, i1);
+        point p02 = planeIntersection(d, tri, i0, i2);
+
+        // forget triangle below plane
+        // - decompose quad above plane into 2 triangles and add to list
+        setTriPoints(tri[i1], tri[i2], p02, nTris, tris);
+        setTriPoints(tri[i1], p02, p01, nTris, tris);
+    }
+    else if ((nPos == 1) && (nCoPlanar != 1))
+    {
+        // 1 point above plane, 2 below
+        // resulting quad below plane split into 2 triangles
+
+        // point above the plane
+        label i0 = posI;
+
+        // indices of remaining points
+        label i1 = d.fcIndex(i0);
+        label i2 = d.fcIndex(i1);
+
+        // determine the two intersection points
+        point p01 = planeIntersection(d, tri, i0, i1);
+        point p02 = planeIntersection(d, tri, i0, i2);
+
+        // forget quad below plane
+        // - add triangle above plane to list
+        setTriPoints(tri[i0], p01, p02, nTris, tris);
+    }
+    else
+    {
+        // all points below cutting plane - forget
+    }
+}
+
+
+Foam::scalar Foam::faceAreaIntersect::triangleIntersect
+(
+    const triPoints& src,
+    const triPoints& tgt,
+    const vector& n
+)
+{
+    // Work storage
+    FixedList<triPoints, 10> cutTris;
+    label nCutTris = 0;
+
+    FixedList<triPoints, 10> tris;
+    label nTris = 0;
+
+    // cut source triangle with all inwards pointing faces of target triangle
+    // - triangles in cutTris are inside target triangle
+
+    // edge 0
+    {
+        // cut triangle src with plane and put resulting sub-triangles in
+        // cutTris list
+
+        plane pl0(tgt[0], tgt[1], tgt[1] + n);
+        triSliceWithPlane(src, pl0, cutTris, nCutTris);
+    }
+
+    if (nCutTris == 0)
+    {
+        return 0.0;
+    }
+
+    // edge1
+    {
+        // cut cutTris with plane and put resulting sub-triangles in
+        // tris list (re-use tris storage)
+
+        plane pl1(tgt[1], tgt[2], tgt[2] + n);
+
+        nTris = 0;
+
+        for (label i = 0; i < nCutTris; i++)
+        {
+            triSliceWithPlane(cutTris[i], pl1, tris, nTris);
+        }
+
+        if (nTris == 0)
+        {
+            return 0.0;
+        }
+    }
+
+    // edge2
+    {
+        // cut tris with plane and put resulting sub-triangles in
+        // cutTris list (re-use cutTris storage)
+
+        plane pl2(tgt[2], tgt[0], tgt[0] + n);
+
+        nCutTris = 0;
+
+        for (label i = 0; i < nTris; i++)
+        {
+            triSliceWithPlane(tris[i], pl2, cutTris, nCutTris);
+        }
+
+        if (nCutTris == 0)
+        {
+            return 0.0;
+        }
+        else
+        {
+            // calculate area of sub-triangles
+            scalar area = 0.0;
+            for (label i = 0; i < nCutTris; i++)
+            {
+                const triPoints& t = cutTris[i];
+                area += mag(0.5*((t[1] - t[0])^(t[2] - t[0])));
+            }
+
+            return area;
+        }
+    }
+}
+
+
+// * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * * //
+
+Foam::faceAreaIntersect::faceAreaIntersect
+(
+    const pointField& pointsA,
+    const pointField& pointsB
+)
+:
+    pointsA_(pointsA),
+    pointsB_(pointsB)
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+Foam::scalar Foam::faceAreaIntersect::calc
+(
+    const face& faceA,
+    const face& faceB,
+    const vector& n
+)
+{
+    // split faces into triangles
+    DynamicList<face> trisA;
+    DynamicList<face> trisB;
+
+//    if (useTriangleFan)
+//    {
+//        triangleFan(faceA, trisA);
+//        triangleFan(faceB, trisB);
+//    }
+//    else
+//    {
+//        faceA.triangles(pointsA_, trisA);
+//        faceB.triangles(pointsB_, trisB);
+//    }
+
+    faceA.triangles(pointsA_, trisA);
+    faceB.triangles(pointsB_, trisB);
+
+    // intersect triangles
+    scalar totalArea = 0.0;
+    forAll(trisA, tA)
+    {
+        triPoints tpA = getTriPoints(pointsA_, trisA[tA], false);
+
+        if (triArea(tpA) > ROOTVSMALL)
+        {
+            forAll(trisB, tB)
+            {
+                triPoints tpB = getTriPoints(pointsB_, trisB[tB], true);
+
+                if (triArea(tpB) > ROOTVSMALL)
+                {
+                    totalArea += triangleIntersect(tpA, tpB, n);
+                }
+            }
+        }
+    }
+
+    return totalArea;
+}
+
+
+// ************************************************************************* //
diff --git a/src/AMIInterpolation/faceAreaIntersect/faceAreaIntersect.H b/src/AMIInterpolation/faceAreaIntersect/faceAreaIntersect.H
new file mode 100644
index 0000000000..77638e51dd
--- /dev/null
+++ b/src/AMIInterpolation/faceAreaIntersect/faceAreaIntersect.H
@@ -0,0 +1,161 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2011 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::faceAreaIntersect
+
+Description
+    Face intersection class
+    - calculates intersection area by sub-dividing face into triangles
+      and cutting
+
+SourceFiles
+    faceAreaIntersect.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef faceAreaIntersect_H
+#define faceAreaIntersect_H
+
+#include "pointField.H"
+#include "FixedList.H"
+#include "plane.H"
+#include "face.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                       Class faceAreaIntersect Declaration
+\*---------------------------------------------------------------------------*/
+
+class faceAreaIntersect
+{
+    typedef FixedList<point, 3> triPoints;
+
+    // Private data
+
+        //- Reference to the points of sideA
+        const pointField& pointsA_;
+
+        //- Reference to the points of sideB
+        const pointField& pointsB_;
+
+
+    // Private Member Functions
+
+        //- Get triPoints from face
+        inline triPoints getTriPoints
+        (
+            const pointField& points,
+            const face& f,
+            const bool reverse
+        ) const;
+
+        //- Set triPoints into tri list
+        inline void setTriPoints
+        (
+            const point& a,
+            const point& b,
+            const point& c,
+            label& count,
+            FixedList<triPoints, 10>& tris
+        ) const;
+
+        //- Decompose face into triangle fan
+        inline void triangleFan
+        (
+            const face& f,
+            DynamicList<face>& faces
+        ) const;
+
+        //- Return point of intersection between plane and triangle edge
+        inline point planeIntersection
+        (
+            const FixedList<scalar, 3>& d,
+            const triPoints& t,
+            const label negI,
+            const label posI
+        ) const;
+
+        //- Return triangle area
+        inline scalar triArea(const triPoints& t) const;
+
+
+        //- Slice triangle with plane and generate new cut sub-triangles
+        void triSliceWithPlane
+        (
+            const triPoints& tri,
+            const plane& p,
+            FixedList<triPoints, 10>& tris,
+            label& nTris
+        );
+
+        //- Return area of intersection of triangles src and tgt
+        scalar triangleIntersect
+        (
+            const triPoints& src,
+            const triPoints& tgt,
+            const vector& n
+        );
+
+
+public:
+
+    // Constructors
+
+        //- Construct from components
+        faceAreaIntersect
+        (
+            const pointField& pointsA,
+            const pointField& pointsB
+        );
+
+
+    // Public Member Functions
+
+        //- Return area of intersection of faceA with faceB
+        scalar calc
+        (
+            const face& faceA,
+            const face& faceB,
+            const vector& n
+        );
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#include "faceAreaIntersectI.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/AMIInterpolation/faceAreaIntersect/faceAreaIntersectI.H b/src/AMIInterpolation/faceAreaIntersect/faceAreaIntersectI.H
new file mode 100644
index 0000000000..033a4d3f9e
--- /dev/null
+++ b/src/AMIInterpolation/faceAreaIntersect/faceAreaIntersectI.H
@@ -0,0 +1,109 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2011 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+inline void Foam::faceAreaIntersect::setTriPoints
+(
+    const point& a,
+    const point& b,
+    const point& c,
+    label& count,
+    FixedList<triPoints, 10>& tris
+) const
+{
+    triPoints& tp = tris[count++];
+    tp[0] = a;
+    tp[1] = b;
+    tp[2] = c;
+}
+
+
+inline Foam::faceAreaIntersect::triPoints Foam::faceAreaIntersect::getTriPoints
+(
+    const pointField& points,
+    const face& f,
+    const bool reverse
+) const
+{
+    triPoints result;
+
+    if (reverse)
+    {
+        result[2] = points[f[0]];
+        result[1] = points[f[1]];
+        result[0] = points[f[2]];
+    }
+    else
+    {
+        result[0] = points[f[0]];
+        result[1] = points[f[1]];
+        result[2] = points[f[2]];
+    }
+
+    return result;
+}
+
+
+inline void Foam::faceAreaIntersect::triangleFan
+(
+    const face& f,
+    DynamicList<face>& faces
+) const
+{
+    if (f.size() > 2)
+    {
+        const label v0 = 0;
+
+        labelList indices(3);
+
+        for (label i = 1; i < f.size() - 1; i++)
+        {
+            indices[0] = f[v0];
+            indices[1] = f[i];
+            indices[2] = f[i + 1];
+            faces.append(face(indices));
+        }
+    }
+}
+
+
+inline Foam::point Foam::faceAreaIntersect::planeIntersection
+(
+    const FixedList<scalar, 3>& d,
+    const triPoints& t,
+    const label negI,
+    const label posI
+) const
+{
+    return (d[posI]*t[negI] - d[negI]*t[posI])/(-d[negI] + d[posI]);
+}
+
+
+inline Foam::scalar Foam::faceAreaIntersect::triArea(const triPoints& t) const
+{
+    return mag(0.5*((t[1] - t[0])^(t[2] - t[0])));
+}
+
+
+// ************************************************************************* //
diff --git a/src/OpenFOAM/meshes/boundBox/boundBox.C b/src/OpenFOAM/meshes/boundBox/boundBox.C
index 6f1bc61221..823b82b56a 100644
--- a/src/OpenFOAM/meshes/boundBox/boundBox.C
+++ b/src/OpenFOAM/meshes/boundBox/boundBox.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2004-2010 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2004-2011 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -163,6 +163,21 @@ Foam::tmp<Foam::pointField> Foam::boundBox::points() const
 }
 
 
+void Foam::boundBox::inflate(const scalar s)
+{
+    boundBox bb(*this);
+
+    vector dir = bb.span();
+    scalar magDir = Foam::mag(dir);
+    dir /= magDir;
+
+    scalar ext = s*magDir;
+
+    min_ -= dir*ext;
+    max_ += dir*ext;
+}
+
+
 bool Foam::boundBox::contains(const UList<point>& points) const
 {
     if (points.empty())
diff --git a/src/OpenFOAM/meshes/boundBox/boundBox.H b/src/OpenFOAM/meshes/boundBox/boundBox.H
index 411f66f185..6394aa08d7 100644
--- a/src/OpenFOAM/meshes/boundBox/boundBox.H
+++ b/src/OpenFOAM/meshes/boundBox/boundBox.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2004-2010 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2004-2011 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -160,6 +160,13 @@ public:
             //- Return corner points in an order corresponding to a 'hex' cell
             tmp<pointField> points() const;
 
+
+        // Manipulate
+
+            //- Inflate box by factor*mag(span) in all dimensions
+            void inflate(const scalar s);
+
+
         // Query
 
             //- Overlaps/touches boundingBox?

From 4ee5d991b8a87233b744d00a1e75acff8e2a0ba0 Mon Sep 17 00:00:00 2001
From: andy <andy>
Date: Wed, 20 Jul 2011 18:19:36 +0100
Subject: [PATCH 03/45] ENH: Initial commit of arbitrary mesh interface
 boundary handling

---
 src/AMIInterpolation/Make/files               |   8 +
 src/AMIInterpolation/Make/options             |   2 +
 .../cyclicAMIFvPatch/cyclicAMIFvPatch.C       | 143 ++++
 .../cyclicAMIFvPatch/cyclicAMIFvPatch.H       | 193 +++++
 .../cyclicAMIFvPatchField.C                   | 234 ++++++
 .../cyclicAMIFvPatchField.H                   | 216 +++++
 .../cyclicAMIFvPatchFields.C                  |  43 +
 .../cyclicAMIFvPatchFields.H                  |  49 ++
 .../cyclicAMIFvPatchFieldsFwd.H               |  50 ++
 .../cyclicAMIFvsPatchField.C                  | 126 +++
 .../cyclicAMIFvsPatchField.H                  | 143 ++++
 .../cyclicAMIFvsPatchFields.C                 |  43 +
 .../cyclicAMIFvsPatchFields.H                 |  49 ++
 .../cyclicAMIFvsPatchFieldsFwd.H              |  50 ++
 .../cyclicAMILduInterface.C                   |  39 +
 .../cyclicAMILduInterface.H                   |  97 +++
 .../cyclicAMILduInterfaceField.C              |  62 ++
 .../cyclicAMILduInterfaceField.H              | 103 +++
 .../cyclicAMIPolyPatch/cyclicAMIPolyPatch.C   | 754 ++++++++++++++++++
 .../cyclicAMIPolyPatch/cyclicAMIPolyPatch.H   | 382 +++++++++
 20 files changed, 2786 insertions(+)
 create mode 100644 src/AMIInterpolation/patches/cyclicAMIFvPatch/cyclicAMIFvPatch.C
 create mode 100644 src/AMIInterpolation/patches/cyclicAMIFvPatch/cyclicAMIFvPatch.H
 create mode 100644 src/AMIInterpolation/patches/cyclicAMIFvPatchField/cyclicAMIFvPatchField.C
 create mode 100644 src/AMIInterpolation/patches/cyclicAMIFvPatchField/cyclicAMIFvPatchField.H
 create mode 100644 src/AMIInterpolation/patches/cyclicAMIFvPatchField/cyclicAMIFvPatchFields.C
 create mode 100644 src/AMIInterpolation/patches/cyclicAMIFvPatchField/cyclicAMIFvPatchFields.H
 create mode 100644 src/AMIInterpolation/patches/cyclicAMIFvPatchField/cyclicAMIFvPatchFieldsFwd.H
 create mode 100644 src/AMIInterpolation/patches/cyclicAMIFvsPatchField/cyclicAMIFvsPatchField.C
 create mode 100644 src/AMIInterpolation/patches/cyclicAMIFvsPatchField/cyclicAMIFvsPatchField.H
 create mode 100644 src/AMIInterpolation/patches/cyclicAMIFvsPatchField/cyclicAMIFvsPatchFields.C
 create mode 100644 src/AMIInterpolation/patches/cyclicAMIFvsPatchField/cyclicAMIFvsPatchFields.H
 create mode 100644 src/AMIInterpolation/patches/cyclicAMIFvsPatchField/cyclicAMIFvsPatchFieldsFwd.H
 create mode 100644 src/AMIInterpolation/patches/cyclicAMILduInterfaceField/cyclicAMILduInterface.C
 create mode 100644 src/AMIInterpolation/patches/cyclicAMILduInterfaceField/cyclicAMILduInterface.H
 create mode 100644 src/AMIInterpolation/patches/cyclicAMILduInterfaceField/cyclicAMILduInterfaceField.C
 create mode 100644 src/AMIInterpolation/patches/cyclicAMILduInterfaceField/cyclicAMILduInterfaceField.H
 create mode 100644 src/AMIInterpolation/patches/cyclicAMIPolyPatch/cyclicAMIPolyPatch.C
 create mode 100644 src/AMIInterpolation/patches/cyclicAMIPolyPatch/cyclicAMIPolyPatch.H

diff --git a/src/AMIInterpolation/Make/files b/src/AMIInterpolation/Make/files
index 76d2ff7f43..7a47cad93c 100644
--- a/src/AMIInterpolation/Make/files
+++ b/src/AMIInterpolation/Make/files
@@ -1,4 +1,12 @@
 AMIInterpolationName.C
 faceAreaIntersect/faceAreaIntersect.C
 
+patches/cyclicAMILduInterfaceField/cyclicAMILduInterface.C
+patches/cyclicAMILduInterfaceField/cyclicAMILduInterfaceField.C
+
+patches/cyclicAMIPolyPatch/cyclicAMIPolyPatch.C
+patches/cyclicAMIFvPatch/cyclicAMIFvPatch.C
+patches/cyclicAMIFvPatchField/cyclicAMIFvPatchFields.C
+patches/cyclicAMIFvsPatchField/cyclicAMIFvsPatchFields.C
+
 LIB = $(FOAM_USER_LIBBIN)/libAMIInterpolation
diff --git a/src/AMIInterpolation/Make/options b/src/AMIInterpolation/Make/options
index 1b3eff5f59..431de9fbf4 100644
--- a/src/AMIInterpolation/Make/options
+++ b/src/AMIInterpolation/Make/options
@@ -1,6 +1,8 @@
 EXE_INC = \
     -DFULLDEBUG -g -O0 \
+    -I$(LIB_SRC)/finiteVolume/lnInclude \
     -I$(LIB_SRC)/meshTools/lnInclude
 
 LIB_LIBS = \
+    -lfiniteVolume \
     -lmeshTools
diff --git a/src/AMIInterpolation/patches/cyclicAMIFvPatch/cyclicAMIFvPatch.C b/src/AMIInterpolation/patches/cyclicAMIFvPatch/cyclicAMIFvPatch.C
new file mode 100644
index 0000000000..d000c52c31
--- /dev/null
+++ b/src/AMIInterpolation/patches/cyclicAMIFvPatch/cyclicAMIFvPatch.C
@@ -0,0 +1,143 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2011 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "cyclicAMIFvPatch.H"
+#include "addToRunTimeSelectionTable.H"
+#include "fvMesh.H"
+#include "transform.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(cyclicAMIFvPatch, 0);
+    addToRunTimeSelectionTable(fvPatch, cyclicAMIFvPatch, polyPatch);
+}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+void Foam::cyclicAMIFvPatch::makeWeights(scalarField& w) const
+{
+    const cyclicAMIFvPatch& nbrPatch = neighbFvPatch();
+
+    const scalarField deltas(nf() & fvPatch::delta());
+
+    const scalarField nbrDeltas
+    (
+        interpolateToSource(nbrPatch.nf() & nbrPatchDelta())
+    );
+
+    forAll(deltas, faceI)
+    {
+        scalar di = deltas[faceI];
+        scalar dni = nbrDeltas[faceI];
+
+        w[faceI] = dni/(di + dni);
+    }
+}
+
+
+void Foam::cyclicAMIFvPatch::makeDeltaCoeffs(scalarField& dc) const
+{
+    const cyclicAMIFvPatch& nbrPatch = neighbFvPatch();
+
+    const scalarField deltas(nf() & fvPatch::delta());
+
+    const scalarField nbrDeltas
+    (
+        interpolateToSource(nbrPatch.nf() & nbrPatchDelta())
+    );
+
+    forAll(deltas, faceI)
+    {
+        scalar di = deltas[faceI];
+        scalar dni = nbrDeltas[faceI];
+
+        dc[faceI] = 1.0/(di + dni);
+    }
+}
+
+
+Foam::tmp<Foam::vectorField> Foam::cyclicAMIFvPatch::delta() const
+{
+    const vectorField patchD(fvPatch::delta());
+
+    const vectorField& nbrPatchD(interpolateToSource(nbrPatchDelta()));
+
+    tmp<vectorField> tpdv(new vectorField(patchD.size()));
+    vectorField& pdv = tpdv();
+
+    // To the transformation if necessary
+    if (parallel())
+    {
+        forAll(patchD, faceI)
+        {
+            vector ddi = patchD[faceI];
+            vector dni = nbrPatchD[faceI];
+
+            pdv[faceI] = ddi - dni;
+        }
+    }
+    else
+    {
+        forAll(patchD, faceI)
+        {
+            vector ddi = patchD[faceI];
+            vector dni = nbrPatchD[faceI];
+
+            pdv[faceI] = ddi - transform(forwardT()[0], dni);
+        }
+    }
+
+    return tpdv;
+}
+
+
+Foam::tmp<Foam::labelField> Foam::cyclicAMIFvPatch::interfaceInternalField
+(
+    const labelUList& internalData
+) const
+{
+    return patchInternalField(internalData);
+}
+
+
+Foam::tmp<Foam::labelField> Foam::cyclicAMIFvPatch::internalFieldTransfer
+(
+    const Pstream::commsTypes commsType,
+    const labelUList& iF
+) const
+{
+    tmp<labelField> tnpif(neighbFvPatch().patchInternalField(iF));
+    labelField& npif = tnpif();
+
+    interpolateToSource(npif);
+
+    return tnpif;
+}
+
+
+// ************************************************************************* //
diff --git a/src/AMIInterpolation/patches/cyclicAMIFvPatch/cyclicAMIFvPatch.H b/src/AMIInterpolation/patches/cyclicAMIFvPatch/cyclicAMIFvPatch.H
new file mode 100644
index 0000000000..5ccdd01d89
--- /dev/null
+++ b/src/AMIInterpolation/patches/cyclicAMIFvPatch/cyclicAMIFvPatch.H
@@ -0,0 +1,193 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2011 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::cyclicAMIFvPatch
+
+Description
+    Cyclic patch for Arbitrary Mesh Interface (AMI)
+
+SourceFiles
+    cyclicAMIFvPatch.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef cyclicAMIFvPatch_H
+#define cyclicAMIFvPatch_H
+
+#include "coupledFvPatch.H"
+#include "cyclicAMILduInterface.H"
+#include "cyclicAMIPolyPatch.H"
+#include "fvBoundaryMesh.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                      Class cyclicAMIFvPatch Declaration
+\*---------------------------------------------------------------------------*/
+
+class cyclicAMIFvPatch
+:
+    public coupledFvPatch,
+    public cyclicAMILduInterface
+{
+    // Private data
+
+        const cyclicAMIPolyPatch& cyclicAMIPolyPatch_;
+
+
+protected:
+
+    // Protected Member functions
+
+        //- Make patch weighting factors
+        void makeWeights(scalarField&) const;
+
+        //- Make patch face - neighbour cell distances
+        void makeDeltaCoeffs(scalarField&) const;
+
+
+public:
+
+    //- Runtime type information
+    TypeName(cyclicAMIPolyPatch::typeName_());
+
+
+    // Constructors
+
+        //- Construct from polyPatch
+        cyclicAMIFvPatch(const polyPatch& patch, const fvBoundaryMesh& bm)
+        :
+            coupledFvPatch(patch, bm),
+            cyclicAMILduInterface(),
+            cyclicAMIPolyPatch_(refCast<const cyclicAMIPolyPatch>(patch))
+        {}
+
+
+    // Member functions
+
+        // Access
+
+            //- Return local reference cast into the cyclic patch
+            const cyclicAMIPolyPatch& cyclicAMIPatch() const
+            {
+                return cyclicAMIPolyPatch_;
+            }
+
+            //- Return neighbour
+            virtual label neighbPatchID() const
+            {
+                return cyclicAMIPolyPatch_.nbrPatchID();
+            }
+
+            virtual bool owner() const
+            {
+                return cyclicAMIPolyPatch_.owner();
+            }
+
+            //- Return processor number
+            virtual const cyclicAMIFvPatch& neighbPatch() const
+            {
+                return refCast<const cyclicAMIFvPatch>
+                (
+                    this->boundaryMesh()[cyclicAMIPolyPatch_.nbrPatchID()]
+                );
+            }
+
+            //- Are the cyclic planes parallel
+            virtual bool parallel() const
+            {
+                return cyclicAMIPolyPatch_.parallel();
+            }
+
+            //- Return face transformation tensor
+            virtual const tensorField& forwardT() const
+            {
+                return cyclicAMIPolyPatch_.forwardT();
+            }
+
+            //- Return neighbour-cell transformation tensor
+            virtual const tensorField& reverseT() const
+            {
+                return cyclicAMIPolyPatch_.reverseT();
+            }
+
+            const cyclicAMIFvPatch& neighbFvPatch() const
+            {
+                return refCast<const cyclicAMIFvPatch>
+                (
+                    this->boundaryMesh()[cyclicAMIPolyPatch_.nbrPatchID()]
+                );
+            }
+
+            //- Return delta (P to N) vectors across coupled patch
+            virtual tmp<vectorField> delta() const;
+
+            template<class Type>
+            tmp<Field<Type> > interpolateToSource(const Field<Type>& fld) const
+            {
+                return cyclicAMIPolyPatch_.interpolateToSource(fld);
+            }
+
+            template<class Type>
+            tmp<Field<Type> > interpolateToSource(const tmp<Field<Type> >& tFld) const
+            {
+                return cyclicAMIPolyPatch_.interpolateToSource(tFld);
+            }
+
+            const vectorField& nbrPatchDelta() const
+            {
+                return cyclicAMIPolyPatch_.nbrPatchDelta();
+            }
+
+
+        // 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/AMIInterpolation/patches/cyclicAMIFvPatchField/cyclicAMIFvPatchField.C b/src/AMIInterpolation/patches/cyclicAMIFvPatchField/cyclicAMIFvPatchField.C
new file mode 100644
index 0000000000..6014ef8b90
--- /dev/null
+++ b/src/AMIInterpolation/patches/cyclicAMIFvPatchField/cyclicAMIFvPatchField.C
@@ -0,0 +1,234 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2011 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "cyclicAMIFvPatchField.H"
+#include "transformField.H"
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+template<class Type>
+Foam::cyclicAMIFvPatchField<Type>::cyclicAMIFvPatchField
+(
+    const fvPatch& p,
+    const DimensionedField<Type, volMesh>& iF
+)
+:
+    cyclicAMILduInterfaceField(),
+    coupledFvPatchField<Type>(p, iF),
+    cyclicAMIPatch_(refCast<const cyclicAMIFvPatch>(p))
+{}
+
+
+template<class Type>
+Foam::cyclicAMIFvPatchField<Type>::cyclicAMIFvPatchField
+(
+    const cyclicAMIFvPatchField<Type>& ptf,
+    const fvPatch& p,
+    const DimensionedField<Type, volMesh>& iF,
+    const fvPatchFieldMapper& mapper
+)
+:
+    cyclicAMILduInterfaceField(),
+    coupledFvPatchField<Type>(ptf, p, iF, mapper),
+    cyclicAMIPatch_(refCast<const cyclicAMIFvPatch>(p))
+{
+    if (!isA<cyclicAMIFvPatch>(this->patch()))
+    {
+        FatalErrorIn
+        (
+            "cyclicAMIFvPatchField<Type>::cyclicAMIFvPatchField"
+            "("
+                "const cyclicAMIFvPatchField<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::cyclicAMIFvPatchField<Type>::cyclicAMIFvPatchField
+(
+    const fvPatch& p,
+    const DimensionedField<Type, volMesh>& iF,
+    const dictionary& dict
+)
+:
+    cyclicAMILduInterfaceField(),
+    coupledFvPatchField<Type>(p, iF, dict),
+    cyclicAMIPatch_(refCast<const cyclicAMIFvPatch>(p))
+{
+    if (!isA<cyclicAMIFvPatch>(p))
+    {
+        FatalIOErrorIn
+        (
+            "cyclicAMIFvPatchField<Type>::cyclicAMIFvPatchField"
+            "("
+                "const fvPatch&, "
+                "const Field<Type>&, "
+                "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);
+    }
+
+    this->evaluate(Pstream::blocking);
+}
+
+
+template<class Type>
+Foam::cyclicAMIFvPatchField<Type>::cyclicAMIFvPatchField
+(
+    const cyclicAMIFvPatchField<Type>& ptf
+)
+:
+    cyclicAMILduInterfaceField(),
+    coupledFvPatchField<Type>(ptf),
+    cyclicAMIPatch_(ptf.cyclicAMIPatch_)
+{}
+
+
+template<class Type>
+Foam::cyclicAMIFvPatchField<Type>::cyclicAMIFvPatchField
+(
+    const cyclicAMIFvPatchField<Type>& ptf,
+    const DimensionedField<Type, volMesh>& iF
+)
+:
+    cyclicAMILduInterfaceField(),
+    coupledFvPatchField<Type>(ptf, iF),
+    cyclicAMIPatch_(ptf.cyclicAMIPatch_)
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+template<class Type>
+Foam::tmp<Foam::Field<Type> >
+Foam::cyclicAMIFvPatchField<Type>::patchNeighbourField() const
+{
+    const Field<Type>& iField = this->internalField();
+    const labelUList& nbrFaceCells =
+        cyclicAMIPatch_.cyclicAMIPatch().nbrPatch().faceCells();
+
+    tmp<Field<Type> > tpnf(new Field<Type>(nbrFaceCells.size()));
+    Field<Type>& pnf = tpnf();
+
+
+    if (doTransform())
+    {
+        forAll(pnf, faceI)
+        {
+            pnf[faceI] = transform
+            (
+                forwardT()[0], iField[nbrFaceCells[faceI]]
+            );
+        }
+    }
+    else
+    {
+        forAll(pnf, faceI)
+        {
+            pnf[faceI] = iField[nbrFaceCells[faceI]];
+        }
+    }
+
+    return cyclicAMIPatch_.interpolateToSource(pnf);
+}
+
+
+template<class Type>
+const Foam::cyclicAMIFvPatchField<Type>&
+Foam::cyclicAMIFvPatchField<Type>::neighbourPatchField() const
+{
+    const GeometricField<Type, fvPatchField, volMesh>& fld =
+        static_cast<const GeometricField<Type, fvPatchField, volMesh>&>
+        (
+            this->internalField()
+        );
+
+    return refCast<const cyclicAMIFvPatchField<Type> >
+    (
+        fld.boundaryField()[cyclicAMIPatch_.neighbPatchID()]
+    );
+}
+
+
+template<class Type>
+void Foam::cyclicAMIFvPatchField<Type>::updateInterfaceMatrix
+(
+    const scalarField& psiInternal,
+    scalarField& result,
+    const lduMatrix&,
+    const scalarField& coeffs,
+    const direction cmpt,
+    const Pstream::commsTypes
+) const
+{
+    const labelUList& nbrFaceCells =
+        cyclicAMIPatch_.cyclicAMIPatch().nbrPatch().faceCells();
+
+    scalarField pnf(nbrFaceCells.size());
+
+    forAll(pnf, faceI)
+    {
+        pnf[faceI] = psiInternal[nbrFaceCells[faceI]];
+    }
+
+    // Transform according to the transformation tensors
+    transformCoupleField(pnf, cmpt);
+
+    pnf = cyclicAMIPatch_.interpolateToSource(pnf);
+
+    // Multiply the field by coefficients and add into the result
+    const labelUList& faceCells = cyclicAMIPatch_.faceCells();
+
+    forAll(faceCells, elemI)
+    {
+        result[faceCells[elemI]] -= coeffs[elemI]*pnf[elemI];
+    }
+}
+
+
+template<class Type>
+void Foam::cyclicAMIFvPatchField<Type>::write(Ostream& os) const
+{
+    fvPatchField<Type>::write(os);
+}
+
+
+// ************************************************************************* //
diff --git a/src/AMIInterpolation/patches/cyclicAMIFvPatchField/cyclicAMIFvPatchField.H b/src/AMIInterpolation/patches/cyclicAMIFvPatchField/cyclicAMIFvPatchField.H
new file mode 100644
index 0000000000..b4a14380a3
--- /dev/null
+++ b/src/AMIInterpolation/patches/cyclicAMIFvPatchField/cyclicAMIFvPatchField.H
@@ -0,0 +1,216 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2011 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::cyclicAMIFvPatchField
+
+Description
+    Foam::cyclicAMIFvPatchField
+
+SourceFiles
+    cyclicAMIFvPatchField.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef cyclicAMIFvPatchField_H
+#define cyclicAMIFvPatchField_H
+
+#include "coupledFvPatchField.H"
+#include "cyclicAMILduInterfaceField.H"
+#include "cyclicAMIFvPatch.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                    Class cyclicAMIFvPatchField Declaration
+\*---------------------------------------------------------------------------*/
+
+template<class Type>
+class cyclicAMIFvPatchField
+:
+    virtual public cyclicAMILduInterfaceField,
+    public coupledFvPatchField<Type>
+{
+    // Private data
+
+        //- Local reference cast into the cyclic patch
+        const cyclicAMIFvPatch& cyclicAMIPatch_;
+
+
+    // 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(cyclicAMIFvPatch::typeName_());
+
+
+    // Constructors
+
+        //- Construct from patch and internal field
+        cyclicAMIFvPatchField
+        (
+            const fvPatch&,
+            const DimensionedField<Type, volMesh>&
+        );
+
+        //- Construct from patch, internal field and dictionary
+        cyclicAMIFvPatchField
+        (
+            const fvPatch&,
+            const DimensionedField<Type, volMesh>&,
+            const dictionary&
+        );
+
+        //- Construct by mapping given cyclicAMIFvPatchField onto a new patch
+        cyclicAMIFvPatchField
+        (
+            const cyclicAMIFvPatchField<Type>&,
+            const fvPatch&,
+            const DimensionedField<Type, volMesh>&,
+            const fvPatchFieldMapper&
+        );
+
+        //- Construct as copy
+        cyclicAMIFvPatchField(const cyclicAMIFvPatchField<Type>&);
+
+        //- Construct and return a clone
+        virtual tmp<fvPatchField<Type> > clone() const
+        {
+            return tmp<fvPatchField<Type> >
+            (
+                new cyclicAMIFvPatchField<Type>(*this)
+            );
+        }
+
+        //- Construct as copy setting internal field reference
+        cyclicAMIFvPatchField
+        (
+            const cyclicAMIFvPatchField<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 cyclicAMIFvPatchField<Type>(*this, iF)
+            );
+        }
+
+
+    // Member functions
+
+        // Access
+
+            //- Return local reference cast into the cyclic AMI patch
+            const cyclicAMIFvPatch& cyclicAMIPatch() const
+            {
+                return cyclicAMIPatch_;
+            }
+
+
+        // Evaluation functions
+
+            //- Return neighbour coupled internal cell data
+            tmp<Field<Type> > patchNeighbourField() const;
+
+            //- Return reference to neighbour patchField
+            const cyclicAMIFvPatchField<Type>& neighbourPatchField() const;
+
+            //- Update result field based on interface functionality
+            virtual void updateInterfaceMatrix
+            (
+                const scalarField& psiInternal,
+                scalarField& result,
+                const lduMatrix&,
+                const scalarField& coeffs,
+                const direction cmpt,
+                const Pstream::commsTypes commsType
+            ) const;
+
+
+        // Cyclic AMI coupled interface functions
+
+            //- Does the patch field perform the transformation
+            virtual bool doTransform() const
+            {
+                return !(cyclicAMIPatch_.parallel() || pTraits<Type>::rank == 0);
+            }
+
+            //- Return face transformation tensor
+            virtual const tensorField& forwardT() const
+            {
+                return cyclicAMIPatch_.forwardT();
+            }
+
+            //- Return neighbour-cell transformation tensor
+            virtual const tensorField& reverseT() const
+            {
+                return cyclicAMIPatch_.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 "cyclicAMIFvPatchField.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/AMIInterpolation/patches/cyclicAMIFvPatchField/cyclicAMIFvPatchFields.C b/src/AMIInterpolation/patches/cyclicAMIFvPatchField/cyclicAMIFvPatchFields.C
new file mode 100644
index 0000000000..2bd5752dee
--- /dev/null
+++ b/src/AMIInterpolation/patches/cyclicAMIFvPatchField/cyclicAMIFvPatchFields.C
@@ -0,0 +1,43 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2011 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "cyclicAMIFvPatchFields.H"
+#include "addToRunTimeSelectionTable.H"
+#include "volFields.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+makePatchFields(cyclicAMI);
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// ************************************************************************* //
diff --git a/src/AMIInterpolation/patches/cyclicAMIFvPatchField/cyclicAMIFvPatchFields.H b/src/AMIInterpolation/patches/cyclicAMIFvPatchField/cyclicAMIFvPatchFields.H
new file mode 100644
index 0000000000..7fd67d201b
--- /dev/null
+++ b/src/AMIInterpolation/patches/cyclicAMIFvPatchField/cyclicAMIFvPatchFields.H
@@ -0,0 +1,49 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2011 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef cyclicAMIFvPatchFields_H
+#define cyclicAMIFvPatchFields_H
+
+#include "cyclicAMIFvPatchField.H"
+#include "fieldTypes.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+makePatchTypeFieldTypedefs(cyclicAMI);
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/AMIInterpolation/patches/cyclicAMIFvPatchField/cyclicAMIFvPatchFieldsFwd.H b/src/AMIInterpolation/patches/cyclicAMIFvPatchField/cyclicAMIFvPatchFieldsFwd.H
new file mode 100644
index 0000000000..6f6a207070
--- /dev/null
+++ b/src/AMIInterpolation/patches/cyclicAMIFvPatchField/cyclicAMIFvPatchFieldsFwd.H
@@ -0,0 +1,50 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2011 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef cyclicAMIFvPatchFieldsFwd_H
+#define cyclicAMIFvPatchFieldsFwd_H
+
+#include "fieldTypes.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+template<class Type> class cyclicAMIFvPatchField;
+
+makePatchTypeFieldTypedefs(cyclicAMI);
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/AMIInterpolation/patches/cyclicAMIFvsPatchField/cyclicAMIFvsPatchField.C b/src/AMIInterpolation/patches/cyclicAMIFvsPatchField/cyclicAMIFvsPatchField.C
new file mode 100644
index 0000000000..9a197c01e7
--- /dev/null
+++ b/src/AMIInterpolation/patches/cyclicAMIFvsPatchField/cyclicAMIFvsPatchField.C
@@ -0,0 +1,126 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2011 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "cyclicAMIFvsPatchField.H"
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+template<class Type>
+Foam::cyclicAMIFvsPatchField<Type>::cyclicAMIFvsPatchField
+(
+    const fvPatch& p,
+    const DimensionedField<Type, surfaceMesh>& iF
+)
+:
+    coupledFvsPatchField<Type>(p, iF),
+    cyclicAMIPatch_(refCast<const cyclicAMIFvPatch>(p))
+{}
+
+
+template<class Type>
+Foam::cyclicAMIFvsPatchField<Type>::cyclicAMIFvsPatchField
+(
+    const cyclicAMIFvsPatchField<Type>& ptf,
+    const fvPatch& p,
+    const DimensionedField<Type, surfaceMesh>& iF,
+    const fvPatchFieldMapper& mapper
+)
+:
+    coupledFvsPatchField<Type>(ptf, p, iF, mapper),
+    cyclicAMIPatch_(refCast<const cyclicAMIFvPatch>(p))
+{
+    if (!isA<cyclicAMIFvPatch>(this->patch()))
+    {
+        FatalErrorIn
+        (
+            "cyclicAMIFvsPatchField<Type>::cyclicAMIFvsPatchField\n"
+            "("
+                "const cyclicAMIFvsPatchField<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::cyclicAMIFvsPatchField<Type>::cyclicAMIFvsPatchField
+(
+    const fvPatch& p,
+    const DimensionedField<Type, surfaceMesh>& iF,
+    const dictionary& dict
+)
+:
+    coupledFvsPatchField<Type>(p, iF, dict),
+    cyclicAMIPatch_(refCast<const cyclicAMIFvPatch>(p))
+{
+    if (!isA<cyclicAMIFvPatch>(p))
+    {
+        FatalIOErrorIn
+        (
+            "cyclicAMIFvsPatchField<Type>::cyclicAMIFvsPatchField"
+            "("
+                "const fvPatch&, "
+                "const Field<Type>&, "
+                "const dictionary&"
+            ")",
+            dict
+        )   << "patch " << this->patch().index() << " not cyclicAMI type. "
+            << "Patch type = " << p.type()
+            << exit(FatalIOError);
+    }
+}
+
+
+template<class Type>
+Foam::cyclicAMIFvsPatchField<Type>::cyclicAMIFvsPatchField
+(
+    const cyclicAMIFvsPatchField<Type>& ptf
+)
+:
+    coupledFvsPatchField<Type>(ptf),
+    cyclicAMIPatch_(ptf.cyclicAMIPatch_)
+{}
+
+
+template<class Type>
+Foam::cyclicAMIFvsPatchField<Type>::cyclicAMIFvsPatchField
+(
+    const cyclicAMIFvsPatchField<Type>& ptf,
+    const DimensionedField<Type, surfaceMesh>& iF
+)
+:
+    coupledFvsPatchField<Type>(ptf, iF),
+    cyclicAMIPatch_(ptf.cyclicAMIPatch_)
+{}
+
+
+// ************************************************************************* //
diff --git a/src/AMIInterpolation/patches/cyclicAMIFvsPatchField/cyclicAMIFvsPatchField.H b/src/AMIInterpolation/patches/cyclicAMIFvsPatchField/cyclicAMIFvsPatchField.H
new file mode 100644
index 0000000000..01fd762f4f
--- /dev/null
+++ b/src/AMIInterpolation/patches/cyclicAMIFvsPatchField/cyclicAMIFvsPatchField.H
@@ -0,0 +1,143 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2011 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::cyclicAMIFvsPatchField
+
+Description
+    Foam::cyclicAMIFvsPatchField
+
+SourceFiles
+    cyclicAMIFvsPatchField.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef cyclicAMIFvsPatchField_H
+#define cyclicAMIFvsPatchField_H
+
+#include "coupledFvsPatchField.H"
+#include "cyclicAMIFvPatch.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                    Class cyclicAMIFvsPatchField Declaration
+\*---------------------------------------------------------------------------*/
+
+template<class Type>
+class cyclicAMIFvsPatchField
+:
+    public coupledFvsPatchField<Type>
+{
+    // Private data
+
+        //- Local reference cast into the cyclic patch
+        const cyclicAMIFvPatch& cyclicAMIPatch_;
+
+
+public:
+
+    //- Runtime type information
+    TypeName(cyclicAMIFvPatch::typeName_());
+
+
+    // Constructors
+
+        //- Construct from patch and internal field
+        cyclicAMIFvsPatchField
+        (
+            const fvPatch&,
+            const DimensionedField<Type, surfaceMesh>&
+        );
+
+        //- Construct from patch, internal field and dictionary
+        cyclicAMIFvsPatchField
+        (
+            const fvPatch&,
+            const DimensionedField<Type, surfaceMesh>&,
+            const dictionary&
+        );
+
+        //- Construct by mapping given cyclicAMIFvsPatchField onto a new patch
+        cyclicAMIFvsPatchField
+        (
+            const cyclicAMIFvsPatchField<Type>&,
+            const fvPatch&,
+            const DimensionedField<Type, surfaceMesh>&,
+            const fvPatchFieldMapper&
+        );
+
+        //- Construct as copy
+        cyclicAMIFvsPatchField
+        (
+            const cyclicAMIFvsPatchField<Type>&
+        );
+
+        //- Construct and return a clone
+        virtual tmp<fvsPatchField<Type> > clone() const
+        {
+            return tmp<fvsPatchField<Type> >
+            (
+                new cyclicAMIFvsPatchField<Type>(*this)
+            );
+        }
+
+        //- Construct as copy setting internal field reference
+        cyclicAMIFvsPatchField
+        (
+            const cyclicAMIFvsPatchField<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 cyclicAMIFvsPatchField<Type>(*this, iF)
+            );
+        }
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+#   include "cyclicAMIFvsPatchField.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/AMIInterpolation/patches/cyclicAMIFvsPatchField/cyclicAMIFvsPatchFields.C b/src/AMIInterpolation/patches/cyclicAMIFvsPatchField/cyclicAMIFvsPatchFields.C
new file mode 100644
index 0000000000..a439f7f83a
--- /dev/null
+++ b/src/AMIInterpolation/patches/cyclicAMIFvsPatchField/cyclicAMIFvsPatchFields.C
@@ -0,0 +1,43 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2011 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "cyclicAMIFvsPatchFields.H"
+#include "fvsPatchFields.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+makeFvsPatchFields(cyclicAMI);
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// ************************************************************************* //
diff --git a/src/AMIInterpolation/patches/cyclicAMIFvsPatchField/cyclicAMIFvsPatchFields.H b/src/AMIInterpolation/patches/cyclicAMIFvsPatchField/cyclicAMIFvsPatchFields.H
new file mode 100644
index 0000000000..18021d6e17
--- /dev/null
+++ b/src/AMIInterpolation/patches/cyclicAMIFvsPatchField/cyclicAMIFvsPatchFields.H
@@ -0,0 +1,49 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2011 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef cyclicAMIFvsPatchFields_H
+#define cyclicAMIFvsPatchFields_H
+
+#include "cyclicAMIFvsPatchField.H"
+#include "fieldTypes.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+makeFvsPatchTypeFieldTypedefs(cyclicAMI);
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/AMIInterpolation/patches/cyclicAMIFvsPatchField/cyclicAMIFvsPatchFieldsFwd.H b/src/AMIInterpolation/patches/cyclicAMIFvsPatchField/cyclicAMIFvsPatchFieldsFwd.H
new file mode 100644
index 0000000000..72fdc4d4ce
--- /dev/null
+++ b/src/AMIInterpolation/patches/cyclicAMIFvsPatchField/cyclicAMIFvsPatchFieldsFwd.H
@@ -0,0 +1,50 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2011 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef cyclicAMIFvsPatchFieldsFwd_H
+#define cyclicAMIFvsPatchFieldsFwd_H
+
+#include "fieldTypes.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+template<class Type> class cyclicAMIFvsPatchField;
+
+makeFvsPatchTypeFieldTypedefs(cyclicAMI);
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/AMIInterpolation/patches/cyclicAMILduInterfaceField/cyclicAMILduInterface.C b/src/AMIInterpolation/patches/cyclicAMILduInterfaceField/cyclicAMILduInterface.C
new file mode 100644
index 0000000000..70eaba2fd4
--- /dev/null
+++ b/src/AMIInterpolation/patches/cyclicAMILduInterfaceField/cyclicAMILduInterface.C
@@ -0,0 +1,39 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2011 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "cyclicAMILduInterface.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+defineTypeNameAndDebug(Foam::cyclicAMILduInterface, 0);
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::cyclicAMILduInterface::~cyclicAMILduInterface()
+{}
+
+
+// ************************************************************************* //
diff --git a/src/AMIInterpolation/patches/cyclicAMILduInterfaceField/cyclicAMILduInterface.H b/src/AMIInterpolation/patches/cyclicAMILduInterfaceField/cyclicAMILduInterface.H
new file mode 100644
index 0000000000..67016cb4be
--- /dev/null
+++ b/src/AMIInterpolation/patches/cyclicAMILduInterfaceField/cyclicAMILduInterface.H
@@ -0,0 +1,97 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2011 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::cyclicAMILduInterface
+
+Description
+    An abstract base class for cyclic AMI coupled interfaces
+
+SourceFiles
+    cyclicAMILduInterface.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef cyclicAMILduInterface_H
+#define cyclicAMILduInterface_H
+
+#include "primitiveFieldsFwd.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                  Class cyclicAMILduInterface Declaration
+\*---------------------------------------------------------------------------*/
+
+class cyclicAMILduInterface
+{
+
+public:
+
+    //- Runtime type information
+    TypeName("cyclicAMILduInterface");
+
+
+    // Constructors
+
+        //- Construct null
+        cyclicAMILduInterface()
+        {}
+
+
+    //- Destructor
+    virtual ~cyclicAMILduInterface();
+
+
+    // Member Functions
+
+        // Access
+
+            //- Return neighbour
+            virtual label neighbPatchID() const = 0;
+
+            virtual bool owner() const = 0;
+
+            //- Return processor number
+            virtual const cyclicAMILduInterface& neighbPatch() const = 0;
+
+            //- Return face transformation tensor
+            virtual const tensorField& forwardT() const = 0;
+
+            //- Return face reverse transformation tensor
+            virtual const tensorField& reverseT() const = 0;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/AMIInterpolation/patches/cyclicAMILduInterfaceField/cyclicAMILduInterfaceField.C b/src/AMIInterpolation/patches/cyclicAMILduInterfaceField/cyclicAMILduInterfaceField.C
new file mode 100644
index 0000000000..fa9b5a772d
--- /dev/null
+++ b/src/AMIInterpolation/patches/cyclicAMILduInterfaceField/cyclicAMILduInterfaceField.C
@@ -0,0 +1,62 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2011 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "cyclicAMILduInterfaceField.H"
+#include "diagTensorField.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+defineTypeNameAndDebug(Foam::cyclicAMILduInterfaceField, 0);
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::cyclicAMILduInterfaceField::~cyclicAMILduInterfaceField()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+void Foam::cyclicAMILduInterfaceField::transformCoupleField
+(
+    scalarField& f,
+    const direction cmpt
+) const
+{
+    if (doTransform())
+    {
+        if (forwardT().size() == 1)
+        {
+            f *= pow(diag(forwardT()[0]).component(cmpt), rank());
+        }
+        else
+        {
+            f *= pow(diag(forwardT())().component(cmpt), rank());
+        }
+    }
+}
+
+
+// ************************************************************************* //
diff --git a/src/AMIInterpolation/patches/cyclicAMILduInterfaceField/cyclicAMILduInterfaceField.H b/src/AMIInterpolation/patches/cyclicAMILduInterfaceField/cyclicAMILduInterfaceField.H
new file mode 100644
index 0000000000..29173e3fab
--- /dev/null
+++ b/src/AMIInterpolation/patches/cyclicAMILduInterfaceField/cyclicAMILduInterfaceField.H
@@ -0,0 +1,103 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2011 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::cyclicAMILduInterfaceField
+
+Description
+    Abstract base class for cyclic AMI coupled interfaces
+
+SourceFiles
+    cyclicAMILduInterfaceField.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef cyclicAMILduInterfaceField_H
+#define cyclicAMILduInterfaceField_H
+
+#include "primitiveFieldsFwd.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                  Class cyclicAMILduInterfaceField Declaration
+\*---------------------------------------------------------------------------*/
+
+class cyclicAMILduInterfaceField
+{
+
+public:
+
+    //- Runtime type information
+    TypeName("cyclicAMILduInterfaceField");
+
+
+    // Constructors
+
+        //- Construct null
+        cyclicAMILduInterfaceField()
+        {}
+
+
+    //- Destructor
+    virtual ~cyclicAMILduInterfaceField();
+
+
+    // Member Functions
+
+        // Access
+
+            //- Is the transform required
+            virtual bool doTransform() const = 0;
+
+            //- Return face transformation tensor
+            virtual const tensorField& forwardT() const = 0;
+
+            //- Return neighbour-cell transformation tensor
+            virtual const tensorField& reverseT() const = 0;
+
+            //- Return rank of component for transform
+            virtual int rank() const = 0;
+
+
+        //- Transform given patch internal field
+        void transformCoupleField
+        (
+            scalarField& psiInternal,
+            const direction cmpt
+        ) const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/AMIInterpolation/patches/cyclicAMIPolyPatch/cyclicAMIPolyPatch.C b/src/AMIInterpolation/patches/cyclicAMIPolyPatch/cyclicAMIPolyPatch.C
new file mode 100644
index 0000000000..7ae69325b7
--- /dev/null
+++ b/src/AMIInterpolation/patches/cyclicAMIPolyPatch/cyclicAMIPolyPatch.C
@@ -0,0 +1,754 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2011 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "cyclicAMIPolyPatch.H"
+#include "transformField.H"
+#include "SubField.H"
+#include "polyMesh.H"
+#include "Time.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(cyclicAMIPolyPatch, 0);
+
+    addToRunTimeSelectionTable(polyPatch, cyclicAMIPolyPatch, word);
+    addToRunTimeSelectionTable(polyPatch, cyclicAMIPolyPatch, dictionary);
+}
+
+
+// * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * * //
+
+Foam::label Foam::cyclicAMIPolyPatch::findFaceMaxRadius
+(
+    const pointField& faceCentres
+) const
+{
+    // Determine a face furthest away from the axis
+
+    const scalarField magRadSqr
+    (
+        magSqr((faceCentres - rotationCentre_) ^ rotationAxis_)
+    );
+
+    label faceI = findMax(magRadSqr);
+
+    if (debug)
+    {
+        Info<< "findFaceMaxRadius(const pointField&)" << nl
+            << "    rotFace  = " << faceI << nl
+            << "    point    =  " << faceCentres[faceI] << nl
+            << "    distance = " << Foam::sqrt(magRadSqr[faceI])
+            << endl;
+    }
+
+    return faceI;
+}
+
+
+// * * * * * * * * * * * Protecetd Member Functions  * * * * * * * * * * * * //
+
+
+void Foam::cyclicAMIPolyPatch::calcTransforms()
+{
+    if (size())
+    {
+        // Half0
+        const cyclicAMIPolyPatch& half0 = *this;
+        vectorField half0Areas(half0.size());
+        forAll(half0, facei)
+        {
+            half0Areas[facei] = half0[facei].normal(half0.points());
+        }
+
+        // Half1
+        const cyclicAMIPolyPatch& half1 = nbrPatch();
+        vectorField half1Areas(half1.size());
+        forAll(half1, facei)
+        {
+            half1Areas[facei] = half1[facei].normal(half1.points());
+        }
+
+        calcTransforms
+        (
+            half0,
+            half0.faceCentres(),
+            half0Areas,
+            half1.faceCentres(),
+            half1Areas
+        );
+    }
+}
+
+
+void Foam::cyclicAMIPolyPatch::calcTransforms
+(
+    const primitivePatch& half0,
+    const pointField& half0Ctrs,
+    const vectorField& half0Areas,
+    const pointField& half1Ctrs,
+    const vectorField& half1Areas
+)
+{
+    if (transform_ != nbrPatch().transform_)
+    {
+        FatalErrorIn("cyclicAMIPolyPatch::calcTransforms()")
+            << "Patch " << name()
+            << " has transform type " << transformTypeNames[transform_]
+            << ", neighbour patch " << nbrPatchName_
+            << " has transform type "
+            << nbrPatch().transformTypeNames[transform_]
+            << exit(FatalError);
+    }
+
+
+    // Calculate transformation tensors
+
+    if ((half0Ctrs.size() <= 0) || (half1Ctrs.size() <= 0))
+    {
+        return;
+    }
+
+    switch (transform_)
+    {
+        case ROTATIONAL:
+        {
+            label face0 = findFaceMaxRadius(half0Ctrs);
+            label face1 = findFaceMaxRadius(half1Ctrs);
+
+            vector n0 = ((half0Ctrs[face0] - rotationCentre_) ^ rotationAxis_);
+            vector n1 = ((half1Ctrs[face1] - rotationCentre_) ^ -rotationAxis_);
+            n0 /= mag(n0) + VSMALL;
+            n1 /= mag(n1) + VSMALL;
+
+            if (debug)
+            {
+                Pout<< "cyclicAMIPolyPatch::calcTransforms :"
+                    << " Specified rotation :"
+                    << " n0:" << n0 << " n1:" << n1 << endl;
+            }
+
+            // Extended tensor from two local coordinate systems calculated
+            // using normal and rotation axis
+            const tensor E0
+            (
+                rotationAxis_,
+                (n0 ^ rotationAxis_),
+                n0
+            );
+            const tensor E1
+            (
+                rotationAxis_,
+                (-n1 ^ rotationAxis_),
+                -n1
+            );
+            const tensor revT(E1.T() & E0);
+            const_cast<tensorField&>(forwardT()) = tensorField(1, revT.T());
+            const_cast<tensorField&>(reverseT()) = tensorField(1, revT);
+            const_cast<vectorField&>(separation()).setSize(0);
+            const_cast<boolList&>(collocated()) = boolList(1, false);
+
+            break;
+        }
+        case TRANSLATIONAL:
+        {
+            // Transform 0 points.
+
+            if (debug)
+            {
+                Pout<< "cyclicAMIPolyPatch::calcTransforms :"
+                    << "Specified translation : " << separationVector_
+                    << endl;
+            }
+
+                const_cast<tensorField&>(forwardT()).clear();
+                const_cast<tensorField&>(reverseT()).clear();
+                const_cast<vectorField&>(separation()) = vectorField
+                (
+                    1,
+                    separationVector_
+                );
+                const_cast<boolList&>(collocated()) = boolList(1, false);
+            break;
+        }
+        default:
+        {
+/*
+            // Assumes that cyclic is planar. This is also the initial
+            // condition for patches without faces.
+
+            // Determine the face with max area on both halves. These
+            // two faces are used to determine the transformation tensors
+            label max0I = findMaxArea(pp0.points(), pp0);
+            vector n0 = pp0[max0I].normal(pp0.points());
+            n0 /= mag(n0) + VSMALL;
+
+            label max1I = findMaxArea(pp1.points(), pp1);
+            vector n1 = pp1[max1I].normal(pp1.points());
+            n1 /= mag(n1) + VSMALL;
+
+            if (mag(n0 & n1) < 1 - matchTolerance())
+            {
+                if (debug)
+                {
+                    Pout<< "cyclicAMIPolyPatch::calcTransforms :"
+                        << " Detected rotation :"
+                        << " n0:" << n0 << " n1:" << n1 << endl;
+                }
+
+                // Rotation (around origin)
+                const tensor revT(rotationTensor(n0, -n1));
+                const_cast<tensorField&>(forwardT()) = tensorField(1, revT.T());
+                const_cast<tensorField&>(reverseT()) = tensorField(1, revT);
+                const_cast<vectorField&>(separation()).setSize(0);
+                const_cast<boolList&>(collocated()) = boolList(1, false);
+            }
+            else
+            {
+                // Parallel translation
+                const_cast<tensorField&>(forwardT()).clear();
+                const_cast<tensorField&>(reverseT()).clear();
+                const_cast<vectorField&>(separation()) = vectorField
+                (
+                    1,
+                    separationVector_
+                );
+                const_cast<boolList&>(collocated()) = boolList(1, false);
+
+            }
+*/
+
+            notImplemented("calcTransforms - unknown transform clause");
+            break;
+        }
+    }
+
+
+    // Calculate typical distance per face
+//    tols = calcFaceTol(matchTolerance(), pp1, pp1.points(), half1Ctrs);
+}
+
+
+const Foam::AMIPatchToPatchInterpolation& Foam::cyclicAMIPolyPatch::AMI()
+{
+    if (!AMIPtr_)
+    {
+        const polyPatch& nbr = nbrPatch();
+        pointField nbrPoints = nbrPatch().localPoints();
+
+
+const word myName = nbrPatch().nbrPatch().nbrPatchName();
+
+OFstream osNorg(myName + "_neighbourPatch-org.obj");
+meshTools::writeOBJ(osNorg, nbrPatch().localFaces(), nbrPoints);
+
+        transformPosition(nbrPoints);
+        primitivePatch nbrPatch0
+        (
+            SubList<face>
+            (
+                nbr.localFaces(),
+                nbr.size()
+            ),
+            nbrPoints
+        );
+
+OFstream osN(myName + "_neighbourPatch-trans.obj");
+meshTools::writeOBJ(osN, nbrPatch0.localFaces(), nbrPoints);
+
+OFstream osO(myName + "_ownerPatch.obj");
+meshTools::writeOBJ(osO, this->localFaces(), localPoints());
+
+        // Construct/apply AMI interpolation to determine addressing and weights
+        AMIPtr_ = new AMIPatchToPatchInterpolation
+        (
+            *this,
+            nbrPatch0,
+            surfPtr_()
+        );
+
+
+        vectorField nbrPatchNf
+        (
+            nbrPatch().faceAreas()/mag(nbrPatch().faceAreas())
+        );
+        nbrPatchDelta_ =
+            nbrPatch0.faceCentres() - nbrPatch().faceCellCentres();
+        nbrPatchDelta_ = nbrPatchNf*(nbrPatchNf & nbrPatchDelta_);
+    }
+
+    return *AMIPtr_;
+}
+
+
+// * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
+
+void Foam::cyclicAMIPolyPatch::initGeometry(PstreamBuffers& pBufs)
+{
+    polyPatch::initGeometry(pBufs);
+}
+
+
+void Foam::cyclicAMIPolyPatch::calcGeometry(PstreamBuffers& pBufs)
+{
+    calcGeometry
+    (
+        *this,
+        faceCentres(),
+        faceAreas(),
+        faceCellCentres(),
+        nbrPatch().faceCentres(),
+        nbrPatch().faceAreas(),
+        nbrPatch().faceCellCentres()
+    );
+}
+
+
+void Foam::cyclicAMIPolyPatch::initMovePoints
+(
+    PstreamBuffers& pBufs,
+    const pointField& p
+)
+{
+    polyPatch::initMovePoints(pBufs, p);
+}
+
+
+void Foam::cyclicAMIPolyPatch::movePoints
+(
+    PstreamBuffers& pBufs,
+    const pointField& p
+)
+{
+    polyPatch::movePoints(pBufs, p);
+
+    calcTransforms();
+
+    deleteDemandDrivenData(AMIPtr_);
+
+    AMI();
+}
+
+
+void Foam::cyclicAMIPolyPatch::initUpdateMesh(PstreamBuffers& pBufs)
+{
+    polyPatch::initUpdateMesh(pBufs);
+}
+
+
+void Foam::cyclicAMIPolyPatch::updateMesh(PstreamBuffers& pBufs)
+{
+    polyPatch::updateMesh(pBufs);
+    deleteDemandDrivenData(AMIPtr_);
+//    deleteDemandDrivenData(surfPtr_);
+}
+
+
+// * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * * * //
+
+Foam::cyclicAMIPolyPatch::cyclicAMIPolyPatch
+(
+    const word& name,
+    const label size,
+    const label start,
+    const label index,
+    const polyBoundaryMesh& bm
+)
+:
+    coupledPolyPatch(name, size, start, index, bm),
+    nbrPatchName_(word::null),
+    nbrPatchID_(-1),
+    transform_(UNKNOWN),
+    rotationAxis_(vector::zero),
+    rotationCentre_(point::zero),
+    separationVector_(vector::zero),
+    AMIPtr_(NULL),
+    surfPtr_(NULL)
+{
+    // Neighbour patch might not be valid yet so no transformation
+    // calculation possible
+}
+
+
+Foam::cyclicAMIPolyPatch::cyclicAMIPolyPatch
+(
+    const word& name,
+    const dictionary& dict,
+    const label index,
+    const polyBoundaryMesh& bm
+)
+:
+    coupledPolyPatch(name, dict, index, bm),
+    nbrPatchName_(dict.lookup("neighbourPatch")),
+    nbrPatchID_(-1),
+    transform_(UNKNOWN),
+    rotationAxis_(vector::zero),
+    rotationCentre_(point::zero),
+    separationVector_(vector::zero),
+    AMIPtr_(NULL),
+    surfPtr_
+    (
+        searchableSurface::New
+        (
+            dict.lookup("projectionSurfaceType"),
+            IOobject
+            (
+                dict.lookup("projectionSurfaceName"),
+                bm.mesh().time().constant(),
+                "triSurface",
+                bm.mesh(),
+                IOobject::MUST_READ,
+                IOobject::NO_WRITE
+            ),
+            dict
+        )
+    )
+{
+    if (nbrPatchName_ == name)
+    {
+        FatalIOErrorIn
+        (
+            "cyclicAMIPolyPatch::cyclicAMIPolyPatch"
+            "("
+                "const word&, "
+                "const dictionary&, "
+                "const label, "
+                "const polyBoundaryMesh&"
+            ")",
+            dict
+        )   << "Neighbour patch name " << nbrPatchName_
+            << " cannot be the same as this patch " << name
+            << exit(FatalIOError);
+    }
+
+    if (dict.found("transform"))
+    {
+        transform_ = transformTypeNames.read(dict.lookup("transform"));
+        switch (transform_)
+        {
+            case ROTATIONAL:
+            {
+                dict.lookup("rotationAxis") >> rotationAxis_;
+                dict.lookup("rotationCentre") >> rotationCentre_;
+
+                scalar magRot = mag(rotationAxis_);
+                if (magRot < SMALL)
+                {
+                    FatalIOErrorIn
+                    (
+                        "cyclicAMIPolyPatch::cyclicAMIPolyPatch"
+                        "("
+                            "const word&, "
+                            "const dictionary&, "
+                            "const label, "
+                            "const polyBoundaryMesh&"
+                        ")",
+                        dict
+                    )   << "Illegal rotationAxis " << rotationAxis_ << endl
+                        << "Please supply a non-zero vector."
+                        << exit(FatalIOError);
+                }
+                rotationAxis_ /= magRot;
+
+                break;
+            }
+            case TRANSLATIONAL:
+            {
+                dict.lookup("separationVector") >> separationVector_;
+                break;
+            }
+            default:
+            {
+                // no additional info required
+            }
+        }
+    }
+
+    // Neighbour patch might not be valid yet so no transformation
+    // calculation possible
+}
+
+
+Foam::cyclicAMIPolyPatch::cyclicAMIPolyPatch
+(
+    const cyclicAMIPolyPatch& pp,
+    const polyBoundaryMesh& bm
+)
+:
+    coupledPolyPatch(pp, bm),
+    nbrPatchName_(pp.nbrPatchName_),
+    nbrPatchID_(-1),
+    transform_(UNKNOWN),
+    rotationAxis_(vector::zero),
+    rotationCentre_(point::zero),
+    separationVector_(vector::zero),
+    AMIPtr_(NULL),
+    surfPtr_(NULL)
+{
+    // Neighbour patch might not be valid yet so no transformation
+    // calculation possible
+}
+
+
+Foam::cyclicAMIPolyPatch::cyclicAMIPolyPatch
+(
+    const cyclicAMIPolyPatch& pp,
+    const polyBoundaryMesh& bm,
+    const label index,
+    const label newSize,
+    const label newStart,
+    const word& nbrPatchName
+)
+:
+    coupledPolyPatch(pp, bm, index, newSize, newStart),
+    nbrPatchName_(nbrPatchName),
+    nbrPatchID_(-1),
+    transform_(UNKNOWN),
+    rotationAxis_(vector::zero),
+    rotationCentre_(point::zero),
+    separationVector_(vector::zero),
+    AMIPtr_(NULL),
+    surfPtr_(NULL)
+{
+    if (nbrPatchName_ == name())
+    {
+        FatalErrorIn
+        (
+            "const cyclicAMIPolyPatch& "
+            "const polyBoundaryMesh&, "
+            "const label, "
+            "const label, "
+            "const label, "
+            "const word&"
+        )   << "Neighbour patch name " << nbrPatchName_
+            << " cannot be the same as this patch " << name()
+            << exit(FatalError);
+    }
+
+    // Neighbour patch might not be valid yet so no transformation
+    // calculation possible
+}
+
+
+Foam::cyclicAMIPolyPatch::cyclicAMIPolyPatch
+(
+    const cyclicAMIPolyPatch& pp,
+    const polyBoundaryMesh& bm,
+    const label index,
+    const labelUList& mapAddressing,
+    const label newStart
+)
+:
+    coupledPolyPatch(pp, bm, index, mapAddressing, newStart),
+    nbrPatchName_(pp.nbrPatchName_),
+    nbrPatchID_(-1),
+    transform_(pp.transform_),
+    rotationAxis_(pp.rotationAxis_),
+    rotationCentre_(pp.rotationCentre_),
+    separationVector_(pp.separationVector_),
+    AMIPtr_(NULL),
+    surfPtr_(NULL)
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::cyclicAMIPolyPatch::~cyclicAMIPolyPatch()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+Foam::label Foam::cyclicAMIPolyPatch::nbrPatchID() const
+{
+    if (nbrPatchID_ == -1)
+    {
+        nbrPatchID_ = this->boundaryMesh().findPatchID(nbrPatchName_);
+
+        if (nbrPatchID_ == -1)
+        {
+            FatalErrorIn("cyclicPolyAMIPatch::nbrPatchID() const")
+                << "Illegal neighbourPatch name " << nbrPatchName_
+                << nl << "Valid patch names are "
+                << this->boundaryMesh().names()
+                << exit(FatalError);
+        }
+
+        // Check that it is a cyclic AMI patch
+        const cyclicAMIPolyPatch& nbrPatch =
+            refCast<const cyclicAMIPolyPatch>
+            (
+                this->boundaryMesh()[nbrPatchID_]
+            );
+
+        if (nbrPatch.nbrPatchName() != name())
+        {
+            WarningIn("cyclicAMIPolyPatch::nbrPatchID() const")
+                << "Patch " << name()
+                << " specifies neighbour patch " << nbrPatchName()
+                << nl << " but that in return specifies "
+                << nbrPatch.nbrPatchName() << endl;
+        }
+    }
+
+    return nbrPatchID_;
+}
+
+
+void Foam::cyclicAMIPolyPatch::transformPosition(pointField& l) const
+{
+    if (!parallel())
+    {
+        if (transform_ == ROTATIONAL)
+        {
+            l = Foam::transform(forwardT(), l - rotationCentre_)
+              + rotationCentre_;
+        }
+        else
+        {
+            l = Foam::transform(forwardT(), l);
+        }
+    }
+    else if (separated())
+    {
+        // transformPosition gets called on the receiving side,
+        // separation gets calculated on the sending side so subtract
+
+        const vectorField& s = separation();
+        if (s.size() == 1)
+        {
+            forAll(l, i)
+            {
+                l[i] -= s[0];
+            }
+        }
+        else
+        {
+            l -= s;
+        }
+    }
+}
+
+
+void Foam::cyclicAMIPolyPatch::transformPosition
+(
+    point& l,
+    const label faceI
+) const
+{
+    if (!parallel())
+    {
+        const tensor& T =
+        (
+            forwardT().size() == 1
+          ? forwardT()[0]
+          : forwardT()[faceI]
+        );
+
+        if (transform_ == ROTATIONAL)
+        {
+            l = Foam::transform(T, l - rotationCentre_) + rotationCentre_;
+        }
+        else
+        {
+            l = Foam::transform(T, l);
+        }
+    }
+    else if (separated())
+    {
+        const vector& s =
+        (
+            separation().size() == 1
+          ? separation()[0]
+          : separation()[faceI]
+        );
+
+        l -= s;
+    }
+}
+
+
+void Foam::cyclicAMIPolyPatch::calcGeometry
+(
+    const primitivePatch& referPatch,
+    const pointField& thisCtrs,
+    const vectorField& thisAreas,
+    const pointField& thisCc,
+    const pointField& nbrCtrs,
+    const vectorField& nbrAreas,
+    const pointField& nbrCc
+)
+{
+    calcTransforms
+    (
+        referPatch,
+        thisCtrs,
+        thisAreas,
+        nbrCtrs,
+        nbrAreas
+    );
+
+    deleteDemandDrivenData(AMIPtr_);
+
+    AMI();
+}
+
+
+void Foam::cyclicAMIPolyPatch::initOrder
+(
+    PstreamBuffers& pBufs,
+    const primitivePatch& pp
+) const
+{}
+
+
+bool Foam::cyclicAMIPolyPatch::order
+(
+    PstreamBuffers& pBufs,
+    const primitivePatch& pp,
+    labelList& faceMap,
+    labelList& rotation
+) const
+{
+    faceMap.setSize(pp.size());
+    faceMap = -1;
+
+    rotation.setSize(pp.size());
+    rotation = 0;
+
+    // do nothing
+    return false;
+}
+
+
+void Foam::cyclicAMIPolyPatch::write(Ostream& os) const
+{
+    coupledPolyPatch::write(os);
+}
+
+
+// ************************************************************************* //
diff --git a/src/AMIInterpolation/patches/cyclicAMIPolyPatch/cyclicAMIPolyPatch.H b/src/AMIInterpolation/patches/cyclicAMIPolyPatch/cyclicAMIPolyPatch.H
new file mode 100644
index 0000000000..c54ae0f853
--- /dev/null
+++ b/src/AMIInterpolation/patches/cyclicAMIPolyPatch/cyclicAMIPolyPatch.H
@@ -0,0 +1,382 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2011 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::cyclicAMIPolyPatch
+
+Description
+    Cyclic patch for Arbitrary Mesh Interface (AMI)
+
+SourceFiles
+    cyclicAMIPolyPatch.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef cyclicAMIPolyPatch_H
+#define cyclicAMIPolyPatch_H
+
+#include "coupledPolyPatch.H"
+#include "AMIPatchToPatchInterpolation.H"
+#include "polyBoundaryMesh.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                    Class cyclicAMIPolyPatch Declaration
+\*---------------------------------------------------------------------------*/
+
+class cyclicAMIPolyPatch
+:
+    public coupledPolyPatch
+{
+
+private:
+
+    // Private data
+
+        //- Name of other half
+        const word nbrPatchName_;
+
+        //- Index of other half
+        mutable label nbrPatchID_;
+
+        //- Neighbour delta field to *this patch
+        vectorField nbrPatchDelta_;
+
+
+        // Transformations
+
+            //- Type of transformation - rotational or translational
+            transformType transform_;
+
+
+            // For rotation
+
+                //- Axis of rotation for rotational cyclics
+                vector rotationAxis_;
+
+                //- point on axis of rotation for rotational cyclics
+                point rotationCentre_;
+
+
+            // For translation
+
+                //- Translation vector
+                vector separationVector_;
+
+
+        //- AMI interpolation class
+        AMIPatchToPatchInterpolation* AMIPtr_;
+
+        //- Projection surface
+        autoPtr<searchableSurface> surfPtr_;
+
+
+    // Private Member Functions
+
+        //- Return face ID of face at max distance from rotation axis
+        label findFaceMaxRadius(const pointField& faceCentres) const;
+
+        void calcTransforms
+        (
+            const primitivePatch& half0,
+            const pointField& half0Ctrs,
+            const vectorField& half0Areas,
+            const pointField& half1Ctrs,
+            const vectorField& half1Areas
+        );
+
+
+protected:
+
+    // Protected Member Functions
+
+        //- Recalculate the transformation tensors
+        virtual void calcTransforms();
+
+        //- 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&);
+
+
+public:
+
+//    //- Declare friendship with processorCyclicPolyPatch
+//    friend class processorCyclicPolyPatch;
+
+    //- Runtime type information
+    TypeName("cyclicAMI");
+
+
+    // Constructors
+
+        //- Construct from (base couped patch) components
+        cyclicAMIPolyPatch
+        (
+            const word& name,
+            const label size,
+            const label start,
+            const label index,
+            const polyBoundaryMesh& bm
+        );
+
+        //- Construct from dictionary
+        cyclicAMIPolyPatch
+        (
+            const word& name,
+            const dictionary& dict,
+            const label index,
+            const polyBoundaryMesh& bm
+        );
+
+        //- Construct as copy, resetting the boundary mesh
+        cyclicAMIPolyPatch(const cyclicAMIPolyPatch&, const polyBoundaryMesh&);
+
+        //- Construct given the original patch and resetting the
+        //  face list and boundary mesh information
+        cyclicAMIPolyPatch
+        (
+            const cyclicAMIPolyPatch& pp,
+            const polyBoundaryMesh& bm,
+            const label index,
+            const label newSize,
+            const label newStart,
+            const word& nbrPatchName
+        );
+
+        //- Construct given the original patch and a map
+        cyclicAMIPolyPatch
+        (
+            const cyclicAMIPolyPatch& 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 cyclicAMIPolyPatch(*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 cyclicAMIPolyPatch
+                (
+                    *this,
+                    bm,
+                    index,
+                    newSize,
+                    newStart,
+                    nbrPatchName_
+                )
+            );
+        }
+
+        //- 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 cyclicAMIPolyPatch
+                (
+                    *this,
+                    bm,
+                    index,
+                    mapAddressing,
+                    newStart
+                )
+            );
+        }
+
+
+    //- Destructor
+    virtual ~cyclicAMIPolyPatch();
+
+
+    // Member Functions
+
+        // Access
+
+            //- Neighbour patch name
+            const word& nbrPatchName() const
+            {
+                return nbrPatchName_;
+            }
+
+            //- Neighbour patch ID
+            virtual label nbrPatchID() const;
+
+            //- Does this side own the patch ?
+            virtual bool owner() const
+            {
+                return index() < nbrPatchID();
+            }
+
+            const cyclicAMIPolyPatch& nbrPatch() const
+            {
+                const polyPatch& pp = this->boundaryMesh()[nbrPatchID()];
+                return refCast<const cyclicAMIPolyPatch>(pp);
+            }
+
+
+            const vectorField& nbrPatchDelta() const
+            {
+                return nbrPatchDelta_;
+            }
+
+            const AMIPatchToPatchInterpolation& AMI();
+
+
+            // Transformations
+
+                //- Type of transform
+                transformType transform() const
+                {
+                    return transform_;
+                }
+
+                //- Axis of rotation for rotational cyclic AMI
+                const vector& rotationAxis() const
+                {
+                    return rotationAxis_;
+                }
+
+                //- point on axis of rotation for rotational cyclic AMI
+                const point& rotationCentre() const
+                {
+                    return rotationCentre_;
+                }
+
+                //- Translation vector for translational cyclic AMI
+                const vector& separationVector() const
+                {
+                    return separationVector_;
+                }
+
+                //- Transform patch-based positions from nbr side to this side
+                virtual void transformPosition(pointField&) const;
+
+                //- Transform a patch-based position from nbr side to this side
+                virtual void transformPosition
+                (
+                    point& l,
+                    const label faceI
+                ) const;
+
+                template<class Type>
+                tmp<Field<Type> > interpolateToSource(const Field<Type>& fld) const
+                {
+                    return AMIPtr_->interpolateToSource(fld);
+                }
+
+                template<class Type>
+                tmp<Field<Type> > interpolateToSource(const tmp<Field<Type> >& tFld) const
+                {
+                    return AMIPtr_->interpolateToSource(tFld);
+                }
+
+
+        //- 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
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

From a372dbfb5391b7c620240d026de7e2ed4ffb356c Mon Sep 17 00:00:00 2001
From: andy <andy>
Date: Thu, 21 Jul 2011 17:48:20 +0100
Subject: [PATCH 04/45] ENH: Further updates to AMI functionality

---
 src/AMIInterpolation/AMIInterpolation.C       | 214 +++++++++++---
 src/AMIInterpolation/AMIInterpolation.H       | 172 ++++++++----
 src/AMIInterpolation/AMIInterpolationI.H      |  58 ++++
 src/AMIInterpolation/Make/files               |   1 +
 src/AMIInterpolation/Make/options             |   7 +-
 .../faceAreaIntersect/faceAreaIntersect.C     | 120 ++++----
 .../faceAreaIntersect/faceAreaIntersect.H     |  17 +-
 .../cyclicAMIFvPatch/cyclicAMIFvPatch.C       |   7 +-
 .../cyclicAMIFvPatch/cyclicAMIFvPatch.H       |   5 -
 .../cyclicAMIPointPatch/cyclicAMIPointPatch.C |  99 +++++++
 .../cyclicAMIPointPatch/cyclicAMIPointPatch.H | 121 ++++++++
 .../cyclicAMIPolyPatch/cyclicAMIPolyPatch.C   | 262 +++++++++++-------
 .../cyclicAMIPolyPatch/cyclicAMIPolyPatch.H   | 100 ++++---
 .../cyclicAMIPolyPatch/cyclicAMIPolyPatchI.H  |  67 +++++
 .../cyclicAMIPolyPatchTemplates.C             |  64 +++++
 src/OpenFOAM/meshes/boundBox/boundBox.C       |  12 +-
 16 files changed, 1000 insertions(+), 326 deletions(-)
 create mode 100644 src/AMIInterpolation/AMIInterpolationI.H
 create mode 100644 src/AMIInterpolation/patches/cyclicAMIPointPatch/cyclicAMIPointPatch.C
 create mode 100644 src/AMIInterpolation/patches/cyclicAMIPointPatch/cyclicAMIPointPatch.H
 create mode 100644 src/AMIInterpolation/patches/cyclicAMIPolyPatch/cyclicAMIPolyPatchI.H
 create mode 100644 src/AMIInterpolation/patches/cyclicAMIPolyPatch/cyclicAMIPolyPatchTemplates.C

diff --git a/src/AMIInterpolation/AMIInterpolation.C b/src/AMIInterpolation/AMIInterpolation.C
index 0e5c6348e5..99fae0b857 100644
--- a/src/AMIInterpolation/AMIInterpolation.C
+++ b/src/AMIInterpolation/AMIInterpolation.C
@@ -24,13 +24,14 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "AMIInterpolation.H"
-#include "faceAreaIntersect.H"
 #include "Random.H"
 #include "treeDataPrimitivePatch.H"
 #include "indexedOctree.H"
 #include "primitivePatch.H"
 #include "meshTools.H"
 
+#include "vtkSurfaceWriter.H"
+
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 
 template<class SourcePatch, class TargetPatch>
@@ -95,9 +96,9 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::checkPatches
     const scalar maxBoundsError = 0.05;
 
     // sanity checks
-    boundBox bbSrc(srcPatch.points());
-    boundBox bbTgt(tgtPatch.points());
-    boundBox bbSurf(srcPatch.points());
+    boundBox bbSrc(srcPatch.points(), srcPatch.meshPoints());
+    boundBox bbTgt(tgtPatch.points(), tgtPatch.meshPoints());
+    boundBox bbSurf(bbTgt); // USE POINTS OF SURFACE!!!!!!!!!!!!!!!!!!
 
 
     // projection surface bounds - check against bounds of source and target
@@ -132,7 +133,6 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::checkPatches
 
 
     // check bounds of source and target
-
     bbTgt.inflate(maxBoundsError);
 
     if (!bbTgt.contains(bbSrc))
@@ -144,8 +144,11 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::checkPatches
                 "const primitivePatch&, "
                 "const primitivePatch&"
             ")"
-        )   << "Source and target patch bounding boxes are not similar"
-            << endl;
+        )   << "Source and target patch bounding boxes are not similar" << nl
+            << "    src span : " << bbSrc.span() << nl
+            << "    tgt span : " << bbTgt.span() << nl
+            << "    source: " << bbSrc << nl
+            << "    target: " << bbTgt << endl;
     }
 }
 
@@ -157,6 +160,16 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::projectPointsToSurface
     pointField& pts
 ) const
 {
+    if (!projectPoints_)
+    {
+        return;
+    }
+
+    if (debug)
+    {
+        Info<< "AMI: projecting points to surface" << endl;
+    }
+
     List<pointIndexHit> nearInfo;
 
     surf.findNearest(pts, scalarField(pts.size(), GREAT), nearInfo);
@@ -313,7 +326,7 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::setNextFaces
     const boolList& mapFlag,
     labelList& seedFaces,
     const DynamicList<label>& visitedFaces
-) const
+)
 {
 //    const labelList& srcNbrFaces = srcPatch0.pointFaces()[srcFaceI];
     const labelList& srcNbrFaces = srcPatch0.faceFaces()[srcFaceI];
@@ -356,14 +369,24 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::setNextFaces
     else
     {
         // try to use existing seed
-        forAll(mapFlag, faceI)
+        bool foundNextSeed = false;
+        for (label faceI = startSeedI_; faceI < mapFlag.size(); faceI++)
         {
-            if (mapFlag[faceI] && seedFaces[faceI] != -1)
+            if (mapFlag[faceI])
             {
-                srcFaceI = faceI;
-                tgtFaceI = seedFaces[faceI];
+                if (!foundNextSeed)
+                {
+                    startSeedI_ = faceI + 1;
+                    foundNextSeed = true;
+                }
 
-                return;
+                if (seedFaces[faceI] != -1)
+                {
+                    srcFaceI = faceI;
+                    tgtFaceI = seedFaces[faceI];
+
+                    return;
+                }
             }
         }
 
@@ -374,10 +397,12 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::setNextFaces
                 << "target face" << endl;
         }
 
-        forAll(mapFlag, faceI)
+        for (label faceI = startSeedI_; faceI < mapFlag.size(); faceI++)
         {
             if (mapFlag[faceI])
             {
+                startSeedI_ = faceI + 1;
+
                 srcFaceI = faceI;
                 tgtFaceI = findTargetFace(srcFaceI, srcPatch0, tgtPatch0);
 
@@ -429,7 +454,7 @@ Foam::scalar Foam::AMIInterpolation<SourcePatch, TargetPatch>::interArea
     // crude resultant norm
     const vector n = 0.5*(tgt.normal(tgtPoints) - src.normal(srcPoints));
 
-    scalar area = inter.calc(src, tgt, n);
+    scalar area = inter.calc(src, tgt, n, triMode_);
 
     if ((debug > 1) && (area > 0))
     {
@@ -447,10 +472,11 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::normaliseWeights
     const primitivePatch& patch,
     const pointField& points,
     const List<DynamicList<label> >& addr,
-    List<DynamicList<scalar> >& wght
+    List<DynamicList<scalar> >& wght,
+    const bool output
 )
 {
-    scalarList wghtSum(patch.size(), 0.0);
+    scalarField wghtSum(patch.size(), 0.0);
 
     // normalise weights by face areas
     forAll(wght, faceI)
@@ -464,8 +490,37 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::normaliseWeights
         }
     }
 
-    Info<< "Cumulative " << patchType <<  "source weights min/max = "
-        << min(wghtSum) << ", " << max(wghtSum) << endl;
+//    if (debug)
+    {
+        vtkSurfaceWriter writer;
+
+        writer.write
+        (
+            "VTK",
+            patchType,
+            patch.localPoints(),
+            patch.localFaces(),
+            "weights",
+            wghtSum,
+            false
+        );
+    }
+
+    if (output)
+    {
+        Info<< "AMI: Patch " << patchType << " weights min/max = "
+            << min(wghtSum) << ", " << max(wghtSum) << endl;
+    }
+
+
+    forAll(wght, faceI)
+    {
+        const DynamicList<label>& addressing = addr[faceI];
+        forAll(addressing, addrI)
+        {
+            wght[faceI][addrI] /= wghtSum[faceI];
+        }
+    }
 }
 
 
@@ -476,17 +531,29 @@ Foam::AMIInterpolation<SourcePatch, TargetPatch>::AMIInterpolation
 (
     const SourcePatch& srcPatch,
     const TargetPatch& tgtPatch,
-    const searchableSurface& surf
+    const searchableSurface& surf,
+    const faceAreaIntersect::triangulationMode& triMode,
+    const bool projectPoints
 )
 :
     srcAddress_(),
     srcWeights_(),
     tgtAddress_(),
-    tgtWeights_()
+    tgtWeights_(),
+    startSeedI_(0),
+    triMode_(triMode),
+    projectPoints_(projectPoints)
 {
-    checkPatches(srcPatch, tgtPatch);
+    if (srcPatch.size() && tgtPatch.size())
+    {
+        checkPatches(srcPatch, tgtPatch);
 
-    calcAddressing(srcPatch, tgtPatch, surf);
+        Info<< "AMI: Creating interpolation addressing and weights" << nl
+            << "    Source faces = " << srcPatch.size() << nl
+            << "    Target faces = " << tgtPatch.size() << endl;
+
+        calcAddressing(srcPatch, tgtPatch, surf);
+    }
 }
 
 
@@ -557,7 +624,7 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::calcAddressing
 
     if (debug)
     {
-        OFstream os("osTgtPoints.obj");
+        OFstream os("amiTgtPoints.obj");
         forAll(tgtPoints, i)
         {
             meshTools::writeOBJ(os, tgtPoints[i]);
@@ -565,11 +632,6 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::calcAddressing
     }
 
 
-    if (debug)
-    {
-        Info<< "AMI: projecting points to surface" << endl;
-    }
-
     // map source and target patches onto projection surface
     // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     projectPointsToSurface(surf, srcPoints);
@@ -589,7 +651,7 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::calcAddressing
 
     // construct weights and addressing
     // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    label facesRemaining = srcPatch0.size();
+    label nFacesRemaining = srcPatch0.size();
 
     // list of tgt face neighbour faces
     DynamicList<label> nbrFaces(10);
@@ -598,11 +660,13 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::calcAddressing
     DynamicList<label> visitedFaces(10);
 
     // list to keep track of tgt faces used to seed src faces
-    labelList seedFaces(facesRemaining, -1);
+    labelList seedFaces(nFacesRemaining, -1);
     seedFaces[srcFaceI] = tgtFaceI;
 
     // list to keep track of whether src face can be mapped
-    boolList mapFlag(facesRemaining, true);
+    boolList mapFlag(nFacesRemaining, true);
+
+    label nFail = 0;
 
     do
     {
@@ -613,6 +677,8 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::calcAddressing
         nbrFaces.append(tgtFaceI);
         appendNbrFaces(tgtFaceI, tgtPatch0, visitedFaces, nbrFaces);
 
+        bool faceProcessed = false;
+
         do
         {
             // process new target face
@@ -630,16 +696,30 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::calcAddressing
                 tgtWght[tgtFaceI].append(area);
 
                 appendNbrFaces(tgtFaceI, tgtPatch0, visitedFaces, nbrFaces);
+
+                faceProcessed = true;
             }
 
         } while (nbrFaces.size() > 0);
 
-        mapFlag[srcFaceI] = false;
+        if (faceProcessed)
+        {
+            mapFlag[srcFaceI] = false;
 
-        facesRemaining--;
+            nFacesRemaining--;
+        }
+        else
+        {
+            nFail++;
+
+            if (nFail > 1000)
+            {
+                Info<< "nFail = " << nFail << endl;
+            }
+        }
 
         // choose new src face from current src face neighbour
-        if (facesRemaining > 0)
+        if (nFacesRemaining > 0)
         {
             setNextFaces
             (
@@ -652,12 +732,12 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::calcAddressing
                 visitedFaces
             );
         }
-    } while (facesRemaining > 0);
+    } while (nFacesRemaining > 0);
 
 
     // weights normalisation
-    normaliseWeights("source", srcPatch0, srcPoints, srcAddr, srcWght);
-    normaliseWeights("target", tgtPatch0, tgtPoints, tgtAddr, tgtWght);
+    normaliseWeights("source", srcPatch0, srcPoints, srcAddr, srcWght, true);
+    normaliseWeights("target", tgtPatch0, tgtPoints, tgtAddr, tgtWght, true);
 
     // transfer data to persistent storage
     srcAddress_.setSize(srcAddr.size());
@@ -675,6 +755,32 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::calcAddressing
         tgtAddress_[i].transfer(tgtAddr[i]);
         tgtWeights_[i].transfer(tgtWght[i]);
     }
+
+// ADD PARALLEL BITS
+/*
+    if (Pstream::parRun())
+    {
+        // Source fields - addesses and weights
+        const label nSrc = srcAddess.size();
+        const globalIndex globalSrcFaces(nSrc);
+
+        List<Map<label> > compactMapSrcAddress;
+        labelListList transSrcAddress;
+
+        mapDistribute srcMapDist
+        (
+            globalSrcFaces,
+            srcAddress_,
+            globalIndexAndTransform(mesh), // mesh not available!!!!!!!!
+            transSrcAddress,
+            compactMapSrcAddress
+        );
+
+
+    }
+*/
+    // reset starting seed
+    startSeedI_ = 0;
 }
 
 
@@ -790,4 +896,36 @@ Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolateToTarget
 }
 
 
+template<class SourcePatch, class TargetPatch>
+void Foam::AMIInterpolation<SourcePatch, TargetPatch>::writeFaceConnectivity
+(
+    const primitivePatch& srcPatch,
+    const primitivePatch& tgtPatch
+)
+const
+{
+    OFstream os("faceConnectivity.obj");
+
+    label ptI = 1;
+
+    forAll(srcAddress_, i)
+    {
+        const labelList& addr = srcAddress_[i];
+        const point& srcPt = srcPatch.faceCentres()[i];
+        forAll(addr, j)
+        {
+            label tgtPtI = addr[j];
+            const point& tgtPt = tgtPatch.faceCentres()[tgtPtI];
+
+            meshTools::writeOBJ(os, srcPt);
+            meshTools::writeOBJ(os, tgtPt);
+
+            os  << "l " << ptI << " " << ptI + 1 << endl;
+
+            ptI += 2;
+        }
+    }
+}
+
+
 // ************************************************************************* //
diff --git a/src/AMIInterpolation/AMIInterpolation.H b/src/AMIInterpolation/AMIInterpolation.H
index 246c1660a6..8dd8b72c1b 100644
--- a/src/AMIInterpolation/AMIInterpolation.H
+++ b/src/AMIInterpolation/AMIInterpolation.H
@@ -26,7 +26,14 @@ Class
 
 Description
     Interpolation class dealing with transfer of data between two
-    primitive patches with an arbitrary mesh interface (AMI)
+    primitive patches with an arbitrary mesh interface (AMI).
+
+    Based on the algorithm given in:
+
+        Conservative interpolation between volume meshes by local Galerkin
+        projection, Farrell PE and Maddison JR, 2011, Comput. Methods Appl.
+        Mech Engrg, Volume 200, Issues 1-4, pp 89-100
+
 
 SourceFiles
     AMIInterpolation.C
@@ -42,6 +49,7 @@ SourceFiles
 #include "searchableSurface.H"
 #include "boolList.H"
 #include "primitivePatch.H"
+#include "faceAreaIntersect.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -84,6 +92,16 @@ class AMIInterpolation
             scalarListList tgtWeights_;
 
 
+        //- Starting face seed index
+        label startSeedI_;
+
+        //- Face triangulation mode
+        const faceAreaIntersect::triangulationMode triMode_;
+
+        //- Flag to indicate whether or not to project points
+        const bool projectPoints_;
+
+
     // Private Member Functions
 
         //- Disallow default bitwise copy construct
@@ -92,70 +110,94 @@ class AMIInterpolation
         //- Disallow default bitwise assignment
         void operator=(const AMIInterpolation&);
 
-        //- Write triangle intersection to OBJ file
-        void writeIntersectionOBJ
-        (
-            const scalar area,
-            const face& f1,
-            const face& f2,
-            const pointField& f1Points,
-            const pointField& f2Points
-        ) const;
 
-        void checkPatches
-        (
-            const primitivePatch& srcPatch,
-            const primitivePatch& tgtPatch
-        );
+        // Helper functions
 
-        void projectPointsToSurface
-        (
-            const searchableSurface& surf,
-            pointField& pts
-        ) const;
+            //- Write triangle intersection to OBJ file
+            void writeIntersectionOBJ
+            (
+                const scalar area,
+                const face& f1,
+                const face& f2,
+                const pointField& f1Points,
+                const pointField& f2Points
+            ) const;
 
-        label findTargetFace
-        (
-            const label srcFaceI,
-            const primitivePatch& srcPatch,
-            const primitivePatch& tgtPatch
-        ) const;
+            //- Check that patches are valid
+            void checkPatches
+            (
+                const primitivePatch& srcPatch,
+                const primitivePatch& tgtPatch
+            );
 
-        void appendNbrFaces
-        (
-            const label faceI,
-            const primitivePatch& patch,
-            const DynamicList<label>& visitedFaces,
-            DynamicList<label>& faceIDs
-        ) const;
 
-        void setNextFaces
-        (
-            label& srcFaceI,
-            label& tgtFaceI,
-            const primitivePatch& srcPatch0,
-            const primitivePatch& tgtPatch0,
-            const boolList& mapFlag,
-            labelList& seedFaces,
-            const DynamicList<label>& visitedFaces
-        ) const;
+        // Initialisation
 
-        scalar interArea
-        (
-            const label srcFaceI,
-            const label tgtFaceI,
-            const primitivePatch& srcPatch,
-            const primitivePatch& tgtPatch
-        ) const;
+            //- Project points to surface
+            void projectPointsToSurface
+            (
+                const searchableSurface& surf,
+                pointField& pts
+            ) const;
 
-        void normaliseWeights
-        (
-            const word& patchType,
-            const primitivePatch& patch,
-            const pointField& points,
-            const List<DynamicList<label> >& addr,
-            List<DynamicList<scalar> >& wght
-        );
+
+        // Marching front
+
+            //- Find face on target patch that overlaps source face
+            label findTargetFace
+            (
+                const label srcFaceI,
+                const primitivePatch& srcPatch,
+                const primitivePatch& tgtPatch
+            ) const;
+
+            //- Add faces neighbouring faceI to the ID list
+            void appendNbrFaces
+            (
+                const label faceI,
+                const primitivePatch& patch,
+                const DynamicList<label>& visitedFaces,
+                DynamicList<label>& faceIDs
+            ) const;
+
+            //- Set the source and target seed faces
+            void setNextFaces
+            (
+                label& srcFaceI,
+                label& tgtFaceI,
+                const primitivePatch& srcPatch0,
+                const primitivePatch& tgtPatch0,
+                const boolList& mapFlag,
+                labelList& seedFaces,
+                const DynamicList<label>& visitedFaces
+            );
+
+
+        // Evaluation
+
+            //- Area of intersection between source and target faces
+            scalar interArea
+            (
+                const label srcFaceI,
+                const label tgtFaceI,
+                const primitivePatch& srcPatch,
+                const primitivePatch& tgtPatch
+            ) const;
+
+            //- Normalise the (area) weights - suppresses numerical error in
+            //  weights calculation
+            //  NOTE: if area weights are incorrect by 'a significant amount'
+            //     normalisation may stabilise the solution, but will introduce
+            //     numerical error!
+            void normaliseWeights
+            (
+                const word& patchType,
+                const primitivePatch& patch,
+                const pointField& points,
+                const List<DynamicList<label> >& addr,
+                List<DynamicList<scalar> >& wght,
+                const bool output
+            );
 
 
 public:
@@ -167,7 +209,9 @@ public:
         (
             const SourcePatch& srcPatch,
             const TargetPatch& tgtPatch,
-            const searchableSurface& surf
+            const searchableSurface& surf,
+            const faceAreaIntersect::triangulationMode& triMode,
+            const bool projectPoints
         );
 
 
@@ -234,6 +278,16 @@ public:
             (
                 const tmp<Field<Type> >& tFld
             ) const;
+
+
+        // Checks
+
+            //- Write face connectivity as OBJ file
+            void writeFaceConnectivity
+            (
+                const primitivePatch& srcPatch,
+                const primitivePatch& tgtPatch
+            ) const;
 };
 
 
diff --git a/src/AMIInterpolation/AMIInterpolationI.H b/src/AMIInterpolation/AMIInterpolationI.H
new file mode 100644
index 0000000000..a38c83ebaf
--- /dev/null
+++ b/src/AMIInterpolation/AMIInterpolationI.H
@@ -0,0 +1,58 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2011 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+template<class SourcePatch, class TargetPatch>
+inline const Foam::labelListList&
+Foam::AMIInterpolation<SourcePatch, TargetPatch>::srcAddress()
+{
+    return srcAddress_;
+}
+
+
+template<class SourcePatch, class TargetPatch>
+inline const Foam::scalarListList&
+Foam::AMIInterpolation<SourcePatch, TargetPatch>::srcWeights()
+{
+    return srcWeights_;
+}
+
+
+template<class SourcePatch, class TargetPatch>
+inline const Foam::labelListList&
+Foam::AMIInterpolation<SourcePatch, TargetPatch>::tgtAddress()
+{
+    return tgtAddress_;
+}
+
+
+template<class SourcePatch, class TargetPatch>
+inline const Foam::scalarListList&
+Foam::AMIInterpolation<SourcePatch, TargetPatch>::tgtWeights()
+{
+    return tgtWeights_;
+}
+
+
+// ************************************************************************* //
diff --git a/src/AMIInterpolation/Make/files b/src/AMIInterpolation/Make/files
index 7a47cad93c..1c4f231be8 100644
--- a/src/AMIInterpolation/Make/files
+++ b/src/AMIInterpolation/Make/files
@@ -8,5 +8,6 @@ patches/cyclicAMIPolyPatch/cyclicAMIPolyPatch.C
 patches/cyclicAMIFvPatch/cyclicAMIFvPatch.C
 patches/cyclicAMIFvPatchField/cyclicAMIFvPatchFields.C
 patches/cyclicAMIFvsPatchField/cyclicAMIFvsPatchFields.C
+patches/cyclicAMIPointPatch/cyclicAMIPointPatch.C
 
 LIB = $(FOAM_USER_LIBBIN)/libAMIInterpolation
diff --git a/src/AMIInterpolation/Make/options b/src/AMIInterpolation/Make/options
index 431de9fbf4..b1bf11173c 100644
--- a/src/AMIInterpolation/Make/options
+++ b/src/AMIInterpolation/Make/options
@@ -1,8 +1,11 @@
 EXE_INC = \
     -DFULLDEBUG -g -O0 \
     -I$(LIB_SRC)/finiteVolume/lnInclude \
-    -I$(LIB_SRC)/meshTools/lnInclude
+    -I$(LIB_SRC)/meshTools/lnInclude \
+    -I$(LIB_SRC)/sampling/lnInclude
+
 
 LIB_LIBS = \
     -lfiniteVolume \
-    -lmeshTools
+    -lmeshTools \
+    -lsampling
diff --git a/src/AMIInterpolation/faceAreaIntersect/faceAreaIntersect.C b/src/AMIInterpolation/faceAreaIntersect/faceAreaIntersect.C
index 174fcdd461..e6294ba63e 100644
--- a/src/AMIInterpolation/faceAreaIntersect/faceAreaIntersect.C
+++ b/src/AMIInterpolation/faceAreaIntersect/faceAreaIntersect.C
@@ -32,9 +32,12 @@ void Foam::faceAreaIntersect::triSliceWithPlane
     const triPoints& tri,
     const plane& p,
     FixedList<triPoints, 10>& tris,
-    label& nTris
+    label& nTris,
+    const scalar len
 )
 {
+    const scalar matchTol = 1e-4;
+
     // distance to cutting plane
     FixedList<scalar, 3> d;
 
@@ -43,22 +46,16 @@ void Foam::faceAreaIntersect::triSliceWithPlane
     label nPos = 0;
     label posI = -1;
     label negI = -1;
-    bool coPlanar;
     forAll(tri, i)
     {
         d[i] = ((tri[i] - p.refPoint()) & p.normal());
 
-        if (mag(d[i]) < 1e-10)
+        if (mag(d[i]) < matchTol*len)
         {
-            coPlanar = true;
+            d[i] = 0.0;
             nCoPlanar++;
         }
         else
-        {
-            coPlanar = false;
-        }
-
-        if (!coPlanar)
         {
             if (d[i] > 0)
             {
@@ -133,44 +130,48 @@ Foam::scalar Foam::faceAreaIntersect::triangleIntersect
 )
 {
     // Work storage
-    FixedList<triPoints, 10> cutTris;
-    label nCutTris = 0;
+    FixedList<triPoints, 10> workTris1;
+    label nWorkTris1 = 0;
 
-    FixedList<triPoints, 10> tris;
-    label nTris = 0;
+    FixedList<triPoints, 10> workTris2;
+    label nWorkTris2 = 0;
 
     // cut source triangle with all inwards pointing faces of target triangle
-    // - triangles in cutTris are inside target triangle
+    // - triangles in workTris1 are inside target triangle
+
+    scalar t = sqrt(triArea(src));
 
     // edge 0
     {
         // cut triangle src with plane and put resulting sub-triangles in
-        // cutTris list
+        // workTris1 list
 
-        plane pl0(tgt[0], tgt[1], tgt[1] + n);
-        triSliceWithPlane(src, pl0, cutTris, nCutTris);
+        scalar s = mag(tgt[1] - tgt[0]);
+        plane pl0(tgt[0], tgt[1], tgt[1] + s*n);
+        triSliceWithPlane(src, pl0, workTris1, nWorkTris1, t);
     }
 
-    if (nCutTris == 0)
+    if (nWorkTris1 == 0)
     {
         return 0.0;
     }
 
     // edge1
     {
-        // cut cutTris with plane and put resulting sub-triangles in
-        // tris list (re-use tris storage)
+        // cut workTris1 with plane and put resulting sub-triangles in
+        // workTris2 list (re-use tris storage)
 
-        plane pl1(tgt[1], tgt[2], tgt[2] + n);
+        scalar s = mag(tgt[2] - tgt[1]);
+        plane pl1(tgt[1], tgt[2], tgt[2] + s*n);
 
-        nTris = 0;
+        nWorkTris2 = 0;
 
-        for (label i = 0; i < nCutTris; i++)
+        for (label i = 0; i < nWorkTris1; i++)
         {
-            triSliceWithPlane(cutTris[i], pl1, tris, nTris);
+            triSliceWithPlane(workTris1[i], pl1, workTris2, nWorkTris2, t);
         }
 
-        if (nTris == 0)
+        if (nWorkTris2 == 0)
         {
             return 0.0;
         }
@@ -178,19 +179,20 @@ Foam::scalar Foam::faceAreaIntersect::triangleIntersect
 
     // edge2
     {
-        // cut tris with plane and put resulting sub-triangles in
-        // cutTris list (re-use cutTris storage)
+        // cut workTris2 with plane and put resulting sub-triangles in
+        // workTris1 list (re-use workTris1 storage)
 
-        plane pl2(tgt[2], tgt[0], tgt[0] + n);
+        scalar s = mag(tgt[2] - tgt[0]);
+        plane pl2(tgt[2], tgt[0], tgt[0] + s*n);
 
-        nCutTris = 0;
+        nWorkTris1 = 0;
 
-        for (label i = 0; i < nTris; i++)
+        for (label i = 0; i < nWorkTris2; i++)
         {
-            triSliceWithPlane(tris[i], pl2, cutTris, nCutTris);
+            triSliceWithPlane(workTris2[i], pl2, workTris1, nWorkTris1, t);
         }
 
-        if (nCutTris == 0)
+        if (nWorkTris1 == 0)
         {
             return 0.0;
         }
@@ -198,10 +200,9 @@ Foam::scalar Foam::faceAreaIntersect::triangleIntersect
         {
             // calculate area of sub-triangles
             scalar area = 0.0;
-            for (label i = 0; i < nCutTris; i++)
+            for (label i = 0; i < nWorkTris1; i++)
             {
-                const triPoints& t = cutTris[i];
-                area += mag(0.5*((t[1] - t[0])^(t[2] - t[0])));
+                area += triArea(workTris1[i]);
             }
 
             return area;
@@ -229,26 +230,45 @@ Foam::scalar Foam::faceAreaIntersect::calc
 (
     const face& faceA,
     const face& faceB,
-    const vector& n
+    const vector& n,
+    const triangulationMode& triMode
 )
 {
     // split faces into triangles
     DynamicList<face> trisA;
     DynamicList<face> trisB;
 
-//    if (useTriangleFan)
-//    {
-//        triangleFan(faceA, trisA);
-//        triangleFan(faceB, trisB);
-//    }
-//    else
-//    {
-//        faceA.triangles(pointsA_, trisA);
-//        faceB.triangles(pointsB_, trisB);
-//    }
+    switch (triMode)
+    {
+        case tmFan:
+        {
+            triangleFan(faceA, trisA);
+            triangleFan(faceB, trisB);
 
-    faceA.triangles(pointsA_, trisA);
-    faceB.triangles(pointsB_, trisB);
+            break;
+        }
+        case tmMesh:
+        {
+            faceA.triangles(pointsA_, trisA);
+            faceB.triangles(pointsB_, trisB);
+
+            break;
+        }
+        default:
+        {
+            FatalErrorIn
+            (
+                "Foam::scalar Foam::faceAreaIntersect::calc"
+                "("
+                    "const face&, "
+                    "const face&, "
+                    "const vector&, "
+                    "const triangulationMode&"
+                ")"
+            )   << "Unknown triangulation mode enumeration"
+                << abort(FatalError);
+        }
+    }
 
     // intersect triangles
     scalar totalArea = 0.0;
@@ -256,13 +276,13 @@ Foam::scalar Foam::faceAreaIntersect::calc
     {
         triPoints tpA = getTriPoints(pointsA_, trisA[tA], false);
 
-        if (triArea(tpA) > ROOTVSMALL)
+//        if (triArea(tpA) > ROOTVSMALL)
         {
             forAll(trisB, tB)
             {
                 triPoints tpB = getTriPoints(pointsB_, trisB[tB], true);
 
-                if (triArea(tpB) > ROOTVSMALL)
+//                if (triArea(tpB) > ROOTVSMALL)
                 {
                     totalArea += triangleIntersect(tpA, tpB, n);
                 }
diff --git a/src/AMIInterpolation/faceAreaIntersect/faceAreaIntersect.H b/src/AMIInterpolation/faceAreaIntersect/faceAreaIntersect.H
index 77638e51dd..fd464b8458 100644
--- a/src/AMIInterpolation/faceAreaIntersect/faceAreaIntersect.H
+++ b/src/AMIInterpolation/faceAreaIntersect/faceAreaIntersect.H
@@ -53,8 +53,19 @@ namespace Foam
 
 class faceAreaIntersect
 {
+public:
+
     typedef FixedList<point, 3> triPoints;
 
+    enum triangulationMode
+    {
+        tmFan,
+        tmMesh
+    };
+
+
+private:
+
     // Private data
 
         //- Reference to the points of sideA
@@ -110,7 +121,8 @@ class faceAreaIntersect
             const triPoints& tri,
             const plane& p,
             FixedList<triPoints, 10>& tris,
-            label& nTris
+            label& nTris,
+            const scalar len
         );
 
         //- Return area of intersection of triangles src and tgt
@@ -141,7 +153,8 @@ public:
         (
             const face& faceA,
             const face& faceB,
-            const vector& n
+            const vector& n,
+            const triangulationMode& triMode
         );
 };
 
diff --git a/src/AMIInterpolation/patches/cyclicAMIFvPatch/cyclicAMIFvPatch.C b/src/AMIInterpolation/patches/cyclicAMIFvPatch/cyclicAMIFvPatch.C
index d000c52c31..7c11307f6d 100644
--- a/src/AMIInterpolation/patches/cyclicAMIFvPatch/cyclicAMIFvPatch.C
+++ b/src/AMIInterpolation/patches/cyclicAMIFvPatch/cyclicAMIFvPatch.C
@@ -47,7 +47,7 @@ void Foam::cyclicAMIFvPatch::makeWeights(scalarField& w) const
 
     const scalarField nbrDeltas
     (
-        interpolateToSource(nbrPatch.nf() & nbrPatchDelta())
+        interpolateToSource(nbrPatch.nf() & nbrPatch.fvPatch::delta())
     );
 
     forAll(deltas, faceI)
@@ -68,7 +68,7 @@ void Foam::cyclicAMIFvPatch::makeDeltaCoeffs(scalarField& dc) const
 
     const scalarField nbrDeltas
     (
-        interpolateToSource(nbrPatch.nf() & nbrPatchDelta())
+        interpolateToSource(nbrPatch.nf() & nbrPatch.fvPatch::delta())
     );
 
     forAll(deltas, faceI)
@@ -85,7 +85,8 @@ Foam::tmp<Foam::vectorField> Foam::cyclicAMIFvPatch::delta() const
 {
     const vectorField patchD(fvPatch::delta());
 
-    const vectorField& nbrPatchD(interpolateToSource(nbrPatchDelta()));
+    const cyclicAMIFvPatch& nbrPatch = neighbFvPatch();
+    const vectorField nbrPatchD(interpolateToSource(nbrPatch.fvPatch::delta()));
 
     tmp<vectorField> tpdv(new vectorField(patchD.size()));
     vectorField& pdv = tpdv();
diff --git a/src/AMIInterpolation/patches/cyclicAMIFvPatch/cyclicAMIFvPatch.H b/src/AMIInterpolation/patches/cyclicAMIFvPatch/cyclicAMIFvPatch.H
index 5ccdd01d89..c0d32162e8 100644
--- a/src/AMIInterpolation/patches/cyclicAMIFvPatch/cyclicAMIFvPatch.H
+++ b/src/AMIInterpolation/patches/cyclicAMIFvPatch/cyclicAMIFvPatch.H
@@ -158,11 +158,6 @@ public:
                 return cyclicAMIPolyPatch_.interpolateToSource(tFld);
             }
 
-            const vectorField& nbrPatchDelta() const
-            {
-                return cyclicAMIPolyPatch_.nbrPatchDelta();
-            }
-
 
         // Interface transfer functions
 
diff --git a/src/AMIInterpolation/patches/cyclicAMIPointPatch/cyclicAMIPointPatch.C b/src/AMIInterpolation/patches/cyclicAMIPointPatch/cyclicAMIPointPatch.C
new file mode 100644
index 0000000000..c41779078a
--- /dev/null
+++ b/src/AMIInterpolation/patches/cyclicAMIPointPatch/cyclicAMIPointPatch.C
@@ -0,0 +1,99 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2011 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "cyclicAMIPointPatch.H"
+#include "pointBoundaryMesh.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(cyclicAMIPointPatch, 0);
+    addToRunTimeSelectionTable
+    (
+        facePointPatch,
+        cyclicAMIPointPatch,
+        polyPatch
+    );
+}
+
+
+// * * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * //
+
+void Foam::cyclicAMIPointPatch::initGeometry(PstreamBuffers&)
+{}
+
+
+void Foam::cyclicAMIPointPatch::calcGeometry(PstreamBuffers&)
+{}
+
+
+void Foam::cyclicAMIPointPatch::initMovePoints
+(
+    PstreamBuffers&,
+    const pointField&
+)
+{}
+
+
+void Foam::cyclicAMIPointPatch::movePoints(PstreamBuffers&, const pointField&)
+{}
+
+
+void Foam::cyclicAMIPointPatch::initUpdateMesh(PstreamBuffers& pBufs)
+{
+    facePointPatch::initUpdateMesh(pBufs);
+//    cyclicAMIPointPatch::initGeometry(pBufs);
+}
+
+
+void Foam::cyclicAMIPointPatch::updateMesh(PstreamBuffers& pBufs)
+{
+    facePointPatch::updateMesh(pBufs);
+//    cyclicAMIPointPatch::calcGeometry(pBufs);
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::cyclicAMIPointPatch::cyclicAMIPointPatch
+(
+    const polyPatch& patch,
+    const pointBoundaryMesh& bm
+)
+:
+    coupledFacePointPatch(patch, bm),
+    cyclicAMIPolyPatch_(refCast<const cyclicAMIPolyPatch>(patch))
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::cyclicAMIPointPatch::~cyclicAMIPointPatch()
+{}
+
+
+// ************************************************************************* //
diff --git a/src/AMIInterpolation/patches/cyclicAMIPointPatch/cyclicAMIPointPatch.H b/src/AMIInterpolation/patches/cyclicAMIPointPatch/cyclicAMIPointPatch.H
new file mode 100644
index 0000000000..ddfa71d7cd
--- /dev/null
+++ b/src/AMIInterpolation/patches/cyclicAMIPointPatch/cyclicAMIPointPatch.H
@@ -0,0 +1,121 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2011 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::cyclicAMIPointPatch
+
+Description
+    Cyclic AMI point patch - place holder only
+
+SourceFiles
+    cyclicAMIPointPatch.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef cyclicAMIPointPatch_H
+#define cyclicAMIPointPatch_H
+
+#include "coupledFacePointPatch.H"
+#include "cyclicAMIPolyPatch.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                      Class cyclicAMIPointPatch Declaration
+\*---------------------------------------------------------------------------*/
+
+class cyclicAMIPointPatch
+:
+    public coupledFacePointPatch
+{
+    // Private data
+
+        //- Local reference cast into the cyclic AMI patch
+        const cyclicAMIPolyPatch& cyclicAMIPolyPatch_;
+
+
+    // Private Member Functions
+
+        //- Disallow default construct as copy
+        cyclicAMIPointPatch(const cyclicAMIPointPatch&);
+
+        //- Disallow default assignment
+        void operator=(const cyclicAMIPointPatch&);
+
+
+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(cyclicAMIPolyPatch::typeName_());
+
+
+    // Constructors
+
+        //- Construct from components
+        cyclicAMIPointPatch
+        (
+            const polyPatch& patch,
+            const pointBoundaryMesh& bm
+        );
+
+
+    //- Destructor
+    virtual ~cyclicAMIPointPatch();
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/AMIInterpolation/patches/cyclicAMIPolyPatch/cyclicAMIPolyPatch.C b/src/AMIInterpolation/patches/cyclicAMIPolyPatch/cyclicAMIPolyPatch.C
index 7ae69325b7..ba2bf63630 100644
--- a/src/AMIInterpolation/patches/cyclicAMIPolyPatch/cyclicAMIPolyPatch.C
+++ b/src/AMIInterpolation/patches/cyclicAMIPolyPatch/cyclicAMIPolyPatch.C
@@ -29,6 +29,7 @@ License
 #include "polyMesh.H"
 #include "Time.H"
 #include "addToRunTimeSelectionTable.H"
+#include "faceAreaIntersect.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -72,7 +73,6 @@ Foam::label Foam::cyclicAMIPolyPatch::findFaceMaxRadius
 
 // * * * * * * * * * * * Protecetd Member Functions  * * * * * * * * * * * * //
 
-
 void Foam::cyclicAMIPolyPatch::calcTransforms()
 {
     if (size())
@@ -121,7 +121,7 @@ void Foam::cyclicAMIPolyPatch::calcTransforms
             << " has transform type " << transformTypeNames[transform_]
             << ", neighbour patch " << nbrPatchName_
             << " has transform type "
-            << nbrPatch().transformTypeNames[transform_]
+            << nbrPatch().transformTypeNames[nbrPatch().transform_]
             << exit(FatalError);
     }
 
@@ -176,8 +176,7 @@ void Foam::cyclicAMIPolyPatch::calcTransforms
         }
         case TRANSLATIONAL:
         {
-            // Transform 0 points.
-
+            // Transform 0 points
             if (debug)
             {
                 Pout<< "cyclicAMIPolyPatch::calcTransforms :"
@@ -185,64 +184,33 @@ void Foam::cyclicAMIPolyPatch::calcTransforms
                     << endl;
             }
 
-                const_cast<tensorField&>(forwardT()).clear();
-                const_cast<tensorField&>(reverseT()).clear();
-                const_cast<vectorField&>(separation()) = vectorField
-                (
-                    1,
-                    separationVector_
-                );
-                const_cast<boolList&>(collocated()) = boolList(1, false);
+            const_cast<tensorField&>(forwardT()).clear();
+            const_cast<tensorField&>(reverseT()).clear();
+            const_cast<vectorField&>(separation()) = vectorField
+            (
+                1,
+                separationVector_
+            );
+            const_cast<boolList&>(collocated()) = boolList(1, false);
+
             break;
         }
         default:
         {
-/*
-            // Assumes that cyclic is planar. This is also the initial
-            // condition for patches without faces.
-
-            // Determine the face with max area on both halves. These
-            // two faces are used to determine the transformation tensors
-            label max0I = findMaxArea(pp0.points(), pp0);
-            vector n0 = pp0[max0I].normal(pp0.points());
-            n0 /= mag(n0) + VSMALL;
-
-            label max1I = findMaxArea(pp1.points(), pp1);
-            vector n1 = pp1[max1I].normal(pp1.points());
-            n1 /= mag(n1) + VSMALL;
-
-            if (mag(n0 & n1) < 1 - matchTolerance())
+            if (debug)
             {
-                if (debug)
-                {
-                    Pout<< "cyclicAMIPolyPatch::calcTransforms :"
-                        << " Detected rotation :"
-                        << " n0:" << n0 << " n1:" << n1 << endl;
-                }
-
-                // Rotation (around origin)
-                const tensor revT(rotationTensor(n0, -n1));
-                const_cast<tensorField&>(forwardT()) = tensorField(1, revT.T());
-                const_cast<tensorField&>(reverseT()) = tensorField(1, revT);
-                const_cast<vectorField&>(separation()).setSize(0);
-                const_cast<boolList&>(collocated()) = boolList(1, false);
+                Pout<< "Assuming cyclic AMI pairs are colocated" << endl;
             }
-            else
-            {
-                // Parallel translation
-                const_cast<tensorField&>(forwardT()).clear();
-                const_cast<tensorField&>(reverseT()).clear();
-                const_cast<vectorField&>(separation()) = vectorField
-                (
-                    1,
-                    separationVector_
-                );
-                const_cast<boolList&>(collocated()) = boolList(1, false);
 
-            }
-*/
+            const_cast<tensorField&>(forwardT()).clear();
+            const_cast<tensorField&>(reverseT()).clear();
+            const_cast<vectorField&>(separation()) = vectorField
+            (
+                1,
+                vector::zero
+            );
+            const_cast<boolList&>(collocated()) = boolList(1, true);
 
-            notImplemented("calcTransforms - unknown transform clause");
             break;
         }
     }
@@ -253,19 +221,49 @@ void Foam::cyclicAMIPolyPatch::calcTransforms
 }
 
 
+const Foam::searchableSurface& Foam::cyclicAMIPolyPatch::surf()
+{
+    if (projectionSurfaceType_ == "patch")
+    {
+        notImplemented("projectionSurfaceType_ == patch")
+    }
+    else
+    {
+        surfPtr_ =
+            searchableSurface::New
+            (
+                projectionSurfaceType_,
+                IOobject
+                (
+                    projectionName_,
+                    boundaryMesh().mesh().time().constant(),
+                    "triSurface",
+                    boundaryMesh().mesh(),
+                    IOobject::MUST_READ,
+                    IOobject::NO_WRITE
+                ),
+                dict_
+            );
+    }
+
+    return surfPtr_();
+}
+
+
 const Foam::AMIPatchToPatchInterpolation& Foam::cyclicAMIPolyPatch::AMI()
 {
-    if (!AMIPtr_)
+    if (!AMIPtr_.valid() && owner())
     {
         const polyPatch& nbr = nbrPatch();
         pointField nbrPoints = nbrPatch().localPoints();
 
+        if (debug)
+        {
+            OFstream os(name() + "_neighbourPatch-org.obj");
+            meshTools::writeOBJ(os, nbrPatch().localFaces(), nbrPoints);
+        }
 
-const word myName = nbrPatch().nbrPatch().nbrPatchName();
-
-OFstream osNorg(myName + "_neighbourPatch-org.obj");
-meshTools::writeOBJ(osNorg, nbrPatch().localFaces(), nbrPoints);
-
+        // transform neighbour patch to local system
         transformPosition(nbrPoints);
         primitivePatch nbrPatch0
         (
@@ -277,31 +275,30 @@ meshTools::writeOBJ(osNorg, nbrPatch().localFaces(), nbrPoints);
             nbrPoints
         );
 
-OFstream osN(myName + "_neighbourPatch-trans.obj");
-meshTools::writeOBJ(osN, nbrPatch0.localFaces(), nbrPoints);
+        if (debug)
+        {
+            OFstream osN(name() + "_neighbourPatch-trans.obj");
+            meshTools::writeOBJ(osN, nbrPatch0.localFaces(), nbrPoints);
 
-OFstream osO(myName + "_ownerPatch.obj");
-meshTools::writeOBJ(osO, this->localFaces(), localPoints());
+            OFstream osO(name() + "_ownerPatch.obj");
+            meshTools::writeOBJ(osO, this->localFaces(), localPoints());
+        }
 
         // Construct/apply AMI interpolation to determine addressing and weights
-        AMIPtr_ = new AMIPatchToPatchInterpolation
+        AMIPtr_.reset
         (
-            *this,
-            nbrPatch0,
-            surfPtr_()
+            new AMIPatchToPatchInterpolation
+            (
+                *this,
+                nbrPatch0,
+                surf(),
+                faceAreaIntersect::tmMesh,
+                projectPoints_
+            )
         );
-
-
-        vectorField nbrPatchNf
-        (
-            nbrPatch().faceAreas()/mag(nbrPatch().faceAreas())
-        );
-        nbrPatchDelta_ =
-            nbrPatch0.faceCentres() - nbrPatch().faceCellCentres();
-        nbrPatchDelta_ = nbrPatchNf*(nbrPatchNf & nbrPatchDelta_);
     }
 
-    return *AMIPtr_;
+    return AMIPtr_();
 }
 
 
@@ -348,9 +345,11 @@ void Foam::cyclicAMIPolyPatch::movePoints
 
     calcTransforms();
 
-    deleteDemandDrivenData(AMIPtr_);
-
-    AMI();
+    if (owner())
+    {
+        AMIPtr_.clear();
+        AMI();
+    }
 }
 
 
@@ -363,8 +362,6 @@ void Foam::cyclicAMIPolyPatch::initUpdateMesh(PstreamBuffers& pBufs)
 void Foam::cyclicAMIPolyPatch::updateMesh(PstreamBuffers& pBufs)
 {
     polyPatch::updateMesh(pBufs);
-    deleteDemandDrivenData(AMIPtr_);
-//    deleteDemandDrivenData(surfPtr_);
 }
 
 
@@ -380,6 +377,7 @@ Foam::cyclicAMIPolyPatch::cyclicAMIPolyPatch
 )
 :
     coupledPolyPatch(name, size, start, index, bm),
+    dict_(dictionary::null),
     nbrPatchName_(word::null),
     nbrPatchID_(-1),
     transform_(UNKNOWN),
@@ -387,7 +385,10 @@ Foam::cyclicAMIPolyPatch::cyclicAMIPolyPatch
     rotationCentre_(point::zero),
     separationVector_(vector::zero),
     AMIPtr_(NULL),
-    surfPtr_(NULL)
+    surfPtr_(NULL),
+    projectionSurfaceType_(word::null),
+    projectPoints_(false),
+    projectionName_(word::null)
 {
     // Neighbour patch might not be valid yet so no transformation
     // calculation possible
@@ -403,6 +404,7 @@ Foam::cyclicAMIPolyPatch::cyclicAMIPolyPatch
 )
 :
     coupledPolyPatch(name, dict, index, bm),
+    dict_(dict),
     nbrPatchName_(dict.lookup("neighbourPatch")),
     nbrPatchID_(-1),
     transform_(UNKNOWN),
@@ -410,23 +412,10 @@ Foam::cyclicAMIPolyPatch::cyclicAMIPolyPatch
     rotationCentre_(point::zero),
     separationVector_(vector::zero),
     AMIPtr_(NULL),
-    surfPtr_
-    (
-        searchableSurface::New
-        (
-            dict.lookup("projectionSurfaceType"),
-            IOobject
-            (
-                dict.lookup("projectionSurfaceName"),
-                bm.mesh().time().constant(),
-                "triSurface",
-                bm.mesh(),
-                IOobject::MUST_READ,
-                IOobject::NO_WRITE
-            ),
-            dict
-        )
-    )
+    surfPtr_(NULL),
+    projectionSurfaceType_(dict.lookup("projectionSurfaceType")),
+    projectPoints_(readBool(dict.lookup("projectPoints"))),
+    projectionName_(dict.lookupOrDefault("surfaceName", name))
 {
     if (nbrPatchName_ == name)
     {
@@ -500,6 +489,7 @@ Foam::cyclicAMIPolyPatch::cyclicAMIPolyPatch
 )
 :
     coupledPolyPatch(pp, bm),
+    dict_(dictionary::null),
     nbrPatchName_(pp.nbrPatchName_),
     nbrPatchID_(-1),
     transform_(UNKNOWN),
@@ -507,7 +497,10 @@ Foam::cyclicAMIPolyPatch::cyclicAMIPolyPatch
     rotationCentre_(point::zero),
     separationVector_(vector::zero),
     AMIPtr_(NULL),
-    surfPtr_(NULL)
+    surfPtr_(NULL),
+    projectionSurfaceType_(word::null),
+    projectPoints_(false),
+    projectionName_(word::null)
 {
     // Neighbour patch might not be valid yet so no transformation
     // calculation possible
@@ -525,6 +518,7 @@ Foam::cyclicAMIPolyPatch::cyclicAMIPolyPatch
 )
 :
     coupledPolyPatch(pp, bm, index, newSize, newStart),
+    dict_(dictionary::null),
     nbrPatchName_(nbrPatchName),
     nbrPatchID_(-1),
     transform_(UNKNOWN),
@@ -532,7 +526,10 @@ Foam::cyclicAMIPolyPatch::cyclicAMIPolyPatch
     rotationCentre_(point::zero),
     separationVector_(vector::zero),
     AMIPtr_(NULL),
-    surfPtr_(NULL)
+    surfPtr_(NULL),
+    projectionSurfaceType_(word::null),
+    projectPoints_(false),
+    projectionName_(word::null)
 {
     if (nbrPatchName_ == name())
     {
@@ -564,6 +561,7 @@ Foam::cyclicAMIPolyPatch::cyclicAMIPolyPatch
 )
 :
     coupledPolyPatch(pp, bm, index, mapAddressing, newStart),
+    dict_(pp.dict_),
     nbrPatchName_(pp.nbrPatchName_),
     nbrPatchID_(-1),
     transform_(pp.transform_),
@@ -571,7 +569,10 @@ Foam::cyclicAMIPolyPatch::cyclicAMIPolyPatch
     rotationCentre_(pp.rotationCentre_),
     separationVector_(pp.separationVector_),
     AMIPtr_(NULL),
-    surfPtr_(NULL)
+    surfPtr_(NULL),
+    projectionSurfaceType_(pp.projectionSurfaceType_),
+    projectPoints_(pp.projectPoints_),
+    projectionName_(pp.projectionName_)
 {}
 
 
@@ -619,6 +620,12 @@ Foam::label Foam::cyclicAMIPolyPatch::nbrPatchID() const
 }
 
 
+bool Foam::cyclicAMIPolyPatch::owner() const
+{
+    return index() < nbrPatchID();
+}
+
+
 void Foam::cyclicAMIPolyPatch::transformPosition(pointField& l) const
 {
     if (!parallel())
@@ -712,9 +719,11 @@ void Foam::cyclicAMIPolyPatch::calcGeometry
         nbrAreas
     );
 
-    deleteDemandDrivenData(AMIPtr_);
-
-    AMI();
+    if (owner())
+    {
+        AMIPtr_.clear();
+        AMI();
+    }
 }
 
 
@@ -748,6 +757,45 @@ bool Foam::cyclicAMIPolyPatch::order
 void Foam::cyclicAMIPolyPatch::write(Ostream& os) const
 {
     coupledPolyPatch::write(os);
+    os.writeKeyword("neighbourPatch") << nbrPatchName_
+        << token::END_STATEMENT << nl;
+    os.writeKeyword("projectPoints") << projectPoints_
+        << token::END_STATEMENT << nl;
+    os.writeKeyword("projectionSurfaceType") << projectionSurfaceType_
+        << token::END_STATEMENT << nl;
+    os.writeKeyword("surfaceName") << projectionName_
+        << token::END_STATEMENT << nl;
+    switch (transform_)
+    {
+        case ROTATIONAL:
+        {
+            os.writeKeyword("transform") << transformTypeNames[transform_]
+                << token::END_STATEMENT << nl;
+            os.writeKeyword("rotationAxis") << rotationAxis_
+                << token::END_STATEMENT << nl;
+            os.writeKeyword("rotationCentre") << rotationCentre_
+                << token::END_STATEMENT << nl;
+            break;
+        }
+        case TRANSLATIONAL:
+        {
+            os.writeKeyword("transform") << transformTypeNames[transform_]
+                << token::END_STATEMENT << nl;
+            os.writeKeyword("separationVector") << separationVector_
+                << token::END_STATEMENT << nl;
+            break;
+        }
+        case NOORDERING:
+        {
+            os.writeKeyword("transform") << transformTypeNames[transform_]
+                << token::END_STATEMENT << nl;
+            break;
+        }
+        default:
+        {
+            // no additional info to write
+        }
+    }
 }
 
 
diff --git a/src/AMIInterpolation/patches/cyclicAMIPolyPatch/cyclicAMIPolyPatch.H b/src/AMIInterpolation/patches/cyclicAMIPolyPatch/cyclicAMIPolyPatch.H
index c54ae0f853..cfd20c040f 100644
--- a/src/AMIInterpolation/patches/cyclicAMIPolyPatch/cyclicAMIPolyPatch.H
+++ b/src/AMIInterpolation/patches/cyclicAMIPolyPatch/cyclicAMIPolyPatch.H
@@ -57,15 +57,15 @@ private:
 
     // Private data
 
+        //- Dictionary used during construction
+        const dictionary dict_;
+
         //- Name of other half
         const word nbrPatchName_;
 
         //- Index of other half
         mutable label nbrPatchID_;
 
-        //- Neighbour delta field to *this patch
-        vectorField nbrPatchDelta_;
-
 
         // Transformations
 
@@ -89,11 +89,20 @@ private:
 
 
         //- AMI interpolation class
-        AMIPatchToPatchInterpolation* AMIPtr_;
+        autoPtr<AMIPatchToPatchInterpolation> AMIPtr_;
 
         //- Projection surface
         autoPtr<searchableSurface> surfPtr_;
 
+        //- Projection surface type
+        word projectionSurfaceType_;
+
+        //- Flag to activate projection
+        bool projectPoints_;
+
+        //- Name of projection object (if read)
+        const word projectionName_;
+
 
     // Private Member Functions
 
@@ -138,9 +147,6 @@ protected:
 
 public:
 
-//    //- Declare friendship with processorCyclicPolyPatch
-//    friend class processorCyclicPolyPatch;
-
     //- Runtime type information
     TypeName("cyclicAMI");
 
@@ -255,60 +261,37 @@ public:
         // Access
 
             //- Neighbour patch name
-            const word& nbrPatchName() const
-            {
-                return nbrPatchName_;
-            }
+            inline const word& nbrPatchName() const;
 
             //- Neighbour patch ID
             virtual label nbrPatchID() const;
 
-            //- Does this side own the patch ?
-            virtual bool owner() const
-            {
-                return index() < nbrPatchID();
-            }
+            //- Does this side own the patch?
+            virtual bool owner() const;
 
-            const cyclicAMIPolyPatch& nbrPatch() const
-            {
-                const polyPatch& pp = this->boundaryMesh()[nbrPatchID()];
-                return refCast<const cyclicAMIPolyPatch>(pp);
-            }
+            //- Return a reference to the neihgjbour patch
+            inline const cyclicAMIPolyPatch& nbrPatch() const;
 
+            //- Return a reference to the projection surface
+            const searchableSurface& surf();
 
-            const vectorField& nbrPatchDelta() const
-            {
-                return nbrPatchDelta_;
-            }
-
+            //- Return a reference to the AMI interpolator
             const AMIPatchToPatchInterpolation& AMI();
 
 
             // Transformations
 
                 //- Type of transform
-                transformType transform() const
-                {
-                    return transform_;
-                }
+                inline transformType transform() const;
 
                 //- Axis of rotation for rotational cyclic AMI
-                const vector& rotationAxis() const
-                {
-                    return rotationAxis_;
-                }
+                inline const vector& rotationAxis() const;
 
                 //- point on axis of rotation for rotational cyclic AMI
-                const point& rotationCentre() const
-                {
-                    return rotationCentre_;
-                }
+                inline const point& rotationCentre() const;
 
                 //- Translation vector for translational cyclic AMI
-                const vector& separationVector() const
-                {
-                    return separationVector_;
-                }
+                inline const vector& separationVector() const;
 
                 //- Transform patch-based positions from nbr side to this side
                 virtual void transformPosition(pointField&) const;
@@ -320,17 +303,22 @@ public:
                     const label faceI
                 ) const;
 
-                template<class Type>
-                tmp<Field<Type> > interpolateToSource(const Field<Type>& fld) const
-                {
-                    return AMIPtr_->interpolateToSource(fld);
-                }
 
+            // Interpolations
+
+                //- Interpolate from target field to source
                 template<class Type>
-                tmp<Field<Type> > interpolateToSource(const tmp<Field<Type> >& tFld) const
-                {
-                    return AMIPtr_->interpolateToSource(tFld);
-                }
+                tmp<Field<Type> > interpolateToSource
+                (
+                    const Field<Type>& fld
+                ) const;
+
+                //- Interpolate from target tmp field to source
+                template<class Type>
+                tmp<Field<Type> > interpolateToSource
+                (
+                    const tmp<Field<Type> >& tFld
+                ) const;
 
 
         //- Calculate the patch geometry
@@ -377,6 +365,16 @@ public:
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
+#include "cyclicAMIPolyPatchI.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+    #include "cyclicAMIPolyPatchTemplates.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
 #endif
 
 // ************************************************************************* //
diff --git a/src/AMIInterpolation/patches/cyclicAMIPolyPatch/cyclicAMIPolyPatchI.H b/src/AMIInterpolation/patches/cyclicAMIPolyPatch/cyclicAMIPolyPatchI.H
new file mode 100644
index 0000000000..8bb8badc77
--- /dev/null
+++ b/src/AMIInterpolation/patches/cyclicAMIPolyPatch/cyclicAMIPolyPatchI.H
@@ -0,0 +1,67 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2011 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+inline const Foam::word& Foam::cyclicAMIPolyPatch::nbrPatchName() const
+{
+    return nbrPatchName_;
+}
+
+
+inline const Foam::cyclicAMIPolyPatch&
+Foam::cyclicAMIPolyPatch::nbrPatch() const
+{
+    const polyPatch& pp = this->boundaryMesh()[nbrPatchID()];
+    return refCast<const cyclicAMIPolyPatch>(pp);
+}
+
+
+inline Foam::coupledPolyPatch::transformType
+Foam::cyclicAMIPolyPatch::transform() const
+{
+    return transform_;
+}
+
+
+inline const Foam::vector& Foam::cyclicAMIPolyPatch::rotationAxis() const
+{
+    return rotationAxis_;
+}
+
+
+inline const Foam::point& Foam::cyclicAMIPolyPatch::rotationCentre() const
+{
+    return rotationCentre_;
+}
+
+
+inline const Foam::vector& Foam::cyclicAMIPolyPatch::separationVector() const
+{
+    return separationVector_;
+}
+
+
+// ************************************************************************* //
diff --git a/src/AMIInterpolation/patches/cyclicAMIPolyPatch/cyclicAMIPolyPatchTemplates.C b/src/AMIInterpolation/patches/cyclicAMIPolyPatch/cyclicAMIPolyPatchTemplates.C
new file mode 100644
index 0000000000..0e0243c5ef
--- /dev/null
+++ b/src/AMIInterpolation/patches/cyclicAMIPolyPatch/cyclicAMIPolyPatchTemplates.C
@@ -0,0 +1,64 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2011 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+//#include "cyclicAMIPolyPatch.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+template<class Type>
+Foam::tmp<Foam::Field<Type> > Foam::cyclicAMIPolyPatch::interpolateToSource
+(
+    const Field<Type>& fld
+) const
+{
+    if (owner())
+    {
+        return AMIPtr_->interpolateToSource(fld);
+    }
+    else
+    {
+        return nbrPatch().AMIPtr_->interpolateToTarget(fld);
+    }
+}
+
+
+template<class Type>
+Foam::tmp<Foam::Field<Type> > Foam::cyclicAMIPolyPatch::interpolateToSource
+(
+    const tmp<Field<Type> >& tFld
+) const
+{
+    if (owner())
+    {
+        return AMIPtr_->interpolateToSource(tFld);
+    }
+    else
+    {
+        return nbrPatch().AMIPtr_->interpolateToTarget(tFld);
+    }
+}
+
+
+// ************************************************************************* //
diff --git a/src/OpenFOAM/meshes/boundBox/boundBox.C b/src/OpenFOAM/meshes/boundBox/boundBox.C
index 823b82b56a..63795f9145 100644
--- a/src/OpenFOAM/meshes/boundBox/boundBox.C
+++ b/src/OpenFOAM/meshes/boundBox/boundBox.C
@@ -165,16 +165,10 @@ Foam::tmp<Foam::pointField> Foam::boundBox::points() const
 
 void Foam::boundBox::inflate(const scalar s)
 {
-    boundBox bb(*this);
+    vector ext = vector::one*s*mag();
 
-    vector dir = bb.span();
-    scalar magDir = Foam::mag(dir);
-    dir /= magDir;
-
-    scalar ext = s*magDir;
-
-    min_ -= dir*ext;
-    max_ += dir*ext;
+    min_ -= ext;
+    max_ += ext;
 }
 
 

From f9e1917b5f522837de7a88dffd451a1c50f28828 Mon Sep 17 00:00:00 2001
From: andy <andy>
Date: Fri, 29 Jul 2011 10:17:02 +0100
Subject: [PATCH 05/45] ENH: Added cell zone option to solid body point motion

---
 .../solidBodyMotionFvMesh.C                   | 89 +++++++++++++++++--
 .../solidBodyMotionFvMesh.H                   |  5 +-
 2 files changed, 85 insertions(+), 9 deletions(-)

diff --git a/src/dynamicFvMesh/solidBodyMotionFvMesh/solidBodyMotionFvMesh.C b/src/dynamicFvMesh/solidBodyMotionFvMesh/solidBodyMotionFvMesh.C
index 9351673f14..c0a3d78127 100644
--- a/src/dynamicFvMesh/solidBodyMotionFvMesh/solidBodyMotionFvMesh.C
+++ b/src/dynamicFvMesh/solidBodyMotionFvMesh/solidBodyMotionFvMesh.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2004-2010 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2004-2011 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -27,6 +27,9 @@ License
 #include "addToRunTimeSelectionTable.H"
 #include "volFields.H"
 #include "transformField.H"
+#include "cellZoneMesh.H"
+#include "boolList.H"
+#include "syncTools.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
@@ -69,8 +72,58 @@ Foam::solidBodyMotionFvMesh::solidBodyMotionFvMesh(const IOobject& io)
             IOobject::MUST_READ,
             IOobject::NO_WRITE
         )
-    )
-{}
+    ),
+    pointIDs_()
+{
+    word cellZoneName =
+        dynamicMeshCoeffs_.lookupOrDefault<word>("cellZone", "none");
+
+    if (cellZoneName != "none")
+    {
+        label zoneI = cellZones().findZoneID(cellZoneName);
+        Info<< "Applying solid body motion to cellZone " << cellZoneName
+            << endl;
+
+        const cellZone& cz = cellZones()[zoneI];
+
+
+        // collect point IDs of points in cell zone
+
+        boolList movePts(nPoints(), false);
+
+        forAll(cz, i)
+        {
+            label cellI = cz[i];
+            const cell& c = cells()[cellI];
+            forAll(c, j)
+            {
+                const face& f = faces()[c[j]];
+                forAll(f, k)
+                {
+                    label pointI = f[k];
+                    movePts[pointI] = true;
+                }
+            }
+        }
+
+        syncTools::syncPointList(*this, movePts, orEqOp<bool>(), false);
+
+        DynamicList<label> ptIDs(nPoints());
+        forAll(movePts, i)
+        {
+            if (movePts[i])
+            {
+                ptIDs.append(i);
+            }
+        }
+
+        pointIDs_.transfer(ptIDs);
+    }
+    else
+    {
+        Info<< "Applying solid body motion to entire mesh" << endl;
+    }
+}
 
 
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
@@ -85,11 +138,31 @@ bool Foam::solidBodyMotionFvMesh::update()
 {
     static bool hasWarned = false;
 
-    fvMesh::movePoints
-    (
-        transform(SBMFPtr_().transformation(),
-        undisplacedPoints_)
-    );
+    if (pointIDs_.size() > 0)
+    {
+        pointField transformedPts(undisplacedPoints_);
+
+        UIndirectList<point>(transformedPts, pointIDs_) =
+            transform
+            (
+                SBMFPtr_().transformation(),
+                pointField(transformedPts, pointIDs_)
+            );
+
+        fvMesh::movePoints(transformedPts);
+    }
+    else
+    {
+        fvMesh::movePoints
+        (
+            transform
+            (
+                SBMFPtr_().transformation(),
+                undisplacedPoints_
+            )
+        );
+    }
+
 
     if (foundObject<volVectorField>("U"))
     {
diff --git a/src/dynamicFvMesh/solidBodyMotionFvMesh/solidBodyMotionFvMesh.H b/src/dynamicFvMesh/solidBodyMotionFvMesh/solidBodyMotionFvMesh.H
index 748d2f3f2f..cc3b4ce201 100644
--- a/src/dynamicFvMesh/solidBodyMotionFvMesh/solidBodyMotionFvMesh.H
+++ b/src/dynamicFvMesh/solidBodyMotionFvMesh/solidBodyMotionFvMesh.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2004-2010 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2004-2011 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -65,6 +65,9 @@ class solidBodyMotionFvMesh
         //- The reference points which are transformed
         pointIOField undisplacedPoints_;
 
+        //- Points to move when cell zone is supplied
+        labelList pointIDs_;
+
 
     // Private Member Functions
 

From c6c83f65de0c166ee0a982af2a38fd635f13bd77 Mon Sep 17 00:00:00 2001
From: andy <andy>
Date: Fri, 29 Jul 2011 10:18:31 +0100
Subject: [PATCH 06/45] STYLE: Correct spelling error in comment

---
 .../solidBodyMotionFvMesh/solidBodyMotionFvMesh.H             | 2 +-
 .../fvPatchFields/constraint/cyclic/cyclicFvPatchField.H      | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/dynamicFvMesh/solidBodyMotionFvMesh/solidBodyMotionFvMesh.H b/src/dynamicFvMesh/solidBodyMotionFvMesh/solidBodyMotionFvMesh.H
index cc3b4ce201..20178bff6b 100644
--- a/src/dynamicFvMesh/solidBodyMotionFvMesh/solidBodyMotionFvMesh.H
+++ b/src/dynamicFvMesh/solidBodyMotionFvMesh/solidBodyMotionFvMesh.H
@@ -47,7 +47,7 @@ namespace Foam
 {
 
 /*---------------------------------------------------------------------------*\
-                           Class solidBodyMotionFvMesh Declaration
+                   Class solidBodyMotionFvMesh Declaration
 \*---------------------------------------------------------------------------*/
 
 class solidBodyMotionFvMesh
diff --git a/src/finiteVolume/fields/fvPatchFields/constraint/cyclic/cyclicFvPatchField.H b/src/finiteVolume/fields/fvPatchFields/constraint/cyclic/cyclicFvPatchField.H
index bafdee2dae..252fbbad29 100644
--- a/src/finiteVolume/fields/fvPatchFields/constraint/cyclic/cyclicFvPatchField.H
+++ b/src/finiteVolume/fields/fvPatchFields/constraint/cyclic/cyclicFvPatchField.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2004-2010 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2004-2011 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -170,7 +170,7 @@ public:
 
         // Cyclic coupled interface functions
 
-            //- Does the patch field perform the transfromation
+            //- Does the patch field perform the transformation
             virtual bool doTransform() const
             {
                 return !(cyclicPatch_.parallel() || pTraits<Type>::rank == 0);

From 8ffd5df908227dc5ba4703b2a1ea8a75da34e4c2 Mon Sep 17 00:00:00 2001
From: andy <andy>
Date: Mon, 1 Aug 2011 18:04:00 +0100
Subject: [PATCH 07/45] ENH: Initial commit of parallel AMI functionality

---
 src/AMIInterpolation/AMIInterpolation.C | 980 +++++++++++++++++++-----
 src/AMIInterpolation/AMIInterpolation.H | 115 ++-
 2 files changed, 876 insertions(+), 219 deletions(-)

diff --git a/src/AMIInterpolation/AMIInterpolation.C b/src/AMIInterpolation/AMIInterpolation.C
index 99fae0b857..799116e027 100644
--- a/src/AMIInterpolation/AMIInterpolation.C
+++ b/src/AMIInterpolation/AMIInterpolation.C
@@ -27,8 +27,9 @@ License
 #include "Random.H"
 #include "treeDataPrimitivePatch.H"
 #include "indexedOctree.H"
-#include "primitivePatch.H"
 #include "meshTools.H"
+#include "mergePoints.H"
+#include "globalIndex.H"
 
 #include "vtkSurfaceWriter.H"
 
@@ -95,44 +96,10 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::checkPatches
 {
     const scalar maxBoundsError = 0.05;
 
-    // sanity checks
+    // check bounds of source and target
     boundBox bbSrc(srcPatch.points(), srcPatch.meshPoints());
     boundBox bbTgt(tgtPatch.points(), tgtPatch.meshPoints());
-    boundBox bbSurf(bbTgt); // USE POINTS OF SURFACE!!!!!!!!!!!!!!!!!!
 
-
-    // projection surface bounds - check against bounds of source and target
-
-    bbSurf.inflate(maxBoundsError);
-
-    if (!bbSurf.contains(bbSrc))
-    {
-        WarningIn
-        (
-            "AMIInterpolation<SourcePatch, TargetPatch>::checkPatches"
-            "("
-                "const primitivePatch&, "
-                "const primitivePatch&"
-            ")"
-        )   << "Source patch is larger than, or misaligned with the "
-            << "projection surface" << endl;
-    }
-
-    if (!bbSurf.contains(bbTgt))
-    {
-        WarningIn
-        (
-            "AMIInterpolation<SourcePatch, TargetPatch>::checkPatches"
-            "("
-                "const primitivePatch&, "
-                "const primitivePatch&"
-            ")"
-        )   << "Target patch is larger than, or misaligned with the "
-            << "projection surface" << endl;
-    }
-
-
-    // check bounds of source and target
     bbTgt.inflate(maxBoundsError);
 
     if (!bbTgt.contains(bbSrc))
@@ -153,6 +120,354 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::checkPatches
 }
 
 
+template<class SourcePatch, class TargetPatch>
+Foam::label
+Foam::AMIInterpolation<SourcePatch, TargetPatch>::calcOverlappingProcs
+(
+    const List<treeBoundBoxList>& procBb,
+    const treeBoundBox& bb,
+    boolList& overlaps
+)
+{
+    overlaps.setSize(procBb.size());
+    overlaps = false;
+
+    label nOverlaps = 0;
+
+    forAll(procBb, procI)
+    {
+        const List<treeBoundBox>& bbs = procBb[procI];
+
+        forAll(bbs, bbI)
+        {
+            if (bbs[bbI].overlaps(bb))
+            {
+                overlaps[procI] = true;
+                nOverlaps++;
+                break;
+            }
+        }
+    }
+    return nOverlaps;
+}
+
+
+template<class SourcePatch, class TargetPatch>
+void Foam::AMIInterpolation<SourcePatch, TargetPatch>::distributePatches
+(
+    const mapDistribute& map,
+    const primitivePatch& pp,
+    List<faceList>& faces,
+    List<pointField>& points
+)
+{
+    PstreamBuffers pBufs(Pstream::nonBlocking);
+
+    for (label domain = 0; domain < Pstream::nProcs(); domain++)
+    {
+        const labelList& sendElems = map.subMap()[domain];
+
+        if (domain != Pstream::myProcNo() && sendElems.size())
+        {
+            faceList subFaces(UIndirectList<face>(pp, sendElems));
+            primitivePatch subPatch
+            (
+                SubList<face>(subFaces, subFaces.size()),
+                pp.points()
+            );
+
+            if (debug)
+            {
+                Pout<< "distributePatches: to processor " << domain
+                    << " sending faces " << subPatch.faceCentres() << endl;
+            }
+
+            UOPstream toDomain(domain, pBufs);
+            toDomain << subPatch.localFaces() << subPatch.localPoints();
+        }
+    }
+
+    // Start receiving
+    pBufs.finishedSends();
+
+    faces.setSize(Pstream::nProcs());
+    points.setSize(Pstream::nProcs());
+
+    {
+        // Set up 'send' to myself
+        const labelList& sendElems = map.subMap()[Pstream::myProcNo()];
+        faceList subFaces(UIndirectList<face>(pp, sendElems));
+        primitivePatch subPatch
+        (
+            SubList<face>(subFaces, subFaces.size()),
+            pp.points()
+        );
+
+        // Receive
+        if (debug)
+        {
+            Pout<< "distributePatches: to processor " << Pstream::myProcNo()
+                << " sending faces " << subPatch.faceCentres() << endl;
+        }
+
+        faces[Pstream::myProcNo()] = subPatch.localFaces();
+        points[Pstream::myProcNo()] = subPatch.localPoints();
+    }
+
+    // Consume
+    for (label domain = 0; domain < Pstream::nProcs(); domain++)
+    {
+        const labelList& recvElems = map.constructMap()[domain];
+
+        if (domain != Pstream::myProcNo() && recvElems.size())
+        {
+            UIPstream str(domain, pBufs);
+            faceList localFaces(str);
+            pointField localPoints(str);
+
+            faces[domain] = localFaces;
+            points[domain] = localPoints;
+        }
+    }
+}
+
+
+template<class SourcePatch, class TargetPatch>
+void Foam::AMIInterpolation<SourcePatch, TargetPatch>::
+distributeAndMergePatches
+(
+    const mapDistribute& map,
+    const primitivePatch& tgtPatch,
+    faceList& tgtFaces,
+    pointField& tgtPoints
+)
+{
+    // Exchange per-processor data
+    List<faceList> allFaces;
+    List<pointField> allPoints;
+    distributePatches(map, tgtPatch, allFaces, allPoints);
+
+    // Renumber and flatten
+    label nFaces = 0;
+    label nPoints = 0;
+    forAll(allFaces, procI)
+    {
+        nFaces += allFaces[procI].size();
+        nPoints += allPoints[procI].size();
+    }
+    tgtFaces.setSize(nFaces);
+    nFaces = 0;
+    tgtPoints.setSize(nPoints);
+    nPoints = 0;
+
+    // My own data first
+    {
+        const faceList& fcs = allFaces[Pstream::myProcNo()];
+        forAll(fcs, i)
+        {
+            const face& f = fcs[i];
+            face& newF = tgtFaces[nFaces++];
+            newF.setSize(f.size());
+            forAll(f, fp)
+            {
+                newF[fp] = f[fp] + nPoints;
+            }
+        }
+        const pointField& pts = allPoints[Pstream::myProcNo()];
+        forAll(pts, i)
+        {
+            tgtPoints[nPoints++] = pts[i];
+        }
+    }
+
+    // Other proc data first
+    forAll(allFaces, procI)
+    {
+        if (procI != Pstream::myProcNo())
+        {
+            const faceList& fcs = allFaces[procI];
+            forAll(fcs, i)
+            {
+                const face& f = fcs[i];
+                face& newF = tgtFaces[nFaces++];
+                newF.setSize(f.size());
+                forAll(f, fp)
+                {
+                    newF[fp] = f[fp] + nPoints;
+                }
+            }
+            const pointField& pts = allPoints[procI];
+            forAll(pts, i)
+            {
+                tgtPoints[nPoints++] = pts[i];
+            }
+        }
+    }
+
+    // Merge
+    labelList oldToNew;
+    pointField newTgtPoints;
+    bool hasMerged = mergePoints
+    (
+        tgtPoints,
+        SMALL,
+        false,
+        oldToNew,
+        newTgtPoints
+    );
+
+    if (hasMerged)
+    {
+        if (debug)
+        {
+            Pout<< "Merged from " << tgtPoints.size()
+                << " down to " << newTgtPoints.size() << " points" << endl;
+        }
+
+        tgtPoints.transfer(newTgtPoints);
+        forAll(tgtFaces, i)
+        {
+            inplaceRenumber(oldToNew, tgtFaces[i]);
+        }
+    }
+}
+
+
+template<class SourcePatch, class TargetPatch>
+Foam::autoPtr<Foam::mapDistribute>
+Foam::AMIInterpolation<SourcePatch, TargetPatch>::calcProcMap
+(
+    const primitivePatch& srcPatch,
+    const primitivePatch& tgtPatch
+)
+{
+    // Get decomposition of patch
+    List<treeBoundBoxList> procBb(Pstream::nProcs());
+
+    if (srcPatch.size())
+    {
+        procBb[Pstream::myProcNo()] = treeBoundBoxList
+        (
+            1,  // For now single bounding box per proc
+            treeBoundBox
+            (
+                srcPatch.points(),
+                srcPatch.meshPoints()
+            )
+        );
+    }
+    else
+    {
+        procBb[Pstream::myProcNo()] = treeBoundBoxList();
+    }
+
+    forAll(procBb[Pstream::myProcNo()], bbI)
+    {
+        treeBoundBox& bb = procBb[Pstream::myProcNo()][bbI];
+        for (direction dir = 0; dir < vector::nComponents; dir++)
+        {
+            if (mag(bb.max()[dir] - bb.max()[dir]) < SMALL)
+            {
+                bb.min()[dir] -= 1E-6;
+                bb.max()[dir] += 1E-6;
+            }
+        }
+    }
+
+    Pstream::gatherList(procBb);
+    Pstream::scatterList(procBb);
+
+    // Determine which faces of tgtPatch overlaps srcPatch per proc
+    const faceList& faces = tgtPatch.localFaces();
+    const pointField& points = tgtPatch.localPoints();
+
+    labelListList sendMap;
+
+    {
+        // Per processor indices into all segments to send
+        List<DynamicList<label> > dynSendMap(Pstream::nProcs());
+
+        // Work array - whether processor bb overlaps the face bounds
+        boolList procBbOverlaps(Pstream::nProcs());
+
+        forAll(faces, faceI)
+        {
+            if (faces[faceI].size())
+            {
+                treeBoundBox faceBb(points, faces[faceI]);
+
+                // Find the processor this face overlaps
+                calcOverlappingProcs(procBb, faceBb, procBbOverlaps);
+
+                forAll(procBbOverlaps, procI)
+                {
+                    if (procBbOverlaps[procI])
+                    {
+                        dynSendMap[procI].append(faceI);
+                    }
+                }
+            }
+        }
+
+        // Convert dynamicList to labelList
+        sendMap.setSize(Pstream::nProcs());
+        forAll(sendMap, procI)
+        {
+            sendMap[procI].transfer(dynSendMap[procI]);
+        }
+    }
+
+
+    // Send over how many faces I need to receive
+    labelListList sendSizes(Pstream::nProcs());
+    sendSizes[Pstream::myProcNo()].setSize(Pstream::nProcs());
+    forAll(sendMap, procI)
+    {
+        sendSizes[Pstream::myProcNo()][procI] = sendMap[procI].size();
+    }
+    Pstream::gatherList(sendSizes);
+    Pstream::scatterList(sendSizes);
+
+
+    // Determine order of receiving
+    labelListList constructMap(Pstream::nProcs());
+
+    // My local segment first
+    constructMap[Pstream::myProcNo()] = identity
+    (
+        sendMap[Pstream::myProcNo()].size()
+    );
+
+    label segmentI = constructMap[Pstream::myProcNo()].size();
+    forAll(constructMap, procI)
+    {
+        if (procI != Pstream::myProcNo())
+        {
+            // What I need to receive is what other processor is sending to me
+            label nRecv = sendSizes[procI][Pstream::myProcNo()];
+            constructMap[procI].setSize(nRecv);
+
+            for (label i = 0; i < nRecv; i++)
+            {
+                constructMap[procI][i] = segmentI++;
+            }
+        }
+    }
+
+    autoPtr<mapDistribute> mapPtr
+    (
+        new mapDistribute
+        (
+            segmentI,       // size after construction
+            sendMap.xfer(),
+            constructMap.xfer()
+        )
+    );
+
+    return mapPtr;
+}
+
+
 template<class SourcePatch, class TargetPatch>
 void Foam::AMIInterpolation<SourcePatch, TargetPatch>::projectPointsToSurface
 (
@@ -252,19 +567,6 @@ Foam::label Foam::AMIInterpolation<SourcePatch, TargetPatch>::findTargetFace
     {
         targetFaceI = sample.index();
     }
-    else
-    {
-        FatalErrorIn
-        (
-            "Foam::label Foam::cyclicAMIPolyPatch::findTargetFace"
-            "("
-                "const label, "
-                "const primitivePatch&"
-                "const primitivePatch&"
-            ") const"
-        )   << "Unable to find target face for source face" << srcFaceI
-            << abort(FatalError);
-    }
 
     return targetFaceI;
 }
@@ -397,16 +699,24 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::setNextFaces
                 << "target face" << endl;
         }
 
+//        foundNextSeed = false;
         for (label faceI = startSeedI_; faceI < mapFlag.size(); faceI++)
         {
             if (mapFlag[faceI])
             {
-                startSeedI_ = faceI + 1;
+                if (!foundNextSeed)
+                {
+                    startSeedI_ = faceI + 1;
+                    foundNextSeed = true;
+                }
 
                 srcFaceI = faceI;
                 tgtFaceI = findTargetFace(srcFaceI, srcPatch0, tgtPatch0);
 
-                return;
+                if (tgtFaceI >= 0)
+                {
+                    return;
+                }
             }
         }
 
@@ -465,116 +775,29 @@ Foam::scalar Foam::AMIInterpolation<SourcePatch, TargetPatch>::interArea
 }
 
 
-template<class SourcePatch, class TargetPatch>
-void Foam::AMIInterpolation<SourcePatch, TargetPatch>::normaliseWeights
-(
-    const word& patchType,
-    const primitivePatch& patch,
-    const pointField& points,
-    const List<DynamicList<label> >& addr,
-    List<DynamicList<scalar> >& wght,
-    const bool output
-)
-{
-    scalarField wghtSum(patch.size(), 0.0);
-
-    // normalise weights by face areas
-    forAll(wght, faceI)
-    {
-        const DynamicList<label>& addressing = addr[faceI];
-        forAll(addressing, addrI)
-        {
-            const scalar faceArea = patch[faceI].mag(points);
-            wght[faceI][addrI] /= faceArea;
-            wghtSum[faceI] += wght[faceI][addrI];
-        }
-    }
-
-//    if (debug)
-    {
-        vtkSurfaceWriter writer;
-
-        writer.write
-        (
-            "VTK",
-            patchType,
-            patch.localPoints(),
-            patch.localFaces(),
-            "weights",
-            wghtSum,
-            false
-        );
-    }
-
-    if (output)
-    {
-        Info<< "AMI: Patch " << patchType << " weights min/max = "
-            << min(wghtSum) << ", " << max(wghtSum) << endl;
-    }
-
-
-    forAll(wght, faceI)
-    {
-        const DynamicList<label>& addressing = addr[faceI];
-        forAll(addressing, addrI)
-        {
-            wght[faceI][addrI] /= wghtSum[faceI];
-        }
-    }
-}
-
-
-// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
-
-template<class SourcePatch, class TargetPatch>
-Foam::AMIInterpolation<SourcePatch, TargetPatch>::AMIInterpolation
-(
-    const SourcePatch& srcPatch,
-    const TargetPatch& tgtPatch,
-    const searchableSurface& surf,
-    const faceAreaIntersect::triangulationMode& triMode,
-    const bool projectPoints
-)
-:
-    srcAddress_(),
-    srcWeights_(),
-    tgtAddress_(),
-    tgtWeights_(),
-    startSeedI_(0),
-    triMode_(triMode),
-    projectPoints_(projectPoints)
-{
-    if (srcPatch.size() && tgtPatch.size())
-    {
-        checkPatches(srcPatch, tgtPatch);
-
-        Info<< "AMI: Creating interpolation addressing and weights" << nl
-            << "    Source faces = " << srcPatch.size() << nl
-            << "    Target faces = " << tgtPatch.size() << endl;
-
-        calcAddressing(srcPatch, tgtPatch, surf);
-    }
-}
-
-
-
-// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
-
-template<class SourcePatch, class TargetPatch>
-Foam::AMIInterpolation<SourcePatch, TargetPatch>::~AMIInterpolation()
-{}
-
-
-// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
-
 template<class SourcePatch, class TargetPatch>
 void Foam::AMIInterpolation<SourcePatch, TargetPatch>::calcAddressing
 (
     const primitivePatch& srcPatch,
     const primitivePatch& tgtPatch,
-    const searchableSurface& surf
+    const searchableSurface& surf,
+    label srcFaceI,
+    label tgtFaceI
 )
 {
+    if (!srcPatch.size() || !tgtPatch.size())
+    {
+        if (debug)
+        {
+            Pout<< "AMI: Patches not on processor: Source faces = "
+                << srcPatch.size() << ", target faces = " << tgtPatch.size()
+                << endl;
+        }
+
+        return;
+    }
+
+
     if (debug)
     {
         Info<< "AMI: calcAddressing" << endl;
@@ -640,8 +863,38 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::calcAddressing
 
     // find initial face match using brute force/octree search
     // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    label srcFaceI = 0;
-    label tgtFaceI = findTargetFace(srcFaceI, srcPatch0, tgtPatch0);
+    if ((srcFaceI == -1) || (tgtFaceI == -1))
+    {
+        srcFaceI = 0;
+        tgtFaceI = 0;
+        bool foundFace = false;
+        forAll(srcPatch0, faceI)
+        {
+            tgtFaceI = findTargetFace(srcFaceI, srcPatch0, tgtPatch0);
+            if (tgtFaceI >= 0)
+            {
+                srcFaceI = faceI;
+                foundFace = true;
+                break;
+            }
+        }
+
+        if (!foundFace)
+        {
+            FatalErrorIn
+            (
+                "void Foam::AMIInterpolation<SourcePatch, TargetPatch>::"
+                "calcAddressing"
+                "("
+                    "const primitivePatch&, "
+                    "const primitivePatch&, "
+                    "const searchableSurface&, "
+                    "label, "
+                    "label"
+                ")"
+            )   << "Unable to find initial target face" << abort(FatalError);
+        }
+    }
 
     if (debug)
     {
@@ -666,8 +919,10 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::calcAddressing
     // list to keep track of whether src face can be mapped
     boolList mapFlag(nFacesRemaining, true);
 
-    label nFail = 0;
+    // reset starting seed
+    startSeedI_ = 0;
 
+    label nNonOverlap = 0;
     do
     {
         nbrFaces.clear();
@@ -702,20 +957,13 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::calcAddressing
 
         } while (nbrFaces.size() > 0);
 
-        if (faceProcessed)
-        {
-            mapFlag[srcFaceI] = false;
+        mapFlag[srcFaceI] = false;
 
-            nFacesRemaining--;
-        }
-        else
-        {
-            nFail++;
+        nFacesRemaining--;
 
-            if (nFail > 1000)
-            {
-                Info<< "nFail = " << nFail << endl;
-            }
+        if (!faceProcessed)
+        {
+            nNonOverlap++;
         }
 
         // choose new src face from current src face neighbour
@@ -734,53 +982,249 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::calcAddressing
         }
     } while (nFacesRemaining > 0);
 
+    if (nNonOverlap != 0)
+    {
+        Pout<< "AMI: " << nNonOverlap << " non-overlap faces identified"
+            << endl;
+    }
 
-    // weights normalisation
-    normaliseWeights("source", srcPatch0, srcPoints, srcAddr, srcWght, true);
-    normaliseWeights("target", tgtPatch0, tgtPoints, tgtAddr, tgtWght, true);
+    // normalise weights by face areas
+    forAll(srcAddr, faceI)
+    {
+        const DynamicList<label>& addressing = srcAddr[faceI];
+        forAll(addressing, addrI)
+        {
+            const scalar faceArea = srcPatch0[faceI].mag(srcPoints);
+            srcWght[faceI][addrI] /= faceArea;
+        }
+    }
+
+    forAll(tgtAddr, faceI)
+    {
+        const DynamicList<label>& addressing = tgtAddr[faceI];
+        forAll(addressing, addrI)
+        {
+            const scalar faceArea = tgtPatch0[faceI].mag(tgtPoints);
+            tgtWght[faceI][addrI] /= faceArea;
+        }
+    }
 
     // transfer data to persistent storage
-    srcAddress_.setSize(srcAddr.size());
-    srcWeights_.setSize(srcWght.size());
+    srcAddress_.setSize(srcPatch.size());
+    srcWeights_.setSize(srcPatch.size());
     forAll(srcAddr, i)
     {
         srcAddress_[i].transfer(srcAddr[i]);
         srcWeights_[i].transfer(srcWght[i]);
     }
 
-    tgtAddress_.setSize(tgtAddr.size());
-    tgtWeights_.setSize(tgtWght.size());
+    tgtAddress_.setSize(tgtPatch.size());
+    tgtWeights_.setSize(tgtPatch.size());
     forAll(tgtAddr, i)
     {
         tgtAddress_[i].transfer(tgtAddr[i]);
         tgtWeights_[i].transfer(tgtWght[i]);
     }
+}
+
+
+
+template<class SourcePatch, class TargetPatch>
+void Foam::AMIInterpolation<SourcePatch, TargetPatch>::normaliseWeights
+(
+    const word& patchType,
+    const labelListList& addr,
+    scalarListList& wght,
+    const bool output
+)
+{
+    scalarList wghtSum(wght.size(), 0.0);
+
+    // Normalise the weights
+    forAll(wght, faceI)
+    {
+        scalar s = sum(wght[faceI]);
+        wghtSum[faceI] = s;
+
+        forAll(addr[faceI], i)
+        {
+            wght[faceI][i] /= s;
+        }
+    }
+
+    if (output)
+    {
+        Info<< "AMI: Patch " << patchType << " weights min/max = "
+            << gMin(wghtSum) << ", " << gMax(wghtSum) << endl;
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+template<class SourcePatch, class TargetPatch>
+Foam::AMIInterpolation<SourcePatch, TargetPatch>::AMIInterpolation
+(
+    const SourcePatch& srcPatch,
+    const TargetPatch& tgtPatch,
+    const searchableSurface& surf,
+    const faceAreaIntersect::triangulationMode& triMode,
+    const bool projectPoints
+)
+:
+    srcAddress_(),
+    srcWeights_(),
+    tgtAddress_(),
+    tgtWeights_(),
+    startSeedI_(0),
+    triMode_(triMode),
+    projectPoints_(projectPoints),
+    srcMapPtr_(NULL),
+    tgtMapPtr_(NULL)
+{
+    label srcSize = returnReduce(srcPatch.size(), sumOp<label>());
+    label tgtSize = returnReduce(tgtPatch.size(), sumOp<label>());
+
+    Info<< "AMI: Creating interpolation addressing and weights" << nl
+        << "    Source faces = " << srcSize << nl
+        << "    Target faces = " << tgtSize << endl;
+
+    if (debug)
+    {
+        writePatch(srcPatch, "VTK", "source");
+        writePatch(tgtPatch, "VTK", "target");
+    }
+
+    update(srcPatch, tgtPatch, surf);
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
+
+template<class SourcePatch, class TargetPatch>
+Foam::AMIInterpolation<SourcePatch, TargetPatch>::~AMIInterpolation()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+template<class SourcePatch, class TargetPatch>
+void Foam::AMIInterpolation<SourcePatch, TargetPatch>::update
+(
+    const primitivePatch& srcPatch,
+    const primitivePatch& tgtPatch,
+    const searchableSurface& surf
+)
+{
+    static label patchI = 0;
 
-// ADD PARALLEL BITS
-/*
     if (Pstream::parRun())
     {
-        // Source fields - addesses and weights
-        const label nSrc = srcAddess.size();
-        const globalIndex globalSrcFaces(nSrc);
+        // create processor map of overlapping faces
+        autoPtr<mapDistribute> mapPtr = calcProcMap(srcPatch, tgtPatch);
+        const mapDistribute& map = mapPtr();
 
-        List<Map<label> > compactMapSrcAddress;
-        labelListList transSrcAddress;
+        // create new target patch that fully encompasses source patch
+        faceList newTgtFaces;
+        pointField newTgtPoints;
+        distributeAndMergePatches(map, tgtPatch, newTgtFaces, newTgtPoints);
 
-        mapDistribute srcMapDist
+        primitivePatch
+            newTgtPatch
+            (
+                SubList<face>
+                (
+                    newTgtFaces,
+                    newTgtFaces.size()
+                ),
+                newTgtPoints
+            );
+
+//        checkPatches(srcPatch, newTgtPatch);
+
+
+        // calculate AMI interpolation
+        calcAddressing(srcPatch, newTgtPatch, surf);
+
+
+        // convert local addressing to global addressing
+        globalIndex globalSrcFaces(srcAddress_.size());
+        forAll(tgtAddress_, i)
+        {
+            labelList& addressing = tgtAddress_[i];
+            forAll(addressing, addrI)
+            {
+                addressing[addrI] = globalSrcFaces.toGlobal(addressing[addrI]);
+            }
+        }
+        globalIndex globalTgtFaces(tgtAddress_.size());
+        forAll(srcAddress_, i)
+        {
+            labelList& addressing = srcAddress_[i];
+            forAll(addressing, addrI)
+            {
+                addressing[addrI] = globalTgtFaces.toGlobal(addressing[addrI]);
+            }
+        }
+
+        if (debug)
+        {
+            writeWeights(srcWeights_, srcPatch, "VTK", "source");
+            writeWeights(tgtWeights_, newTgtPatch, "VTK", "target");
+        }
+
+        // send maps
+        mapDistribute::distribute
         (
-            globalSrcFaces,
-            srcAddress_,
-            globalIndexAndTransform(mesh), // mesh not available!!!!!!!!
-            transSrcAddress,
-            compactMapSrcAddress
+            Pstream::nonBlocking,
+            List<labelPair>(),
+            tgtPatch.size(),
+            map.constructMap(),
+            map.subMap(),
+            tgtAddress_,
+            ListPlusEqOp<label>(),
+            labelList()
         );
 
+        mapDistribute::distribute
+        (
+            Pstream::nonBlocking,
+            List<labelPair>(),
+            tgtPatch.size(),
+            map.constructMap(),
+            map.subMap(),
+            tgtWeights_,
+            ListPlusEqOp<scalar>(),
+            scalarList()
+        );
 
+        // weights normalisation
+        normaliseWeights("source", srcAddress_, srcWeights_, true);
+        normaliseWeights("target", tgtAddress_, tgtWeights_, true);
+
+
+        // cache maps
+        List<Map<label> > cMap;
+        srcMapPtr_.reset(new mapDistribute(globalSrcFaces, tgtAddress_, cMap));
+        tgtMapPtr_.reset(new mapDistribute(globalTgtFaces, srcAddress_, cMap));
     }
-*/
-    // reset starting seed
-    startSeedI_ = 0;
+    else
+    {
+        checkPatches(srcPatch, tgtPatch);
+
+        calcAddressing(srcPatch, tgtPatch, surf);
+
+        if (debug)
+        {
+            writeWeights(srcWeights_, srcPatch, "VTK", "source");
+            writeWeights(tgtWeights_, tgtPatch, "VTK", "target");
+        }
+
+        normaliseWeights("source", srcAddress_, srcWeights_, true);
+        normaliseWeights("target", tgtAddress_, tgtWeights_, true);
+    }
+
+    patchI++;
 }
 
 
@@ -803,27 +1247,55 @@ Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolateToSource
     {
         FatalErrorIn
         (
-            "AMIInterpolation::interpolateToSource(const Field<Type>)"
+            "AMIInterpolation::interpolateToSource(const Field<Type>) const"
         )   << "Supplied field size is not equal to target patch size. "
-            << "Target patch = " << tgtAddress_.size() << ", supplied field: "
+            << "Target patch = " << tgtAddress_.size() << ", supplied field = "
             << fld.size() << abort(FatalError);
     }
 
     tmp<Field<Type> > tresult
     (
-        new Field<Type>(srcAddress_.size(), pTraits<Type>::zero)
+        new Field<Type>
+        (
+            srcAddress_.size(),
+            pTraits<Type>::zero
+        )
     );
 
     Field<Type>& result = tresult();
 
-    forAll(result, faceI)
+    if (Pstream::parRun())
     {
-        const labelList& faces = srcAddress_[faceI];
-        const scalarList& weights = srcWeights_[faceI];
+        const mapDistribute& map = tgtMapPtr_();
 
-        forAll(faces, i)
+        Field<Type> work(map.constructSize());
+
+        SubList<Type>(work, fld.size()).assign(fld);
+
+        map.distribute(work);
+
+        forAll(result, faceI)
         {
-            result[faceI] += fld[faces[i]]*weights[i];
+            const labelList& faces = srcAddress_[faceI];
+            const scalarList& weights = srcWeights_[faceI];
+
+            forAll(faces, i)
+            {
+                result[faceI] += work[faces[i]]*weights[i];
+            }
+        }
+    }
+    else
+    {
+        forAll(result, faceI)
+        {
+            const labelList& faces = srcAddress_[faceI];
+            const scalarList& weights = srcWeights_[faceI];
+
+            forAll(faces, i)
+            {
+                result[faceI] += fld[faces[i]]*weights[i];
+            }
         }
     }
 
@@ -856,27 +1328,55 @@ Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolateToTarget
     {
         FatalErrorIn
         (
-            "AMIInterpolation::interpolateToSource(const Field<Type>)"
+            "AMIInterpolation::interpolateToSource(const Field<Type>) const"
         )   << "Supplied field size is not equal to source patch size. "
-            << "Source patch = " << srcAddress_.size() << ", supplied field: "
+            << "Source patch = " << srcAddress_.size() << ", supplied field = "
             << fld.size() << abort(FatalError);
     }
 
     tmp<Field<Type> > tresult
     (
-        new Field<Type>(tgtAddress_.size(), pTraits<Type>::zero)
+        new Field<Type>
+        (
+            tgtAddress_.size(),
+            pTraits<Type>::zero
+        )
     );
 
     Field<Type>& result = tresult();
 
-    forAll(result, faceI)
+    if (Pstream::parRun())
     {
-        const labelList& faces = tgtAddress_[faceI];
-        const scalarList& weights = tgtWeights_[faceI];
+        const mapDistribute& map = srcMapPtr_();
 
-        forAll(faces, i)
+        Field<Type> work(map.constructSize());
+
+        SubList<Type>(work, fld.size()).assign(fld);
+
+        map.distribute(work);
+
+        forAll(result, faceI)
         {
-            result[faceI] += fld[faces[i]]*weights[i];
+            const labelList& faces = tgtAddress_[faceI];
+            const scalarList& weights = tgtWeights_[faceI];
+
+            forAll(faces, i)
+            {
+                result[faceI] += work[faces[i]]*weights[i];
+            }
+        }
+    }
+    else
+    {
+        forAll(result, faceI)
+        {
+            const labelList& faces = tgtAddress_[faceI];
+            const scalarList& weights = tgtWeights_[faceI];
+
+            forAll(faces, i)
+            {
+                result[faceI] += fld[faces[i]]*weights[i];
+            }
         }
     }
 
@@ -928,4 +1428,68 @@ const
 }
 
 
+template<class SourcePatch, class TargetPatch>
+void Foam::AMIInterpolation<SourcePatch, TargetPatch>::writeWeights
+(
+    const scalarListList& weights,
+    const primitivePatch& patch,
+    const word& folder,
+    const word& prefix
+)
+const
+{
+    static label i = 0;
+
+    scalarField wghtSum(weights.size(), 0.0);
+
+    forAll(weights, faceI)
+    {
+        scalar s = sum(weights[faceI]);
+        wghtSum[faceI] = s;
+    }
+
+    vtkSurfaceWriter writer;
+
+    writer.write
+    (
+        folder,
+        prefix + '_' + Foam::name(i) + '_' + Foam::name(Pstream::myProcNo()),
+        patch.localPoints(),
+        patch.localFaces(),
+        "weights",
+        wghtSum,
+        false
+    );
+
+    i++;
+}
+
+
+template<class SourcePatch, class TargetPatch>
+void Foam::AMIInterpolation<SourcePatch, TargetPatch>::writePatch
+(
+    const primitivePatch& patch,
+    const word& folder,
+    const word& prefix
+)
+const
+{
+    static label i = 0;
+
+    vtkSurfaceWriter writer;
+    writer.write
+    (
+        folder,
+        prefix + '_' + Foam::name(i) + '_' + Foam::name(Pstream::myProcNo()),
+        patch.localPoints(),
+        patch.localFaces(),
+        "AMIPatch",
+        scalarField(patch.size(), Pstream::myProcNo()),
+        false
+    );
+
+    i++;
+}
+
+
 // ************************************************************************* //
diff --git a/src/AMIInterpolation/AMIInterpolation.H b/src/AMIInterpolation/AMIInterpolation.H
index 8dd8b72c1b..f39b883e8a 100644
--- a/src/AMIInterpolation/AMIInterpolation.H
+++ b/src/AMIInterpolation/AMIInterpolation.H
@@ -50,6 +50,8 @@ SourceFiles
 #include "boolList.H"
 #include "primitivePatch.H"
 #include "faceAreaIntersect.H"
+#include "treeBoundBox.H"
+#include "treeBoundBoxList.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -72,23 +74,51 @@ class AMIInterpolation
 :
     public AMIInterpolationName
 {
-    // Static data
+
+    //- Helper class for list
+    template<class T>
+    class ListPlusEqOp
+    {
+        public:
+        void operator()(List<T>& x, const List<T> y) const
+        {
+            if (y.size())
+            {
+                if (x.size())
+                {
+                    label sz = x.size();
+                    x.setSize(sz + y.size());
+                    forAll(y, i)
+                    {
+                        x[sz++] = y[i];
+                    }
+                }
+                else
+                {
+                    x = y;
+                }
+            }
+        }
+    };
+
+
+    // Private data
 
         // Source patch
 
-            //- Addressing
+            //- Addresses of target faces per source face
             labelListList srcAddress_;
 
-            //- Weighting factors
+            //- Weights of target faces per source face
             scalarListList srcWeights_;
 
 
         // Target patch
 
-            //- Addressing
+            //- Addresses of source faces per target face
             labelListList tgtAddress_;
 
-            //- Weighting factors
+            //- Weights of wource faces per target face
             scalarListList tgtWeights_;
 
 
@@ -101,6 +131,10 @@ class AMIInterpolation
         //- Flag to indicate whether or not to project points
         const bool projectPoints_;
 
+        autoPtr<mapDistribute> srcMapPtr_;
+
+        autoPtr<mapDistribute> tgtMapPtr_;
+
 
     // Private Member Functions
 
@@ -131,6 +165,38 @@ class AMIInterpolation
             );
 
 
+        // Parallel functionality
+
+            label calcOverlappingProcs
+            (
+                const List<treeBoundBoxList>& procBb,
+                const treeBoundBox& bb,
+                boolList& overlaps
+            );
+
+            void distributePatches
+            (
+                const mapDistribute& map,
+                const primitivePatch& pp,
+                List<faceList>& faces,
+                List<pointField>& points
+            );
+
+            void distributeAndMergePatches
+            (
+                const mapDistribute& map,
+                const primitivePatch& tgtPatch,
+                faceList& tgtFaces,
+                pointField& tgtPoints
+            );
+
+            autoPtr<mapDistribute> calcProcMap
+            (
+                const primitivePatch& srcPatch,
+                const primitivePatch& tgtPatch
+            );
+
+
         // Initialisation
 
             //- Project points to surface
@@ -184,6 +250,16 @@ class AMIInterpolation
                 const primitivePatch& tgtPatch
             ) const;
 
+            //- Calculate addressing
+            void calcAddressing
+            (
+                const primitivePatch& srcPatch,
+                const primitivePatch& tgtPatch,
+                const searchableSurface& surf,
+                label srcFaceI = -1,
+                label tgtFaceI = -1
+            );
+
             //- Normalise the (area) weights - suppresses numerical error in
             //  weights calculation
             //  NOTE: if area weights are incorrect by 'a significant amount'
@@ -192,10 +268,8 @@ class AMIInterpolation
             void normaliseWeights
             (
                 const word& patchType,
-                const primitivePatch& patch,
-                const pointField& points,
-                const List<DynamicList<label> >& addr,
-                List<DynamicList<scalar> >& wght,
+                const labelListList& addr,
+                scalarListList& wght,
                 const bool output
             );
 
@@ -243,8 +317,8 @@ public:
 
         // Manipulation
 
-            //- Calculate addressing
-            void calcAddressing
+            //- Update addressing and weights
+            void update
             (
                 const primitivePatch& srcPatch,
                 const primitivePatch& tgtPatch,
@@ -288,6 +362,25 @@ public:
                 const primitivePatch& srcPatch,
                 const primitivePatch& tgtPatch
             ) const;
+
+            //- Write weights to VTK file
+            void writeWeights
+            (
+                const scalarListList& weights,
+                const primitivePatch& patch,
+                const word& folder,
+                const word& prefix
+            )
+            const;
+
+            //- Write patch
+            void writePatch
+            (
+                const primitivePatch& patch,
+                const word& folder,
+                const word& prefix
+            )
+            const;
 };
 
 

From b73049222c8893c11148b97cef3fb2b039433243 Mon Sep 17 00:00:00 2001
From: andy <andy>
Date: Tue, 2 Aug 2011 10:58:56 +0100
Subject: [PATCH 08/45] ENH: AMI code refactoring

---
 .../patches/cyclicAMIFvPatch/cyclicAMIFvPatch.C   | 15 +++++----------
 .../patches/cyclicAMIFvPatch/cyclicAMIFvPatch.H   |  8 ++++----
 .../cyclicAMIFvPatchField/cyclicAMIFvPatchField.C |  6 +++---
 .../cyclicAMIPolyPatch/cyclicAMIPolyPatch.H       | 11 ++++-------
 .../cyclicAMIPolyPatchTemplates.C                 |  4 ++--
 5 files changed, 18 insertions(+), 26 deletions(-)

diff --git a/src/AMIInterpolation/patches/cyclicAMIFvPatch/cyclicAMIFvPatch.C b/src/AMIInterpolation/patches/cyclicAMIFvPatch/cyclicAMIFvPatch.C
index 7c11307f6d..878d3b6ff8 100644
--- a/src/AMIInterpolation/patches/cyclicAMIFvPatch/cyclicAMIFvPatch.C
+++ b/src/AMIInterpolation/patches/cyclicAMIFvPatch/cyclicAMIFvPatch.C
@@ -47,7 +47,7 @@ void Foam::cyclicAMIFvPatch::makeWeights(scalarField& w) const
 
     const scalarField nbrDeltas
     (
-        interpolateToSource(nbrPatch.nf() & nbrPatch.fvPatch::delta())
+        interpolate(nbrPatch.nf() & nbrPatch.fvPatch::delta())
     );
 
     forAll(deltas, faceI)
@@ -68,7 +68,7 @@ void Foam::cyclicAMIFvPatch::makeDeltaCoeffs(scalarField& dc) const
 
     const scalarField nbrDeltas
     (
-        interpolateToSource(nbrPatch.nf() & nbrPatch.fvPatch::delta())
+        interpolate(nbrPatch.nf() & nbrPatch.fvPatch::delta())
     );
 
     forAll(deltas, faceI)
@@ -86,12 +86,12 @@ Foam::tmp<Foam::vectorField> Foam::cyclicAMIFvPatch::delta() const
     const vectorField patchD(fvPatch::delta());
 
     const cyclicAMIFvPatch& nbrPatch = neighbFvPatch();
-    const vectorField nbrPatchD(interpolateToSource(nbrPatch.fvPatch::delta()));
+    const vectorField nbrPatchD(interpolate(nbrPatch.fvPatch::delta()));
 
     tmp<vectorField> tpdv(new vectorField(patchD.size()));
     vectorField& pdv = tpdv();
 
-    // To the transformation if necessary
+    // do the transformation if necessary
     if (parallel())
     {
         forAll(patchD, faceI)
@@ -132,12 +132,7 @@ Foam::tmp<Foam::labelField> Foam::cyclicAMIFvPatch::internalFieldTransfer
     const labelUList& iF
 ) const
 {
-    tmp<labelField> tnpif(neighbFvPatch().patchInternalField(iF));
-    labelField& npif = tnpif();
-
-    interpolateToSource(npif);
-
-    return tnpif;
+    return interpolate(neighbFvPatch().patchInternalField(iF));
 }
 
 
diff --git a/src/AMIInterpolation/patches/cyclicAMIFvPatch/cyclicAMIFvPatch.H b/src/AMIInterpolation/patches/cyclicAMIFvPatch/cyclicAMIFvPatch.H
index c0d32162e8..500676016b 100644
--- a/src/AMIInterpolation/patches/cyclicAMIFvPatch/cyclicAMIFvPatch.H
+++ b/src/AMIInterpolation/patches/cyclicAMIFvPatch/cyclicAMIFvPatch.H
@@ -147,15 +147,15 @@ public:
             virtual tmp<vectorField> delta() const;
 
             template<class Type>
-            tmp<Field<Type> > interpolateToSource(const Field<Type>& fld) const
+            tmp<Field<Type> > interpolate(const Field<Type>& fld) const
             {
-                return cyclicAMIPolyPatch_.interpolateToSource(fld);
+                return cyclicAMIPolyPatch_.interpolate(fld);
             }
 
             template<class Type>
-            tmp<Field<Type> > interpolateToSource(const tmp<Field<Type> >& tFld) const
+            tmp<Field<Type> > interpolate(const tmp<Field<Type> >& tFld) const
             {
-                return cyclicAMIPolyPatch_.interpolateToSource(tFld);
+                return cyclicAMIPolyPatch_.interpolate(tFld);
             }
 
 
diff --git a/src/AMIInterpolation/patches/cyclicAMIFvPatchField/cyclicAMIFvPatchField.C b/src/AMIInterpolation/patches/cyclicAMIFvPatchField/cyclicAMIFvPatchField.C
index 6014ef8b90..aba7f11a68 100644
--- a/src/AMIInterpolation/patches/cyclicAMIFvPatchField/cyclicAMIFvPatchField.C
+++ b/src/AMIInterpolation/patches/cyclicAMIFvPatchField/cyclicAMIFvPatchField.C
@@ -167,7 +167,7 @@ Foam::cyclicAMIFvPatchField<Type>::patchNeighbourField() const
         }
     }
 
-    return cyclicAMIPatch_.interpolateToSource(pnf);
+    return cyclicAMIPatch_.interpolate(pnf);
 }
 
 
@@ -209,11 +209,11 @@ void Foam::cyclicAMIFvPatchField<Type>::updateInterfaceMatrix
         pnf[faceI] = psiInternal[nbrFaceCells[faceI]];
     }
 
+    pnf = cyclicAMIPatch_.interpolate(pnf);
+
     // Transform according to the transformation tensors
     transformCoupleField(pnf, cmpt);
 
-    pnf = cyclicAMIPatch_.interpolateToSource(pnf);
-
     // Multiply the field by coefficients and add into the result
     const labelUList& faceCells = cyclicAMIPatch_.faceCells();
 
diff --git a/src/AMIInterpolation/patches/cyclicAMIPolyPatch/cyclicAMIPolyPatch.H b/src/AMIInterpolation/patches/cyclicAMIPolyPatch/cyclicAMIPolyPatch.H
index cfd20c040f..49a8a34d10 100644
--- a/src/AMIInterpolation/patches/cyclicAMIPolyPatch/cyclicAMIPolyPatch.H
+++ b/src/AMIInterpolation/patches/cyclicAMIPolyPatch/cyclicAMIPolyPatch.H
@@ -306,16 +306,13 @@ public:
 
             // Interpolations
 
-                //- Interpolate from target field to source
+                //- Interpolate field
                 template<class Type>
-                tmp<Field<Type> > interpolateToSource
-                (
-                    const Field<Type>& fld
-                ) const;
+                tmp<Field<Type> > interpolate(const Field<Type>& fld) const;
 
-                //- Interpolate from target tmp field to source
+                //- Interpolate tmp field
                 template<class Type>
-                tmp<Field<Type> > interpolateToSource
+                tmp<Field<Type> > interpolate
                 (
                     const tmp<Field<Type> >& tFld
                 ) const;
diff --git a/src/AMIInterpolation/patches/cyclicAMIPolyPatch/cyclicAMIPolyPatchTemplates.C b/src/AMIInterpolation/patches/cyclicAMIPolyPatch/cyclicAMIPolyPatchTemplates.C
index 0e0243c5ef..6f78781ada 100644
--- a/src/AMIInterpolation/patches/cyclicAMIPolyPatch/cyclicAMIPolyPatchTemplates.C
+++ b/src/AMIInterpolation/patches/cyclicAMIPolyPatch/cyclicAMIPolyPatchTemplates.C
@@ -28,7 +28,7 @@ License
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 template<class Type>
-Foam::tmp<Foam::Field<Type> > Foam::cyclicAMIPolyPatch::interpolateToSource
+Foam::tmp<Foam::Field<Type> > Foam::cyclicAMIPolyPatch::interpolate
 (
     const Field<Type>& fld
 ) const
@@ -45,7 +45,7 @@ Foam::tmp<Foam::Field<Type> > Foam::cyclicAMIPolyPatch::interpolateToSource
 
 
 template<class Type>
-Foam::tmp<Foam::Field<Type> > Foam::cyclicAMIPolyPatch::interpolateToSource
+Foam::tmp<Foam::Field<Type> > Foam::cyclicAMIPolyPatch::interpolate
 (
     const tmp<Field<Type> >& tFld
 ) const

From 27213aed5af50ecae8334167a9440af186194c12 Mon Sep 17 00:00:00 2001
From: andy <andy>
Date: Wed, 3 Aug 2011 09:55:51 +0100
Subject: [PATCH 09/45] ENH: not storing undisplaced points on db to avoid name
 clash

---
 .../solidBodyMotionFvMesh/solidBodyMotionFvMesh.C              | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/dynamicFvMesh/solidBodyMotionFvMesh/solidBodyMotionFvMesh.C b/src/dynamicFvMesh/solidBodyMotionFvMesh/solidBodyMotionFvMesh.C
index c0a3d78127..ac3d20bf7a 100644
--- a/src/dynamicFvMesh/solidBodyMotionFvMesh/solidBodyMotionFvMesh.C
+++ b/src/dynamicFvMesh/solidBodyMotionFvMesh/solidBodyMotionFvMesh.C
@@ -70,7 +70,8 @@ Foam::solidBodyMotionFvMesh::solidBodyMotionFvMesh(const IOobject& io)
             meshSubDir,
             *this,
             IOobject::MUST_READ,
-            IOobject::NO_WRITE
+            IOobject::NO_WRITE,
+            false
         )
     ),
     pointIDs_()

From ae6aefde5786c7e62584a3c842563f52205469b5 Mon Sep 17 00:00:00 2001
From: andy <andy>
Date: Wed, 3 Aug 2011 14:56:01 +0100
Subject: [PATCH 10/45] ENH: Further AMI functionality updates

---
 src/AMIInterpolation/AMIInterpolation.C       | 15 ++--
 src/AMIInterpolation/AMIInterpolation.H       |  4 +
 .../cyclicAMIFvPatch/cyclicAMIFvPatch.C       |  2 +-
 .../cyclicAMIFvPatchField.C                   | 28 ++----
 .../cyclicAMIPolyPatch/cyclicAMIPolyPatch.C   | 89 ++++++++-----------
 .../cyclicAMIPolyPatch/cyclicAMIPolyPatch.H   | 13 +--
 6 files changed, 56 insertions(+), 95 deletions(-)

diff --git a/src/AMIInterpolation/AMIInterpolation.C b/src/AMIInterpolation/AMIInterpolation.C
index 799116e027..19bffee5bf 100644
--- a/src/AMIInterpolation/AMIInterpolation.C
+++ b/src/AMIInterpolation/AMIInterpolation.C
@@ -361,17 +361,12 @@ Foam::AMIInterpolation<SourcePatch, TargetPatch>::calcProcMap
         procBb[Pstream::myProcNo()] = treeBoundBoxList();
     }
 
+    // slightly increase size of bounding boxes to allow for cases where
+    // bounding boxes are perfectly alligned
     forAll(procBb[Pstream::myProcNo()], bbI)
     {
         treeBoundBox& bb = procBb[Pstream::myProcNo()][bbI];
-        for (direction dir = 0; dir < vector::nComponents; dir++)
-        {
-            if (mag(bb.max()[dir] - bb.max()[dir]) < SMALL)
-            {
-                bb.min()[dir] -= 1E-6;
-                bb.max()[dir] += 1E-6;
-            }
-        }
+        bb.inflate(0.01);
     }
 
     Pstream::gatherList(procBb);
@@ -1076,6 +1071,7 @@ Foam::AMIInterpolation<SourcePatch, TargetPatch>::AMIInterpolation
     srcWeights_(),
     tgtAddress_(),
     tgtWeights_(),
+    tgtPatchSize_(tgtPatch.size()),
     startSeedI_(0),
     triMode_(triMode),
     projectPoints_(projectPoints),
@@ -1338,7 +1334,8 @@ Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolateToTarget
     (
         new Field<Type>
         (
-            tgtAddress_.size(),
+//            tgtAddress_.size(),
+            tgtPatchSize_,
             pTraits<Type>::zero
         )
     );
diff --git a/src/AMIInterpolation/AMIInterpolation.H b/src/AMIInterpolation/AMIInterpolation.H
index f39b883e8a..f3733b8b3d 100644
--- a/src/AMIInterpolation/AMIInterpolation.H
+++ b/src/AMIInterpolation/AMIInterpolation.H
@@ -121,6 +121,10 @@ class AMIInterpolation
             //- Weights of wource faces per target face
             scalarListList tgtWeights_;
 
+            //- Cache local size of target patch
+            //  Note: size could be manipulated in parallel
+            label tgtPatchSize_;
+
 
         //- Starting face seed index
         label startSeedI_;
diff --git a/src/AMIInterpolation/patches/cyclicAMIFvPatch/cyclicAMIFvPatch.C b/src/AMIInterpolation/patches/cyclicAMIFvPatch/cyclicAMIFvPatch.C
index 878d3b6ff8..fa88405077 100644
--- a/src/AMIInterpolation/patches/cyclicAMIFvPatch/cyclicAMIFvPatch.C
+++ b/src/AMIInterpolation/patches/cyclicAMIFvPatch/cyclicAMIFvPatch.C
@@ -132,7 +132,7 @@ Foam::tmp<Foam::labelField> Foam::cyclicAMIFvPatch::internalFieldTransfer
     const labelUList& iF
 ) const
 {
-    return interpolate(neighbFvPatch().patchInternalField(iF));
+    return neighbFvPatch().patchInternalField(iF);
 }
 
 
diff --git a/src/AMIInterpolation/patches/cyclicAMIFvPatchField/cyclicAMIFvPatchField.C b/src/AMIInterpolation/patches/cyclicAMIFvPatchField/cyclicAMIFvPatchField.C
index aba7f11a68..278b877d7f 100644
--- a/src/AMIInterpolation/patches/cyclicAMIFvPatchField/cyclicAMIFvPatchField.C
+++ b/src/AMIInterpolation/patches/cyclicAMIFvPatchField/cyclicAMIFvPatchField.C
@@ -145,29 +145,16 @@ Foam::cyclicAMIFvPatchField<Type>::patchNeighbourField() const
     const labelUList& nbrFaceCells =
         cyclicAMIPatch_.cyclicAMIPatch().nbrPatch().faceCells();
 
-    tmp<Field<Type> > tpnf(new Field<Type>(nbrFaceCells.size()));
-    Field<Type>& pnf = tpnf();
+    Field<Type> pnf(iField, nbrFaceCells);
 
+    tmp<Field<Type> > tpnf(new Field<Type>(cyclicAMIPatch_.interpolate(pnf)));
 
     if (doTransform())
     {
-        forAll(pnf, faceI)
-        {
-            pnf[faceI] = transform
-            (
-                forwardT()[0], iField[nbrFaceCells[faceI]]
-            );
-        }
-    }
-    else
-    {
-        forAll(pnf, faceI)
-        {
-            pnf[faceI] = iField[nbrFaceCells[faceI]];
-        }
+        tpnf() = transform(forwardT(), tpnf());
     }
 
-    return cyclicAMIPatch_.interpolate(pnf);
+    return tpnf;
 }
 
 
@@ -202,12 +189,7 @@ void Foam::cyclicAMIFvPatchField<Type>::updateInterfaceMatrix
     const labelUList& nbrFaceCells =
         cyclicAMIPatch_.cyclicAMIPatch().nbrPatch().faceCells();
 
-    scalarField pnf(nbrFaceCells.size());
-
-    forAll(pnf, faceI)
-    {
-        pnf[faceI] = psiInternal[nbrFaceCells[faceI]];
-    }
+    scalarField pnf(psiInternal, nbrFaceCells);
 
     pnf = cyclicAMIPatch_.interpolate(pnf);
 
diff --git a/src/AMIInterpolation/patches/cyclicAMIPolyPatch/cyclicAMIPolyPatch.C b/src/AMIInterpolation/patches/cyclicAMIPolyPatch/cyclicAMIPolyPatch.C
index ba2bf63630..19a762b64d 100644
--- a/src/AMIInterpolation/patches/cyclicAMIPolyPatch/cyclicAMIPolyPatch.C
+++ b/src/AMIInterpolation/patches/cyclicAMIPolyPatch/cyclicAMIPolyPatch.C
@@ -215,36 +215,39 @@ void Foam::cyclicAMIPolyPatch::calcTransforms
         }
     }
 
-
-    // Calculate typical distance per face
-//    tols = calcFaceTol(matchTolerance(), pp1, pp1.points(), half1Ctrs);
+    if (debug)
+    {
+        Pout<< "patch: " << name() << nl
+            << "    forwardT = " << forwardT() << nl
+            << "    reverseT = " << reverseT() << nl
+            << "    separation = " << separation() << nl
+            << "    collocated = " << collocated() << nl << endl;
+    }
 }
 
 
 const Foam::searchableSurface& Foam::cyclicAMIPolyPatch::surf()
 {
-    if (projectionSurfaceType_ == "patch")
-    {
-        notImplemented("projectionSurfaceType_ == patch")
-    }
-    else
-    {
-        surfPtr_ =
-            searchableSurface::New
+    word surfType(surfDict_.lookup("type"));
+    word surfName(surfDict_.lookupOrDefault("name", name()));
+
+    const polyMesh& mesh = boundaryMesh().mesh();
+
+    surfPtr_ =
+        searchableSurface::New
+        (
+            surfType,
+            IOobject
             (
-                projectionSurfaceType_,
-                IOobject
-                (
-                    projectionName_,
-                    boundaryMesh().mesh().time().constant(),
-                    "triSurface",
-                    boundaryMesh().mesh(),
-                    IOobject::MUST_READ,
-                    IOobject::NO_WRITE
-                ),
-                dict_
-            );
-    }
+                surfName,
+                boundaryMesh().mesh().time().constant(),
+                "triSurface",
+                boundaryMesh().mesh(),
+                IOobject::MUST_READ,
+                IOobject::NO_WRITE
+            ),
+            surfDict_
+        );
 
     return surfPtr_();
 }
@@ -284,6 +287,8 @@ const Foam::AMIPatchToPatchInterpolation& Foam::cyclicAMIPolyPatch::AMI()
             meshTools::writeOBJ(osO, this->localFaces(), localPoints());
         }
 
+        bool projectPoints(readBool(surfDict_.lookup("projectPoints")));
+
         // Construct/apply AMI interpolation to determine addressing and weights
         AMIPtr_.reset
         (
@@ -293,7 +298,7 @@ const Foam::AMIPatchToPatchInterpolation& Foam::cyclicAMIPolyPatch::AMI()
                 nbrPatch0,
                 surf(),
                 faceAreaIntersect::tmMesh,
-                projectPoints_
+                projectPoints
             )
         );
     }
@@ -377,7 +382,6 @@ Foam::cyclicAMIPolyPatch::cyclicAMIPolyPatch
 )
 :
     coupledPolyPatch(name, size, start, index, bm),
-    dict_(dictionary::null),
     nbrPatchName_(word::null),
     nbrPatchID_(-1),
     transform_(UNKNOWN),
@@ -386,9 +390,7 @@ Foam::cyclicAMIPolyPatch::cyclicAMIPolyPatch
     separationVector_(vector::zero),
     AMIPtr_(NULL),
     surfPtr_(NULL),
-    projectionSurfaceType_(word::null),
-    projectPoints_(false),
-    projectionName_(word::null)
+    surfDict_(dictionary::null)
 {
     // Neighbour patch might not be valid yet so no transformation
     // calculation possible
@@ -404,7 +406,6 @@ Foam::cyclicAMIPolyPatch::cyclicAMIPolyPatch
 )
 :
     coupledPolyPatch(name, dict, index, bm),
-    dict_(dict),
     nbrPatchName_(dict.lookup("neighbourPatch")),
     nbrPatchID_(-1),
     transform_(UNKNOWN),
@@ -413,9 +414,7 @@ Foam::cyclicAMIPolyPatch::cyclicAMIPolyPatch
     separationVector_(vector::zero),
     AMIPtr_(NULL),
     surfPtr_(NULL),
-    projectionSurfaceType_(dict.lookup("projectionSurfaceType")),
-    projectPoints_(readBool(dict.lookup("projectPoints"))),
-    projectionName_(dict.lookupOrDefault("surfaceName", name))
+    surfDict_(dict.subDict("surface"))
 {
     if (nbrPatchName_ == name)
     {
@@ -489,7 +488,6 @@ Foam::cyclicAMIPolyPatch::cyclicAMIPolyPatch
 )
 :
     coupledPolyPatch(pp, bm),
-    dict_(dictionary::null),
     nbrPatchName_(pp.nbrPatchName_),
     nbrPatchID_(-1),
     transform_(UNKNOWN),
@@ -498,9 +496,7 @@ Foam::cyclicAMIPolyPatch::cyclicAMIPolyPatch
     separationVector_(vector::zero),
     AMIPtr_(NULL),
     surfPtr_(NULL),
-    projectionSurfaceType_(word::null),
-    projectPoints_(false),
-    projectionName_(word::null)
+    surfDict_(dictionary::null)
 {
     // Neighbour patch might not be valid yet so no transformation
     // calculation possible
@@ -518,7 +514,6 @@ Foam::cyclicAMIPolyPatch::cyclicAMIPolyPatch
 )
 :
     coupledPolyPatch(pp, bm, index, newSize, newStart),
-    dict_(dictionary::null),
     nbrPatchName_(nbrPatchName),
     nbrPatchID_(-1),
     transform_(UNKNOWN),
@@ -527,9 +522,7 @@ Foam::cyclicAMIPolyPatch::cyclicAMIPolyPatch
     separationVector_(vector::zero),
     AMIPtr_(NULL),
     surfPtr_(NULL),
-    projectionSurfaceType_(word::null),
-    projectPoints_(false),
-    projectionName_(word::null)
+    surfDict_(dictionary::null)
 {
     if (nbrPatchName_ == name())
     {
@@ -561,7 +554,6 @@ Foam::cyclicAMIPolyPatch::cyclicAMIPolyPatch
 )
 :
     coupledPolyPatch(pp, bm, index, mapAddressing, newStart),
-    dict_(pp.dict_),
     nbrPatchName_(pp.nbrPatchName_),
     nbrPatchID_(-1),
     transform_(pp.transform_),
@@ -570,9 +562,7 @@ Foam::cyclicAMIPolyPatch::cyclicAMIPolyPatch
     separationVector_(pp.separationVector_),
     AMIPtr_(NULL),
     surfPtr_(NULL),
-    projectionSurfaceType_(pp.projectionSurfaceType_),
-    projectPoints_(pp.projectPoints_),
-    projectionName_(pp.projectionName_)
+    surfDict_(pp.surfDict_)
 {}
 
 
@@ -759,12 +749,6 @@ void Foam::cyclicAMIPolyPatch::write(Ostream& os) const
     coupledPolyPatch::write(os);
     os.writeKeyword("neighbourPatch") << nbrPatchName_
         << token::END_STATEMENT << nl;
-    os.writeKeyword("projectPoints") << projectPoints_
-        << token::END_STATEMENT << nl;
-    os.writeKeyword("projectionSurfaceType") << projectionSurfaceType_
-        << token::END_STATEMENT << nl;
-    os.writeKeyword("surfaceName") << projectionName_
-        << token::END_STATEMENT << nl;
     switch (transform_)
     {
         case ROTATIONAL:
@@ -796,6 +780,9 @@ void Foam::cyclicAMIPolyPatch::write(Ostream& os) const
             // no additional info to write
         }
     }
+
+    os.writeKeyword(surfDict_.dictName());
+    os  << surfDict_;
 }
 
 
diff --git a/src/AMIInterpolation/patches/cyclicAMIPolyPatch/cyclicAMIPolyPatch.H b/src/AMIInterpolation/patches/cyclicAMIPolyPatch/cyclicAMIPolyPatch.H
index 49a8a34d10..e733d3e727 100644
--- a/src/AMIInterpolation/patches/cyclicAMIPolyPatch/cyclicAMIPolyPatch.H
+++ b/src/AMIInterpolation/patches/cyclicAMIPolyPatch/cyclicAMIPolyPatch.H
@@ -57,9 +57,6 @@ private:
 
     // Private data
 
-        //- Dictionary used during construction
-        const dictionary dict_;
-
         //- Name of other half
         const word nbrPatchName_;
 
@@ -94,14 +91,8 @@ private:
         //- Projection surface
         autoPtr<searchableSurface> surfPtr_;
 
-        //- Projection surface type
-        word projectionSurfaceType_;
-
-        //- Flag to activate projection
-        bool projectPoints_;
-
-        //- Name of projection object (if read)
-        const word projectionName_;
+        //- Dictionary used during projection surface construction
+        const dictionary surfDict_;
 
 
     // Private Member Functions

From c8b8905284db6623952fa5c797dcee184e7e0efa Mon Sep 17 00:00:00 2001
From: andy <andy>
Date: Tue, 16 Aug 2011 15:39:06 +0100
Subject: [PATCH 11/45] STYLE: Minor code formatting

---
 .../meshes/polyMesh/polyPatches/basic/coupled/coupledPolyPatch.H | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/OpenFOAM/meshes/polyMesh/polyPatches/basic/coupled/coupledPolyPatch.H b/src/OpenFOAM/meshes/polyMesh/polyPatches/basic/coupled/coupledPolyPatch.H
index 58cb8e66fa..c4da9b790e 100644
--- a/src/OpenFOAM/meshes/polyMesh/polyPatches/basic/coupled/coupledPolyPatch.H
+++ b/src/OpenFOAM/meshes/polyMesh/polyPatches/basic/coupled/coupledPolyPatch.H
@@ -87,6 +87,7 @@ private:
         //- Are faces collocated. Either size 0,1 or length of patch.
         mutable boolList collocated_;
 
+
 protected:
 
     // Protected Member Functions

From d443ad27aa0e0fa26ceda64e2720efa7528b8a9d Mon Sep 17 00:00:00 2001
From: andy <andy>
Date: Tue, 16 Aug 2011 16:27:47 +0100
Subject: [PATCH 12/45] STYLE: Updated AMI code copyright headers

---
 src/AMIInterpolation/AMIInterpolation.C                         | 2 +-
 src/AMIInterpolation/AMIInterpolation.H                         | 2 +-
 src/AMIInterpolation/AMIInterpolationI.H                        | 2 +-
 src/AMIInterpolation/AMIInterpolationName.C                     | 2 +-
 src/AMIInterpolation/AMIPatchToPatchInterpolation.H             | 2 +-
 src/AMIInterpolation/faceAreaIntersect/faceAreaIntersect.C      | 2 +-
 src/AMIInterpolation/faceAreaIntersect/faceAreaIntersect.H      | 2 +-
 src/AMIInterpolation/faceAreaIntersect/faceAreaIntersectI.H     | 2 +-
 .../patches/cyclicAMIFvPatch/cyclicAMIFvPatch.C                 | 2 +-
 .../patches/cyclicAMIFvPatch/cyclicAMIFvPatch.H                 | 2 +-
 .../patches/cyclicAMIFvPatchField/cyclicAMIFvPatchField.C       | 2 +-
 .../patches/cyclicAMIFvPatchField/cyclicAMIFvPatchField.H       | 2 +-
 .../patches/cyclicAMIFvPatchField/cyclicAMIFvPatchFields.C      | 2 +-
 .../patches/cyclicAMIFvPatchField/cyclicAMIFvPatchFields.H      | 2 +-
 .../patches/cyclicAMIFvPatchField/cyclicAMIFvPatchFieldsFwd.H   | 2 +-
 .../patches/cyclicAMIFvsPatchField/cyclicAMIFvsPatchField.C     | 2 +-
 .../patches/cyclicAMIFvsPatchField/cyclicAMIFvsPatchField.H     | 2 +-
 .../patches/cyclicAMIFvsPatchField/cyclicAMIFvsPatchFields.C    | 2 +-
 .../patches/cyclicAMIFvsPatchField/cyclicAMIFvsPatchFields.H    | 2 +-
 .../patches/cyclicAMIFvsPatchField/cyclicAMIFvsPatchFieldsFwd.H | 2 +-
 .../patches/cyclicAMILduInterfaceField/cyclicAMILduInterface.C  | 2 +-
 .../patches/cyclicAMILduInterfaceField/cyclicAMILduInterface.H  | 2 +-
 .../cyclicAMILduInterfaceField/cyclicAMILduInterfaceField.C     | 2 +-
 .../cyclicAMILduInterfaceField/cyclicAMILduInterfaceField.H     | 2 +-
 .../patches/cyclicAMIPointPatch/cyclicAMIPointPatch.C           | 2 +-
 .../patches/cyclicAMIPointPatch/cyclicAMIPointPatch.H           | 2 +-
 .../patches/cyclicAMIPolyPatch/cyclicAMIPolyPatch.C             | 2 +-
 .../patches/cyclicAMIPolyPatch/cyclicAMIPolyPatch.H             | 2 +-
 .../patches/cyclicAMIPolyPatch/cyclicAMIPolyPatchI.H            | 2 +-
 .../patches/cyclicAMIPolyPatch/cyclicAMIPolyPatchTemplates.C    | 2 +-
 30 files changed, 30 insertions(+), 30 deletions(-)

diff --git a/src/AMIInterpolation/AMIInterpolation.C b/src/AMIInterpolation/AMIInterpolation.C
index 19bffee5bf..98036386cc 100644
--- a/src/AMIInterpolation/AMIInterpolation.C
+++ b/src/AMIInterpolation/AMIInterpolation.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2011 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
diff --git a/src/AMIInterpolation/AMIInterpolation.H b/src/AMIInterpolation/AMIInterpolation.H
index f3733b8b3d..026ccbfcb2 100644
--- a/src/AMIInterpolation/AMIInterpolation.H
+++ b/src/AMIInterpolation/AMIInterpolation.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2011 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
diff --git a/src/AMIInterpolation/AMIInterpolationI.H b/src/AMIInterpolation/AMIInterpolationI.H
index a38c83ebaf..9163979727 100644
--- a/src/AMIInterpolation/AMIInterpolationI.H
+++ b/src/AMIInterpolation/AMIInterpolationI.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2011 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
diff --git a/src/AMIInterpolation/AMIInterpolationName.C b/src/AMIInterpolation/AMIInterpolationName.C
index 064f5604dc..d70d09184d 100644
--- a/src/AMIInterpolation/AMIInterpolationName.C
+++ b/src/AMIInterpolation/AMIInterpolationName.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2011 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
diff --git a/src/AMIInterpolation/AMIPatchToPatchInterpolation.H b/src/AMIInterpolation/AMIPatchToPatchInterpolation.H
index bf9d082762..30a29fac5d 100644
--- a/src/AMIInterpolation/AMIPatchToPatchInterpolation.H
+++ b/src/AMIInterpolation/AMIPatchToPatchInterpolation.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2011 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
diff --git a/src/AMIInterpolation/faceAreaIntersect/faceAreaIntersect.C b/src/AMIInterpolation/faceAreaIntersect/faceAreaIntersect.C
index e6294ba63e..3a4a1384e9 100644
--- a/src/AMIInterpolation/faceAreaIntersect/faceAreaIntersect.C
+++ b/src/AMIInterpolation/faceAreaIntersect/faceAreaIntersect.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2011 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
diff --git a/src/AMIInterpolation/faceAreaIntersect/faceAreaIntersect.H b/src/AMIInterpolation/faceAreaIntersect/faceAreaIntersect.H
index fd464b8458..f2c8d13e2c 100644
--- a/src/AMIInterpolation/faceAreaIntersect/faceAreaIntersect.H
+++ b/src/AMIInterpolation/faceAreaIntersect/faceAreaIntersect.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2011 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
diff --git a/src/AMIInterpolation/faceAreaIntersect/faceAreaIntersectI.H b/src/AMIInterpolation/faceAreaIntersect/faceAreaIntersectI.H
index 033a4d3f9e..0b8265aad6 100644
--- a/src/AMIInterpolation/faceAreaIntersect/faceAreaIntersectI.H
+++ b/src/AMIInterpolation/faceAreaIntersect/faceAreaIntersectI.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2011 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
diff --git a/src/AMIInterpolation/patches/cyclicAMIFvPatch/cyclicAMIFvPatch.C b/src/AMIInterpolation/patches/cyclicAMIFvPatch/cyclicAMIFvPatch.C
index fa88405077..a7f9f6592e 100644
--- a/src/AMIInterpolation/patches/cyclicAMIFvPatch/cyclicAMIFvPatch.C
+++ b/src/AMIInterpolation/patches/cyclicAMIFvPatch/cyclicAMIFvPatch.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2011 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
diff --git a/src/AMIInterpolation/patches/cyclicAMIFvPatch/cyclicAMIFvPatch.H b/src/AMIInterpolation/patches/cyclicAMIFvPatch/cyclicAMIFvPatch.H
index 500676016b..3e29a2be42 100644
--- a/src/AMIInterpolation/patches/cyclicAMIFvPatch/cyclicAMIFvPatch.H
+++ b/src/AMIInterpolation/patches/cyclicAMIFvPatch/cyclicAMIFvPatch.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2011 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
diff --git a/src/AMIInterpolation/patches/cyclicAMIFvPatchField/cyclicAMIFvPatchField.C b/src/AMIInterpolation/patches/cyclicAMIFvPatchField/cyclicAMIFvPatchField.C
index 278b877d7f..121dc2d088 100644
--- a/src/AMIInterpolation/patches/cyclicAMIFvPatchField/cyclicAMIFvPatchField.C
+++ b/src/AMIInterpolation/patches/cyclicAMIFvPatchField/cyclicAMIFvPatchField.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2011 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
diff --git a/src/AMIInterpolation/patches/cyclicAMIFvPatchField/cyclicAMIFvPatchField.H b/src/AMIInterpolation/patches/cyclicAMIFvPatchField/cyclicAMIFvPatchField.H
index b4a14380a3..653d50ed37 100644
--- a/src/AMIInterpolation/patches/cyclicAMIFvPatchField/cyclicAMIFvPatchField.H
+++ b/src/AMIInterpolation/patches/cyclicAMIFvPatchField/cyclicAMIFvPatchField.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2011 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
diff --git a/src/AMIInterpolation/patches/cyclicAMIFvPatchField/cyclicAMIFvPatchFields.C b/src/AMIInterpolation/patches/cyclicAMIFvPatchField/cyclicAMIFvPatchFields.C
index 2bd5752dee..3fbaee838e 100644
--- a/src/AMIInterpolation/patches/cyclicAMIFvPatchField/cyclicAMIFvPatchFields.C
+++ b/src/AMIInterpolation/patches/cyclicAMIFvPatchField/cyclicAMIFvPatchFields.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2011 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
diff --git a/src/AMIInterpolation/patches/cyclicAMIFvPatchField/cyclicAMIFvPatchFields.H b/src/AMIInterpolation/patches/cyclicAMIFvPatchField/cyclicAMIFvPatchFields.H
index 7fd67d201b..81a6e2a179 100644
--- a/src/AMIInterpolation/patches/cyclicAMIFvPatchField/cyclicAMIFvPatchFields.H
+++ b/src/AMIInterpolation/patches/cyclicAMIFvPatchField/cyclicAMIFvPatchFields.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2011 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
diff --git a/src/AMIInterpolation/patches/cyclicAMIFvPatchField/cyclicAMIFvPatchFieldsFwd.H b/src/AMIInterpolation/patches/cyclicAMIFvPatchField/cyclicAMIFvPatchFieldsFwd.H
index 6f6a207070..bd1d27b207 100644
--- a/src/AMIInterpolation/patches/cyclicAMIFvPatchField/cyclicAMIFvPatchFieldsFwd.H
+++ b/src/AMIInterpolation/patches/cyclicAMIFvPatchField/cyclicAMIFvPatchFieldsFwd.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2011 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
diff --git a/src/AMIInterpolation/patches/cyclicAMIFvsPatchField/cyclicAMIFvsPatchField.C b/src/AMIInterpolation/patches/cyclicAMIFvsPatchField/cyclicAMIFvsPatchField.C
index 9a197c01e7..a347bc4347 100644
--- a/src/AMIInterpolation/patches/cyclicAMIFvsPatchField/cyclicAMIFvsPatchField.C
+++ b/src/AMIInterpolation/patches/cyclicAMIFvsPatchField/cyclicAMIFvsPatchField.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2011 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
diff --git a/src/AMIInterpolation/patches/cyclicAMIFvsPatchField/cyclicAMIFvsPatchField.H b/src/AMIInterpolation/patches/cyclicAMIFvsPatchField/cyclicAMIFvsPatchField.H
index 01fd762f4f..fe84983134 100644
--- a/src/AMIInterpolation/patches/cyclicAMIFvsPatchField/cyclicAMIFvsPatchField.H
+++ b/src/AMIInterpolation/patches/cyclicAMIFvsPatchField/cyclicAMIFvsPatchField.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2011 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
diff --git a/src/AMIInterpolation/patches/cyclicAMIFvsPatchField/cyclicAMIFvsPatchFields.C b/src/AMIInterpolation/patches/cyclicAMIFvsPatchField/cyclicAMIFvsPatchFields.C
index a439f7f83a..0134ad0577 100644
--- a/src/AMIInterpolation/patches/cyclicAMIFvsPatchField/cyclicAMIFvsPatchFields.C
+++ b/src/AMIInterpolation/patches/cyclicAMIFvsPatchField/cyclicAMIFvsPatchFields.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2011 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
diff --git a/src/AMIInterpolation/patches/cyclicAMIFvsPatchField/cyclicAMIFvsPatchFields.H b/src/AMIInterpolation/patches/cyclicAMIFvsPatchField/cyclicAMIFvsPatchFields.H
index 18021d6e17..df03f2be8b 100644
--- a/src/AMIInterpolation/patches/cyclicAMIFvsPatchField/cyclicAMIFvsPatchFields.H
+++ b/src/AMIInterpolation/patches/cyclicAMIFvsPatchField/cyclicAMIFvsPatchFields.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2011 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
diff --git a/src/AMIInterpolation/patches/cyclicAMIFvsPatchField/cyclicAMIFvsPatchFieldsFwd.H b/src/AMIInterpolation/patches/cyclicAMIFvsPatchField/cyclicAMIFvsPatchFieldsFwd.H
index 72fdc4d4ce..b7c9efd6f9 100644
--- a/src/AMIInterpolation/patches/cyclicAMIFvsPatchField/cyclicAMIFvsPatchFieldsFwd.H
+++ b/src/AMIInterpolation/patches/cyclicAMIFvsPatchField/cyclicAMIFvsPatchFieldsFwd.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2011 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
diff --git a/src/AMIInterpolation/patches/cyclicAMILduInterfaceField/cyclicAMILduInterface.C b/src/AMIInterpolation/patches/cyclicAMILduInterfaceField/cyclicAMILduInterface.C
index 70eaba2fd4..7d9a1a71e3 100644
--- a/src/AMIInterpolation/patches/cyclicAMILduInterfaceField/cyclicAMILduInterface.C
+++ b/src/AMIInterpolation/patches/cyclicAMILduInterfaceField/cyclicAMILduInterface.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2011 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
diff --git a/src/AMIInterpolation/patches/cyclicAMILduInterfaceField/cyclicAMILduInterface.H b/src/AMIInterpolation/patches/cyclicAMILduInterfaceField/cyclicAMILduInterface.H
index 67016cb4be..6243a84ea6 100644
--- a/src/AMIInterpolation/patches/cyclicAMILduInterfaceField/cyclicAMILduInterface.H
+++ b/src/AMIInterpolation/patches/cyclicAMILduInterfaceField/cyclicAMILduInterface.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2011 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
diff --git a/src/AMIInterpolation/patches/cyclicAMILduInterfaceField/cyclicAMILduInterfaceField.C b/src/AMIInterpolation/patches/cyclicAMILduInterfaceField/cyclicAMILduInterfaceField.C
index fa9b5a772d..20cb7784da 100644
--- a/src/AMIInterpolation/patches/cyclicAMILduInterfaceField/cyclicAMILduInterfaceField.C
+++ b/src/AMIInterpolation/patches/cyclicAMILduInterfaceField/cyclicAMILduInterfaceField.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2011 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
diff --git a/src/AMIInterpolation/patches/cyclicAMILduInterfaceField/cyclicAMILduInterfaceField.H b/src/AMIInterpolation/patches/cyclicAMILduInterfaceField/cyclicAMILduInterfaceField.H
index 29173e3fab..d34c04406b 100644
--- a/src/AMIInterpolation/patches/cyclicAMILduInterfaceField/cyclicAMILduInterfaceField.H
+++ b/src/AMIInterpolation/patches/cyclicAMILduInterfaceField/cyclicAMILduInterfaceField.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2011 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
diff --git a/src/AMIInterpolation/patches/cyclicAMIPointPatch/cyclicAMIPointPatch.C b/src/AMIInterpolation/patches/cyclicAMIPointPatch/cyclicAMIPointPatch.C
index c41779078a..fec146018d 100644
--- a/src/AMIInterpolation/patches/cyclicAMIPointPatch/cyclicAMIPointPatch.C
+++ b/src/AMIInterpolation/patches/cyclicAMIPointPatch/cyclicAMIPointPatch.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2011 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
diff --git a/src/AMIInterpolation/patches/cyclicAMIPointPatch/cyclicAMIPointPatch.H b/src/AMIInterpolation/patches/cyclicAMIPointPatch/cyclicAMIPointPatch.H
index ddfa71d7cd..3ade3aeaef 100644
--- a/src/AMIInterpolation/patches/cyclicAMIPointPatch/cyclicAMIPointPatch.H
+++ b/src/AMIInterpolation/patches/cyclicAMIPointPatch/cyclicAMIPointPatch.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2011 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
diff --git a/src/AMIInterpolation/patches/cyclicAMIPolyPatch/cyclicAMIPolyPatch.C b/src/AMIInterpolation/patches/cyclicAMIPolyPatch/cyclicAMIPolyPatch.C
index 19a762b64d..46577d1665 100644
--- a/src/AMIInterpolation/patches/cyclicAMIPolyPatch/cyclicAMIPolyPatch.C
+++ b/src/AMIInterpolation/patches/cyclicAMIPolyPatch/cyclicAMIPolyPatch.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2011 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
diff --git a/src/AMIInterpolation/patches/cyclicAMIPolyPatch/cyclicAMIPolyPatch.H b/src/AMIInterpolation/patches/cyclicAMIPolyPatch/cyclicAMIPolyPatch.H
index e733d3e727..1ad095036b 100644
--- a/src/AMIInterpolation/patches/cyclicAMIPolyPatch/cyclicAMIPolyPatch.H
+++ b/src/AMIInterpolation/patches/cyclicAMIPolyPatch/cyclicAMIPolyPatch.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2011 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
diff --git a/src/AMIInterpolation/patches/cyclicAMIPolyPatch/cyclicAMIPolyPatchI.H b/src/AMIInterpolation/patches/cyclicAMIPolyPatch/cyclicAMIPolyPatchI.H
index 8bb8badc77..773fbde64e 100644
--- a/src/AMIInterpolation/patches/cyclicAMIPolyPatch/cyclicAMIPolyPatchI.H
+++ b/src/AMIInterpolation/patches/cyclicAMIPolyPatch/cyclicAMIPolyPatchI.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2011 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
diff --git a/src/AMIInterpolation/patches/cyclicAMIPolyPatch/cyclicAMIPolyPatchTemplates.C b/src/AMIInterpolation/patches/cyclicAMIPolyPatch/cyclicAMIPolyPatchTemplates.C
index 6f78781ada..87b70173fd 100644
--- a/src/AMIInterpolation/patches/cyclicAMIPolyPatch/cyclicAMIPolyPatchTemplates.C
+++ b/src/AMIInterpolation/patches/cyclicAMIPolyPatch/cyclicAMIPolyPatchTemplates.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2011 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License

From ca367eed163dc83033132470affcdd922465c0ee Mon Sep 17 00:00:00 2001
From: andy <andy>
Date: Thu, 18 Aug 2011 10:10:24 +0100
Subject: [PATCH 13/45] ENH: Further AMI updates

---
 src/AMIInterpolation/AMIInterpolation.C       | 85 ++++++++++++-------
 src/AMIInterpolation/AMIInterpolation.H       |  3 -
 .../cyclicAMIPolyPatch/cyclicAMIPolyPatch.C   |  6 +-
 3 files changed, 56 insertions(+), 38 deletions(-)

diff --git a/src/AMIInterpolation/AMIInterpolation.C b/src/AMIInterpolation/AMIInterpolation.C
index 98036386cc..03854ac029 100644
--- a/src/AMIInterpolation/AMIInterpolation.C
+++ b/src/AMIInterpolation/AMIInterpolation.C
@@ -24,7 +24,6 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "AMIInterpolation.H"
-#include "Random.H"
 #include "treeDataPrimitivePatch.H"
 #include "indexedOctree.H"
 #include "meshTools.H"
@@ -527,19 +526,18 @@ Foam::label Foam::AMIInterpolation<SourcePatch, TargetPatch>::findTargetFace
 {
     label targetFaceI = -1;
 
-    Random rndGen(123456);
-
     treeBoundBox bb(tgtPatch.points());
+    bb.inflate(0.01);
 
     typedef treeDataPrimitivePatch<face, SubList, const pointField&> treeType;
 
     indexedOctree<treeType> tree
     (
         treeType(false, tgtPatch),
-        bb.extend(rndGen, 1E-4),                // overall search domain
-        8,                                      // maxLevel
-        10,                                     // leafsize
-        3.0                                     // duplicity
+        bb,                         // overall search domain
+        8,                          // maxLevel
+        10,                         // leaf size
+        3.0                         // duplicity
     );
 
     const pointField& srcPts = srcPatch.points();
@@ -1153,6 +1151,7 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::update
                 addressing[addrI] = globalSrcFaces.toGlobal(addressing[addrI]);
             }
         }
+
         globalIndex globalTgtFaces(tgtAddress_.size());
         forAll(srcAddress_, i)
         {
@@ -1163,13 +1162,34 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::update
             }
         }
 
-        if (debug)
-        {
-            writeWeights(srcWeights_, srcPatch, "VTK", "source");
-            writeWeights(tgtWeights_, newTgtPatch, "VTK", "target");
-        }
 
         // send maps
+/*
+        mapDistribute::distribute
+        (
+            Pstream::nonBlocking,
+            List<labelPair>(),
+            srcPatch.size(),
+            map.constructMap(),
+            map.subMap(),
+            srcAddress_,
+            ListPlusEqOp<label>(),
+            labelList()
+        );
+
+        mapDistribute::distribute
+        (
+            Pstream::nonBlocking,
+            List<labelPair>(),
+            srcPatch.size(),
+            map.constructMap(),
+            map.subMap(),
+            srcWeights_,
+            ListPlusEqOp<scalar>(),
+            scalarList()
+        );
+*/
+
         mapDistribute::distribute
         (
             Pstream::nonBlocking,
@@ -1194,15 +1214,27 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::update
             scalarList()
         );
 
+        if (debug)
+        {
+            writeWeights(srcWeights_, srcPatch, "VTK", "source");
+            writeWeights(tgtWeights_, newTgtPatch, "VTK", "target");
+        }
+
+
         // weights normalisation
         normaliseWeights("source", srcAddress_, srcWeights_, true);
         normaliseWeights("target", tgtAddress_, tgtWeights_, true);
 
 
-        // cache maps
+        // cache maps and reset addresses
         List<Map<label> > cMap;
         srcMapPtr_.reset(new mapDistribute(globalSrcFaces, tgtAddress_, cMap));
         tgtMapPtr_.reset(new mapDistribute(globalTgtFaces, srcAddress_, cMap));
+
+        if (debug)
+        {
+            writeFaceConnectivity(srcPatch, newTgtPatch);
+        }
     }
     else
     {
@@ -1224,13 +1256,6 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::update
 }
 
 
-template<class SourcePatch, class TargetPatch>
-bool Foam::AMIInterpolation<SourcePatch, TargetPatch>::movePoints()
-{
-    return true;
-}
-
-
 template<class SourcePatch, class TargetPatch>
 template<class Type>
 Foam::tmp<Foam::Field<Type> >
@@ -1264,10 +1289,7 @@ Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolateToSource
     {
         const mapDistribute& map = tgtMapPtr_();
 
-        Field<Type> work(map.constructSize());
-
-        SubList<Type>(work, fld.size()).assign(fld);
-
+        Field<Type> work(fld);
         map.distribute(work);
 
         forAll(result, faceI)
@@ -1324,7 +1346,7 @@ Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolateToTarget
     {
         FatalErrorIn
         (
-            "AMIInterpolation::interpolateToSource(const Field<Type>) const"
+            "AMIInterpolation::interpolateToSource(const Field<Type>&) const"
         )   << "Supplied field size is not equal to source patch size. "
             << "Source patch = " << srcAddress_.size() << ", supplied field = "
             << fld.size() << abort(FatalError);
@@ -1346,10 +1368,7 @@ Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolateToTarget
     {
         const mapDistribute& map = srcMapPtr_();
 
-        Field<Type> work(map.constructSize());
-
-        SubList<Type>(work, fld.size()).assign(fld);
-
+        Field<Type> work(fld);
         map.distribute(work);
 
         forAll(result, faceI)
@@ -1401,7 +1420,7 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::writeFaceConnectivity
 )
 const
 {
-    OFstream os("faceConnectivity.obj");
+    OFstream os("faceConnectivity" + Foam::name(Pstream::myProcNo()) + ".obj");
 
     label ptI = 1;
 
@@ -1450,7 +1469,8 @@ const
     writer.write
     (
         folder,
-        prefix + '_' + Foam::name(i) + '_' + Foam::name(Pstream::myProcNo()),
+        prefix
+          + '_' + Foam::name(i) + "_proc" + Foam::name(Pstream::myProcNo()),
         patch.localPoints(),
         patch.localFaces(),
         "weights",
@@ -1477,7 +1497,8 @@ const
     writer.write
     (
         folder,
-        prefix + '_' + Foam::name(i) + '_' + Foam::name(Pstream::myProcNo()),
+        prefix
+          + '_' + Foam::name(i) + "_proc" + Foam::name(Pstream::myProcNo()),
         patch.localPoints(),
         patch.localFaces(),
         "AMIPatch",
diff --git a/src/AMIInterpolation/AMIInterpolation.H b/src/AMIInterpolation/AMIInterpolation.H
index 026ccbfcb2..711c8d71a7 100644
--- a/src/AMIInterpolation/AMIInterpolation.H
+++ b/src/AMIInterpolation/AMIInterpolation.H
@@ -329,9 +329,6 @@ public:
                 const searchableSurface& surf
             );
 
-            //- Correct weighting factors for moving mesh
-            bool movePoints();
-
 
         // Evaluation
 
diff --git a/src/AMIInterpolation/patches/cyclicAMIPolyPatch/cyclicAMIPolyPatch.C b/src/AMIInterpolation/patches/cyclicAMIPolyPatch/cyclicAMIPolyPatch.C
index 46577d1665..d3dd917a38 100644
--- a/src/AMIInterpolation/patches/cyclicAMIPolyPatch/cyclicAMIPolyPatch.C
+++ b/src/AMIInterpolation/patches/cyclicAMIPolyPatch/cyclicAMIPolyPatch.C
@@ -240,9 +240,9 @@ const Foam::searchableSurface& Foam::cyclicAMIPolyPatch::surf()
             IOobject
             (
                 surfName,
-                boundaryMesh().mesh().time().constant(),
+                mesh.time().constant(),
                 "triSurface",
-                boundaryMesh().mesh(),
+                mesh,
                 IOobject::MUST_READ,
                 IOobject::NO_WRITE
             ),
@@ -414,7 +414,7 @@ Foam::cyclicAMIPolyPatch::cyclicAMIPolyPatch
     separationVector_(vector::zero),
     AMIPtr_(NULL),
     surfPtr_(NULL),
-    surfDict_(dict.subDict("surface"))
+    surfDict_(dict.subOrEmptyDict("surface"))
 {
     if (nbrPatchName_ == name)
     {

From fe2633b094813ca9f96e178d9f6da929619b294d Mon Sep 17 00:00:00 2001
From: andy <andy>
Date: Wed, 24 Aug 2011 09:46:39 +0100
Subject: [PATCH 14/45] ENH: Added AMI mixed tutorial case

---
 .../pimpleDyMFoam/mixerVesselAMI2D/0/U        |   56 +
 .../pimpleDyMFoam/mixerVesselAMI2D/0/epsilon  |   58 +
 .../pimpleDyMFoam/mixerVesselAMI2D/0/k        |   58 +
 .../pimpleDyMFoam/mixerVesselAMI2D/0/nut      |   58 +
 .../pimpleDyMFoam/mixerVesselAMI2D/0/p        |   54 +
 .../pimpleDyMFoam/mixerVesselAMI2D/Allrun     |   13 +
 .../mixerVesselAMI2D/constant/MRFZones        |   31 +
 .../mixerVesselAMI2D/constant/RASProperties   |   25 +
 .../mixerVesselAMI2D/constant/dynamicMeshDict |   35 +
 .../constant/polyMesh/blockMeshDict.m4        |  880 +++++++++++
 .../constant/polyMesh/boundary                |   78 +
 .../constant/transportProperties              |   39 +
 .../constant/triSurface/projectionSurface.stl | 1346 +++++++++++++++++
 .../constant/turbulenceProperties             |   21 +
 .../pimpleDyMFoam/mixerVesselAMI2D/makeMesh   |    5 +
 .../mixerVesselAMI2D/system/controlDict       |   54 +
 .../mixerVesselAMI2D/system/fvSchemes         |   64 +
 .../mixerVesselAMI2D/system/fvSolution        |   83 +
 18 files changed, 2958 insertions(+)
 create mode 100644 tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/0/U
 create mode 100644 tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/0/epsilon
 create mode 100644 tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/0/k
 create mode 100644 tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/0/nut
 create mode 100644 tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/0/p
 create mode 100755 tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/Allrun
 create mode 100644 tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/constant/MRFZones
 create mode 100644 tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/constant/RASProperties
 create mode 100644 tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/constant/dynamicMeshDict
 create mode 100644 tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/constant/polyMesh/blockMeshDict.m4
 create mode 100644 tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/constant/polyMesh/boundary
 create mode 100644 tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/constant/transportProperties
 create mode 100644 tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/constant/triSurface/projectionSurface.stl
 create mode 100644 tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/constant/turbulenceProperties
 create mode 100755 tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/makeMesh
 create mode 100644 tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/system/controlDict
 create mode 100644 tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/system/fvSchemes
 create mode 100644 tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/system/fvSolution

diff --git a/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/0/U b/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/0/U
new file mode 100644
index 0000000000..19bc03110e
--- /dev/null
+++ b/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/0/U
@@ -0,0 +1,56 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  dev                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.com                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       volVectorField;
+    object      U;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+dimensions      [0 1 -1 0 0 0 0];
+
+internalField   uniform (0 0 0);
+
+boundaryField
+{
+    rotor
+    {
+        type            movingWallVelocity; // fixedValue;
+        value           uniform (0 0 0);
+    }
+
+    stator
+    {
+        type            movingWallVelocity; // fixedValue;
+        value           uniform (0 0 0);
+    }
+
+    front
+    {
+        type            empty;
+    }
+
+    back
+    {
+        type            empty;
+    }
+
+    AMI1
+    {
+        type            cyclicAMI;
+    }
+
+    AMI2
+    {
+        type            cyclicAMI;
+    }
+}
+
+// ************************************************************************* //
diff --git a/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/0/epsilon b/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/0/epsilon
new file mode 100644
index 0000000000..31ea22a3f1
--- /dev/null
+++ b/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/0/epsilon
@@ -0,0 +1,58 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  dev                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.com                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       volScalarField;
+    location    "0";
+    object      epsilon;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+dimensions      [ 0 2 -3 0 0 0 0 ];
+
+internalField   uniform 20;
+
+boundaryField
+{
+    rotor
+    {
+        type            epsilonWallFunction;
+        value           uniform 0;
+    }
+
+    stator
+    {
+        type            epsilonWallFunction;
+        value           uniform 0;
+    }
+
+    front
+    {
+        type            empty;
+    }
+
+    back
+    {
+        type            empty;
+    }
+
+    AMI1
+    {
+        type            cyclicAMI;
+    }
+
+    AMI2
+    {
+        type            cyclicAMI;
+    }
+}
+
+
+// ************************************************************************* //
diff --git a/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/0/k b/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/0/k
new file mode 100644
index 0000000000..cc4fd2a643
--- /dev/null
+++ b/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/0/k
@@ -0,0 +1,58 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  dev                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.com                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       volScalarField;
+    location    "0";
+    object      k;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+dimensions      [ 0 2 -2 0 0 0 0 ];
+
+internalField   uniform 1;
+
+boundaryField
+{
+    rotor
+    {
+        type            kqRWallFunction;
+        value           uniform 0;
+    }
+
+    stator
+    {
+        type            kqRWallFunction;
+        value           uniform 0;
+    }
+
+    front
+    {
+        type            empty;
+    }
+
+    back
+    {
+        type            empty;
+    }
+
+    AMI1
+    {
+        type            cyclicAMI;
+    }
+
+    AMI2
+    {
+        type            cyclicAMI;
+    }
+}
+
+
+// ************************************************************************* //
diff --git a/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/0/nut b/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/0/nut
new file mode 100644
index 0000000000..e741466a01
--- /dev/null
+++ b/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/0/nut
@@ -0,0 +1,58 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  dev                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.com                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       volScalarField;
+    location    "0";
+    object      nut;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+dimensions      [ 0 2 -1 0 0 0 0 ];
+
+internalField   uniform 0;
+
+boundaryField
+{
+    rotor
+    {
+        type            nutkWallFunction;
+        value           uniform 0;
+    }
+
+    stator
+    {
+        type            nutkWallFunction;
+        value           uniform 0;
+    }
+
+    front
+    {
+        type            empty;
+    }
+
+    back
+    {
+        type            empty;
+    }
+
+    AMI1
+    {
+        type            cyclicAMI;
+    }
+
+    AMI2
+    {
+        type            cyclicAMI;
+    }
+}
+
+
+// ************************************************************************* //
diff --git a/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/0/p b/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/0/p
new file mode 100644
index 0000000000..7c1fd17b01
--- /dev/null
+++ b/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/0/p
@@ -0,0 +1,54 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  dev                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.com                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       volScalarField;
+    object      p;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+dimensions      [0 2 -2 0 0 0 0];
+
+internalField   uniform 0;
+
+boundaryField
+{
+    rotor
+    {
+        type            zeroGradient;
+    }
+
+    stator
+    {
+        type            zeroGradient;
+    }
+
+    front
+    {
+        type            empty;
+    }
+
+    back
+    {
+        type            empty;
+    }
+
+    AMI1
+    {
+        type            cyclicAMI;
+    }
+
+    AMI2
+    {
+        type            cyclicAMI;
+    }
+}
+
+// ************************************************************************* //
diff --git a/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/Allrun b/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/Allrun
new file mode 100755
index 0000000000..9210b03c39
--- /dev/null
+++ b/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/Allrun
@@ -0,0 +1,13 @@
+#!/bin/sh
+cd ${0%/*} || exit 1    # run from this directory
+
+
+# Source tutorial run functions
+. $WM_PROJECT_DIR/bin/tools/RunFunctions
+
+application=`getApplication`
+
+./makeMesh
+runApplication $application
+
+# ----------------------------------------------------------------- end-of-file
diff --git a/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/constant/MRFZones b/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/constant/MRFZones
new file mode 100644
index 0000000000..1552f8fc99
--- /dev/null
+++ b/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/constant/MRFZones
@@ -0,0 +1,31 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  dev                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.com                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    location    "constant";
+    object      MRFZones;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+1
+(
+    rotor
+    {
+        // Fixed patches (by default they 'move' with the MRF zone)
+        nonRotatingPatches ();
+
+        origin    origin [0 1 0 0 0 0 0]  (0 0 0);
+        axis      axis   [0 0 0 0 0 0 0]  (0 0 1);
+        omega     omega  [0 0 -1 0 0 0 0] 104.72;
+    }
+)
+
+// ************************************************************************* //
diff --git a/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/constant/RASProperties b/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/constant/RASProperties
new file mode 100644
index 0000000000..67d4d8212c
--- /dev/null
+++ b/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/constant/RASProperties
@@ -0,0 +1,25 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  dev                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.com                      |
+|    \\/     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/mixerVesselAMI2D/constant/dynamicMeshDict b/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/constant/dynamicMeshDict
new file mode 100644
index 0000000000..571ce9ea44
--- /dev/null
+++ b/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/constant/dynamicMeshDict
@@ -0,0 +1,35 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  2.0.0                                 |
+|   \\  /    A nd           | Web:      www.OpenFOAM.com                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    location    "constant";
+    object      dynamicMeshDict;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+dynamicFvMesh   solidBodyMotionFvMesh;
+
+motionSolverLibs ( "libfvMotionSolvers.so" );
+
+solidBodyMotionFvMeshCoeffs
+{
+    cellZone        rotor;
+
+    solidBodyMotionFunction  rotatingMotion;
+    rotatingMotionCoeffs
+    {
+        CofG        (0 0 0);
+        radialVelocity (0 0 360); // deg/s
+    }
+}
+
+
+// ************************************************************************* //
diff --git a/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/constant/polyMesh/blockMeshDict.m4 b/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/constant/polyMesh/blockMeshDict.m4
new file mode 100644
index 0000000000..5aaae14461
--- /dev/null
+++ b/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/constant/polyMesh/blockMeshDict.m4
@@ -0,0 +1,880 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  dev                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.com                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    `format'      ascii;
+    class       dictionary;
+    object      blockMeshDict;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+// General macros to create 2D/extruded-2D meshes
+
+changecom(//)changequote([,])
+define(calc, [esyscmd(perl -e 'print ($1)')])
+define(VCOUNT, 0)
+define(vlabel, [[// ]Vertex $1 = VCOUNT define($1, VCOUNT)define([VCOUNT], incr(VCOUNT))])
+define(pi, 3.14159265)
+
+define(hex2D, hex ($1b $2b $3b $4b $1t $2t $3t $4t))
+define(quad2D, ($1b $2b $2t $1t))
+define(frontQuad, ($1t $2t $3t $4t))
+define(backQuad, ($1b $4b $3b $2b))
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+convertToMeters 0.1;
+
+// Hub radius
+define(r, 0.2)
+
+// Impeller-tip radius
+define(rb, 0.5)
+
+// Baffle-tip radius
+define(Rb, 0.7)
+
+// Tank radius
+define(R, 1)
+
+// MRF region radius
+define(ri, calc(0.5*(rb + Rb)))
+
+// Thickness of 2D slab
+define(z, 0.1)
+
+// Base z
+define(Zb, 0)
+
+// Top z
+define(Zt, calc(Zb + z))
+
+// Number of cells radially between hub and impeller tip
+define(Nr, 12)
+
+// Number of cells radially in each of the two regions between
+// impeller and baffle tips
+define(Ni, 4)
+
+// Number of cells radially between baffle tip and tank
+define(NR, 12)
+
+// Number of cells azimuthally in each of the 8 blocks
+define(Na, 12)
+
+// Number of cells in the thickness of the slab
+define(Nz, 1)
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+define(vert, (x$1$2 y$1$2 $3))
+define(evert, (ex$1$2 ey$1$2 $3))
+
+define(a0, 0)
+define(a1, -45)
+define(a2, -90)
+define(a3, -135)
+define(a4, 180)
+define(a5, 135)
+define(a6, 90)
+define(a7, 45)
+
+define(ea0, -22.5)
+define(ea1, -67.5)
+define(ea2, -112.5)
+define(ea3, -157.5)
+define(ea4, 157.5)
+define(ea5, 112.5)
+define(ea6, 67.5)
+define(ea7, 22.5)
+
+define(ca0, calc(cos((pi/180)*a0)))
+define(ca1, calc(cos((pi/180)*a1)))
+define(ca2, calc(cos((pi/180)*a2)))
+define(ca3, calc(cos((pi/180)*a3)))
+define(ca4, calc(cos((pi/180)*a4)))
+define(ca5, calc(cos((pi/180)*a5)))
+define(ca6, calc(cos((pi/180)*a6)))
+define(ca7, calc(cos((pi/180)*a7)))
+
+define(sa0, calc(sin((pi/180)*a0)))
+define(sa1, calc(sin((pi/180)*a1)))
+define(sa2, calc(sin((pi/180)*a2)))
+define(sa3, calc(sin((pi/180)*a3)))
+define(sa4, calc(sin((pi/180)*a4)))
+define(sa5, calc(sin((pi/180)*a5)))
+define(sa6, calc(sin((pi/180)*a6)))
+define(sa7, calc(sin((pi/180)*a7)))
+
+define(cea0, calc(cos((pi/180)*ea0)))
+define(cea1, calc(cos((pi/180)*ea1)))
+define(cea2, calc(cos((pi/180)*ea2)))
+define(cea3, calc(cos((pi/180)*ea3)))
+define(cea4, calc(cos((pi/180)*ea4)))
+define(cea5, calc(cos((pi/180)*ea5)))
+define(cea6, calc(cos((pi/180)*ea6)))
+define(cea7, calc(cos((pi/180)*ea7)))
+
+define(sea0, calc(sin((pi/180)*ea0)))
+define(sea1, calc(sin((pi/180)*ea1)))
+define(sea2, calc(sin((pi/180)*ea2)))
+define(sea3, calc(sin((pi/180)*ea3)))
+define(sea4, calc(sin((pi/180)*ea4)))
+define(sea5, calc(sin((pi/180)*ea5)))
+define(sea6, calc(sin((pi/180)*ea6)))
+define(sea7, calc(sin((pi/180)*ea7)))
+
+define(x00, calc(r*ca0))
+define(x01, calc(r*ca1))
+define(x02, calc(r*ca2))
+define(x03, calc(r*ca3))
+define(x04, calc(r*ca4))
+define(x05, calc(r*ca5))
+define(x06, calc(r*ca6))
+define(x07, calc(r*ca7))
+
+define(x10, calc(rb*ca0))
+define(x11, calc(rb*ca1))
+define(x12, calc(rb*ca2))
+define(x13, calc(rb*ca3))
+define(x14, calc(rb*ca4))
+define(x15, calc(rb*ca5))
+define(x16, calc(rb*ca6))
+define(x17, calc(rb*ca7))
+
+define(x20, calc(ri*ca0))
+define(x21, calc(ri*ca1))
+define(x22, calc(ri*ca2))
+define(x23, calc(ri*ca3))
+define(x24, calc(ri*ca4))
+define(x25, calc(ri*ca5))
+define(x26, calc(ri*ca6))
+define(x27, calc(ri*ca7))
+
+define(x30, calc(Rb*ca0))
+define(x31, calc(Rb*ca1))
+define(x32, calc(Rb*ca2))
+define(x33, calc(Rb*ca3))
+define(x34, calc(Rb*ca4))
+define(x35, calc(Rb*ca5))
+define(x36, calc(Rb*ca6))
+define(x37, calc(Rb*ca7))
+
+define(x40, calc(R*ca0))
+define(x41, calc(R*ca1))
+define(x42, calc(R*ca2))
+define(x43, calc(R*ca3))
+define(x44, calc(R*ca4))
+define(x45, calc(R*ca5))
+define(x46, calc(R*ca6))
+define(x47, calc(R*ca7))
+
+define(y00, calc(r*sa0))
+define(y01, calc(r*sa1))
+define(y02, calc(r*sa2))
+define(y03, calc(r*sa3))
+define(y04, calc(r*sa4))
+define(y05, calc(r*sa5))
+define(y06, calc(r*sa6))
+define(y07, calc(r*sa7))
+
+define(y10, calc(rb*sa0))
+define(y11, calc(rb*sa1))
+define(y12, calc(rb*sa2))
+define(y13, calc(rb*sa3))
+define(y14, calc(rb*sa4))
+define(y15, calc(rb*sa5))
+define(y16, calc(rb*sa6))
+define(y17, calc(rb*sa7))
+
+define(y20, calc(ri*sa0))
+define(y21, calc(ri*sa1))
+define(y22, calc(ri*sa2))
+define(y23, calc(ri*sa3))
+define(y24, calc(ri*sa4))
+define(y25, calc(ri*sa5))
+define(y26, calc(ri*sa6))
+define(y27, calc(ri*sa7))
+
+define(y30, calc(Rb*sa0))
+define(y31, calc(Rb*sa1))
+define(y32, calc(Rb*sa2))
+define(y33, calc(Rb*sa3))
+define(y34, calc(Rb*sa4))
+define(y35, calc(Rb*sa5))
+define(y36, calc(Rb*sa6))
+define(y37, calc(Rb*sa7))
+
+define(y40, calc(R*sa0))
+define(y41, calc(R*sa1))
+define(y42, calc(R*sa2))
+define(y43, calc(R*sa3))
+define(y44, calc(R*sa4))
+define(y45, calc(R*sa5))
+define(y46, calc(R*sa6))
+define(y47, calc(R*sa7))
+
+define(ex00, calc(r*cea0))
+define(ex01, calc(r*cea1))
+define(ex02, calc(r*cea2))
+define(ex03, calc(r*cea3))
+define(ex04, calc(r*cea4))
+define(ex05, calc(r*cea5))
+define(ex06, calc(r*cea6))
+define(ex07, calc(r*cea7))
+
+define(ex10, calc(rb*cea0))
+define(ex11, calc(rb*cea1))
+define(ex12, calc(rb*cea2))
+define(ex13, calc(rb*cea3))
+define(ex14, calc(rb*cea4))
+define(ex15, calc(rb*cea5))
+define(ex16, calc(rb*cea6))
+define(ex17, calc(rb*cea7))
+
+define(ex20, calc(ri*cea0))
+define(ex21, calc(ri*cea1))
+define(ex22, calc(ri*cea2))
+define(ex23, calc(ri*cea3))
+define(ex24, calc(ri*cea4))
+define(ex25, calc(ri*cea5))
+define(ex26, calc(ri*cea6))
+define(ex27, calc(ri*cea7))
+
+define(ex30, calc(Rb*cea0))
+define(ex31, calc(Rb*cea1))
+define(ex32, calc(Rb*cea2))
+define(ex33, calc(Rb*cea3))
+define(ex34, calc(Rb*cea4))
+define(ex35, calc(Rb*cea5))
+define(ex36, calc(Rb*cea6))
+define(ex37, calc(Rb*cea7))
+
+define(ex40, calc(R*cea0))
+define(ex41, calc(R*cea1))
+define(ex42, calc(R*cea2))
+define(ex43, calc(R*cea3))
+define(ex44, calc(R*cea4))
+define(ex45, calc(R*cea5))
+define(ex46, calc(R*cea6))
+define(ex47, calc(R*cea7))
+
+define(ey00, calc(r*sea0))
+define(ey01, calc(r*sea1))
+define(ey02, calc(r*sea2))
+define(ey03, calc(r*sea3))
+define(ey04, calc(r*sea4))
+define(ey05, calc(r*sea5))
+define(ey06, calc(r*sea6))
+define(ey07, calc(r*sea7))
+
+define(ey10, calc(rb*sea0))
+define(ey11, calc(rb*sea1))
+define(ey12, calc(rb*sea2))
+define(ey13, calc(rb*sea3))
+define(ey14, calc(rb*sea4))
+define(ey15, calc(rb*sea5))
+define(ey16, calc(rb*sea6))
+define(ey17, calc(rb*sea7))
+
+define(ey20, calc(ri*sea0))
+define(ey21, calc(ri*sea1))
+define(ey22, calc(ri*sea2))
+define(ey23, calc(ri*sea3))
+define(ey24, calc(ri*sea4))
+define(ey25, calc(ri*sea5))
+define(ey26, calc(ri*sea6))
+define(ey27, calc(ri*sea7))
+
+define(ey30, calc(Rb*sea0))
+define(ey31, calc(Rb*sea1))
+define(ey32, calc(Rb*sea2))
+define(ey33, calc(Rb*sea3))
+define(ey34, calc(Rb*sea4))
+define(ey35, calc(Rb*sea5))
+define(ey36, calc(Rb*sea6))
+define(ey37, calc(Rb*sea7))
+
+define(ey40, calc(R*sea0))
+define(ey41, calc(R*sea1))
+define(ey42, calc(R*sea2))
+define(ey43, calc(R*sea3))
+define(ey44, calc(R*sea4))
+define(ey45, calc(R*sea5))
+define(ey46, calc(R*sea6))
+define(ey47, calc(R*sea7))
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+vertices
+(
+    vert(0, 0, Zb) vlabel(r0b)
+    vert(0, 0, Zb) vlabel(r0sb)
+    vert(0, 1, Zb) vlabel(r1b)
+    vert(0, 2, Zb) vlabel(r2b)
+    vert(0, 2, Zb) vlabel(r2sb)
+    vert(0, 3, Zb) vlabel(r3b)
+    vert(0, 4, Zb) vlabel(r4b)
+    vert(0, 4, Zb) vlabel(r4sb)
+    vert(0, 5, Zb) vlabel(r5b)
+    vert(0, 6, Zb) vlabel(r6b)
+    vert(0, 6, Zb) vlabel(r6sb)
+    vert(0, 7, Zb) vlabel(r7b)
+
+    vert(1, 0, Zb) vlabel(rb0b)
+    vert(1, 1, Zb) vlabel(rb1b)
+    vert(1, 2, Zb) vlabel(rb2b)
+    vert(1, 3, Zb) vlabel(rb3b)
+    vert(1, 4, Zb) vlabel(rb4b)
+    vert(1, 5, Zb) vlabel(rb5b)
+    vert(1, 6, Zb) vlabel(rb6b)
+    vert(1, 7, Zb) vlabel(rb7b)
+
+    vert(2, 0, Zb) vlabel(ri0b)
+    vert(2, 1, Zb) vlabel(ri1b)
+    vert(2, 2, Zb) vlabel(ri2b)
+    vert(2, 3, Zb) vlabel(ri3b)
+    vert(2, 4, Zb) vlabel(ri4b)
+    vert(2, 5, Zb) vlabel(ri5b)
+    vert(2, 6, Zb) vlabel(ri6b)
+    vert(2, 7, Zb) vlabel(ri7b)
+
+    vert(2, 0, Zb) vlabel(ris0b)
+    vert(2, 1, Zb) vlabel(ris1b)
+    vert(2, 2, Zb) vlabel(ris2b)
+    vert(2, 3, Zb) vlabel(ris3b)
+    vert(2, 4, Zb) vlabel(ris4b)
+    vert(2, 5, Zb) vlabel(ris5b)
+    vert(2, 6, Zb) vlabel(ris6b)
+    vert(2, 7, Zb) vlabel(ris7b)
+
+    vert(3, 0, Zb) vlabel(Rb0b)
+    vert(3, 1, Zb) vlabel(Rb1b)
+    vert(3, 2, Zb) vlabel(Rb2b)
+    vert(3, 3, Zb) vlabel(Rb3b)
+    vert(3, 4, Zb) vlabel(Rb4b)
+    vert(3, 5, Zb) vlabel(Rb5b)
+    vert(3, 6, Zb) vlabel(Rb6b)
+    vert(3, 7, Zb) vlabel(Rb7b)
+
+    vert(4, 0, Zb) vlabel(R0b)
+    vert(4, 1, Zb) vlabel(R1b)
+    vert(4, 1, Zb) vlabel(R1sb)
+    vert(4, 2, Zb) vlabel(R2b)
+    vert(4, 3, Zb) vlabel(R3b)
+    vert(4, 3, Zb) vlabel(R3sb)
+    vert(4, 4, Zb) vlabel(R4b)
+    vert(4, 5, Zb) vlabel(R5b)
+    vert(4, 5, Zb) vlabel(R5sb)
+    vert(4, 6, Zb) vlabel(R6b)
+    vert(4, 7, Zb) vlabel(R7b)
+    vert(4, 7, Zb) vlabel(R7sb)
+
+    vert(0, 0, Zt) vlabel(r0t)
+    vert(0, 0, Zt) vlabel(r0st)
+    vert(0, 1, Zt) vlabel(r1t)
+    vert(0, 2, Zt) vlabel(r2t)
+    vert(0, 2, Zt) vlabel(r2st)
+    vert(0, 3, Zt) vlabel(r3t)
+    vert(0, 4, Zt) vlabel(r4t)
+    vert(0, 4, Zt) vlabel(r4st)
+    vert(0, 5, Zt) vlabel(r5t)
+    vert(0, 6, Zt) vlabel(r6t)
+    vert(0, 6, Zt) vlabel(r6st)
+    vert(0, 7, Zt) vlabel(r7t)
+
+    vert(1, 0, Zt) vlabel(rb0t)
+    vert(1, 1, Zt) vlabel(rb1t)
+    vert(1, 2, Zt) vlabel(rb2t)
+    vert(1, 3, Zt) vlabel(rb3t)
+    vert(1, 4, Zt) vlabel(rb4t)
+    vert(1, 5, Zt) vlabel(rb5t)
+    vert(1, 6, Zt) vlabel(rb6t)
+    vert(1, 7, Zt) vlabel(rb7t)
+
+    vert(2, 0, Zt) vlabel(ri0t)
+    vert(2, 1, Zt) vlabel(ri1t)
+    vert(2, 2, Zt) vlabel(ri2t)
+    vert(2, 3, Zt) vlabel(ri3t)
+    vert(2, 4, Zt) vlabel(ri4t)
+    vert(2, 5, Zt) vlabel(ri5t)
+    vert(2, 6, Zt) vlabel(ri6t)
+    vert(2, 7, Zt) vlabel(ri7t)
+
+    vert(2, 0, Zt) vlabel(ris0t)
+    vert(2, 1, Zt) vlabel(ris1t)
+    vert(2, 2, Zt) vlabel(ris2t)
+    vert(2, 3, Zt) vlabel(ris3t)
+    vert(2, 4, Zt) vlabel(ris4t)
+    vert(2, 5, Zt) vlabel(ris5t)
+    vert(2, 6, Zt) vlabel(ris6t)
+    vert(2, 7, Zt) vlabel(ris7t)
+
+    vert(3, 0, Zt) vlabel(Rb0t)
+    vert(3, 1, Zt) vlabel(Rb1t)
+    vert(3, 2, Zt) vlabel(Rb2t)
+    vert(3, 3, Zt) vlabel(Rb3t)
+    vert(3, 4, Zt) vlabel(Rb4t)
+    vert(3, 5, Zt) vlabel(Rb5t)
+    vert(3, 6, Zt) vlabel(Rb6t)
+    vert(3, 7, Zt) vlabel(Rb7t)
+
+    vert(4, 0, Zt) vlabel(R0t)
+    vert(4, 1, Zt) vlabel(R1t)
+    vert(4, 1, Zt) vlabel(R1st)
+    vert(4, 2, Zt) vlabel(R2t)
+    vert(4, 3, Zt) vlabel(R3t)
+    vert(4, 3, Zt) vlabel(R3st)
+    vert(4, 4, Zt) vlabel(R4t)
+    vert(4, 5, Zt) vlabel(R5t)
+    vert(4, 5, Zt) vlabel(R5st)
+    vert(4, 6, Zt) vlabel(R6t)
+    vert(4, 7, Zt) vlabel(R7t)
+    vert(4, 7, Zt) vlabel(R7st)
+);
+
+blocks
+(
+    // block0
+    hex2D(r0, r1, rb1, rb0)
+    rotor
+    (Na Nr Nz)
+    simpleGrading (1 1 1)
+
+    // block1
+    hex2D(r1, r2s, rb2, rb1)
+    rotor
+    (Na Nr Nz)
+    simpleGrading (1 1 1)
+
+    // block2
+    hex2D(r2, r3, rb3, rb2)
+    rotor
+    (Na Nr Nz)
+    simpleGrading (1 1 1)
+
+    // block3
+    hex2D(r3, r4s, rb4, rb3)
+    rotor
+    (Na Nr Nz)
+    simpleGrading (1 1 1)
+
+    // block4
+    hex2D(r4, r5, rb5, rb4)
+    rotor
+    (Na Nr Nz)
+    simpleGrading (1 1 1)
+
+    // block5
+    hex2D(r5, r6s, rb6, rb5)
+    rotor
+    (Na Nr Nz)
+    simpleGrading (1 1 1)
+
+    // block6
+    hex2D(r6, r7, rb7, rb6)
+    rotor
+    (Na Nr Nz)
+    simpleGrading (1 1 1)
+
+    // block7
+    hex2D(r7, r0s, rb0, rb7)
+    rotor
+    (Na Nr Nz)
+    simpleGrading (1 1 1)
+
+    // block0
+    hex2D(rb0, rb1, ri1, ri0)
+    rotor
+    (Na Ni Nz)
+    simpleGrading (1 1 1)
+
+    // block1
+    hex2D(rb1, rb2, ri2, ri1)
+    rotor
+    (Na Ni Nz)
+    simpleGrading (1 1 1)
+
+    // block2
+    hex2D(rb2, rb3, ri3, ri2)
+    rotor
+    (Na Ni Nz)
+    simpleGrading (1 1 1)
+
+    // block3
+    hex2D(rb3, rb4, ri4, ri3)
+    rotor
+    (Na Ni Nz)
+    simpleGrading (1 1 1)
+
+    // block4
+    hex2D(rb4, rb5, ri5, ri4)
+    rotor
+    (Na Ni Nz)
+    simpleGrading (1 1 1)
+
+    // block5
+    hex2D(rb5, rb6, ri6, ri5)
+    rotor
+    (Na Ni Nz)
+    simpleGrading (1 1 1)
+
+    // block6
+    hex2D(rb6, rb7, ri7, ri6)
+    rotor
+    (Na Ni Nz)
+    simpleGrading (1 1 1)
+
+    // block7
+    hex2D(rb7, rb0, ri0, ri7)
+    rotor
+    (Na Ni Nz)
+    simpleGrading (1 1 1)
+
+    // block0
+    hex2D(ris0, ris1, Rb1, Rb0)
+    (Na Ni Nz)
+    simpleGrading (1 1 1)
+
+    // block1
+    hex2D(ris1, ris2, Rb2, Rb1)
+    (Na Ni Nz)
+    simpleGrading (1 1 1)
+
+    // block2
+    hex2D(ris2, ris3, Rb3, Rb2)
+    (Na Ni Nz)
+    simpleGrading (1 1 1)
+
+    // block3
+    hex2D(ris3, ris4, Rb4, Rb3)
+    (Na Ni Nz)
+    simpleGrading (1 1 1)
+
+    // block4
+    hex2D(ris4, ris5, Rb5, Rb4)
+    (Na Ni Nz)
+    simpleGrading (1 1 1)
+
+    // block5
+    hex2D(ris5, ris6, Rb6, Rb5)
+    (Na Ni Nz)
+    simpleGrading (1 1 1)
+
+    // block6
+    hex2D(ris6, ris7, Rb7, Rb6)
+    (Na Ni Nz)
+    simpleGrading (1 1 1)
+
+    // block7
+    hex2D(ris7, ris0, Rb0, Rb7)
+    (Na Ni Nz)
+    simpleGrading (1 1 1)
+
+    // block0
+    hex2D(Rb0, Rb1, R1s, R0)
+    (Na NR Nz)
+    simpleGrading (1 1 1)
+
+    // block1
+    hex2D(Rb1, Rb2, R2, R1)
+    (Na NR Nz)
+    simpleGrading (1 1 1)
+
+    // block2
+    hex2D(Rb2, Rb3, R3s, R2)
+    (Na NR Nz)
+    simpleGrading (1 1 1)
+
+    // block3
+    hex2D(Rb3, Rb4, R4, R3)
+    (Na NR Nz)
+    simpleGrading (1 1 1)
+
+    // block4
+    hex2D(Rb4, Rb5, R5s, R4)
+    (Na NR Nz)
+    simpleGrading (1 1 1)
+
+    // block5
+    hex2D(Rb5, Rb6, R6, R5)
+    (Na NR Nz)
+    simpleGrading (1 1 1)
+
+    // block6
+    hex2D(Rb6, Rb7, R7s, R6)
+    (Na NR Nz)
+    simpleGrading (1 1 1)
+
+    // block7
+    hex2D(Rb7, Rb0, R0, R7)
+    (Na NR Nz)
+    simpleGrading (1 1 1)
+);
+
+edges
+(
+    arc r0b r1b evert(0, 0, Zb)
+    arc r1b r2sb evert(0, 1, Zb)
+    arc r2b r3b evert(0, 2, Zb)
+    arc r3b r4sb evert(0, 3, Zb)
+    arc r4b r5b evert(0, 4, Zb)
+    arc r5b r6sb evert(0, 5, Zb)
+    arc r6b r7b evert(0, 6, Zb)
+    arc r7b r0sb evert(0, 7, Zb)
+
+    arc rb0b rb1b evert(1, 0, Zb)
+    arc rb1b rb2b evert(1, 1, Zb)
+    arc rb2b rb3b evert(1, 2, Zb)
+    arc rb3b rb4b evert(1, 3, Zb)
+    arc rb4b rb5b evert(1, 4, Zb)
+    arc rb5b rb6b evert(1, 5, Zb)
+    arc rb6b rb7b evert(1, 6, Zb)
+    arc rb7b rb0b evert(1, 7, Zb)
+
+    arc ri0b ri1b evert(2, 0, Zb)
+    arc ri1b ri2b evert(2, 1, Zb)
+    arc ri2b ri3b evert(2, 2, Zb)
+    arc ri3b ri4b evert(2, 3, Zb)
+    arc ri4b ri5b evert(2, 4, Zb)
+    arc ri5b ri6b evert(2, 5, Zb)
+    arc ri6b ri7b evert(2, 6, Zb)
+    arc ri7b ri0b evert(2, 7, Zb)
+
+    arc ris0b ris1b evert(2, 0, Zb)
+    arc ris1b ris2b evert(2, 1, Zb)
+    arc ris2b ris3b evert(2, 2, Zb)
+    arc ris3b ris4b evert(2, 3, Zb)
+    arc ris4b ris5b evert(2, 4, Zb)
+    arc ris5b ris6b evert(2, 5, Zb)
+    arc ris6b ris7b evert(2, 6, Zb)
+    arc ris7b ris0b evert(2, 7, Zb)
+
+    arc Rb0b Rb1b evert(3, 0, Zb)
+    arc Rb1b Rb2b evert(3, 1, Zb)
+    arc Rb2b Rb3b evert(3, 2, Zb)
+    arc Rb3b Rb4b evert(3, 3, Zb)
+    arc Rb4b Rb5b evert(3, 4, Zb)
+    arc Rb5b Rb6b evert(3, 5, Zb)
+    arc Rb6b Rb7b evert(3, 6, Zb)
+    arc Rb7b Rb0b evert(3, 7, Zb)
+
+    arc R0b R1sb evert(4, 0, Zb)
+    arc R1b R2b evert(4, 1, Zb)
+    arc R2b R3sb evert(4, 2, Zb)
+    arc R3b R4b evert(4, 3, Zb)
+    arc R4b R5sb evert(4, 4, Zb)
+    arc R5b R6b evert(4, 5, Zb)
+    arc R6b R7sb evert(4, 6, Zb)
+    arc R7b R0b evert(4, 7, Zb)
+
+    arc r0t r1t evert(0, 0, Zt)
+    arc r1t r2st evert(0, 1, Zt)
+    arc r2t r3t evert(0, 2, Zt)
+    arc r3t r4st evert(0, 3, Zt)
+    arc r4t r5t evert(0, 4, Zt)
+    arc r5t r6st evert(0, 5, Zt)
+    arc r6t r7t evert(0, 6, Zt)
+    arc r7t r0st evert(0, 7, Zt)
+
+    arc rb0t rb1t evert(1, 0, Zt)
+    arc rb1t rb2t evert(1, 1, Zt)
+    arc rb2t rb3t evert(1, 2, Zt)
+    arc rb3t rb4t evert(1, 3, Zt)
+    arc rb4t rb5t evert(1, 4, Zt)
+    arc rb5t rb6t evert(1, 5, Zt)
+    arc rb6t rb7t evert(1, 6, Zt)
+    arc rb7t rb0t evert(1, 7, Zt)
+
+    arc ri0t ri1t evert(2, 0, Zt)
+    arc ri1t ri2t evert(2, 1, Zt)
+    arc ri2t ri3t evert(2, 2, Zt)
+    arc ri3t ri4t evert(2, 3, Zt)
+    arc ri4t ri5t evert(2, 4, Zt)
+    arc ri5t ri6t evert(2, 5, Zt)
+    arc ri6t ri7t evert(2, 6, Zt)
+    arc ri7t ri0t evert(2, 7, Zt)
+
+    arc ris0t ris1t evert(2, 0, Zt)
+    arc ris1t ris2t evert(2, 1, Zt)
+    arc ris2t ris3t evert(2, 2, Zt)
+    arc ris3t ris4t evert(2, 3, Zt)
+    arc ris4t ris5t evert(2, 4, Zt)
+    arc ris5t ris6t evert(2, 5, Zt)
+    arc ris6t ris7t evert(2, 6, Zt)
+    arc ris7t ris0t evert(2, 7, Zt)
+
+    arc Rb0t Rb1t evert(3, 0, Zt)
+    arc Rb1t Rb2t evert(3, 1, Zt)
+    arc Rb2t Rb3t evert(3, 2, Zt)
+    arc Rb3t Rb4t evert(3, 3, Zt)
+    arc Rb4t Rb5t evert(3, 4, Zt)
+    arc Rb5t Rb6t evert(3, 5, Zt)
+    arc Rb6t Rb7t evert(3, 6, Zt)
+    arc Rb7t Rb0t evert(3, 7, Zt)
+
+    arc R0t R1st evert(4, 0, Zt)
+    arc R1t R2t evert(4, 1, Zt)
+    arc R2t R3st evert(4, 2, Zt)
+    arc R3t R4t evert(4, 3, Zt)
+    arc R4t R5st evert(4, 4, Zt)
+    arc R5t R6t evert(4, 5, Zt)
+    arc R6t R7st evert(4, 6, Zt)
+    arc R7t R0t evert(4, 7, Zt)
+);
+
+patches
+(
+    wall rotor
+    (
+        quad2D(r0, r1)
+        quad2D(r1, r2s)
+        quad2D(r2, r3)
+        quad2D(r3, r4s)
+        quad2D(r4, r5)
+        quad2D(r5, r6s)
+        quad2D(r6, r7)
+        quad2D(r7, r0s)
+
+        quad2D(r0, rb0)
+        quad2D(r0s, rb0)
+
+        quad2D(r2, rb2)
+        quad2D(r2s, rb2)
+
+        quad2D(r4, rb4)
+        quad2D(r4s, rb4)
+
+        quad2D(r6, rb6)
+        quad2D(r6s, rb6)
+    )
+
+    wall stator
+    (
+        quad2D(R0, R1s)
+        quad2D(R1, R2)
+        quad2D(R2, R3s)
+        quad2D(R3, R4)
+        quad2D(R4, R5s)
+        quad2D(R5, R6)
+        quad2D(R6, R7s)
+        quad2D(R7, R0)
+
+        quad2D(R1, Rb1)
+        quad2D(R1s, Rb1)
+
+        quad2D(R3, Rb3)
+        quad2D(R3s, Rb3)
+
+        quad2D(R5, Rb5)
+        quad2D(R5s, Rb5)
+
+        quad2D(R7, Rb7)
+        quad2D(R7s, Rb7)
+    )
+
+//    cyclicAMI AMI1
+    patch AMI1
+    (
+        quad2D(ri1, ri0)
+        quad2D(ri2, ri1)
+        quad2D(ri3, ri2)
+        quad2D(ri4, ri3)
+        quad2D(ri5, ri4)
+        quad2D(ri6, ri5)
+        quad2D(ri7, ri6)
+        quad2D(ri0, ri7)
+    )
+
+//    cyclicAMI AMI2
+    patch AMI2
+    (
+        quad2D(ris1, ris0)
+        quad2D(ris2, ris1)
+        quad2D(ris3, ris2)
+        quad2D(ris4, ris3)
+        quad2D(ris5, ris4)
+        quad2D(ris6, ris5)
+        quad2D(ris7, ris6)
+        quad2D(ris0, ris7)
+    )
+
+    empty front
+    (
+        frontQuad(r0, r1, rb1, rb0)
+        frontQuad(r1, r2s, rb2, rb1)
+        frontQuad(r2, r3, rb3, rb2)
+        frontQuad(r3, r4s, rb4, rb3)
+        frontQuad(r4, r5, rb5, rb4)
+        frontQuad(r5, r6s, rb6, rb5)
+        frontQuad(r6, r7, rb7, rb6)
+        frontQuad(r7, r0s, rb0, rb7)
+        frontQuad(rb0, rb1, ri1, ri0)
+        frontQuad(rb1, rb2, ri2, ri1)
+        frontQuad(rb2, rb3, ri3, ri2)
+        frontQuad(rb3, rb4, ri4, ri3)
+        frontQuad(rb4, rb5, ri5, ri4)
+        frontQuad(rb5, rb6, ri6, ri5)
+        frontQuad(rb6, rb7, ri7, ri6)
+        frontQuad(rb7, rb0, ri0, ri7)
+        frontQuad(ris0, ris1, Rb1, Rb0)
+        frontQuad(ris1, ris2, Rb2, Rb1)
+        frontQuad(ris2, ris3, Rb3, Rb2)
+        frontQuad(ris3, ris4, Rb4, Rb3)
+        frontQuad(ris4, ris5, Rb5, Rb4)
+        frontQuad(ris5, ris6, Rb6, Rb5)
+        frontQuad(ris6, ris7, Rb7, Rb6)
+        frontQuad(ris7, ris0, Rb0, Rb7)
+        frontQuad(Rb0, Rb1, R1s, R0)
+        frontQuad(Rb1, Rb2, R2, R1)
+        frontQuad(Rb2, Rb3, R3s, R2)
+        frontQuad(Rb3, Rb4, R4, R3)
+        frontQuad(Rb4, Rb5, R5s, R4)
+        frontQuad(Rb5, Rb6, R6, R5)
+        frontQuad(Rb6, Rb7, R7s, R6)
+        frontQuad(Rb7, Rb0, R0, R7)
+    )
+
+    empty back
+    (
+        backQuad(r0, r1, rb1, rb0)
+        backQuad(r1, r2s, rb2, rb1)
+        backQuad(r2, r3, rb3, rb2)
+        backQuad(r3, r4s, rb4, rb3)
+        backQuad(r4, r5, rb5, rb4)
+        backQuad(r5, r6s, rb6, rb5)
+        backQuad(r6, r7, rb7, rb6)
+        backQuad(r7, r0s, rb0, rb7)
+        backQuad(rb0, rb1, ri1, ri0)
+        backQuad(rb1, rb2, ri2, ri1)
+        backQuad(rb2, rb3, ri3, ri2)
+        backQuad(rb3, rb4, ri4, ri3)
+        backQuad(rb4, rb5, ri5, ri4)
+        backQuad(rb5, rb6, ri6, ri5)
+        backQuad(rb6, rb7, ri7, ri6)
+        backQuad(rb7, rb0, ri0, ri7)
+        backQuad(ris0, ris1, Rb1, Rb0)
+        backQuad(ris1, ris2, Rb2, Rb1)
+        backQuad(ris2, ris3, Rb3, Rb2)
+        backQuad(ris3, ris4, Rb4, Rb3)
+        backQuad(ris4, ris5, Rb5, Rb4)
+        backQuad(ris5, ris6, Rb6, Rb5)
+        backQuad(ris6, ris7, Rb7, Rb6)
+        backQuad(ris7, ris0, Rb0, Rb7)
+        backQuad(Rb0, Rb1, R1s, R0)
+        backQuad(Rb1, Rb2, R2, R1)
+        backQuad(Rb2, Rb3, R3s, R2)
+        backQuad(Rb3, Rb4, R4, R3)
+        backQuad(Rb4, Rb5, R5s, R4)
+        backQuad(Rb5, Rb6, R6, R5)
+        backQuad(Rb6, Rb7, R7s, R6)
+        backQuad(Rb7, Rb0, R0, R7)
+    )
+);
+
+// ************************************************************************* //
diff --git a/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/constant/polyMesh/boundary b/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/constant/polyMesh/boundary
new file mode 100644
index 0000000000..a3990b4b9e
--- /dev/null
+++ b/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/constant/polyMesh/boundary
@@ -0,0 +1,78 @@
+/*--------------------------------*- 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;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+6
+(
+    rotor
+    {
+        type            wall;
+        nFaces          192;
+        startFace       5856;
+    }
+    stator
+    {
+        type            wall;
+        nFaces          192;
+        startFace       6048;
+    }
+    AMI1
+    {
+        type            cyclicAMI;
+        nFaces          96;
+        startFace       6240;
+        matchTolerance  0.0001;
+        neighbourPatch  AMI2;
+        transform       translational;
+        separationVector (0 0 0);
+        surface         
+        {
+            type            triSurfaceMesh;
+            name            projectionSurface.stl;
+            projectPoints   yes;
+        }
+    }
+    AMI2
+    {
+        type            cyclicAMI;
+        nFaces          96;
+        startFace       6336;
+        matchTolerance  0.0001;
+        neighbourPatch  AMI1;
+        transform       translational;
+        separationVector (0 0 0);
+        surface         
+        {
+            type            triSurfaceMesh;
+            name            projectionSurface.stl;
+            projectPoints   yes;
+        }
+    }
+    front
+    {
+        type            empty;
+        nFaces          3072;
+        startFace       6432;
+    }
+    back
+    {
+        type            empty;
+        nFaces          3072;
+        startFace       9504;
+    }
+)
+
+// ************************************************************************* //
diff --git a/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/constant/transportProperties b/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/constant/transportProperties
new file mode 100644
index 0000000000..62cd127719
--- /dev/null
+++ b/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/constant/transportProperties
@@ -0,0 +1,39 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  dev                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.com                      |
+|    \\/     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-05;
+
+CrossPowerLawCoeffs
+{
+    nu0             nu0 [ 0 2 -1 0 0 0 0 ] 1e-06;
+    nuInf           nuInf [ 0 2 -1 0 0 0 0 ] 1e-06;
+    m               m [ 0 0 1 0 0 0 0 ] 1;
+    n               n [ 0 0 0 0 0 0 0 ] 1;
+}
+
+BirdCarreauCoeffs
+{
+    nu0             nu0 [ 0 2 -1 0 0 0 0 ] 1e-06;
+    nuInf           nuInf [ 0 2 -1 0 0 0 0 ] 1e-06;
+    k               k [ 0 0 1 0 0 0 0 ] 0;
+    n               n [ 0 0 0 0 0 0 0 ] 1;
+}
+
+
+// ************************************************************************* //
diff --git a/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/constant/triSurface/projectionSurface.stl b/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/constant/triSurface/projectionSurface.stl
new file mode 100644
index 0000000000..9488327587
--- /dev/null
+++ b/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/constant/triSurface/projectionSurface.stl
@@ -0,0 +1,1346 @@
+solid AMI1
+  facet normal 0.999464 -0.0327281 0
+    outer loop
+       vertex 0.06 0 0
+       vertex 0.06 0 0.01
+       vertex 0.0598715 -0.00392419 0.01
+    endloop
+  endfacet
+  facet normal 0.999464 -0.0327281 0
+    outer loop
+       vertex 0.0598715 -0.00392419 0.01
+       vertex 0.0598715 -0.00392419 0
+       vertex 0.06 0 0
+    endloop
+  endfacet
+  facet normal 0.995186 -0.0980062 0
+    outer loop
+       vertex 0.0598715 -0.00392419 0
+       vertex 0.0598715 -0.00392419 0.01
+       vertex 0.0594867 -0.00783157 0.01
+    endloop
+  endfacet
+  facet normal 0.995186 -0.0980062 0
+    outer loop
+       vertex 0.0594867 -0.00783157 0.01
+       vertex 0.0594867 -0.00783157 0
+       vertex 0.0598715 -0.00392419 0
+    endloop
+  endfacet
+  facet normal 0.986642 -0.162902 0
+    outer loop
+       vertex 0.0594867 -0.00783157 0
+       vertex 0.0594867 -0.00783157 0.01
+       vertex 0.0588471 -0.0117054 0.01
+    endloop
+  endfacet
+  facet normal 0.986642 -0.162902 0
+    outer loop
+       vertex 0.0588471 -0.0117054 0.01
+       vertex 0.0588471 -0.0117054 0
+       vertex 0.0594867 -0.00783157 0
+    endloop
+  endfacet
+  facet normal 0.973875 -0.227085 0
+    outer loop
+       vertex 0.0588471 -0.0117054 0
+       vertex 0.0588471 -0.0117054 0.01
+       vertex 0.0579555 -0.0155291 0.01
+    endloop
+  endfacet
+  facet normal 0.973875 -0.227085 0
+    outer loop
+       vertex 0.0579555 -0.0155291 0.01
+       vertex 0.0579555 -0.0155291 0
+       vertex 0.0588471 -0.0117054 0
+    endloop
+  endfacet
+  facet normal 0.956945 -0.29027 0
+    outer loop
+       vertex 0.0579555 -0.0155291 0
+       vertex 0.0579555 -0.0155291 0.01
+       vertex 0.0568158 -0.0192864 0.01
+    endloop
+  endfacet
+  facet normal 0.956945 -0.29027 0
+    outer loop
+       vertex 0.0568158 -0.0192864 0.01
+       vertex 0.0568158 -0.0192864 0
+       vertex 0.0579555 -0.0155291 0
+    endloop
+  endfacet
+  facet normal 0.935908 -0.352245 0
+    outer loop
+       vertex 0.0568158 -0.0192864 0
+       vertex 0.0568158 -0.0192864 0.01
+       vertex 0.0554328 -0.022961 0.01
+    endloop
+  endfacet
+  facet normal 0.935908 -0.352245 0
+    outer loop
+       vertex 0.0554328 -0.022961 0.01
+       vertex 0.0554328 -0.022961 0
+       vertex 0.0568158 -0.0192864 0
+    endloop
+  endfacet
+  facet normal 0.910864 -0.412707 0
+    outer loop
+       vertex 0.0554328 -0.022961 0
+       vertex 0.0554328 -0.022961 0.01
+       vertex 0.0538124 -0.0265373 0.01
+    endloop
+  endfacet
+  facet normal 0.910864 -0.412707 0
+    outer loop
+       vertex 0.0538124 -0.0265373 0.01
+       vertex 0.0538124 -0.0265373 0
+       vertex 0.0554328 -0.022961 0
+    endloop
+  endfacet
+  facet normal 0.881916 -0.471406 0
+    outer loop
+       vertex 0.0538124 -0.0265373 0
+       vertex 0.0538124 -0.0265373 0.01
+       vertex 0.0519615 -0.03 0.01
+    endloop
+  endfacet
+  facet normal 0.881916 -0.471406 0
+    outer loop
+       vertex 0.0519615 -0.03 0.01
+       vertex 0.0519615 -0.03 0
+       vertex 0.0538124 -0.0265373 0
+    endloop
+  endfacet
+  facet normal 0.849207 -0.528061 0
+    outer loop
+       vertex 0.0519615 -0.03 0
+       vertex 0.0519615 -0.03 0.01
+       vertex 0.0498882 -0.0333342 0.01
+    endloop
+  endfacet
+  facet normal 0.849207 -0.528061 0
+    outer loop
+       vertex 0.0498882 -0.0333342 0.01
+       vertex 0.0498882 -0.0333342 0
+       vertex 0.0519615 -0.03 0
+    endloop
+  endfacet
+  facet normal 0.812846 -0.582478 0
+    outer loop
+       vertex 0.0498882 -0.0333342 0
+       vertex 0.0498882 -0.0333342 0.01
+       vertex 0.0476012 -0.0365257 0.01
+    endloop
+  endfacet
+  facet normal 0.812846 -0.582478 0
+    outer loop
+       vertex 0.0476012 -0.0365257 0.01
+       vertex 0.0476012 -0.0365257 0
+       vertex 0.0498882 -0.0333342 0
+    endloop
+  endfacet
+  facet normal 0.773005 -0.634399 0
+    outer loop
+       vertex 0.0476012 -0.0365257 0
+       vertex 0.0476012 -0.0365257 0.01
+       vertex 0.0451104 -0.0395607 0.01
+    endloop
+  endfacet
+  facet normal 0.773005 -0.634399 0
+    outer loop
+       vertex 0.0451104 -0.0395607 0.01
+       vertex 0.0451104 -0.0395607 0
+       vertex 0.0476012 -0.0365257 0
+    endloop
+  endfacet
+  facet normal 0.729867 -0.683589 0
+    outer loop
+       vertex 0.0451104 -0.0395607 0
+       vertex 0.0451104 -0.0395607 0.01
+       vertex 0.0424264 -0.0424264 0.01
+    endloop
+  endfacet
+  facet normal 0.729867 -0.683589 0
+    outer loop
+       vertex 0.0424264 -0.0424264 0.01
+       vertex 0.0424264 -0.0424264 0
+       vertex 0.0451104 -0.0395607 0
+    endloop
+  endfacet
+  facet normal 0.683589 -0.729867 0
+    outer loop
+       vertex 0.0424264 -0.0424264 0
+       vertex 0.0424264 -0.0424264 0.01
+       vertex 0.0395607 -0.0451104 0.01
+    endloop
+  endfacet
+  facet normal 0.683589 -0.729867 0
+    outer loop
+       vertex 0.0395607 -0.0451104 0.01
+       vertex 0.0395607 -0.0451104 0
+       vertex 0.0424264 -0.0424264 0
+    endloop
+  endfacet
+  facet normal 0.634399 -0.773005 0
+    outer loop
+       vertex 0.0395607 -0.0451104 0
+       vertex 0.0395607 -0.0451104 0.01
+       vertex 0.0365257 -0.0476012 0.01
+    endloop
+  endfacet
+  facet normal 0.634399 -0.773005 0
+    outer loop
+       vertex 0.0365257 -0.0476012 0.01
+       vertex 0.0365257 -0.0476012 0
+       vertex 0.0395607 -0.0451104 0
+    endloop
+  endfacet
+  facet normal 0.582478 -0.812846 0
+    outer loop
+       vertex 0.0365257 -0.0476012 0
+       vertex 0.0365257 -0.0476012 0.01
+       vertex 0.0333342 -0.0498882 0.01
+    endloop
+  endfacet
+  facet normal 0.582478 -0.812846 0
+    outer loop
+       vertex 0.0333342 -0.0498882 0.01
+       vertex 0.0333342 -0.0498882 0
+       vertex 0.0365257 -0.0476012 0
+    endloop
+  endfacet
+  facet normal 0.528061 -0.849207 0
+    outer loop
+       vertex 0.0333342 -0.0498882 0
+       vertex 0.0333342 -0.0498882 0.01
+       vertex 0.03 -0.0519615 0.01
+    endloop
+  endfacet
+  facet normal 0.528061 -0.849207 0
+    outer loop
+       vertex 0.03 -0.0519615 0.01
+       vertex 0.03 -0.0519615 0
+       vertex 0.0333342 -0.0498882 0
+    endloop
+  endfacet
+  facet normal 0.471406 -0.881916 0
+    outer loop
+       vertex 0.03 -0.0519615 0
+       vertex 0.03 -0.0519615 0.01
+       vertex 0.0265373 -0.0538124 0.01
+    endloop
+  endfacet
+  facet normal 0.471406 -0.881916 0
+    outer loop
+       vertex 0.0265373 -0.0538124 0.01
+       vertex 0.0265373 -0.0538124 0
+       vertex 0.03 -0.0519615 0
+    endloop
+  endfacet
+  facet normal 0.412707 -0.910864 0
+    outer loop
+       vertex 0.0265373 -0.0538124 0
+       vertex 0.0265373 -0.0538124 0.01
+       vertex 0.022961 -0.0554328 0.01
+    endloop
+  endfacet
+  facet normal 0.412707 -0.910864 0
+    outer loop
+       vertex 0.022961 -0.0554328 0.01
+       vertex 0.022961 -0.0554328 0
+       vertex 0.0265373 -0.0538124 0
+    endloop
+  endfacet
+  facet normal 0.352245 -0.935908 0
+    outer loop
+       vertex 0.022961 -0.0554328 0
+       vertex 0.022961 -0.0554328 0.01
+       vertex 0.0192864 -0.0568158 0.01
+    endloop
+  endfacet
+  facet normal 0.352245 -0.935908 0
+    outer loop
+       vertex 0.0192864 -0.0568158 0.01
+       vertex 0.0192864 -0.0568158 0
+       vertex 0.022961 -0.0554328 0
+    endloop
+  endfacet
+  facet normal 0.29027 -0.956945 0
+    outer loop
+       vertex 0.0192864 -0.0568158 0
+       vertex 0.0192864 -0.0568158 0.01
+       vertex 0.0155291 -0.0579555 0.01
+    endloop
+  endfacet
+  facet normal 0.29027 -0.956945 0
+    outer loop
+       vertex 0.0155291 -0.0579555 0.01
+       vertex 0.0155291 -0.0579555 0
+       vertex 0.0192864 -0.0568158 0
+    endloop
+  endfacet
+  facet normal 0.227085 -0.973875 0
+    outer loop
+       vertex 0.0155291 -0.0579555 0
+       vertex 0.0155291 -0.0579555 0.01
+       vertex 0.0117054 -0.0588471 0.01
+    endloop
+  endfacet
+  facet normal 0.227085 -0.973875 0
+    outer loop
+       vertex 0.0117054 -0.0588471 0.01
+       vertex 0.0117054 -0.0588471 0
+       vertex 0.0155291 -0.0579555 0
+    endloop
+  endfacet
+  facet normal 0.162902 -0.986642 0
+    outer loop
+       vertex 0.0117054 -0.0588471 0
+       vertex 0.0117054 -0.0588471 0.01
+       vertex 0.00783157 -0.0594867 0.01
+    endloop
+  endfacet
+  facet normal 0.162902 -0.986642 0
+    outer loop
+       vertex 0.00783157 -0.0594867 0.01
+       vertex 0.00783157 -0.0594867 0
+       vertex 0.0117054 -0.0588471 0
+    endloop
+  endfacet
+  facet normal 0.0980062 -0.995186 0
+    outer loop
+       vertex 0.00783157 -0.0594867 0
+       vertex 0.00783157 -0.0594867 0.01
+       vertex 0.00392419 -0.0598715 0.01
+    endloop
+  endfacet
+  facet normal 0.0980062 -0.995186 0
+    outer loop
+       vertex 0.00392419 -0.0598715 0.01
+       vertex 0.00392419 -0.0598715 0
+       vertex 0.00783157 -0.0594867 0
+    endloop
+  endfacet
+  facet normal 0.0327281 -0.999464 0
+    outer loop
+       vertex 0.00392419 -0.0598715 0
+       vertex 0.00392419 -0.0598715 0.01
+       vertex 1.07694e-10 -0.06 0.01
+    endloop
+  endfacet
+  facet normal 0.0327281 -0.999464 0
+    outer loop
+       vertex 1.07694e-10 -0.06 0.01
+       vertex 1.07694e-10 -0.06 0
+       vertex 0.00392419 -0.0598715 0
+    endloop
+  endfacet
+  facet normal -0.0327281 -0.999464 0
+    outer loop
+       vertex 1.07694e-10 -0.06 0
+       vertex 1.07694e-10 -0.06 0.01
+       vertex -0.00392419 -0.0598715 0.01
+    endloop
+  endfacet
+  facet normal -0.0327281 -0.999464 -0
+    outer loop
+       vertex -0.00392419 -0.0598715 0.01
+       vertex -0.00392419 -0.0598715 0
+       vertex 1.07694e-10 -0.06 0
+    endloop
+  endfacet
+  facet normal -0.0980062 -0.995186 0
+    outer loop
+       vertex -0.00392419 -0.0598715 0
+       vertex -0.00392419 -0.0598715 0.01
+       vertex -0.00783157 -0.0594867 0.01
+    endloop
+  endfacet
+  facet normal -0.0980062 -0.995186 -0
+    outer loop
+       vertex -0.00783157 -0.0594867 0.01
+       vertex -0.00783157 -0.0594867 0
+       vertex -0.00392419 -0.0598715 0
+    endloop
+  endfacet
+  facet normal -0.162902 -0.986642 0
+    outer loop
+       vertex -0.00783157 -0.0594867 0
+       vertex -0.00783157 -0.0594867 0.01
+       vertex -0.0117054 -0.0588471 0.01
+    endloop
+  endfacet
+  facet normal -0.162902 -0.986642 -0
+    outer loop
+       vertex -0.0117054 -0.0588471 0.01
+       vertex -0.0117054 -0.0588471 0
+       vertex -0.00783157 -0.0594867 0
+    endloop
+  endfacet
+  facet normal -0.227085 -0.973875 0
+    outer loop
+       vertex -0.0117054 -0.0588471 0
+       vertex -0.0117054 -0.0588471 0.01
+       vertex -0.0155291 -0.0579555 0.01
+    endloop
+  endfacet
+  facet normal -0.227085 -0.973875 -0
+    outer loop
+       vertex -0.0155291 -0.0579555 0.01
+       vertex -0.0155291 -0.0579555 0
+       vertex -0.0117054 -0.0588471 0
+    endloop
+  endfacet
+  facet normal -0.29027 -0.956945 0
+    outer loop
+       vertex -0.0155291 -0.0579555 0
+       vertex -0.0155291 -0.0579555 0.01
+       vertex -0.0192864 -0.0568158 0.01
+    endloop
+  endfacet
+  facet normal -0.29027 -0.956945 -0
+    outer loop
+       vertex -0.0192864 -0.0568158 0.01
+       vertex -0.0192864 -0.0568158 0
+       vertex -0.0155291 -0.0579555 0
+    endloop
+  endfacet
+  facet normal -0.352245 -0.935908 0
+    outer loop
+       vertex -0.0192864 -0.0568158 0
+       vertex -0.0192864 -0.0568158 0.01
+       vertex -0.022961 -0.0554328 0.01
+    endloop
+  endfacet
+  facet normal -0.352245 -0.935908 -0
+    outer loop
+       vertex -0.022961 -0.0554328 0.01
+       vertex -0.022961 -0.0554328 0
+       vertex -0.0192864 -0.0568158 0
+    endloop
+  endfacet
+  facet normal -0.412707 -0.910864 0
+    outer loop
+       vertex -0.022961 -0.0554328 0
+       vertex -0.022961 -0.0554328 0.01
+       vertex -0.0265373 -0.0538124 0.01
+    endloop
+  endfacet
+  facet normal -0.412707 -0.910864 -0
+    outer loop
+       vertex -0.0265373 -0.0538124 0.01
+       vertex -0.0265373 -0.0538124 0
+       vertex -0.022961 -0.0554328 0
+    endloop
+  endfacet
+  facet normal -0.471406 -0.881916 0
+    outer loop
+       vertex -0.0265373 -0.0538124 0
+       vertex -0.0265373 -0.0538124 0.01
+       vertex -0.03 -0.0519615 0.01
+    endloop
+  endfacet
+  facet normal -0.471406 -0.881916 -0
+    outer loop
+       vertex -0.03 -0.0519615 0.01
+       vertex -0.03 -0.0519615 0
+       vertex -0.0265373 -0.0538124 0
+    endloop
+  endfacet
+  facet normal -0.528061 -0.849207 0
+    outer loop
+       vertex -0.03 -0.0519615 0
+       vertex -0.03 -0.0519615 0.01
+       vertex -0.0333342 -0.0498882 0.01
+    endloop
+  endfacet
+  facet normal -0.528061 -0.849207 -0
+    outer loop
+       vertex -0.0333342 -0.0498882 0.01
+       vertex -0.0333342 -0.0498882 0
+       vertex -0.03 -0.0519615 0
+    endloop
+  endfacet
+  facet normal -0.582478 -0.812846 0
+    outer loop
+       vertex -0.0333342 -0.0498882 0
+       vertex -0.0333342 -0.0498882 0.01
+       vertex -0.0365257 -0.0476012 0.01
+    endloop
+  endfacet
+  facet normal -0.582478 -0.812846 -0
+    outer loop
+       vertex -0.0365257 -0.0476012 0.01
+       vertex -0.0365257 -0.0476012 0
+       vertex -0.0333342 -0.0498882 0
+    endloop
+  endfacet
+  facet normal -0.634399 -0.773005 0
+    outer loop
+       vertex -0.0365257 -0.0476012 0
+       vertex -0.0365257 -0.0476012 0.01
+       vertex -0.0395607 -0.0451104 0.01
+    endloop
+  endfacet
+  facet normal -0.634399 -0.773005 -0
+    outer loop
+       vertex -0.0395607 -0.0451104 0.01
+       vertex -0.0395607 -0.0451104 0
+       vertex -0.0365257 -0.0476012 0
+    endloop
+  endfacet
+  facet normal -0.683589 -0.729867 0
+    outer loop
+       vertex -0.0395607 -0.0451104 0
+       vertex -0.0395607 -0.0451104 0.01
+       vertex -0.0424264 -0.0424264 0.01
+    endloop
+  endfacet
+  facet normal -0.683589 -0.729867 -0
+    outer loop
+       vertex -0.0424264 -0.0424264 0.01
+       vertex -0.0424264 -0.0424264 0
+       vertex -0.0395607 -0.0451104 0
+    endloop
+  endfacet
+  facet normal -0.729867 -0.683589 0
+    outer loop
+       vertex -0.0424264 -0.0424264 0
+       vertex -0.0424264 -0.0424264 0.01
+       vertex -0.0451104 -0.0395607 0.01
+    endloop
+  endfacet
+  facet normal -0.729867 -0.683589 -0
+    outer loop
+       vertex -0.0451104 -0.0395607 0.01
+       vertex -0.0451104 -0.0395607 0
+       vertex -0.0424264 -0.0424264 0
+    endloop
+  endfacet
+  facet normal -0.773005 -0.634399 0
+    outer loop
+       vertex -0.0451104 -0.0395607 0
+       vertex -0.0451104 -0.0395607 0.01
+       vertex -0.0476012 -0.0365257 0.01
+    endloop
+  endfacet
+  facet normal -0.773005 -0.634399 -0
+    outer loop
+       vertex -0.0476012 -0.0365257 0.01
+       vertex -0.0476012 -0.0365257 0
+       vertex -0.0451104 -0.0395607 0
+    endloop
+  endfacet
+  facet normal -0.812846 -0.582478 0
+    outer loop
+       vertex -0.0476012 -0.0365257 0
+       vertex -0.0476012 -0.0365257 0.01
+       vertex -0.0498882 -0.0333342 0.01
+    endloop
+  endfacet
+  facet normal -0.812846 -0.582478 -0
+    outer loop
+       vertex -0.0498882 -0.0333342 0.01
+       vertex -0.0498882 -0.0333342 0
+       vertex -0.0476012 -0.0365257 0
+    endloop
+  endfacet
+  facet normal -0.849207 -0.528061 0
+    outer loop
+       vertex -0.0498882 -0.0333342 0
+       vertex -0.0498882 -0.0333342 0.01
+       vertex -0.0519615 -0.03 0.01
+    endloop
+  endfacet
+  facet normal -0.849207 -0.528061 -0
+    outer loop
+       vertex -0.0519615 -0.03 0.01
+       vertex -0.0519615 -0.03 0
+       vertex -0.0498882 -0.0333342 0
+    endloop
+  endfacet
+  facet normal -0.881916 -0.471406 0
+    outer loop
+       vertex -0.0519615 -0.03 0
+       vertex -0.0519615 -0.03 0.01
+       vertex -0.0538124 -0.0265373 0.01
+    endloop
+  endfacet
+  facet normal -0.881916 -0.471406 -0
+    outer loop
+       vertex -0.0538124 -0.0265373 0.01
+       vertex -0.0538124 -0.0265373 0
+       vertex -0.0519615 -0.03 0
+    endloop
+  endfacet
+  facet normal -0.910864 -0.412707 0
+    outer loop
+       vertex -0.0538124 -0.0265373 0
+       vertex -0.0538124 -0.0265373 0.01
+       vertex -0.0554328 -0.022961 0.01
+    endloop
+  endfacet
+  facet normal -0.910864 -0.412707 -0
+    outer loop
+       vertex -0.0554328 -0.022961 0.01
+       vertex -0.0554328 -0.022961 0
+       vertex -0.0538124 -0.0265373 0
+    endloop
+  endfacet
+  facet normal -0.935908 -0.352245 0
+    outer loop
+       vertex -0.0554328 -0.022961 0
+       vertex -0.0554328 -0.022961 0.01
+       vertex -0.0568158 -0.0192864 0.01
+    endloop
+  endfacet
+  facet normal -0.935908 -0.352245 -0
+    outer loop
+       vertex -0.0568158 -0.0192864 0.01
+       vertex -0.0568158 -0.0192864 0
+       vertex -0.0554328 -0.022961 0
+    endloop
+  endfacet
+  facet normal -0.956945 -0.29027 0
+    outer loop
+       vertex -0.0568158 -0.0192864 0
+       vertex -0.0568158 -0.0192864 0.01
+       vertex -0.0579555 -0.0155291 0.01
+    endloop
+  endfacet
+  facet normal -0.956945 -0.29027 -0
+    outer loop
+       vertex -0.0579555 -0.0155291 0.01
+       vertex -0.0579555 -0.0155291 0
+       vertex -0.0568158 -0.0192864 0
+    endloop
+  endfacet
+  facet normal -0.973875 -0.227085 0
+    outer loop
+       vertex -0.0579555 -0.0155291 0
+       vertex -0.0579555 -0.0155291 0.01
+       vertex -0.0588471 -0.0117054 0.01
+    endloop
+  endfacet
+  facet normal -0.973875 -0.227085 -0
+    outer loop
+       vertex -0.0588471 -0.0117054 0.01
+       vertex -0.0588471 -0.0117054 0
+       vertex -0.0579555 -0.0155291 0
+    endloop
+  endfacet
+  facet normal -0.986642 -0.162902 0
+    outer loop
+       vertex -0.0588471 -0.0117054 0
+       vertex -0.0588471 -0.0117054 0.01
+       vertex -0.0594867 -0.00783157 0.01
+    endloop
+  endfacet
+  facet normal -0.986642 -0.162902 -0
+    outer loop
+       vertex -0.0594867 -0.00783157 0.01
+       vertex -0.0594867 -0.00783157 0
+       vertex -0.0588471 -0.0117054 0
+    endloop
+  endfacet
+  facet normal -0.995186 -0.0980062 0
+    outer loop
+       vertex -0.0594867 -0.00783157 0
+       vertex -0.0594867 -0.00783157 0.01
+       vertex -0.0598715 -0.00392419 0.01
+    endloop
+  endfacet
+  facet normal -0.995186 -0.0980062 -0
+    outer loop
+       vertex -0.0598715 -0.00392419 0.01
+       vertex -0.0598715 -0.00392419 0
+       vertex -0.0594867 -0.00783157 0
+    endloop
+  endfacet
+  facet normal -0.999464 -0.0327281 0
+    outer loop
+       vertex -0.0598715 -0.00392419 0
+       vertex -0.0598715 -0.00392419 0.01
+       vertex -0.06 2.15388e-10 0.01
+    endloop
+  endfacet
+  facet normal -0.999464 -0.0327281 -0
+    outer loop
+       vertex -0.06 2.15388e-10 0.01
+       vertex -0.06 2.15388e-10 0
+       vertex -0.0598715 -0.00392419 0
+    endloop
+  endfacet
+  facet normal -0.999464 0.0327281 0
+    outer loop
+       vertex -0.06 2.15388e-10 0
+       vertex -0.06 2.15388e-10 0.01
+       vertex -0.0598715 0.00392419 0.01
+    endloop
+  endfacet
+  facet normal -0.999464 0.0327281 0
+    outer loop
+       vertex -0.0598715 0.00392419 0.01
+       vertex -0.0598715 0.00392419 0
+       vertex -0.06 2.15388e-10 0
+    endloop
+  endfacet
+  facet normal -0.995186 0.0980062 0
+    outer loop
+       vertex -0.0598715 0.00392419 0
+       vertex -0.0598715 0.00392419 0.01
+       vertex -0.0594867 0.00783157 0.01
+    endloop
+  endfacet
+  facet normal -0.995186 0.0980062 0
+    outer loop
+       vertex -0.0594867 0.00783157 0.01
+       vertex -0.0594867 0.00783157 0
+       vertex -0.0598715 0.00392419 0
+    endloop
+  endfacet
+  facet normal -0.986642 0.162902 0
+    outer loop
+       vertex -0.0594867 0.00783157 0
+       vertex -0.0594867 0.00783157 0.01
+       vertex -0.0588471 0.0117054 0.01
+    endloop
+  endfacet
+  facet normal -0.986642 0.162902 0
+    outer loop
+       vertex -0.0588471 0.0117054 0.01
+       vertex -0.0588471 0.0117054 0
+       vertex -0.0594867 0.00783157 0
+    endloop
+  endfacet
+  facet normal -0.973875 0.227085 0
+    outer loop
+       vertex -0.0588471 0.0117054 0
+       vertex -0.0588471 0.0117054 0.01
+       vertex -0.0579555 0.0155291 0.01
+    endloop
+  endfacet
+  facet normal -0.973875 0.227085 0
+    outer loop
+       vertex -0.0579555 0.0155291 0.01
+       vertex -0.0579555 0.0155291 0
+       vertex -0.0588471 0.0117054 0
+    endloop
+  endfacet
+  facet normal -0.956945 0.29027 0
+    outer loop
+       vertex -0.0579555 0.0155291 0
+       vertex -0.0579555 0.0155291 0.01
+       vertex -0.0568158 0.0192864 0.01
+    endloop
+  endfacet
+  facet normal -0.956945 0.29027 0
+    outer loop
+       vertex -0.0568158 0.0192864 0.01
+       vertex -0.0568158 0.0192864 0
+       vertex -0.0579555 0.0155291 0
+    endloop
+  endfacet
+  facet normal -0.935908 0.352245 0
+    outer loop
+       vertex -0.0568158 0.0192864 0
+       vertex -0.0568158 0.0192864 0.01
+       vertex -0.0554328 0.022961 0.01
+    endloop
+  endfacet
+  facet normal -0.935908 0.352245 0
+    outer loop
+       vertex -0.0554328 0.022961 0.01
+       vertex -0.0554328 0.022961 0
+       vertex -0.0568158 0.0192864 0
+    endloop
+  endfacet
+  facet normal -0.910864 0.412707 0
+    outer loop
+       vertex -0.0554328 0.022961 0
+       vertex -0.0554328 0.022961 0.01
+       vertex -0.0538124 0.0265373 0.01
+    endloop
+  endfacet
+  facet normal -0.910864 0.412707 0
+    outer loop
+       vertex -0.0538124 0.0265373 0.01
+       vertex -0.0538124 0.0265373 0
+       vertex -0.0554328 0.022961 0
+    endloop
+  endfacet
+  facet normal -0.881916 0.471406 0
+    outer loop
+       vertex -0.0538124 0.0265373 0
+       vertex -0.0538124 0.0265373 0.01
+       vertex -0.0519615 0.03 0.01
+    endloop
+  endfacet
+  facet normal -0.881916 0.471406 0
+    outer loop
+       vertex -0.0519615 0.03 0.01
+       vertex -0.0519615 0.03 0
+       vertex -0.0538124 0.0265373 0
+    endloop
+  endfacet
+  facet normal -0.849207 0.528061 0
+    outer loop
+       vertex -0.0519615 0.03 0
+       vertex -0.0519615 0.03 0.01
+       vertex -0.0498882 0.0333342 0.01
+    endloop
+  endfacet
+  facet normal -0.849207 0.528061 0
+    outer loop
+       vertex -0.0498882 0.0333342 0.01
+       vertex -0.0498882 0.0333342 0
+       vertex -0.0519615 0.03 0
+    endloop
+  endfacet
+  facet normal -0.812846 0.582478 0
+    outer loop
+       vertex -0.0498882 0.0333342 0
+       vertex -0.0498882 0.0333342 0.01
+       vertex -0.0476012 0.0365257 0.01
+    endloop
+  endfacet
+  facet normal -0.812846 0.582478 0
+    outer loop
+       vertex -0.0476012 0.0365257 0.01
+       vertex -0.0476012 0.0365257 0
+       vertex -0.0498882 0.0333342 0
+    endloop
+  endfacet
+  facet normal -0.773005 0.634399 0
+    outer loop
+       vertex -0.0476012 0.0365257 0
+       vertex -0.0476012 0.0365257 0.01
+       vertex -0.0451104 0.0395607 0.01
+    endloop
+  endfacet
+  facet normal -0.773005 0.634399 0
+    outer loop
+       vertex -0.0451104 0.0395607 0.01
+       vertex -0.0451104 0.0395607 0
+       vertex -0.0476012 0.0365257 0
+    endloop
+  endfacet
+  facet normal -0.729867 0.683589 0
+    outer loop
+       vertex -0.0451104 0.0395607 0
+       vertex -0.0451104 0.0395607 0.01
+       vertex -0.0424264 0.0424264 0.01
+    endloop
+  endfacet
+  facet normal -0.729867 0.683589 0
+    outer loop
+       vertex -0.0424264 0.0424264 0.01
+       vertex -0.0424264 0.0424264 0
+       vertex -0.0451104 0.0395607 0
+    endloop
+  endfacet
+  facet normal -0.683589 0.729867 0
+    outer loop
+       vertex -0.0424264 0.0424264 0
+       vertex -0.0424264 0.0424264 0.01
+       vertex -0.0395607 0.0451104 0.01
+    endloop
+  endfacet
+  facet normal -0.683589 0.729867 0
+    outer loop
+       vertex -0.0395607 0.0451104 0.01
+       vertex -0.0395607 0.0451104 0
+       vertex -0.0424264 0.0424264 0
+    endloop
+  endfacet
+  facet normal -0.634399 0.773005 0
+    outer loop
+       vertex -0.0395607 0.0451104 0
+       vertex -0.0395607 0.0451104 0.01
+       vertex -0.0365257 0.0476012 0.01
+    endloop
+  endfacet
+  facet normal -0.634399 0.773005 0
+    outer loop
+       vertex -0.0365257 0.0476012 0.01
+       vertex -0.0365257 0.0476012 0
+       vertex -0.0395607 0.0451104 0
+    endloop
+  endfacet
+  facet normal -0.582478 0.812846 0
+    outer loop
+       vertex -0.0365257 0.0476012 0
+       vertex -0.0365257 0.0476012 0.01
+       vertex -0.0333342 0.0498882 0.01
+    endloop
+  endfacet
+  facet normal -0.582478 0.812846 0
+    outer loop
+       vertex -0.0333342 0.0498882 0.01
+       vertex -0.0333342 0.0498882 0
+       vertex -0.0365257 0.0476012 0
+    endloop
+  endfacet
+  facet normal -0.528061 0.849207 0
+    outer loop
+       vertex -0.0333342 0.0498882 0
+       vertex -0.0333342 0.0498882 0.01
+       vertex -0.03 0.0519615 0.01
+    endloop
+  endfacet
+  facet normal -0.528061 0.849207 0
+    outer loop
+       vertex -0.03 0.0519615 0.01
+       vertex -0.03 0.0519615 0
+       vertex -0.0333342 0.0498882 0
+    endloop
+  endfacet
+  facet normal -0.471406 0.881916 0
+    outer loop
+       vertex -0.03 0.0519615 0
+       vertex -0.03 0.0519615 0.01
+       vertex -0.0265373 0.0538124 0.01
+    endloop
+  endfacet
+  facet normal -0.471406 0.881916 0
+    outer loop
+       vertex -0.0265373 0.0538124 0.01
+       vertex -0.0265373 0.0538124 0
+       vertex -0.03 0.0519615 0
+    endloop
+  endfacet
+  facet normal -0.412707 0.910864 0
+    outer loop
+       vertex -0.0265373 0.0538124 0
+       vertex -0.0265373 0.0538124 0.01
+       vertex -0.022961 0.0554328 0.01
+    endloop
+  endfacet
+  facet normal -0.412707 0.910864 0
+    outer loop
+       vertex -0.022961 0.0554328 0.01
+       vertex -0.022961 0.0554328 0
+       vertex -0.0265373 0.0538124 0
+    endloop
+  endfacet
+  facet normal -0.352245 0.935908 0
+    outer loop
+       vertex -0.022961 0.0554328 0
+       vertex -0.022961 0.0554328 0.01
+       vertex -0.0192864 0.0568158 0.01
+    endloop
+  endfacet
+  facet normal -0.352245 0.935908 0
+    outer loop
+       vertex -0.0192864 0.0568158 0.01
+       vertex -0.0192864 0.0568158 0
+       vertex -0.022961 0.0554328 0
+    endloop
+  endfacet
+  facet normal -0.29027 0.956945 0
+    outer loop
+       vertex -0.0192864 0.0568158 0
+       vertex -0.0192864 0.0568158 0.01
+       vertex -0.0155291 0.0579555 0.01
+    endloop
+  endfacet
+  facet normal -0.29027 0.956945 0
+    outer loop
+       vertex -0.0155291 0.0579555 0.01
+       vertex -0.0155291 0.0579555 0
+       vertex -0.0192864 0.0568158 0
+    endloop
+  endfacet
+  facet normal -0.227085 0.973875 0
+    outer loop
+       vertex -0.0155291 0.0579555 0
+       vertex -0.0155291 0.0579555 0.01
+       vertex -0.0117054 0.0588471 0.01
+    endloop
+  endfacet
+  facet normal -0.227085 0.973875 0
+    outer loop
+       vertex -0.0117054 0.0588471 0.01
+       vertex -0.0117054 0.0588471 0
+       vertex -0.0155291 0.0579555 0
+    endloop
+  endfacet
+  facet normal -0.162902 0.986642 0
+    outer loop
+       vertex -0.0117054 0.0588471 0
+       vertex -0.0117054 0.0588471 0.01
+       vertex -0.00783157 0.0594867 0.01
+    endloop
+  endfacet
+  facet normal -0.162902 0.986642 0
+    outer loop
+       vertex -0.00783157 0.0594867 0.01
+       vertex -0.00783157 0.0594867 0
+       vertex -0.0117054 0.0588471 0
+    endloop
+  endfacet
+  facet normal -0.0980062 0.995186 0
+    outer loop
+       vertex -0.00783157 0.0594867 0
+       vertex -0.00783157 0.0594867 0.01
+       vertex -0.00392419 0.0598715 0.01
+    endloop
+  endfacet
+  facet normal -0.0980062 0.995186 0
+    outer loop
+       vertex -0.00392419 0.0598715 0.01
+       vertex -0.00392419 0.0598715 0
+       vertex -0.00783157 0.0594867 0
+    endloop
+  endfacet
+  facet normal -0.0327281 0.999464 0
+    outer loop
+       vertex -0.00392419 0.0598715 0
+       vertex -0.00392419 0.0598715 0.01
+       vertex 1.07694e-10 0.06 0.01
+    endloop
+  endfacet
+  facet normal -0.0327281 0.999464 0
+    outer loop
+       vertex 1.07694e-10 0.06 0.01
+       vertex 1.07694e-10 0.06 0
+       vertex -0.00392419 0.0598715 0
+    endloop
+  endfacet
+  facet normal 0.0327281 0.999464 -0
+    outer loop
+       vertex 1.07694e-10 0.06 0
+       vertex 1.07694e-10 0.06 0.01
+       vertex 0.00392419 0.0598715 0.01
+    endloop
+  endfacet
+  facet normal 0.0327281 0.999464 0
+    outer loop
+       vertex 0.00392419 0.0598715 0.01
+       vertex 0.00392419 0.0598715 0
+       vertex 1.07694e-10 0.06 0
+    endloop
+  endfacet
+  facet normal 0.0980062 0.995186 -0
+    outer loop
+       vertex 0.00392419 0.0598715 0
+       vertex 0.00392419 0.0598715 0.01
+       vertex 0.00783157 0.0594867 0.01
+    endloop
+  endfacet
+  facet normal 0.0980062 0.995186 0
+    outer loop
+       vertex 0.00783157 0.0594867 0.01
+       vertex 0.00783157 0.0594867 0
+       vertex 0.00392419 0.0598715 0
+    endloop
+  endfacet
+  facet normal 0.162902 0.986642 -0
+    outer loop
+       vertex 0.00783157 0.0594867 0
+       vertex 0.00783157 0.0594867 0.01
+       vertex 0.0117054 0.0588471 0.01
+    endloop
+  endfacet
+  facet normal 0.162902 0.986642 0
+    outer loop
+       vertex 0.0117054 0.0588471 0.01
+       vertex 0.0117054 0.0588471 0
+       vertex 0.00783157 0.0594867 0
+    endloop
+  endfacet
+  facet normal 0.227085 0.973875 -0
+    outer loop
+       vertex 0.0117054 0.0588471 0
+       vertex 0.0117054 0.0588471 0.01
+       vertex 0.0155291 0.0579555 0.01
+    endloop
+  endfacet
+  facet normal 0.227085 0.973875 0
+    outer loop
+       vertex 0.0155291 0.0579555 0.01
+       vertex 0.0155291 0.0579555 0
+       vertex 0.0117054 0.0588471 0
+    endloop
+  endfacet
+  facet normal 0.29027 0.956945 -0
+    outer loop
+       vertex 0.0155291 0.0579555 0
+       vertex 0.0155291 0.0579555 0.01
+       vertex 0.0192864 0.0568158 0.01
+    endloop
+  endfacet
+  facet normal 0.29027 0.956945 0
+    outer loop
+       vertex 0.0192864 0.0568158 0.01
+       vertex 0.0192864 0.0568158 0
+       vertex 0.0155291 0.0579555 0
+    endloop
+  endfacet
+  facet normal 0.352245 0.935908 -0
+    outer loop
+       vertex 0.0192864 0.0568158 0
+       vertex 0.0192864 0.0568158 0.01
+       vertex 0.022961 0.0554328 0.01
+    endloop
+  endfacet
+  facet normal 0.352245 0.935908 0
+    outer loop
+       vertex 0.022961 0.0554328 0.01
+       vertex 0.022961 0.0554328 0
+       vertex 0.0192864 0.0568158 0
+    endloop
+  endfacet
+  facet normal 0.412707 0.910864 -0
+    outer loop
+       vertex 0.022961 0.0554328 0
+       vertex 0.022961 0.0554328 0.01
+       vertex 0.0265373 0.0538124 0.01
+    endloop
+  endfacet
+  facet normal 0.412707 0.910864 0
+    outer loop
+       vertex 0.0265373 0.0538124 0.01
+       vertex 0.0265373 0.0538124 0
+       vertex 0.022961 0.0554328 0
+    endloop
+  endfacet
+  facet normal 0.471406 0.881916 -0
+    outer loop
+       vertex 0.0265373 0.0538124 0
+       vertex 0.0265373 0.0538124 0.01
+       vertex 0.03 0.0519615 0.01
+    endloop
+  endfacet
+  facet normal 0.471406 0.881916 0
+    outer loop
+       vertex 0.03 0.0519615 0.01
+       vertex 0.03 0.0519615 0
+       vertex 0.0265373 0.0538124 0
+    endloop
+  endfacet
+  facet normal 0.528061 0.849207 -0
+    outer loop
+       vertex 0.03 0.0519615 0
+       vertex 0.03 0.0519615 0.01
+       vertex 0.0333342 0.0498882 0.01
+    endloop
+  endfacet
+  facet normal 0.528061 0.849207 0
+    outer loop
+       vertex 0.0333342 0.0498882 0.01
+       vertex 0.0333342 0.0498882 0
+       vertex 0.03 0.0519615 0
+    endloop
+  endfacet
+  facet normal 0.582478 0.812846 -0
+    outer loop
+       vertex 0.0333342 0.0498882 0
+       vertex 0.0333342 0.0498882 0.01
+       vertex 0.0365257 0.0476012 0.01
+    endloop
+  endfacet
+  facet normal 0.582478 0.812846 0
+    outer loop
+       vertex 0.0365257 0.0476012 0.01
+       vertex 0.0365257 0.0476012 0
+       vertex 0.0333342 0.0498882 0
+    endloop
+  endfacet
+  facet normal 0.634399 0.773005 -0
+    outer loop
+       vertex 0.0365257 0.0476012 0
+       vertex 0.0365257 0.0476012 0.01
+       vertex 0.0395607 0.0451104 0.01
+    endloop
+  endfacet
+  facet normal 0.634399 0.773005 0
+    outer loop
+       vertex 0.0395607 0.0451104 0.01
+       vertex 0.0395607 0.0451104 0
+       vertex 0.0365257 0.0476012 0
+    endloop
+  endfacet
+  facet normal 0.683589 0.729867 -0
+    outer loop
+       vertex 0.0395607 0.0451104 0
+       vertex 0.0395607 0.0451104 0.01
+       vertex 0.0424264 0.0424264 0.01
+    endloop
+  endfacet
+  facet normal 0.683589 0.729867 0
+    outer loop
+       vertex 0.0424264 0.0424264 0.01
+       vertex 0.0424264 0.0424264 0
+       vertex 0.0395607 0.0451104 0
+    endloop
+  endfacet
+  facet normal 0.729867 0.683589 -0
+    outer loop
+       vertex 0.0424264 0.0424264 0
+       vertex 0.0424264 0.0424264 0.01
+       vertex 0.0451104 0.0395607 0.01
+    endloop
+  endfacet
+  facet normal 0.729867 0.683589 0
+    outer loop
+       vertex 0.0451104 0.0395607 0.01
+       vertex 0.0451104 0.0395607 0
+       vertex 0.0424264 0.0424264 0
+    endloop
+  endfacet
+  facet normal 0.773005 0.634399 -0
+    outer loop
+       vertex 0.0451104 0.0395607 0
+       vertex 0.0451104 0.0395607 0.01
+       vertex 0.0476012 0.0365257 0.01
+    endloop
+  endfacet
+  facet normal 0.773005 0.634399 0
+    outer loop
+       vertex 0.0476012 0.0365257 0.01
+       vertex 0.0476012 0.0365257 0
+       vertex 0.0451104 0.0395607 0
+    endloop
+  endfacet
+  facet normal 0.812846 0.582478 -0
+    outer loop
+       vertex 0.0476012 0.0365257 0
+       vertex 0.0476012 0.0365257 0.01
+       vertex 0.0498882 0.0333342 0.01
+    endloop
+  endfacet
+  facet normal 0.812846 0.582478 0
+    outer loop
+       vertex 0.0498882 0.0333342 0.01
+       vertex 0.0498882 0.0333342 0
+       vertex 0.0476012 0.0365257 0
+    endloop
+  endfacet
+  facet normal 0.849207 0.528061 -0
+    outer loop
+       vertex 0.0498882 0.0333342 0
+       vertex 0.0498882 0.0333342 0.01
+       vertex 0.0519615 0.03 0.01
+    endloop
+  endfacet
+  facet normal 0.849207 0.528061 0
+    outer loop
+       vertex 0.0519615 0.03 0.01
+       vertex 0.0519615 0.03 0
+       vertex 0.0498882 0.0333342 0
+    endloop
+  endfacet
+  facet normal 0.881916 0.471406 -0
+    outer loop
+       vertex 0.0519615 0.03 0
+       vertex 0.0519615 0.03 0.01
+       vertex 0.0538124 0.0265373 0.01
+    endloop
+  endfacet
+  facet normal 0.881916 0.471406 0
+    outer loop
+       vertex 0.0538124 0.0265373 0.01
+       vertex 0.0538124 0.0265373 0
+       vertex 0.0519615 0.03 0
+    endloop
+  endfacet
+  facet normal 0.910864 0.412707 -0
+    outer loop
+       vertex 0.0538124 0.0265373 0
+       vertex 0.0538124 0.0265373 0.01
+       vertex 0.0554328 0.022961 0.01
+    endloop
+  endfacet
+  facet normal 0.910864 0.412707 0
+    outer loop
+       vertex 0.0554328 0.022961 0.01
+       vertex 0.0554328 0.022961 0
+       vertex 0.0538124 0.0265373 0
+    endloop
+  endfacet
+  facet normal 0.935908 0.352245 -0
+    outer loop
+       vertex 0.0554328 0.022961 0
+       vertex 0.0554328 0.022961 0.01
+       vertex 0.0568158 0.0192864 0.01
+    endloop
+  endfacet
+  facet normal 0.935908 0.352245 0
+    outer loop
+       vertex 0.0568158 0.0192864 0.01
+       vertex 0.0568158 0.0192864 0
+       vertex 0.0554328 0.022961 0
+    endloop
+  endfacet
+  facet normal 0.956945 0.29027 -0
+    outer loop
+       vertex 0.0568158 0.0192864 0
+       vertex 0.0568158 0.0192864 0.01
+       vertex 0.0579555 0.0155291 0.01
+    endloop
+  endfacet
+  facet normal 0.956945 0.29027 0
+    outer loop
+       vertex 0.0579555 0.0155291 0.01
+       vertex 0.0579555 0.0155291 0
+       vertex 0.0568158 0.0192864 0
+    endloop
+  endfacet
+  facet normal 0.973875 0.227085 -0
+    outer loop
+       vertex 0.0579555 0.0155291 0
+       vertex 0.0579555 0.0155291 0.01
+       vertex 0.0588471 0.0117054 0.01
+    endloop
+  endfacet
+  facet normal 0.973875 0.227085 0
+    outer loop
+       vertex 0.0588471 0.0117054 0.01
+       vertex 0.0588471 0.0117054 0
+       vertex 0.0579555 0.0155291 0
+    endloop
+  endfacet
+  facet normal 0.986642 0.162902 -0
+    outer loop
+       vertex 0.0588471 0.0117054 0
+       vertex 0.0588471 0.0117054 0.01
+       vertex 0.0594867 0.00783157 0.01
+    endloop
+  endfacet
+  facet normal 0.986642 0.162902 0
+    outer loop
+       vertex 0.0594867 0.00783157 0.01
+       vertex 0.0594867 0.00783157 0
+       vertex 0.0588471 0.0117054 0
+    endloop
+  endfacet
+  facet normal 0.995186 0.0980062 -0
+    outer loop
+       vertex 0.0594867 0.00783157 0
+       vertex 0.0594867 0.00783157 0.01
+       vertex 0.0598715 0.00392419 0.01
+    endloop
+  endfacet
+  facet normal 0.995186 0.0980062 0
+    outer loop
+       vertex 0.0598715 0.00392419 0.01
+       vertex 0.0598715 0.00392419 0
+       vertex 0.0594867 0.00783157 0
+    endloop
+  endfacet
+  facet normal 0.999464 0.0327281 -0
+    outer loop
+       vertex 0.0598715 0.00392419 0
+       vertex 0.0598715 0.00392419 0.01
+       vertex 0.06 0 0.01
+    endloop
+  endfacet
+  facet normal 0.999464 0.0327281 0
+    outer loop
+       vertex 0.06 0 0.01
+       vertex 0.06 0 0
+       vertex 0.0598715 0.00392419 0
+    endloop
+  endfacet
+endsolid AMI1
diff --git a/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/constant/turbulenceProperties b/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/constant/turbulenceProperties
new file mode 100644
index 0000000000..d0a0998654
--- /dev/null
+++ b/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/constant/turbulenceProperties
@@ -0,0 +1,21 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  dev                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.com                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    location    "constant";
+    object      turbulenceProperties;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+simulationType  laminar;
+
+
+// ************************************************************************* //
diff --git a/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/makeMesh b/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/makeMesh
new file mode 100755
index 0000000000..937900177c
--- /dev/null
+++ b/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/makeMesh
@@ -0,0 +1,5 @@
+#!/bin/sh
+set -x
+
+m4 < constant/polyMesh/blockMeshDict.m4 > constant/polyMesh/blockMeshDict
+blockMesh > log.blockMesh 2>&1
diff --git a/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/system/controlDict b/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/system/controlDict
new file mode 100644
index 0000000000..4d156a3bd7
--- /dev/null
+++ b/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/system/controlDict
@@ -0,0 +1,54 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  dev                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.com                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    location    "system";
+    object      controlDict;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+libs            ("libAMIInterpolation.so");
+
+application     pimpleDyMFoam;
+
+startFrom       startTime; // latestTime;
+
+startTime       0;
+
+stopAt          endTime;
+
+endTime         5;
+
+deltaT          1e-3;
+
+writeControl    adjustableRunTime;
+
+writeInterval   0.1;
+
+purgeWrite      0;
+
+writeFormat     ascii;
+
+writePrecision  6;
+
+writeCompression off;
+
+timeFormat      general;
+
+timePrecision   6;
+
+runTimeModifiable true;
+
+adjustTimeStep  yes;
+
+maxCo           0.3;
+
+// ************************************************************************* //
diff --git a/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/system/fvSchemes b/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/system/fvSchemes
new file mode 100644
index 0000000000..eb21fd104e
--- /dev/null
+++ b/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/system/fvSchemes
@@ -0,0 +1,64 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  dev                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.com                      |
+|    \\/     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;
+    grad(U)         Gauss linear 1;
+}
+
+divSchemes
+{
+    default         none;
+    div(phi,U)      Gauss upwind;
+    div((nuEff*dev(T(grad(U))))) Gauss linear;
+}
+
+laplacianSchemes
+{
+//    default         Gauss linear corrected;
+    default         Gauss linear uncorrected;
+}
+
+interpolationSchemes
+{
+    default         linear;
+    interpolate(HbyA) linear;
+}
+
+snGradSchemes
+{
+//    default         corrected;
+    default         uncorrected;
+}
+
+fluxRequired
+{
+    default         no;
+    pcorr           ;
+    p               ;
+}
+
+
+// ************************************************************************* //
diff --git a/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/system/fvSolution b/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/system/fvSolution
new file mode 100644
index 0000000000..196ac79893
--- /dev/null
+++ b/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/system/fvSolution
@@ -0,0 +1,83 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  dev                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.com                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    location    "system";
+    object      fvSolution;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+solvers
+{
+    pcorr
+    {
+        solver          PCG;
+        preconditioner  DIC;
+        tolerance       0.02;
+        relTol          0;
+    }
+
+    p
+    {
+        solver          PCG;
+        preconditioner  DIC;
+        tolerance       1e-06;
+        relTol          0.01;
+    }
+
+    pFinal
+    {
+        $p;
+        tolerance       1e-06;
+        relTol          0;
+    }
+
+    U
+    {
+        solver          PBiCG;
+        preconditioner  DILU;
+        tolerance       1e-05;
+        relTol          0.1;
+    }
+
+    UFinal
+    {
+        $U;
+        tolerance       1e-06;
+        relTol          0;
+    }
+
+    cellMotionUx
+    {
+        solver          PCG;
+        preconditioner  DIC;
+        tolerance       1e-08;
+        relTol          0;
+    }
+}
+
+PIMPLE
+{
+    correctPhi          yes;
+    nOuterCorrectors    1;
+    nCorrectors         2;
+    nNonOrthogonalCorrectors 0;
+
+    pRefCell            0;
+    pRefValue           0;
+}
+
+relaxationFactors
+{
+    "U.*"           1;
+}
+
+// ************************************************************************* //

From 9a71ded7901fb2a4c5d70211af01bb49c6a86cf4 Mon Sep 17 00:00:00 2001
From: andy <andy>
Date: Wed, 24 Aug 2011 10:40:11 +0100
Subject: [PATCH 15/45] ENH: Added AMI build to Allwmake

---
 src/Allwmake | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/Allwmake b/src/Allwmake
index aa17b418e3..3089d8fbec 100755
--- a/src/Allwmake
+++ b/src/Allwmake
@@ -50,6 +50,8 @@ wmake $makeType conversion
 
 wmake $makeType sampling
 
+wmake $makeType AMIInterpolation
+
 wmake $makeType dynamicMesh
 wmake $makeType dynamicFvMesh
 wmake $makeType topoChangerFvMesh

From c82b075b6496ffc45bce9d008b69e4fbc7a2464b Mon Sep 17 00:00:00 2001
From: andy <andy>
Date: Wed, 24 Aug 2011 10:44:09 +0100
Subject: [PATCH 16/45] ENH: Minor AMI code update

---
 src/AMIInterpolation/AMIInterpolation.C                     | 6 +-----
 tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/0/U | 2 +-
 .../incompressible/pimpleDyMFoam/mixerVesselAMI2D/0/epsilon | 2 +-
 tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/0/k | 2 +-
 .../incompressible/pimpleDyMFoam/mixerVesselAMI2D/0/nut     | 2 +-
 tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/0/p | 2 +-
 .../pimpleDyMFoam/mixerVesselAMI2D/constant/MRFZones        | 2 +-
 .../pimpleDyMFoam/mixerVesselAMI2D/constant/RASProperties   | 2 +-
 .../pimpleDyMFoam/mixerVesselAMI2D/constant/dynamicMeshDict | 4 ++--
 .../mixerVesselAMI2D/constant/polyMesh/blockMeshDict.m4     | 2 +-
 .../mixerVesselAMI2D/constant/transportProperties           | 2 +-
 .../mixerVesselAMI2D/constant/turbulenceProperties          | 2 +-
 .../pimpleDyMFoam/mixerVesselAMI2D/system/controlDict       | 2 +-
 .../pimpleDyMFoam/mixerVesselAMI2D/system/fvSchemes         | 2 +-
 .../pimpleDyMFoam/mixerVesselAMI2D/system/fvSolution        | 2 +-
 15 files changed, 16 insertions(+), 20 deletions(-)

diff --git a/src/AMIInterpolation/AMIInterpolation.C b/src/AMIInterpolation/AMIInterpolation.C
index 03854ac029..7e9c15caa7 100644
--- a/src/AMIInterpolation/AMIInterpolation.C
+++ b/src/AMIInterpolation/AMIInterpolation.C
@@ -221,11 +221,7 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::distributePatches
         if (domain != Pstream::myProcNo() && recvElems.size())
         {
             UIPstream str(domain, pBufs);
-            faceList localFaces(str);
-            pointField localPoints(str);
-
-            faces[domain] = localFaces;
-            points[domain] = localPoints;
+            str >> faces[domain] >> points[domain];
         }
     }
 }
diff --git a/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/0/U b/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/0/U
index 19bc03110e..50bd4d0f7d 100644
--- a/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/0/U
+++ b/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/0/U
@@ -2,7 +2,7 @@
 | =========                 |                                                 |
 | \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
 |  \\    /   O peration     | Version:  dev                                   |
-|   \\  /    A nd           | Web:      www.OpenFOAM.com                      |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
 |    \\/     M anipulation  |                                                 |
 \*---------------------------------------------------------------------------*/
 FoamFile
diff --git a/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/0/epsilon b/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/0/epsilon
index 31ea22a3f1..194592df48 100644
--- a/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/0/epsilon
+++ b/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/0/epsilon
@@ -2,7 +2,7 @@
 | =========                 |                                                 |
 | \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
 |  \\    /   O peration     | Version:  dev                                   |
-|   \\  /    A nd           | Web:      www.OpenFOAM.com                      |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
 |    \\/     M anipulation  |                                                 |
 \*---------------------------------------------------------------------------*/
 FoamFile
diff --git a/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/0/k b/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/0/k
index cc4fd2a643..85b3438cca 100644
--- a/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/0/k
+++ b/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/0/k
@@ -2,7 +2,7 @@
 | =========                 |                                                 |
 | \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
 |  \\    /   O peration     | Version:  dev                                   |
-|   \\  /    A nd           | Web:      www.OpenFOAM.com                      |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
 |    \\/     M anipulation  |                                                 |
 \*---------------------------------------------------------------------------*/
 FoamFile
diff --git a/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/0/nut b/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/0/nut
index e741466a01..4f141eadcd 100644
--- a/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/0/nut
+++ b/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/0/nut
@@ -2,7 +2,7 @@
 | =========                 |                                                 |
 | \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
 |  \\    /   O peration     | Version:  dev                                   |
-|   \\  /    A nd           | Web:      www.OpenFOAM.com                      |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
 |    \\/     M anipulation  |                                                 |
 \*---------------------------------------------------------------------------*/
 FoamFile
diff --git a/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/0/p b/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/0/p
index 7c1fd17b01..f6a25dfd5b 100644
--- a/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/0/p
+++ b/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/0/p
@@ -2,7 +2,7 @@
 | =========                 |                                                 |
 | \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
 |  \\    /   O peration     | Version:  dev                                   |
-|   \\  /    A nd           | Web:      www.OpenFOAM.com                      |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
 |    \\/     M anipulation  |                                                 |
 \*---------------------------------------------------------------------------*/
 FoamFile
diff --git a/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/constant/MRFZones b/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/constant/MRFZones
index 1552f8fc99..5fd26d2ab9 100644
--- a/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/constant/MRFZones
+++ b/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/constant/MRFZones
@@ -2,7 +2,7 @@
 | =========                 |                                                 |
 | \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
 |  \\    /   O peration     | Version:  dev                                   |
-|   \\  /    A nd           | Web:      www.OpenFOAM.com                      |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
 |    \\/     M anipulation  |                                                 |
 \*---------------------------------------------------------------------------*/
 FoamFile
diff --git a/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/constant/RASProperties b/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/constant/RASProperties
index 67d4d8212c..a4937b503a 100644
--- a/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/constant/RASProperties
+++ b/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/constant/RASProperties
@@ -2,7 +2,7 @@
 | =========                 |                                                 |
 | \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
 |  \\    /   O peration     | Version:  dev                                   |
-|   \\  /    A nd           | Web:      www.OpenFOAM.com                      |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
 |    \\/     M anipulation  |                                                 |
 \*---------------------------------------------------------------------------*/
 FoamFile
diff --git a/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/constant/dynamicMeshDict b/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/constant/dynamicMeshDict
index 571ce9ea44..6f91f2d72f 100644
--- a/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/constant/dynamicMeshDict
+++ b/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/constant/dynamicMeshDict
@@ -1,8 +1,8 @@
 /*--------------------------------*- C++ -*----------------------------------*\
 | =========                 |                                                 |
 | \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
-|  \\    /   O peration     | Version:  2.0.0                                 |
-|   \\  /    A nd           | Web:      www.OpenFOAM.com                      |
+|  \\    /   O peration     | Version:  dev                                 |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
 |    \\/     M anipulation  |                                                 |
 \*---------------------------------------------------------------------------*/
 FoamFile
diff --git a/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/constant/polyMesh/blockMeshDict.m4 b/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/constant/polyMesh/blockMeshDict.m4
index 5aaae14461..0153ff4090 100644
--- a/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/constant/polyMesh/blockMeshDict.m4
+++ b/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/constant/polyMesh/blockMeshDict.m4
@@ -2,7 +2,7 @@
 | =========                 |                                                 |
 | \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
 |  \\    /   O peration     | Version:  dev                                   |
-|   \\  /    A nd           | Web:      www.OpenFOAM.com                      |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
 |    \\/     M anipulation  |                                                 |
 \*---------------------------------------------------------------------------*/
 FoamFile
diff --git a/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/constant/transportProperties b/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/constant/transportProperties
index 62cd127719..b40b7d66cd 100644
--- a/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/constant/transportProperties
+++ b/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/constant/transportProperties
@@ -2,7 +2,7 @@
 | =========                 |                                                 |
 | \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
 |  \\    /   O peration     | Version:  dev                                   |
-|   \\  /    A nd           | Web:      www.OpenFOAM.com                      |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
 |    \\/     M anipulation  |                                                 |
 \*---------------------------------------------------------------------------*/
 FoamFile
diff --git a/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/constant/turbulenceProperties b/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/constant/turbulenceProperties
index d0a0998654..c2c3b28a1b 100644
--- a/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/constant/turbulenceProperties
+++ b/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/constant/turbulenceProperties
@@ -2,7 +2,7 @@
 | =========                 |                                                 |
 | \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
 |  \\    /   O peration     | Version:  dev                                   |
-|   \\  /    A nd           | Web:      www.OpenFOAM.com                      |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
 |    \\/     M anipulation  |                                                 |
 \*---------------------------------------------------------------------------*/
 FoamFile
diff --git a/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/system/controlDict b/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/system/controlDict
index 4d156a3bd7..aa73ebeb25 100644
--- a/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/system/controlDict
+++ b/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/system/controlDict
@@ -2,7 +2,7 @@
 | =========                 |                                                 |
 | \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
 |  \\    /   O peration     | Version:  dev                                   |
-|   \\  /    A nd           | Web:      www.OpenFOAM.com                      |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
 |    \\/     M anipulation  |                                                 |
 \*---------------------------------------------------------------------------*/
 FoamFile
diff --git a/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/system/fvSchemes b/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/system/fvSchemes
index eb21fd104e..82ae10e9a5 100644
--- a/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/system/fvSchemes
+++ b/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/system/fvSchemes
@@ -2,7 +2,7 @@
 | =========                 |                                                 |
 | \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
 |  \\    /   O peration     | Version:  dev                                   |
-|   \\  /    A nd           | Web:      www.OpenFOAM.com                      |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
 |    \\/     M anipulation  |                                                 |
 \*---------------------------------------------------------------------------*/
 FoamFile
diff --git a/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/system/fvSolution b/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/system/fvSolution
index 196ac79893..8584eeaed6 100644
--- a/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/system/fvSolution
+++ b/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/system/fvSolution
@@ -2,7 +2,7 @@
 | =========                 |                                                 |
 | \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
 |  \\    /   O peration     | Version:  dev                                   |
-|   \\  /    A nd           | Web:      www.OpenFOAM.com                      |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
 |    \\/     M anipulation  |                                                 |
 \*---------------------------------------------------------------------------*/
 FoamFile

From 45f5003c53248d59d272e6b010b951740ec697ba Mon Sep 17 00:00:00 2001
From: mattijs <mattijs>
Date: Wed, 24 Aug 2011 17:52:33 +0100
Subject: [PATCH 17/45] BUG: AMIInterpolation: parallel addressing updates

---
 src/AMIInterpolation/AMIInterpolation.C | 204 +++++++++++++-----------
 src/AMIInterpolation/AMIInterpolation.H |  12 +-
 2 files changed, 122 insertions(+), 94 deletions(-)

diff --git a/src/AMIInterpolation/AMIInterpolation.C b/src/AMIInterpolation/AMIInterpolation.C
index 7e9c15caa7..9bc928d69a 100644
--- a/src/AMIInterpolation/AMIInterpolation.C
+++ b/src/AMIInterpolation/AMIInterpolation.C
@@ -28,7 +28,6 @@ License
 #include "indexedOctree.H"
 #include "meshTools.H"
 #include "mergePoints.H"
-#include "globalIndex.H"
 
 #include "vtkSurfaceWriter.H"
 
@@ -156,8 +155,10 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::distributePatches
 (
     const mapDistribute& map,
     const primitivePatch& pp,
+    const globalIndex& gi,
     List<faceList>& faces,
-    List<pointField>& points
+    List<pointField>& points,
+    List<labelList>& faceIDs
 )
 {
     PstreamBuffers pBufs(Pstream::nonBlocking);
@@ -168,6 +169,12 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::distributePatches
 
         if (domain != Pstream::myProcNo() && sendElems.size())
         {
+            labelList globalElems(sendElems.size());
+            forAll(sendElems, i)
+            {
+                globalElems[i] = gi.toGlobal(sendElems[i]);
+            }
+
             faceList subFaces(UIndirectList<face>(pp, sendElems));
             primitivePatch subPatch
             (
@@ -182,7 +189,9 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::distributePatches
             }
 
             UOPstream toDomain(domain, pBufs);
-            toDomain << subPatch.localFaces() << subPatch.localPoints();
+            toDomain
+                << subPatch.localFaces() << subPatch.localPoints()
+                << globalElems;
         }
     }
 
@@ -191,6 +200,7 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::distributePatches
 
     faces.setSize(Pstream::nProcs());
     points.setSize(Pstream::nProcs());
+    faceIDs.setSize(Pstream::nProcs());
 
     {
         // Set up 'send' to myself
@@ -211,6 +221,12 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::distributePatches
 
         faces[Pstream::myProcNo()] = subPatch.localFaces();
         points[Pstream::myProcNo()] = subPatch.localPoints();
+
+        faceIDs[Pstream::myProcNo()].setSize(sendElems.size());
+        forAll(sendElems, i)
+        {
+            faceIDs[Pstream::myProcNo()][i] = gi.toGlobal(sendElems[i]);
+        }
     }
 
     // Consume
@@ -221,7 +237,10 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::distributePatches
         if (domain != Pstream::myProcNo() && recvElems.size())
         {
             UIPstream str(domain, pBufs);
-            str >> faces[domain] >> points[domain];
+
+            str >> faces[domain]
+                >> points[domain]
+                >> faceIDs[domain]; 
         }
     }
 }
@@ -233,14 +252,17 @@ distributeAndMergePatches
 (
     const mapDistribute& map,
     const primitivePatch& tgtPatch,
+    const globalIndex& gi,
     faceList& tgtFaces,
-    pointField& tgtPoints
+    pointField& tgtPoints,
+    labelList& tgtFaceIDs
 )
 {
     // Exchange per-processor data
     List<faceList> allFaces;
     List<pointField> allPoints;
-    distributePatches(map, tgtPatch, allFaces, allPoints);
+    List<labelList> allTgtFaceIDs;
+    distributePatches(map, tgtPatch, gi, allFaces, allPoints, allTgtFaceIDs);
 
     // Renumber and flatten
     label nFaces = 0;
@@ -250,13 +272,21 @@ distributeAndMergePatches
         nFaces += allFaces[procI].size();
         nPoints += allPoints[procI].size();
     }
+
     tgtFaces.setSize(nFaces);
-    nFaces = 0;
     tgtPoints.setSize(nPoints);
+
+//reduce(nFaces, sumOp<label>());
+    tgtFaceIDs.setSize(nFaces);
+
+    nFaces = 0;
     nPoints = 0;
 
     // My own data first
     {
+        const labelList& faceIDs = allTgtFaceIDs[Pstream::myProcNo()];
+        SubList<label>(tgtFaceIDs, faceIDs.size()).assign(faceIDs);
+
         const faceList& fcs = allFaces[Pstream::myProcNo()];
         forAll(fcs, i)
         {
@@ -268,6 +298,7 @@ distributeAndMergePatches
                 newF[fp] = f[fp] + nPoints;
             }
         }
+
         const pointField& pts = allPoints[Pstream::myProcNo()];
         forAll(pts, i)
         {
@@ -275,11 +306,15 @@ distributeAndMergePatches
         }
     }
 
-    // Other proc data first
+
+    // Other proc data follows
     forAll(allFaces, procI)
     {
         if (procI != Pstream::myProcNo())
         {
+            const labelList& faceIDs = allTgtFaceIDs[procI];
+            SubList<label>(tgtFaceIDs, faceIDs.size(), nFaces).assign(faceIDs);
+
             const faceList& fcs = allFaces[procI];
             forAll(fcs, i)
             {
@@ -291,6 +326,7 @@ distributeAndMergePatches
                     newF[fp] = f[fp] + nPoints;
                 }
             }
+
             const pointField& pts = allPoints[procI];
             forAll(pts, i)
             {
@@ -977,27 +1013,6 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::calcAddressing
             << endl;
     }
 
-    // normalise weights by face areas
-    forAll(srcAddr, faceI)
-    {
-        const DynamicList<label>& addressing = srcAddr[faceI];
-        forAll(addressing, addrI)
-        {
-            const scalar faceArea = srcPatch0[faceI].mag(srcPoints);
-            srcWght[faceI][addrI] /= faceArea;
-        }
-    }
-
-    forAll(tgtAddr, faceI)
-    {
-        const DynamicList<label>& addressing = tgtAddr[faceI];
-        forAll(addressing, addrI)
-        {
-            const scalar faceArea = tgtPatch0[faceI].mag(tgtPoints);
-            tgtWght[faceI][addrI] /= faceArea;
-        }
-    }
-
     // transfer data to persistent storage
     srcAddress_.setSize(srcPatch.size());
     srcWeights_.setSize(srcPatch.size());
@@ -1017,11 +1032,11 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::calcAddressing
 }
 
 
-
 template<class SourcePatch, class TargetPatch>
 void Foam::AMIInterpolation<SourcePatch, TargetPatch>::normaliseWeights
 (
-    const word& patchType,
+    const primitivePatch& patch,
+    const word& patchName,
     const labelListList& addr,
     scalarListList& wght,
     const bool output
@@ -1029,11 +1044,26 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::normaliseWeights
 {
     scalarList wghtSum(wght.size(), 0.0);
 
+    scalar minBound = VGREAT;
+    scalar maxBound = -VGREAT;
+
     // Normalise the weights
     forAll(wght, faceI)
     {
         scalar s = sum(wght[faceI]);
         wghtSum[faceI] = s;
+        
+        scalar t = 1; // s/patch[faceI].mag(patch.localPoints());
+
+        if (t < minBound)
+        {
+            minBound = t;
+        }
+
+        if (t > maxBound)
+        {
+            maxBound = t;
+        }
 
         forAll(addr[faceI], i)
         {
@@ -1043,8 +1073,9 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::normaliseWeights
 
     if (output)
     {
-        Info<< "AMI: Patch " << patchType << " weights min/max = "
-            << gMin(wghtSum) << ", " << gMax(wghtSum) << endl;
+        Info<< "AMI: Patch " << patchName << " weights min/max = "
+            << returnReduce(minBound, minOp<scalar>()) << ", "
+            << returnReduce(maxBound, maxOp<scalar>()) << endl;
     }
 }
 
@@ -1110,14 +1141,28 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::update
 
     if (Pstream::parRun())
     {
-        // create processor map of overlapping faces
+        // convert local addressing to global addressing
+        globalIndex globalSrcFaces(srcPatch.size());
+        globalIndex globalTgtFaces(tgtPatch.size());
+
+        // Create processor map of overlapping faces. This map gets
+        // (possibly remote) faces from the tgtPatch such that they together
+        // cover all of the srcPatch.
         autoPtr<mapDistribute> mapPtr = calcProcMap(srcPatch, tgtPatch);
         const mapDistribute& map = mapPtr();
 
         // create new target patch that fully encompasses source patch
+
+        // faces and points
         faceList newTgtFaces;
         pointField newTgtPoints;
-        distributeAndMergePatches(map, tgtPatch, newTgtFaces, newTgtPoints);
+        // original faces from tgtPatch (in globalIndexing since might be
+        // remote)
+        labelList tgtFaceIDs;
+        distributeAndMergePatches
+        (
+            map, tgtPatch, globalTgtFaces, newTgtFaces, newTgtPoints, tgtFaceIDs
+        );
 
         primitivePatch
             newTgtPatch
@@ -1130,15 +1175,33 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::update
                 newTgtPoints
             );
 
-//        checkPatches(srcPatch, newTgtPatch);
+        checkPatches(srcPatch, newTgtPatch);
 
 
-        // calculate AMI interpolation
+        // calculate AMI interpolation.
         calcAddressing(srcPatch, newTgtPatch, surf);
 
+        // Now
+        // ~~~
+        //  srcAddress_ :   per srcPatch face a list of the newTgtPatch (not
+        //                  tgtPatch) faces it overlaps
+        //  tgtAddress_ :   per newTgtPatch (not tgtPatch) face a list of the
+        //                  srcPatch faces it overlaps
+
+
+        // Rework newTgtPatch indices into globalIndices of tgtPatch
+        // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    
+        forAll(srcAddress_, i)
+        {
+            labelList& addressing = srcAddress_[i];
+            forAll(addressing, addrI)
+            {
+                addressing[addrI] = tgtFaceIDs[addressing[addrI]];
+            }
+        }
 
-        // convert local addressing to global addressing
-        globalIndex globalSrcFaces(srcAddress_.size());
         forAll(tgtAddress_, i)
         {
             labelList& addressing = tgtAddress_[i];
@@ -1148,43 +1211,8 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::update
             }
         }
 
-        globalIndex globalTgtFaces(tgtAddress_.size());
-        forAll(srcAddress_, i)
-        {
-            labelList& addressing = srcAddress_[i];
-            forAll(addressing, addrI)
-            {
-                addressing[addrI] = globalTgtFaces.toGlobal(addressing[addrI]);
-            }
-        }
-
-
-        // send maps
-/*
-        mapDistribute::distribute
-        (
-            Pstream::nonBlocking,
-            List<labelPair>(),
-            srcPatch.size(),
-            map.constructMap(),
-            map.subMap(),
-            srcAddress_,
-            ListPlusEqOp<label>(),
-            labelList()
-        );
-
-        mapDistribute::distribute
-        (
-            Pstream::nonBlocking,
-            List<labelPair>(),
-            srcPatch.size(),
-            map.constructMap(),
-            map.subMap(),
-            srcWeights_,
-            ListPlusEqOp<scalar>(),
-            scalarList()
-        );
-*/
+        // send data back to originating procs. Note that contributions
+        // from different processors get added (ListPlusEqOp).
 
         mapDistribute::distribute
         (
@@ -1210,25 +1238,20 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::update
             scalarList()
         );
 
-        if (debug)
-        {
-            writeWeights(srcWeights_, srcPatch, "VTK", "source");
-            writeWeights(tgtWeights_, newTgtPatch, "VTK", "target");
-        }
-
-
         // weights normalisation
-        normaliseWeights("source", srcAddress_, srcWeights_, true);
-        normaliseWeights("target", tgtAddress_, tgtWeights_, true);
-
+        normaliseWeights(srcPatch, "source", srcAddress_, srcWeights_, true);
+        normaliseWeights(tgtPatch, "target", tgtAddress_, tgtWeights_, true);
 
         // cache maps and reset addresses
         List<Map<label> > cMap;
         srcMapPtr_.reset(new mapDistribute(globalSrcFaces, tgtAddress_, cMap));
         tgtMapPtr_.reset(new mapDistribute(globalTgtFaces, srcAddress_, cMap));
 
+
         if (debug)
         {
+            writeWeights(srcWeights_, srcPatch, "VTK", "source");
+            writeWeights(tgtWeights_, tgtPatch, "VTK", "target");
             writeFaceConnectivity(srcPatch, newTgtPatch);
         }
     }
@@ -1244,8 +1267,8 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::update
             writeWeights(tgtWeights_, tgtPatch, "VTK", "target");
         }
 
-        normaliseWeights("source", srcAddress_, srcWeights_, true);
-        normaliseWeights("target", tgtAddress_, tgtWeights_, true);
+        normaliseWeights(srcPatch, "source", srcAddress_, srcWeights_, true);
+        normaliseWeights(tgtPatch, "target", tgtAddress_, tgtWeights_, true);
     }
 
     patchI++;
@@ -1260,13 +1283,13 @@ Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolateToSource
     const Field<Type>& fld
 ) const
 {
-    if (fld.size() != tgtAddress_.size())
+    if (fld.size() != tgtPatchSize_)
     {
         FatalErrorIn
         (
             "AMIInterpolation::interpolateToSource(const Field<Type>) const"
         )   << "Supplied field size is not equal to target patch size. "
-            << "Target patch = " << tgtAddress_.size() << ", supplied field = "
+            << "Target patch = " << tgtPatchSize_ << ", supplied field = "
             << fld.size() << abort(FatalError);
     }
 
@@ -1352,7 +1375,6 @@ Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolateToTarget
     (
         new Field<Type>
         (
-//            tgtAddress_.size(),
             tgtPatchSize_,
             pTraits<Type>::zero
         )
diff --git a/src/AMIInterpolation/AMIInterpolation.H b/src/AMIInterpolation/AMIInterpolation.H
index 711c8d71a7..f9d7227124 100644
--- a/src/AMIInterpolation/AMIInterpolation.H
+++ b/src/AMIInterpolation/AMIInterpolation.H
@@ -52,6 +52,7 @@ SourceFiles
 #include "faceAreaIntersect.H"
 #include "treeBoundBox.H"
 #include "treeBoundBoxList.H"
+#include "globalIndex.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -182,16 +183,20 @@ class AMIInterpolation
             (
                 const mapDistribute& map,
                 const primitivePatch& pp,
+                const globalIndex& gi,
                 List<faceList>& faces,
-                List<pointField>& points
+                List<pointField>& points,
+                List<labelList>& tgtFaceIDs
             );
 
             void distributeAndMergePatches
             (
                 const mapDistribute& map,
                 const primitivePatch& tgtPatch,
+                const globalIndex& gi,
                 faceList& tgtFaces,
-                pointField& tgtPoints
+                pointField& tgtPoints,
+                labelList& tgtFaceIDs
             );
 
             autoPtr<mapDistribute> calcProcMap
@@ -271,7 +276,8 @@ class AMIInterpolation
             //     numerical error!
             void normaliseWeights
             (
-                const word& patchType,
+                const primitivePatch& patch,
+                const word& patchName,
                 const labelListList& addr,
                 scalarListList& wght,
                 const bool output

From bff9bb6f067b2a12fe7224c3522472a59be4f861 Mon Sep 17 00:00:00 2001
From: andy <andy>
Date: Thu, 25 Aug 2011 10:53:52 +0100
Subject: [PATCH 18/45] ENH: Updates to AMI and tutorial

---
 src/AMIInterpolation/AMIInterpolation.C       | 35 ++++++++--------
 src/AMIInterpolation/AMIInterpolation.H       |  4 --
 .../mixerVesselAMI2D/system/decomposeParDict  | 40 +++++++++++++++++++
 .../mixerVesselAMI2D/system/fvSchemes         |  7 +---
 4 files changed, 60 insertions(+), 26 deletions(-)
 create mode 100644 tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/system/decomposeParDict

diff --git a/src/AMIInterpolation/AMIInterpolation.C b/src/AMIInterpolation/AMIInterpolation.C
index 9bc928d69a..485978cf6b 100644
--- a/src/AMIInterpolation/AMIInterpolation.C
+++ b/src/AMIInterpolation/AMIInterpolation.C
@@ -275,8 +275,6 @@ distributeAndMergePatches
 
     tgtFaces.setSize(nFaces);
     tgtPoints.setSize(nPoints);
-
-//reduce(nFaces, sumOp<label>());
     tgtFaceIDs.setSize(nFaces);
 
     nFaces = 0;
@@ -1052,9 +1050,8 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::normaliseWeights
     {
         scalar s = sum(wght[faceI]);
         wghtSum[faceI] = s;
-        
-        scalar t = 1; // s/patch[faceI].mag(patch.localPoints());
 
+        scalar t = s/patch[faceI].mag(patch.points());
         if (t < minBound)
         {
             minBound = t;
@@ -1096,7 +1093,6 @@ Foam::AMIInterpolation<SourcePatch, TargetPatch>::AMIInterpolation
     srcWeights_(),
     tgtAddress_(),
     tgtWeights_(),
-    tgtPatchSize_(tgtPatch.size()),
     startSeedI_(0),
     triMode_(triMode),
     projectPoints_(projectPoints),
@@ -1146,8 +1142,8 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::update
         globalIndex globalTgtFaces(tgtPatch.size());
 
         // Create processor map of overlapping faces. This map gets
-        // (possibly remote) faces from the tgtPatch such that they together
-        // cover all of the srcPatch.
+        // (possibly remote) faces from the tgtPatch such that they (together)
+        // cover all of the srcPatch
         autoPtr<mapDistribute> mapPtr = calcProcMap(srcPatch, tgtPatch);
         const mapDistribute& map = mapPtr();
 
@@ -1161,7 +1157,12 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::update
         labelList tgtFaceIDs;
         distributeAndMergePatches
         (
-            map, tgtPatch, globalTgtFaces, newTgtFaces, newTgtPoints, tgtFaceIDs
+            map,
+            tgtPatch,
+            globalTgtFaces,
+            newTgtFaces,
+            newTgtPoints,
+            tgtFaceIDs
         );
 
         primitivePatch
@@ -1178,7 +1179,7 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::update
         checkPatches(srcPatch, newTgtPatch);
 
 
-        // calculate AMI interpolation.
+        // calculate AMI interpolation
         calcAddressing(srcPatch, newTgtPatch, surf);
 
         // Now
@@ -1212,7 +1213,7 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::update
         }
 
         // send data back to originating procs. Note that contributions
-        // from different processors get added (ListPlusEqOp).
+        // from different processors get added (ListPlusEqOp)
 
         mapDistribute::distribute
         (
@@ -1239,8 +1240,8 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::update
         );
 
         // weights normalisation
-        normaliseWeights(srcPatch, "source", srcAddress_, srcWeights_, true);
-        normaliseWeights(tgtPatch, "target", tgtAddress_, tgtWeights_, true);
+        normaliseWeights(tgtPatch, "source", srcAddress_, srcWeights_, true);
+        normaliseWeights(srcPatch, "target", tgtAddress_, tgtWeights_, true);
 
         // cache maps and reset addresses
         List<Map<label> > cMap;
@@ -1267,8 +1268,8 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::update
             writeWeights(tgtWeights_, tgtPatch, "VTK", "target");
         }
 
-        normaliseWeights(srcPatch, "source", srcAddress_, srcWeights_, true);
-        normaliseWeights(tgtPatch, "target", tgtAddress_, tgtWeights_, true);
+        normaliseWeights(tgtPatch, "source", srcAddress_, srcWeights_, true);
+        normaliseWeights(srcPatch, "target", tgtAddress_, tgtWeights_, true);
     }
 
     patchI++;
@@ -1283,13 +1284,13 @@ Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolateToSource
     const Field<Type>& fld
 ) const
 {
-    if (fld.size() != tgtPatchSize_)
+    if (fld.size() != tgtAddress_.size())
     {
         FatalErrorIn
         (
             "AMIInterpolation::interpolateToSource(const Field<Type>) const"
         )   << "Supplied field size is not equal to target patch size. "
-            << "Target patch = " << tgtPatchSize_ << ", supplied field = "
+            << "Target patch = " << tgtAddress_.size() << ", supplied field = "
             << fld.size() << abort(FatalError);
     }
 
@@ -1375,7 +1376,7 @@ Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolateToTarget
     (
         new Field<Type>
         (
-            tgtPatchSize_,
+            tgtAddress_.size(),
             pTraits<Type>::zero
         )
     );
diff --git a/src/AMIInterpolation/AMIInterpolation.H b/src/AMIInterpolation/AMIInterpolation.H
index f9d7227124..4173362f54 100644
--- a/src/AMIInterpolation/AMIInterpolation.H
+++ b/src/AMIInterpolation/AMIInterpolation.H
@@ -122,10 +122,6 @@ class AMIInterpolation
             //- Weights of wource faces per target face
             scalarListList tgtWeights_;
 
-            //- Cache local size of target patch
-            //  Note: size could be manipulated in parallel
-            label tgtPatchSize_;
-
 
         //- Starting face seed index
         label startSeedI_;
diff --git a/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/system/decomposeParDict b/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/system/decomposeParDict
new file mode 100644
index 0000000000..c19a5c12d4
--- /dev/null
+++ b/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/system/decomposeParDict
@@ -0,0 +1,40 @@
+/*--------------------------------*- 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      decomposeParDict;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+/*
+preservePatches
+(
+    AMI1
+    AMI2
+);
+*/
+numberOfSubdomains 4;
+
+method          simple;
+
+simpleCoeffs
+{
+    n               ( 2 2 1 );
+    delta           0.001;
+}
+
+
+distributed     no;
+
+roots           ( );
+
+
+// ************************************************************************* //
diff --git a/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/system/fvSchemes b/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/system/fvSchemes
index 82ae10e9a5..5e6c6725c5 100644
--- a/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/system/fvSchemes
+++ b/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/system/fvSchemes
@@ -24,7 +24,6 @@ gradSchemes
 {
     default         Gauss linear;
     grad(p)         Gauss linear;
-//    grad(U)         cellLimited Gauss linear 1;
     grad(U)         Gauss linear 1;
 }
 
@@ -37,8 +36,7 @@ divSchemes
 
 laplacianSchemes
 {
-//    default         Gauss linear corrected;
-    default         Gauss linear uncorrected;
+    default         Gauss linear corrected;
 }
 
 interpolationSchemes
@@ -49,8 +47,7 @@ interpolationSchemes
 
 snGradSchemes
 {
-//    default         corrected;
-    default         uncorrected;
+    default         corrected;
 }
 
 fluxRequired

From ad77741dec7a58852a6d30989f792a6048bf1277 Mon Sep 17 00:00:00 2001
From: andy <andy>
Date: Thu, 25 Aug 2011 10:53:52 +0100
Subject: [PATCH 19/45] ENH: Updates to AMI and tutorial

---
 src/AMIInterpolation/AMIInterpolation.C       | 37 ++++++++---------
 src/AMIInterpolation/AMIInterpolation.H       |  4 --
 .../mixerVesselAMI2D/system/decomposeParDict  | 40 +++++++++++++++++++
 .../mixerVesselAMI2D/system/fvSchemes         |  7 +---
 4 files changed, 61 insertions(+), 27 deletions(-)
 create mode 100644 tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/system/decomposeParDict

diff --git a/src/AMIInterpolation/AMIInterpolation.C b/src/AMIInterpolation/AMIInterpolation.C
index 9bc928d69a..dbbf026657 100644
--- a/src/AMIInterpolation/AMIInterpolation.C
+++ b/src/AMIInterpolation/AMIInterpolation.C
@@ -275,8 +275,6 @@ distributeAndMergePatches
 
     tgtFaces.setSize(nFaces);
     tgtPoints.setSize(nPoints);
-
-//reduce(nFaces, sumOp<label>());
     tgtFaceIDs.setSize(nFaces);
 
     nFaces = 0;
@@ -754,7 +752,7 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::setNextFaces
                 "const primitivePatch&, "
                 "const primitivePatch&, "
                 "const boolList&, "
-                "const labelList&, "
+                "labelList&, "
                 "const DynamicList<label>&"
             ") const"
         )  << "Unable to set source and target faces" << abort(FatalError);
@@ -1052,9 +1050,8 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::normaliseWeights
     {
         scalar s = sum(wght[faceI]);
         wghtSum[faceI] = s;
-        
-        scalar t = 1; // s/patch[faceI].mag(patch.localPoints());
 
+        scalar t = s/patch[faceI].mag(patch.points());
         if (t < minBound)
         {
             minBound = t;
@@ -1096,7 +1093,6 @@ Foam::AMIInterpolation<SourcePatch, TargetPatch>::AMIInterpolation
     srcWeights_(),
     tgtAddress_(),
     tgtWeights_(),
-    tgtPatchSize_(tgtPatch.size()),
     startSeedI_(0),
     triMode_(triMode),
     projectPoints_(projectPoints),
@@ -1146,8 +1142,8 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::update
         globalIndex globalTgtFaces(tgtPatch.size());
 
         // Create processor map of overlapping faces. This map gets
-        // (possibly remote) faces from the tgtPatch such that they together
-        // cover all of the srcPatch.
+        // (possibly remote) faces from the tgtPatch such that they (together)
+        // cover all of the srcPatch
         autoPtr<mapDistribute> mapPtr = calcProcMap(srcPatch, tgtPatch);
         const mapDistribute& map = mapPtr();
 
@@ -1161,7 +1157,12 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::update
         labelList tgtFaceIDs;
         distributeAndMergePatches
         (
-            map, tgtPatch, globalTgtFaces, newTgtFaces, newTgtPoints, tgtFaceIDs
+            map,
+            tgtPatch,
+            globalTgtFaces,
+            newTgtFaces,
+            newTgtPoints,
+            tgtFaceIDs
         );
 
         primitivePatch
@@ -1178,7 +1179,7 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::update
         checkPatches(srcPatch, newTgtPatch);
 
 
-        // calculate AMI interpolation.
+        // calculate AMI interpolation
         calcAddressing(srcPatch, newTgtPatch, surf);
 
         // Now
@@ -1212,7 +1213,7 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::update
         }
 
         // send data back to originating procs. Note that contributions
-        // from different processors get added (ListPlusEqOp).
+        // from different processors get added (ListPlusEqOp)
 
         mapDistribute::distribute
         (
@@ -1239,8 +1240,8 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::update
         );
 
         // weights normalisation
-        normaliseWeights(srcPatch, "source", srcAddress_, srcWeights_, true);
-        normaliseWeights(tgtPatch, "target", tgtAddress_, tgtWeights_, true);
+        normaliseWeights(tgtPatch, "source", srcAddress_, srcWeights_, true);
+        normaliseWeights(srcPatch, "target", tgtAddress_, tgtWeights_, true);
 
         // cache maps and reset addresses
         List<Map<label> > cMap;
@@ -1267,8 +1268,8 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::update
             writeWeights(tgtWeights_, tgtPatch, "VTK", "target");
         }
 
-        normaliseWeights(srcPatch, "source", srcAddress_, srcWeights_, true);
-        normaliseWeights(tgtPatch, "target", tgtAddress_, tgtWeights_, true);
+        normaliseWeights(tgtPatch, "source", srcAddress_, srcWeights_, true);
+        normaliseWeights(srcPatch, "target", tgtAddress_, tgtWeights_, true);
     }
 
     patchI++;
@@ -1283,13 +1284,13 @@ Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolateToSource
     const Field<Type>& fld
 ) const
 {
-    if (fld.size() != tgtPatchSize_)
+    if (fld.size() != tgtAddress_.size())
     {
         FatalErrorIn
         (
             "AMIInterpolation::interpolateToSource(const Field<Type>) const"
         )   << "Supplied field size is not equal to target patch size. "
-            << "Target patch = " << tgtPatchSize_ << ", supplied field = "
+            << "Target patch = " << tgtAddress_.size() << ", supplied field = "
             << fld.size() << abort(FatalError);
     }
 
@@ -1375,7 +1376,7 @@ Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolateToTarget
     (
         new Field<Type>
         (
-            tgtPatchSize_,
+            tgtAddress_.size(),
             pTraits<Type>::zero
         )
     );
diff --git a/src/AMIInterpolation/AMIInterpolation.H b/src/AMIInterpolation/AMIInterpolation.H
index f9d7227124..4173362f54 100644
--- a/src/AMIInterpolation/AMIInterpolation.H
+++ b/src/AMIInterpolation/AMIInterpolation.H
@@ -122,10 +122,6 @@ class AMIInterpolation
             //- Weights of wource faces per target face
             scalarListList tgtWeights_;
 
-            //- Cache local size of target patch
-            //  Note: size could be manipulated in parallel
-            label tgtPatchSize_;
-
 
         //- Starting face seed index
         label startSeedI_;
diff --git a/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/system/decomposeParDict b/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/system/decomposeParDict
new file mode 100644
index 0000000000..c19a5c12d4
--- /dev/null
+++ b/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/system/decomposeParDict
@@ -0,0 +1,40 @@
+/*--------------------------------*- 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      decomposeParDict;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+/*
+preservePatches
+(
+    AMI1
+    AMI2
+);
+*/
+numberOfSubdomains 4;
+
+method          simple;
+
+simpleCoeffs
+{
+    n               ( 2 2 1 );
+    delta           0.001;
+}
+
+
+distributed     no;
+
+roots           ( );
+
+
+// ************************************************************************* //
diff --git a/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/system/fvSchemes b/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/system/fvSchemes
index 82ae10e9a5..5e6c6725c5 100644
--- a/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/system/fvSchemes
+++ b/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/system/fvSchemes
@@ -24,7 +24,6 @@ gradSchemes
 {
     default         Gauss linear;
     grad(p)         Gauss linear;
-//    grad(U)         cellLimited Gauss linear 1;
     grad(U)         Gauss linear 1;
 }
 
@@ -37,8 +36,7 @@ divSchemes
 
 laplacianSchemes
 {
-//    default         Gauss linear corrected;
-    default         Gauss linear uncorrected;
+    default         Gauss linear corrected;
 }
 
 interpolationSchemes
@@ -49,8 +47,7 @@ interpolationSchemes
 
 snGradSchemes
 {
-//    default         corrected;
-    default         uncorrected;
+    default         corrected;
 }
 
 fluxRequired

From 43f56cfaf60434c0a42b1bc450e8000050201152 Mon Sep 17 00:00:00 2001
From: andy <andy>
Date: Thu, 25 Aug 2011 12:06:40 +0100
Subject: [PATCH 20/45] BUG: Removed spurious entries in transport dictionary

---
 .../simpleFoam/motorBike/constant/transportProperties    | 9 ---------
 1 file changed, 9 deletions(-)

diff --git a/tutorials/incompressible/simpleFoam/motorBike/constant/transportProperties b/tutorials/incompressible/simpleFoam/motorBike/constant/transportProperties
index aae90f589a..9b41791886 100644
--- a/tutorials/incompressible/simpleFoam/motorBike/constant/transportProperties
+++ b/tutorials/incompressible/simpleFoam/motorBike/constant/transportProperties
@@ -16,15 +16,6 @@ FoamFile
 
 transportModel  Newtonian;
 
-method          hierarchical;
-
-hierarchicalCoeffs
-{
-    n           (2 1 1);
-    delta       0.001;
-    order       xyz;
-}
-
 nu              nu [0 2 -1 0 0 0 0] 1.5e-05;
 
 // ************************************************************************* //

From 721d2092e87e141ab1d6d86174cfea7196464d95 Mon Sep 17 00:00:00 2001
From: mattijs <mattijs>
Date: Thu, 25 Aug 2011 15:14:47 +0100
Subject: [PATCH 21/45] ENH: decomposePar: add
 preserve-faceZone-on-single-processor decomposition

---
 .../decomposePar/decomposeParDict             |  15 +-
 .../domainDecompositionDistribute.C           | 153 +++++++++++++++---
 .../decompositionMethod/decompositionMethod.C |   1 +
 3 files changed, 144 insertions(+), 25 deletions(-)

diff --git a/applications/utilities/parallelProcessing/decomposePar/decomposeParDict b/applications/utilities/parallelProcessing/decomposePar/decomposeParDict
index e60757fffd..c42bdc1c9a 100644
--- a/applications/utilities/parallelProcessing/decomposePar/decomposeParDict
+++ b/applications/utilities/parallelProcessing/decomposePar/decomposeParDict
@@ -15,7 +15,7 @@ FoamFile
 }
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-numberOfSubdomains  8;
+numberOfSubdomains  2;
 
 //- Keep owner and neighbour on same processor for faces in zones:
 // preserveFaceZones (heater solid1 solid3);
@@ -24,13 +24,22 @@ numberOfSubdomains  8;
 //  (makes sense only for cyclic patches)
 //preservePatches (cyclic_half0 cyclic_half1);
 
+//- Keep all of faceZone on a single processor. This puts all cells
+//  connected with a point, edge or face on the same processor.
+//  (just having face connected cells might not guarantee a balanced
+//  decomposition)
+// The processor can be explicitly provided or -1 to have
+// decompositionMethod choose.
+//singleProcessorFaceZones ((f0 -1));
+
+
 //- Use the volScalarField named here as a weight for each cell in the
 //  decomposition.  For example, use a particle population field to decompose
 //  for a balanced number of particles in a lagrangian simulation.
 // weightField dsmcRhoNMean;
 
 method          scotch;
-// method          hierarchical;
+//method          hierarchical;
 // method          simple;
 // method          metis;
 // method          manual;
@@ -70,7 +79,7 @@ simpleCoeffs
 
 hierarchicalCoeffs
 {
-    n           (2 2 1);
+    n           (1 2 1);
     delta       0.001;
     order       xyz;
 }
diff --git a/applications/utilities/parallelProcessing/decomposePar/domainDecompositionDistribute.C b/applications/utilities/parallelProcessing/decomposePar/domainDecompositionDistribute.C
index 4ee3c7555e..0d40f8b232 100644
--- a/applications/utilities/parallelProcessing/decomposePar/domainDecompositionDistribute.C
+++ b/applications/utilities/parallelProcessing/decomposePar/domainDecompositionDistribute.C
@@ -28,6 +28,7 @@ License
 #include "cpuTime.H"
 #include "cellSet.H"
 #include "regionSplit.H"
+#include "Tuple2.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -47,7 +48,8 @@ void Foam::domainDecomposition::distributeCells()
     {
         wordList pNames(decompositionDict_.lookup("preservePatches"));
 
-        Info<< "Keeping owner of faces in patches " << pNames
+        Info<< nl
+            << "Keeping owner of faces in patches " << pNames
             << " on same processor. This only makes sense for cyclics." << endl;
 
         const polyBoundaryMesh& patches = boundaryMesh();
@@ -76,7 +78,8 @@ void Foam::domainDecomposition::distributeCells()
     {
         wordList zNames(decompositionDict_.lookup("preserveFaceZones"));
 
-        Info<< "Keeping owner and neighbour of faces in zones " << zNames
+        Info<< nl
+            << "Keeping owner and neighbour of faces in zones " << zNames
             << " on same processor" << endl;
 
         const faceZoneMesh& fZones = faceZones();
@@ -103,6 +106,67 @@ void Foam::domainDecomposition::distributeCells()
     }
 
 
+    // Specified processor for owner and neighbour of faces
+    Map<label> specifiedProcessorFaces;
+
+    if (decompositionDict_.found("singleProcessorFaceZones"))
+    {
+        List<Tuple2<word, label> > zNameAndProcs
+        (
+            decompositionDict_.lookup("singleProcessorFaceZones")
+        );
+
+        const faceZoneMesh& fZones = faceZones();
+
+        label nCells = 0;
+
+        Info<< endl;
+
+        forAll(zNameAndProcs, i)
+        {
+            Info<< "Keeping all cells connected to faceZone "
+                << zNameAndProcs[i].first()
+                << " on processor " << zNameAndProcs[i].second() << endl;
+
+            label zoneI = fZones.findZoneID(zNameAndProcs[i].first());
+
+            if (zoneI == -1)
+            {
+                FatalErrorIn("domainDecomposition::distributeCells()")
+                    << "Unknown singleProcessorFaceZone "
+                    << zNameAndProcs[i].first()
+                    << endl << "Valid faceZones are " << fZones.names()
+                    << exit(FatalError);
+            }
+
+            const faceZone& fz = fZones[zoneI];
+
+            nCells += fz.size();
+        }
+
+
+        // Size
+        specifiedProcessorFaces.resize(2*nCells);
+
+
+        // Fill
+        forAll(zNameAndProcs, i)
+        {
+            label zoneI = fZones.findZoneID(zNameAndProcs[i].first());
+            const faceZone& fz = fZones[zoneI];
+
+            label procI = zNameAndProcs[i].second();
+
+            forAll(fz, fzI)
+            {
+                label faceI = fz[fzI];
+
+                specifiedProcessorFaces.insert(faceI, procI);
+            }
+        }
+    }
+
+
     // Construct decomposition method and either do decomposition on
     // cell centres or on agglomeration
 
@@ -112,7 +176,8 @@ void Foam::domainDecomposition::distributeCells()
         decompositionDict_
     );
 
-    if (sameProcFaces.empty())
+
+    if (sameProcFaces.empty() && specifiedProcessorFaces.empty())
     {
         if (decompositionDict_.found("weightField"))
         {
@@ -146,9 +211,11 @@ void Foam::domainDecomposition::distributeCells()
     }
     else
     {
-        Info<< "Selected " << sameProcFaces.size()
-            << " faces whose owner and neighbour cell should be kept on the"
-            << " same processor" << endl;
+        Info<< "Constrained decomposition:" << endl
+            << "    faces with same processor owner and neighbour : "
+            << sameProcFaces.size() << endl
+            << "    faces all on same processor                   : "
+            << specifiedProcessorFaces.size() << endl << endl;
 
         // Faces where owner and neighbour are not 'connected' (= all except
         // sameProcFaces)
@@ -159,6 +226,24 @@ void Foam::domainDecomposition::distributeCells()
             blockedFace[iter.key()] = false;
         }
 
+
+        // For specifiedProcessorFaces add all point connected faces
+        {
+            forAllConstIter(Map<label>, specifiedProcessorFaces, iter)
+            {
+                const face& f = faces()[iter.key()];
+                forAll(f, fp)
+                {
+                    const labelList& pFaces = pointFaces()[f[fp]];
+                    forAll(pFaces, i)
+                    {
+                        blockedFace[pFaces[i]] = false;
+                    }
+                }
+            }
+        }
+
+
         // Connect coupled boundary faces
         const polyBoundaryMesh& patches =  boundaryMesh();
 
@@ -201,10 +286,11 @@ void Foam::domainDecomposition::distributeCells()
 
         // Do decomposition on agglomeration
         // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+        scalarField regionWeights(globalRegion.nRegions(), 0);
+
         if (decompositionDict_.found("weightField"))
         {
-            scalarField regionWeights(globalRegion.nRegions(), 0);
-
             word weightName = decompositionDict_.lookup("weightField");
 
             volScalarField weights
@@ -226,23 +312,46 @@ void Foam::domainDecomposition::distributeCells()
 
                 regionWeights[regionI] += weights.internalField()[cellI];
             }
-
-            cellToProc_ = decomposePtr().decompose
-            (
-                *this,
-                globalRegion,
-                regionCentres,
-                regionWeights
-            );
         }
         else
         {
-            cellToProc_ = decomposePtr().decompose
-            (
-                *this,
-                globalRegion,
-                regionCentres
-            );
+            forAll(globalRegion, cellI)
+            {
+                label regionI = globalRegion[cellI];
+
+                regionWeights[regionI] += 1.0;
+            }
+        }
+
+        cellToProc_ = decomposePtr().decompose
+        (
+            *this,
+            globalRegion,
+            regionCentres,
+            regionWeights
+        );
+
+
+        // For specifiedProcessorFaces rework the cellToProc. Note that
+        // this makes the decomposition unbalanced.
+        if (specifiedProcessorFaces.size())
+        {
+            labelList procMap(identity(cellToProc_.size()));
+
+            forAllConstIter(Map<label>, specifiedProcessorFaces, iter)
+            {
+                label faceI = iter.key();
+                label wantedProcI = iter();
+
+                if (wantedProcI != -1)
+                {
+                    cellToProc_[faceOwner()[faceI]] = wantedProcI;
+                    if (isInternalFace(faceI))
+                    {
+                        cellToProc_[faceNeighbour()[faceI]] = wantedProcI;
+                    }
+                }
+            }
         }
     }
 
diff --git a/src/parallel/decompose/decompositionMethods/decompositionMethod/decompositionMethod.C b/src/parallel/decompose/decompositionMethods/decompositionMethod/decompositionMethod.C
index 663f5b003b..1808fc84ab 100644
--- a/src/parallel/decompose/decompositionMethods/decompositionMethod/decompositionMethod.C
+++ b/src/parallel/decompose/decompositionMethods/decompositionMethod/decompositionMethod.C
@@ -403,6 +403,7 @@ void Foam::decompositionMethod::calcCellCells
     forAll(cellCells, cellI)
     {
         nbrCells.clear();
+        nbrCells.insert(cellI);
 
         label& endIndex = cellCells.offsets()[cellI+1];
 

From 91abb4c6f80b9b4c486da7e972d2cd0ef70e67f5 Mon Sep 17 00:00:00 2001
From: andy <andy>
Date: Thu, 25 Aug 2011 15:52:17 +0100
Subject: [PATCH 22/45] BUG: Corrected AMI weights normalisation output info

---
 src/AMIInterpolation/AMIInterpolation.C | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/AMIInterpolation/AMIInterpolation.C b/src/AMIInterpolation/AMIInterpolation.C
index dbbf026657..cb11c6602b 100644
--- a/src/AMIInterpolation/AMIInterpolation.C
+++ b/src/AMIInterpolation/AMIInterpolation.C
@@ -1240,8 +1240,8 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::update
         );
 
         // weights normalisation
-        normaliseWeights(tgtPatch, "source", srcAddress_, srcWeights_, true);
-        normaliseWeights(srcPatch, "target", tgtAddress_, tgtWeights_, true);
+        normaliseWeights(srcPatch, "source", srcAddress_, srcWeights_, true);
+        normaliseWeights(tgtPatch, "target", tgtAddress_, tgtWeights_, true);
 
         // cache maps and reset addresses
         List<Map<label> > cMap;
@@ -1268,8 +1268,8 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::update
             writeWeights(tgtWeights_, tgtPatch, "VTK", "target");
         }
 
-        normaliseWeights(tgtPatch, "source", srcAddress_, srcWeights_, true);
-        normaliseWeights(srcPatch, "target", tgtAddress_, tgtWeights_, true);
+        normaliseWeights(srcPatch, "source", srcAddress_, srcWeights_, true);
+        normaliseWeights(tgtPatch, "target", tgtAddress_, tgtWeights_, true);
     }
 
     patchI++;

From 95a2ed3f1fbcce0f5b54bd5bae7c3d72a5522e5f Mon Sep 17 00:00:00 2001
From: mattijs <mattijs>
Date: Fri, 26 Aug 2011 12:21:06 +0100
Subject: [PATCH 23/45] BUG: decomposePar: constrained decomposition - enforce
 single processor

---
 .../decomposePar/decomposeParDict             |  4 +-
 .../domainDecompositionDistribute.C           | 50 +++++++++++++------
 2 files changed, 38 insertions(+), 16 deletions(-)

diff --git a/applications/utilities/parallelProcessing/decomposePar/decomposeParDict b/applications/utilities/parallelProcessing/decomposePar/decomposeParDict
index c42bdc1c9a..c5b5c45135 100644
--- a/applications/utilities/parallelProcessing/decomposePar/decomposeParDict
+++ b/applications/utilities/parallelProcessing/decomposePar/decomposeParDict
@@ -28,8 +28,8 @@ numberOfSubdomains  2;
 //  connected with a point, edge or face on the same processor.
 //  (just having face connected cells might not guarantee a balanced
 //  decomposition)
-// The processor can be explicitly provided or -1 to have
-// decompositionMethod choose.
+// The processor can be -1 (the decompositionMethod chooses the processor
+// for a good load balance) or explicitly provided (upsets balance).
 //singleProcessorFaceZones ((f0 -1));
 
 
diff --git a/applications/utilities/parallelProcessing/decomposePar/domainDecompositionDistribute.C b/applications/utilities/parallelProcessing/decomposePar/domainDecompositionDistribute.C
index 0d40f8b232..e8b6997bc4 100644
--- a/applications/utilities/parallelProcessing/decomposePar/domainDecompositionDistribute.C
+++ b/applications/utilities/parallelProcessing/decomposePar/domainDecompositionDistribute.C
@@ -108,13 +108,11 @@ void Foam::domainDecomposition::distributeCells()
 
     // Specified processor for owner and neighbour of faces
     Map<label> specifiedProcessorFaces;
+    List<Tuple2<word, label> > zNameAndProcs;
 
     if (decompositionDict_.found("singleProcessorFaceZones"))
     {
-        List<Tuple2<word, label> > zNameAndProcs
-        (
-            decompositionDict_.lookup("singleProcessorFaceZones")
-        );
+        decompositionDict_.lookup("singleProcessorFaceZones") >> zNameAndProcs;
 
         const faceZoneMesh& fZones = faceZones();
 
@@ -332,23 +330,47 @@ void Foam::domainDecomposition::distributeCells()
         );
 
 
-        // For specifiedProcessorFaces rework the cellToProc. Note that
-        // this makes the decomposition unbalanced.
+        // For specifiedProcessorFaces rework the cellToProc to enforce
+        // all on one processor since we can't guarantee that the input
+        // to regionSplit was a single region.
+        // E.g. faceZone 'a' with the cells split into two regions
+        // by a notch formed by two walls
+        //
+        //          \   /
+        //           \ /
+        //    ---a----+-----a-----
+        //
+        // 
+        // Note that reworking the cellToProc might make the decomposition
+        // unbalanced.
         if (specifiedProcessorFaces.size())
         {
-            labelList procMap(identity(cellToProc_.size()));
+            const faceZoneMesh& fZones = faceZones();
 
-            forAllConstIter(Map<label>, specifiedProcessorFaces, iter)
+            forAll(zNameAndProcs, i)
             {
-                label faceI = iter.key();
-                label wantedProcI = iter();
+                label zoneI = fZones.findZoneID(zNameAndProcs[i].first());
+                const faceZone& fz = fZones[zoneI];
 
-                if (wantedProcI != -1)
+                if (fz.size())
                 {
-                    cellToProc_[faceOwner()[faceI]] = wantedProcI;
-                    if (isInternalFace(faceI))
+                    label procI = zNameAndProcs[i].second();
+                    if (procI == -1)
                     {
-                        cellToProc_[faceNeighbour()[faceI]] = wantedProcI;
+                        // If no processor specified use the one from the
+                        // 0th element
+                        procI = cellToProc_[faceOwner()[fz[0]]];
+                    }
+
+                    forAll(fz, fzI)
+                    {
+                        label faceI = fz[fzI];
+
+                        cellToProc_[faceOwner()[faceI]] = procI;
+                        if (isInternalFace(faceI))
+                        {
+                            cellToProc_[faceNeighbour()[faceI]] = procI;
+                        }
                     }
                 }
             }

From a11d308ebeb156b75ee6f9f378160afe245d3b58 Mon Sep 17 00:00:00 2001
From: mattijs <mattijs>
Date: Fri, 26 Aug 2011 12:28:46 +0100
Subject: [PATCH 24/45] ENH: coupledPolyPatch: zero sized patch is parallel,
 non-separated

---
 .../polyMesh/polyPatches/basic/coupled/coupledPolyPatch.C   | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/OpenFOAM/meshes/polyMesh/polyPatches/basic/coupled/coupledPolyPatch.C b/src/OpenFOAM/meshes/polyMesh/polyPatches/basic/coupled/coupledPolyPatch.C
index a98019a5f5..ca7155704d 100644
--- a/src/OpenFOAM/meshes/polyMesh/polyPatches/basic/coupled/coupledPolyPatch.C
+++ b/src/OpenFOAM/meshes/polyMesh/polyPatches/basic/coupled/coupledPolyPatch.C
@@ -244,10 +244,10 @@ void Foam::coupledPolyPatch::calcTransformTensors
 
     if (Cf.size() == 0)
     {
-        // Dummy geometry.
+        // Dummy geometry. Assume non-separated, parallel.
         separation_.setSize(0);
-        forwardT_ = I;
-        reverseT_ = I;
+        forwardT_.clear();
+        reverseT_.clear();
         collocated_.setSize(0);
     }
     else

From 03cf8f707531fb9f491976baf67104cb7b813bd0 Mon Sep 17 00:00:00 2001
From: andy <andy>
Date: Fri, 26 Aug 2011 13:32:12 +0100
Subject: [PATCH 25/45] BUG: AMI - corrected colocated separation vector

---
 .../patches/cyclicAMIPolyPatch/cyclicAMIPolyPatch.C        | 7 +------
 1 file changed, 1 insertion(+), 6 deletions(-)

diff --git a/src/AMIInterpolation/patches/cyclicAMIPolyPatch/cyclicAMIPolyPatch.C b/src/AMIInterpolation/patches/cyclicAMIPolyPatch/cyclicAMIPolyPatch.C
index d3dd917a38..8c36c91907 100644
--- a/src/AMIInterpolation/patches/cyclicAMIPolyPatch/cyclicAMIPolyPatch.C
+++ b/src/AMIInterpolation/patches/cyclicAMIPolyPatch/cyclicAMIPolyPatch.C
@@ -176,7 +176,6 @@ void Foam::cyclicAMIPolyPatch::calcTransforms
         }
         case TRANSLATIONAL:
         {
-            // Transform 0 points
             if (debug)
             {
                 Pout<< "cyclicAMIPolyPatch::calcTransforms :"
@@ -204,11 +203,7 @@ void Foam::cyclicAMIPolyPatch::calcTransforms
 
             const_cast<tensorField&>(forwardT()).clear();
             const_cast<tensorField&>(reverseT()).clear();
-            const_cast<vectorField&>(separation()) = vectorField
-            (
-                1,
-                vector::zero
-            );
+            const_cast<vectorField&>(separation()).setSize(0);
             const_cast<boolList&>(collocated()) = boolList(1, true);
 
             break;

From 59ca09f15217fc98d16867c269de896816a93fd7 Mon Sep 17 00:00:00 2001
From: andy <andy>
Date: Fri, 26 Aug 2011 14:53:45 +0100
Subject: [PATCH 26/45] BUG: AMI - corrected 'next' face selection

---
 src/AMIInterpolation/AMIInterpolation.C | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/AMIInterpolation/AMIInterpolation.C b/src/AMIInterpolation/AMIInterpolation.C
index cb11c6602b..c116ee2030 100644
--- a/src/AMIInterpolation/AMIInterpolation.C
+++ b/src/AMIInterpolation/AMIInterpolation.C
@@ -701,7 +701,7 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::setNextFaces
             {
                 if (!foundNextSeed)
                 {
-                    startSeedI_ = faceI + 1;
+                    startSeedI_ = faceI;
                     foundNextSeed = true;
                 }
 

From a29da9dc885b0e59d08720ee928642567d5c234a Mon Sep 17 00:00:00 2001
From: andy <andy>
Date: Thu, 1 Sep 2011 15:45:20 +0100
Subject: [PATCH 27/45] ENH: Updated AMI functionality - re: projection surface

---
 src/AMIInterpolation/AMIInterpolation.C       | 156 +++++++++---------
 src/AMIInterpolation/AMIInterpolation.H       |  14 +-
 .../cyclicAMIPolyPatch/cyclicAMIPolyPatch.C   | 105 +++++++-----
 .../cyclicAMIPolyPatch/cyclicAMIPolyPatch.H   |   5 +-
 4 files changed, 143 insertions(+), 137 deletions(-)

diff --git a/src/AMIInterpolation/AMIInterpolation.C b/src/AMIInterpolation/AMIInterpolation.C
index c116ee2030..7ffbb3e90a 100644
--- a/src/AMIInterpolation/AMIInterpolation.C
+++ b/src/AMIInterpolation/AMIInterpolation.C
@@ -499,11 +499,6 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::projectPointsToSurface
     pointField& pts
 ) const
 {
-    if (!projectPoints_)
-    {
-        return;
-    }
-
     if (debug)
     {
         Info<< "AMI: projecting points to surface" << endl;
@@ -803,7 +798,6 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::calcAddressing
 (
     const primitivePatch& srcPatch,
     const primitivePatch& tgtPatch,
-    const searchableSurface& surf,
     label srcFaceI,
     label tgtFaceI
 )
@@ -824,6 +818,8 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::calcAddressing
     if (debug)
     {
         Info<< "AMI: calcAddressing" << endl;
+        writePatch(srcPatch, "VTK", "source");
+        writePatch(tgtPatch, "VTK", "target");
     }
 
     // temporary storage for addressing and weights
@@ -833,57 +829,6 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::calcAddressing
     List<DynamicList<scalar> > tgtWght(tgtPatch.size());
 
 
-    // create new patches for source and target
-    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    pointField srcPoints = srcPatch.points();
-    primitivePatch srcPatch0
-    (
-        SubList<face>
-        (
-            srcPatch,
-            srcPatch.size(),
-            0
-        ),
-        srcPoints
-    );
-
-    if (debug)
-    {
-        OFstream os("amiSrcPoints.obj");
-        forAll(srcPoints, i)
-        {
-            meshTools::writeOBJ(os, srcPoints[i]);
-        }
-    }
-
-    pointField tgtPoints = tgtPatch.points();
-    primitivePatch tgtPatch0
-    (
-        SubList<face>
-        (
-            tgtPatch,
-            tgtPatch.size(),
-            0
-        ),
-        tgtPoints
-    );
-
-    if (debug)
-    {
-        OFstream os("amiTgtPoints.obj");
-        forAll(tgtPoints, i)
-        {
-            meshTools::writeOBJ(os, tgtPoints[i]);
-        }
-    }
-
-
-    // map source and target patches onto projection surface
-    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    projectPointsToSurface(surf, srcPoints);
-    projectPointsToSurface(surf, tgtPoints);
-
-
     // find initial face match using brute force/octree search
     // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     if ((srcFaceI == -1) || (tgtFaceI == -1))
@@ -891,9 +836,9 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::calcAddressing
         srcFaceI = 0;
         tgtFaceI = 0;
         bool foundFace = false;
-        forAll(srcPatch0, faceI)
+        forAll(srcPatch, faceI)
         {
-            tgtFaceI = findTargetFace(srcFaceI, srcPatch0, tgtPatch0);
+            tgtFaceI = findTargetFace(faceI, srcPatch, tgtPatch);
             if (tgtFaceI >= 0)
             {
                 srcFaceI = faceI;
@@ -911,7 +856,6 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::calcAddressing
                 "("
                     "const primitivePatch&, "
                     "const primitivePatch&, "
-                    "const searchableSurface&, "
                     "label, "
                     "label"
                 ")"
@@ -927,7 +871,7 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::calcAddressing
 
     // construct weights and addressing
     // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    label nFacesRemaining = srcPatch0.size();
+    label nFacesRemaining = srcPatch.size();
 
     // list of tgt face neighbour faces
     DynamicList<label> nbrFaces(10);
@@ -953,7 +897,7 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::calcAddressing
 
         // append initial target face and neighbours
         nbrFaces.append(tgtFaceI);
-        appendNbrFaces(tgtFaceI, tgtPatch0, visitedFaces, nbrFaces);
+        appendNbrFaces(tgtFaceI, tgtPatch, visitedFaces, nbrFaces);
 
         bool faceProcessed = false;
 
@@ -962,7 +906,7 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::calcAddressing
             // process new target face
             tgtFaceI = nbrFaces.remove();
             visitedFaces.append(tgtFaceI);
-            scalar area = interArea(srcFaceI, tgtFaceI, srcPatch0, tgtPatch0);
+            scalar area = interArea(srcFaceI, tgtFaceI, srcPatch, tgtPatch);
 
             // store when intersection area > 0
             if (area > 0)
@@ -973,7 +917,7 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::calcAddressing
                 tgtAddr[tgtFaceI].append(srcFaceI);
                 tgtWght[tgtFaceI].append(area);
 
-                appendNbrFaces(tgtFaceI, tgtPatch0, visitedFaces, nbrFaces);
+                appendNbrFaces(tgtFaceI, tgtPatch, visitedFaces, nbrFaces);
 
                 faceProcessed = true;
             }
@@ -996,8 +940,8 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::calcAddressing
             (
                 srcFaceI,
                 tgtFaceI,
-                srcPatch0,
-                tgtPatch0,
+                srcPatch,
+                tgtPatch,
                 mapFlag,
                 seedFaces,
                 visitedFaces
@@ -1084,9 +1028,8 @@ Foam::AMIInterpolation<SourcePatch, TargetPatch>::AMIInterpolation
 (
     const SourcePatch& srcPatch,
     const TargetPatch& tgtPatch,
-    const searchableSurface& surf,
-    const faceAreaIntersect::triangulationMode& triMode,
-    const bool projectPoints
+    const autoPtr<searchableSurface>& surfPtr,
+    const faceAreaIntersect::triangulationMode& triMode
 )
 :
     srcAddress_(),
@@ -1095,24 +1038,74 @@ Foam::AMIInterpolation<SourcePatch, TargetPatch>::AMIInterpolation
     tgtWeights_(),
     startSeedI_(0),
     triMode_(triMode),
-    projectPoints_(projectPoints),
     srcMapPtr_(NULL),
     tgtMapPtr_(NULL)
 {
     label srcSize = returnReduce(srcPatch.size(), sumOp<label>());
     label tgtSize = returnReduce(tgtPatch.size(), sumOp<label>());
 
-    Info<< "AMI: Creating interpolation addressing and weights" << nl
-        << "    Source faces = " << srcSize << nl
-        << "    Target faces = " << tgtSize << endl;
+    Info<< "AMI: Creating addressing and weights between "
+        << srcSize << " source faces and " << tgtSize << " target faces"
+        << endl;
 
-    if (debug)
+    if (surfPtr.valid())
     {
-        writePatch(srcPatch, "VTK", "source");
-        writePatch(tgtPatch, "VTK", "target");
-    }
+        // create new patches for source and target
+        pointField srcPoints = srcPatch.points();
+        primitivePatch srcPatch0
+        (
+            SubList<face>
+            (
+                srcPatch,
+                srcPatch.size(),
+                0
+            ),
+            srcPoints
+        );
 
-    update(srcPatch, tgtPatch, surf);
+        if (debug)
+        {
+            OFstream os("amiSrcPoints.obj");
+            forAll(srcPoints, i)
+            {
+                meshTools::writeOBJ(os, srcPoints[i]);
+            }
+        }
+
+        pointField tgtPoints = tgtPatch.points();
+        primitivePatch tgtPatch0
+        (
+            SubList<face>
+            (
+                tgtPatch,
+                tgtPatch.size(),
+                0
+            ),
+            tgtPoints
+        );
+
+        if (debug)
+        {
+            OFstream os("amiTgtPoints.obj");
+            forAll(tgtPoints, i)
+            {
+                meshTools::writeOBJ(os, tgtPoints[i]);
+            }
+        }
+
+
+        // map source and target patches onto projection surface
+        projectPointsToSurface(surfPtr(), srcPoints);
+        projectPointsToSurface(surfPtr(), tgtPoints);
+
+
+        // calculate AMI interpolation
+        update(srcPatch0, tgtPatch0);
+    }
+    else
+    {
+        update(srcPatch, tgtPatch);
+    }
 }
 
 
@@ -1129,8 +1122,7 @@ template<class SourcePatch, class TargetPatch>
 void Foam::AMIInterpolation<SourcePatch, TargetPatch>::update
 (
     const primitivePatch& srcPatch,
-    const primitivePatch& tgtPatch,
-    const searchableSurface& surf
+    const primitivePatch& tgtPatch
 )
 {
     static label patchI = 0;
@@ -1180,7 +1172,7 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::update
 
 
         // calculate AMI interpolation
-        calcAddressing(srcPatch, newTgtPatch, surf);
+        calcAddressing(srcPatch, newTgtPatch);
 
         // Now
         // ~~~
@@ -1260,7 +1252,7 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::update
     {
         checkPatches(srcPatch, tgtPatch);
 
-        calcAddressing(srcPatch, tgtPatch, surf);
+        calcAddressing(srcPatch, tgtPatch);
 
         if (debug)
         {
diff --git a/src/AMIInterpolation/AMIInterpolation.H b/src/AMIInterpolation/AMIInterpolation.H
index 4173362f54..2142114661 100644
--- a/src/AMIInterpolation/AMIInterpolation.H
+++ b/src/AMIInterpolation/AMIInterpolation.H
@@ -129,11 +129,10 @@ class AMIInterpolation
         //- Face triangulation mode
         const faceAreaIntersect::triangulationMode triMode_;
 
-        //- Flag to indicate whether or not to project points
-        const bool projectPoints_;
-
+        //- Source map pointer - parallel running only
         autoPtr<mapDistribute> srcMapPtr_;
 
+        //- Target map pointer - parallel running only
         autoPtr<mapDistribute> tgtMapPtr_;
 
 
@@ -260,7 +259,6 @@ class AMIInterpolation
             (
                 const primitivePatch& srcPatch,
                 const primitivePatch& tgtPatch,
-                const searchableSurface& surf,
                 label srcFaceI = -1,
                 label tgtFaceI = -1
             );
@@ -289,9 +287,8 @@ public:
         (
             const SourcePatch& srcPatch,
             const TargetPatch& tgtPatch,
-            const searchableSurface& surf,
-            const faceAreaIntersect::triangulationMode& triMode,
-            const bool projectPoints
+            const autoPtr<searchableSurface>& surf,
+            const faceAreaIntersect::triangulationMode& triMode
         );
 
 
@@ -327,8 +324,7 @@ public:
             void update
             (
                 const primitivePatch& srcPatch,
-                const primitivePatch& tgtPatch,
-                const searchableSurface& surf
+                const primitivePatch& tgtPatch
             );
 
 
diff --git a/src/AMIInterpolation/patches/cyclicAMIPolyPatch/cyclicAMIPolyPatch.C b/src/AMIInterpolation/patches/cyclicAMIPolyPatch/cyclicAMIPolyPatch.C
index 8c36c91907..58cd9d8e2a 100644
--- a/src/AMIInterpolation/patches/cyclicAMIPolyPatch/cyclicAMIPolyPatch.C
+++ b/src/AMIInterpolation/patches/cyclicAMIPolyPatch/cyclicAMIPolyPatch.C
@@ -221,36 +221,11 @@ void Foam::cyclicAMIPolyPatch::calcTransforms
 }
 
 
-const Foam::searchableSurface& Foam::cyclicAMIPolyPatch::surf()
+void Foam::cyclicAMIPolyPatch::resetAMI()
 {
-    word surfType(surfDict_.lookup("type"));
-    word surfName(surfDict_.lookupOrDefault("name", name()));
+    AMIPtr_.clear();
 
-    const polyMesh& mesh = boundaryMesh().mesh();
-
-    surfPtr_ =
-        searchableSurface::New
-        (
-            surfType,
-            IOobject
-            (
-                surfName,
-                mesh.time().constant(),
-                "triSurface",
-                mesh,
-                IOobject::MUST_READ,
-                IOobject::NO_WRITE
-            ),
-            surfDict_
-        );
-
-    return surfPtr_();
-}
-
-
-const Foam::AMIPatchToPatchInterpolation& Foam::cyclicAMIPolyPatch::AMI()
-{
-    if (!AMIPtr_.valid() && owner())
+    if (owner())
     {
         const polyPatch& nbr = nbrPatch();
         pointField nbrPoints = nbrPatch().localPoints();
@@ -282,8 +257,6 @@ const Foam::AMIPatchToPatchInterpolation& Foam::cyclicAMIPolyPatch::AMI()
             meshTools::writeOBJ(osO, this->localFaces(), localPoints());
         }
 
-        bool projectPoints(readBool(surfDict_.lookup("projectPoints")));
-
         // Construct/apply AMI interpolation to determine addressing and weights
         AMIPtr_.reset
         (
@@ -291,14 +264,11 @@ const Foam::AMIPatchToPatchInterpolation& Foam::cyclicAMIPolyPatch::AMI()
             (
                 *this,
                 nbrPatch0,
-                surf(),
-                faceAreaIntersect::tmMesh,
-                projectPoints
+                surfPtr_,
+                faceAreaIntersect::tmMesh
             )
         );
     }
-
-    return AMIPtr_();
 }
 
 
@@ -345,11 +315,7 @@ void Foam::cyclicAMIPolyPatch::movePoints
 
     calcTransforms();
 
-    if (owner())
-    {
-        AMIPtr_.clear();
-        AMI();
-    }
+    resetAMI();
 }
 
 
@@ -611,6 +577,59 @@ bool Foam::cyclicAMIPolyPatch::owner() const
 }
 
 
+const Foam::autoPtr<Foam::searchableSurface>&
+Foam::cyclicAMIPolyPatch::surfPtr()
+{
+    word surfType(surfDict_.lookup("type"));
+
+    if (!surfPtr_.valid() && owner() && surfType != "none")
+    {
+        word surfName(surfDict_.lookupOrDefault("name", name()));
+
+        const polyMesh& mesh = boundaryMesh().mesh();
+
+        surfPtr_ =
+            searchableSurface::New
+            (
+                surfType,
+                IOobject
+                (
+                    surfName,
+                    mesh.time().constant(),
+                    "triSurface",
+                    mesh,
+                    IOobject::MUST_READ,
+                    IOobject::NO_WRITE
+                ),
+                surfDict_
+            );
+    }
+
+    return surfPtr_;
+}
+
+
+const Foam::AMIPatchToPatchInterpolation& Foam::cyclicAMIPolyPatch::AMI()
+{
+    if (!owner())
+    {
+        FatalErrorIn
+        (
+            "const AMIPatchToPatchInterpolation& cyclicAMIPolyPatch::AMI()"
+        )
+            << "AMI interpolator only available to owner patch"
+            << abort(FatalError);
+    }
+
+    if (!AMIPtr_.valid())
+    {
+        resetAMI();
+    }
+
+    return AMIPtr_();
+}
+
+
 void Foam::cyclicAMIPolyPatch::transformPosition(pointField& l) const
 {
     if (!parallel())
@@ -704,11 +723,7 @@ void Foam::cyclicAMIPolyPatch::calcGeometry
         nbrAreas
     );
 
-    if (owner())
-    {
-        AMIPtr_.clear();
-        AMI();
-    }
+    resetAMI();
 }
 
 
diff --git a/src/AMIInterpolation/patches/cyclicAMIPolyPatch/cyclicAMIPolyPatch.H b/src/AMIInterpolation/patches/cyclicAMIPolyPatch/cyclicAMIPolyPatch.H
index 1ad095036b..352bbddb54 100644
--- a/src/AMIInterpolation/patches/cyclicAMIPolyPatch/cyclicAMIPolyPatch.H
+++ b/src/AMIInterpolation/patches/cyclicAMIPolyPatch/cyclicAMIPolyPatch.H
@@ -109,6 +109,9 @@ private:
             const vectorField& half1Areas
         );
 
+        //- Reset the AMI interpolator
+        void resetAMI();
+
 
 protected:
 
@@ -264,7 +267,7 @@ public:
             inline const cyclicAMIPolyPatch& nbrPatch() const;
 
             //- Return a reference to the projection surface
-            const searchableSurface& surf();
+            const autoPtr<searchableSurface>& surfPtr();
 
             //- Return a reference to the AMI interpolator
             const AMIPatchToPatchInterpolation& AMI();

From 3a2b4dca633c3f5466cc81e1cfef4cde2d519459 Mon Sep 17 00:00:00 2001
From: andy <andy>
Date: Thu, 1 Sep 2011 15:45:20 +0100
Subject: [PATCH 28/45] ENH: Updated AMI functionality - re: projection surface

---
 src/AMIInterpolation/AMIInterpolation.C       | 165 +++++++++---------
 src/AMIInterpolation/AMIInterpolation.H       |  17 +-
 .../cyclicAMIPolyPatch/cyclicAMIPolyPatch.C   | 107 +++++++-----
 .../cyclicAMIPolyPatch/cyclicAMIPolyPatch.H   |   5 +-
 .../constant/polyMesh/boundary                |   2 -
 5 files changed, 151 insertions(+), 145 deletions(-)

diff --git a/src/AMIInterpolation/AMIInterpolation.C b/src/AMIInterpolation/AMIInterpolation.C
index c116ee2030..ca265b4e25 100644
--- a/src/AMIInterpolation/AMIInterpolation.C
+++ b/src/AMIInterpolation/AMIInterpolation.C
@@ -499,11 +499,6 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::projectPointsToSurface
     pointField& pts
 ) const
 {
-    if (!projectPoints_)
-    {
-        return;
-    }
-
     if (debug)
     {
         Info<< "AMI: projecting points to surface" << endl;
@@ -803,7 +798,6 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::calcAddressing
 (
     const primitivePatch& srcPatch,
     const primitivePatch& tgtPatch,
-    const searchableSurface& surf,
     label srcFaceI,
     label tgtFaceI
 )
@@ -824,6 +818,8 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::calcAddressing
     if (debug)
     {
         Info<< "AMI: calcAddressing" << endl;
+        writePatch(srcPatch, "VTK", "source");
+        writePatch(tgtPatch, "VTK", "target");
     }
 
     // temporary storage for addressing and weights
@@ -833,57 +829,6 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::calcAddressing
     List<DynamicList<scalar> > tgtWght(tgtPatch.size());
 
 
-    // create new patches for source and target
-    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    pointField srcPoints = srcPatch.points();
-    primitivePatch srcPatch0
-    (
-        SubList<face>
-        (
-            srcPatch,
-            srcPatch.size(),
-            0
-        ),
-        srcPoints
-    );
-
-    if (debug)
-    {
-        OFstream os("amiSrcPoints.obj");
-        forAll(srcPoints, i)
-        {
-            meshTools::writeOBJ(os, srcPoints[i]);
-        }
-    }
-
-    pointField tgtPoints = tgtPatch.points();
-    primitivePatch tgtPatch0
-    (
-        SubList<face>
-        (
-            tgtPatch,
-            tgtPatch.size(),
-            0
-        ),
-        tgtPoints
-    );
-
-    if (debug)
-    {
-        OFstream os("amiTgtPoints.obj");
-        forAll(tgtPoints, i)
-        {
-            meshTools::writeOBJ(os, tgtPoints[i]);
-        }
-    }
-
-
-    // map source and target patches onto projection surface
-    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    projectPointsToSurface(surf, srcPoints);
-    projectPointsToSurface(surf, tgtPoints);
-
-
     // find initial face match using brute force/octree search
     // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     if ((srcFaceI == -1) || (tgtFaceI == -1))
@@ -891,9 +836,9 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::calcAddressing
         srcFaceI = 0;
         tgtFaceI = 0;
         bool foundFace = false;
-        forAll(srcPatch0, faceI)
+        forAll(srcPatch, faceI)
         {
-            tgtFaceI = findTargetFace(srcFaceI, srcPatch0, tgtPatch0);
+            tgtFaceI = findTargetFace(faceI, srcPatch, tgtPatch);
             if (tgtFaceI >= 0)
             {
                 srcFaceI = faceI;
@@ -911,7 +856,6 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::calcAddressing
                 "("
                     "const primitivePatch&, "
                     "const primitivePatch&, "
-                    "const searchableSurface&, "
                     "label, "
                     "label"
                 ")"
@@ -927,7 +871,7 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::calcAddressing
 
     // construct weights and addressing
     // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    label nFacesRemaining = srcPatch0.size();
+    label nFacesRemaining = srcPatch.size();
 
     // list of tgt face neighbour faces
     DynamicList<label> nbrFaces(10);
@@ -953,7 +897,7 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::calcAddressing
 
         // append initial target face and neighbours
         nbrFaces.append(tgtFaceI);
-        appendNbrFaces(tgtFaceI, tgtPatch0, visitedFaces, nbrFaces);
+        appendNbrFaces(tgtFaceI, tgtPatch, visitedFaces, nbrFaces);
 
         bool faceProcessed = false;
 
@@ -962,7 +906,7 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::calcAddressing
             // process new target face
             tgtFaceI = nbrFaces.remove();
             visitedFaces.append(tgtFaceI);
-            scalar area = interArea(srcFaceI, tgtFaceI, srcPatch0, tgtPatch0);
+            scalar area = interArea(srcFaceI, tgtFaceI, srcPatch, tgtPatch);
 
             // store when intersection area > 0
             if (area > 0)
@@ -973,7 +917,7 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::calcAddressing
                 tgtAddr[tgtFaceI].append(srcFaceI);
                 tgtWght[tgtFaceI].append(area);
 
-                appendNbrFaces(tgtFaceI, tgtPatch0, visitedFaces, nbrFaces);
+                appendNbrFaces(tgtFaceI, tgtPatch, visitedFaces, nbrFaces);
 
                 faceProcessed = true;
             }
@@ -996,8 +940,8 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::calcAddressing
             (
                 srcFaceI,
                 tgtFaceI,
-                srcPatch0,
-                tgtPatch0,
+                srcPatch,
+                tgtPatch,
                 mapFlag,
                 seedFaces,
                 visitedFaces
@@ -1084,9 +1028,8 @@ Foam::AMIInterpolation<SourcePatch, TargetPatch>::AMIInterpolation
 (
     const SourcePatch& srcPatch,
     const TargetPatch& tgtPatch,
-    const searchableSurface& surf,
-    const faceAreaIntersect::triangulationMode& triMode,
-    const bool projectPoints
+    const autoPtr<searchableSurface>& surfPtr,
+    const faceAreaIntersect::triangulationMode& triMode
 )
 :
     srcAddress_(),
@@ -1095,24 +1038,74 @@ Foam::AMIInterpolation<SourcePatch, TargetPatch>::AMIInterpolation
     tgtWeights_(),
     startSeedI_(0),
     triMode_(triMode),
-    projectPoints_(projectPoints),
     srcMapPtr_(NULL),
     tgtMapPtr_(NULL)
 {
     label srcSize = returnReduce(srcPatch.size(), sumOp<label>());
     label tgtSize = returnReduce(tgtPatch.size(), sumOp<label>());
 
-    Info<< "AMI: Creating interpolation addressing and weights" << nl
-        << "    Source faces = " << srcSize << nl
-        << "    Target faces = " << tgtSize << endl;
+    Info<< "AMI: Creating addressing and weights between "
+        << srcSize << " source faces and " << tgtSize << " target faces"
+        << endl;
 
-    if (debug)
+    if (surfPtr.valid())
     {
-        writePatch(srcPatch, "VTK", "source");
-        writePatch(tgtPatch, "VTK", "target");
-    }
+        // create new patches for source and target
+        pointField srcPoints = srcPatch.points();
+        primitivePatch srcPatch0
+        (
+            SubList<face>
+            (
+                srcPatch,
+                srcPatch.size(),
+                0
+            ),
+            srcPoints
+        );
 
-    update(srcPatch, tgtPatch, surf);
+        if (debug)
+        {
+            OFstream os("amiSrcPoints.obj");
+            forAll(srcPoints, i)
+            {
+                meshTools::writeOBJ(os, srcPoints[i]);
+            }
+        }
+
+        pointField tgtPoints = tgtPatch.points();
+        primitivePatch tgtPatch0
+        (
+            SubList<face>
+            (
+                tgtPatch,
+                tgtPatch.size(),
+                0
+            ),
+            tgtPoints
+        );
+
+        if (debug)
+        {
+            OFstream os("amiTgtPoints.obj");
+            forAll(tgtPoints, i)
+            {
+                meshTools::writeOBJ(os, tgtPoints[i]);
+            }
+        }
+
+
+        // map source and target patches onto projection surface
+        projectPointsToSurface(surfPtr(), srcPoints);
+        projectPointsToSurface(surfPtr(), tgtPoints);
+
+
+        // calculate AMI interpolation
+        update(srcPatch0, tgtPatch0);
+    }
+    else
+    {
+        update(srcPatch, tgtPatch);
+    }
 }
 
 
@@ -1129,8 +1122,7 @@ template<class SourcePatch, class TargetPatch>
 void Foam::AMIInterpolation<SourcePatch, TargetPatch>::update
 (
     const primitivePatch& srcPatch,
-    const primitivePatch& tgtPatch,
-    const searchableSurface& surf
+    const primitivePatch& tgtPatch
 )
 {
     static label patchI = 0;
@@ -1180,7 +1172,7 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::update
 
 
         // calculate AMI interpolation
-        calcAddressing(srcPatch, newTgtPatch, surf);
+        calcAddressing(srcPatch, newTgtPatch);
 
         // Now
         // ~~~
@@ -1253,14 +1245,14 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::update
         {
             writeWeights(srcWeights_, srcPatch, "VTK", "source");
             writeWeights(tgtWeights_, tgtPatch, "VTK", "target");
-            writeFaceConnectivity(srcPatch, newTgtPatch);
+            writeFaceConnectivity(srcPatch, newTgtPatch, srcAddress_);
         }
     }
     else
     {
         checkPatches(srcPatch, tgtPatch);
 
-        calcAddressing(srcPatch, tgtPatch, surf);
+        calcAddressing(srcPatch, tgtPatch);
 
         if (debug)
         {
@@ -1435,7 +1427,8 @@ template<class SourcePatch, class TargetPatch>
 void Foam::AMIInterpolation<SourcePatch, TargetPatch>::writeFaceConnectivity
 (
     const primitivePatch& srcPatch,
-    const primitivePatch& tgtPatch
+    const primitivePatch& tgtPatch,
+    const labelListList& srcAddress
 )
 const
 {
@@ -1443,9 +1436,9 @@ const
 
     label ptI = 1;
 
-    forAll(srcAddress_, i)
+    forAll(srcAddress, i)
     {
-        const labelList& addr = srcAddress_[i];
+        const labelList& addr = srcAddress[i];
         const point& srcPt = srcPatch.faceCentres()[i];
         forAll(addr, j)
         {
diff --git a/src/AMIInterpolation/AMIInterpolation.H b/src/AMIInterpolation/AMIInterpolation.H
index 4173362f54..3e7e93831a 100644
--- a/src/AMIInterpolation/AMIInterpolation.H
+++ b/src/AMIInterpolation/AMIInterpolation.H
@@ -129,11 +129,10 @@ class AMIInterpolation
         //- Face triangulation mode
         const faceAreaIntersect::triangulationMode triMode_;
 
-        //- Flag to indicate whether or not to project points
-        const bool projectPoints_;
-
+        //- Source map pointer - parallel running only
         autoPtr<mapDistribute> srcMapPtr_;
 
+        //- Target map pointer - parallel running only
         autoPtr<mapDistribute> tgtMapPtr_;
 
 
@@ -260,7 +259,6 @@ class AMIInterpolation
             (
                 const primitivePatch& srcPatch,
                 const primitivePatch& tgtPatch,
-                const searchableSurface& surf,
                 label srcFaceI = -1,
                 label tgtFaceI = -1
             );
@@ -289,9 +287,8 @@ public:
         (
             const SourcePatch& srcPatch,
             const TargetPatch& tgtPatch,
-            const searchableSurface& surf,
-            const faceAreaIntersect::triangulationMode& triMode,
-            const bool projectPoints
+            const autoPtr<searchableSurface>& surf,
+            const faceAreaIntersect::triangulationMode& triMode
         );
 
 
@@ -327,8 +324,7 @@ public:
             void update
             (
                 const primitivePatch& srcPatch,
-                const primitivePatch& tgtPatch,
-                const searchableSurface& surf
+                const primitivePatch& tgtPatch
             );
 
 
@@ -363,7 +359,8 @@ public:
             void writeFaceConnectivity
             (
                 const primitivePatch& srcPatch,
-                const primitivePatch& tgtPatch
+                const primitivePatch& tgtPatch,
+                const labelListList& srcAddress
             ) const;
 
             //- Write weights to VTK file
diff --git a/src/AMIInterpolation/patches/cyclicAMIPolyPatch/cyclicAMIPolyPatch.C b/src/AMIInterpolation/patches/cyclicAMIPolyPatch/cyclicAMIPolyPatch.C
index 8c36c91907..c046f23ac5 100644
--- a/src/AMIInterpolation/patches/cyclicAMIPolyPatch/cyclicAMIPolyPatch.C
+++ b/src/AMIInterpolation/patches/cyclicAMIPolyPatch/cyclicAMIPolyPatch.C
@@ -221,37 +221,12 @@ void Foam::cyclicAMIPolyPatch::calcTransforms
 }
 
 
-const Foam::searchableSurface& Foam::cyclicAMIPolyPatch::surf()
+void Foam::cyclicAMIPolyPatch::resetAMI()
 {
-    word surfType(surfDict_.lookup("type"));
-    word surfName(surfDict_.lookupOrDefault("name", name()));
-
-    const polyMesh& mesh = boundaryMesh().mesh();
-
-    surfPtr_ =
-        searchableSurface::New
-        (
-            surfType,
-            IOobject
-            (
-                surfName,
-                mesh.time().constant(),
-                "triSurface",
-                mesh,
-                IOobject::MUST_READ,
-                IOobject::NO_WRITE
-            ),
-            surfDict_
-        );
-
-    return surfPtr_();
-}
-
-
-const Foam::AMIPatchToPatchInterpolation& Foam::cyclicAMIPolyPatch::AMI()
-{
-    if (!AMIPtr_.valid() && owner())
+    if (owner())
     {
+        AMIPtr_.clear();
+
         const polyPatch& nbr = nbrPatch();
         pointField nbrPoints = nbrPatch().localPoints();
 
@@ -282,8 +257,6 @@ const Foam::AMIPatchToPatchInterpolation& Foam::cyclicAMIPolyPatch::AMI()
             meshTools::writeOBJ(osO, this->localFaces(), localPoints());
         }
 
-        bool projectPoints(readBool(surfDict_.lookup("projectPoints")));
-
         // Construct/apply AMI interpolation to determine addressing and weights
         AMIPtr_.reset
         (
@@ -291,14 +264,11 @@ const Foam::AMIPatchToPatchInterpolation& Foam::cyclicAMIPolyPatch::AMI()
             (
                 *this,
                 nbrPatch0,
-                surf(),
-                faceAreaIntersect::tmMesh,
-                projectPoints
+                surfPtr(),
+                faceAreaIntersect::tmMesh
             )
         );
     }
-
-    return AMIPtr_();
 }
 
 
@@ -345,11 +315,7 @@ void Foam::cyclicAMIPolyPatch::movePoints
 
     calcTransforms();
 
-    if (owner())
-    {
-        AMIPtr_.clear();
-        AMI();
-    }
+    resetAMI();
 }
 
 
@@ -611,6 +577,59 @@ bool Foam::cyclicAMIPolyPatch::owner() const
 }
 
 
+const Foam::autoPtr<Foam::searchableSurface>&
+Foam::cyclicAMIPolyPatch::surfPtr()
+{
+    word surfType(surfDict_.lookup("type"));
+
+    if (!surfPtr_.valid() && owner() && surfType != "none")
+    {
+        word surfName(surfDict_.lookupOrDefault("name", name()));
+
+        const polyMesh& mesh = boundaryMesh().mesh();
+
+        surfPtr_ =
+            searchableSurface::New
+            (
+                surfType,
+                IOobject
+                (
+                    surfName,
+                    mesh.time().constant(),
+                    "triSurface",
+                    mesh,
+                    IOobject::MUST_READ,
+                    IOobject::NO_WRITE
+                ),
+                surfDict_
+            );
+    }
+
+    return surfPtr_;
+}
+
+
+const Foam::AMIPatchToPatchInterpolation& Foam::cyclicAMIPolyPatch::AMI()
+{
+    if (!owner())
+    {
+        FatalErrorIn
+        (
+            "const AMIPatchToPatchInterpolation& cyclicAMIPolyPatch::AMI()"
+        )
+            << "AMI interpolator only available to owner patch"
+            << abort(FatalError);
+    }
+
+    if (!AMIPtr_.valid())
+    {
+        resetAMI();
+    }
+
+    return AMIPtr_();
+}
+
+
 void Foam::cyclicAMIPolyPatch::transformPosition(pointField& l) const
 {
     if (!parallel())
@@ -704,11 +723,7 @@ void Foam::cyclicAMIPolyPatch::calcGeometry
         nbrAreas
     );
 
-    if (owner())
-    {
-        AMIPtr_.clear();
-        AMI();
-    }
+    resetAMI();
 }
 
 
diff --git a/src/AMIInterpolation/patches/cyclicAMIPolyPatch/cyclicAMIPolyPatch.H b/src/AMIInterpolation/patches/cyclicAMIPolyPatch/cyclicAMIPolyPatch.H
index 1ad095036b..352bbddb54 100644
--- a/src/AMIInterpolation/patches/cyclicAMIPolyPatch/cyclicAMIPolyPatch.H
+++ b/src/AMIInterpolation/patches/cyclicAMIPolyPatch/cyclicAMIPolyPatch.H
@@ -109,6 +109,9 @@ private:
             const vectorField& half1Areas
         );
 
+        //- Reset the AMI interpolator
+        void resetAMI();
+
 
 protected:
 
@@ -264,7 +267,7 @@ public:
             inline const cyclicAMIPolyPatch& nbrPatch() const;
 
             //- Return a reference to the projection surface
-            const searchableSurface& surf();
+            const autoPtr<searchableSurface>& surfPtr();
 
             //- Return a reference to the AMI interpolator
             const AMIPatchToPatchInterpolation& AMI();
diff --git a/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/constant/polyMesh/boundary b/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/constant/polyMesh/boundary
index a3990b4b9e..edd458d6b3 100644
--- a/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/constant/polyMesh/boundary
+++ b/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/constant/polyMesh/boundary
@@ -42,7 +42,6 @@ FoamFile
         {
             type            triSurfaceMesh;
             name            projectionSurface.stl;
-            projectPoints   yes;
         }
     }
     AMI2
@@ -58,7 +57,6 @@ FoamFile
         {
             type            triSurfaceMesh;
             name            projectionSurface.stl;
-            projectPoints   yes;
         }
     }
     front

From cd891db49044fd169230f05c2e687923df73f9bd Mon Sep 17 00:00:00 2001
From: andy <andy>
Date: Fri, 2 Sep 2011 18:01:15 +0100
Subject: [PATCH 29/45] ENH: Created AMI mapped patches and relocated cyclic
 variants

---
 src/AMIInterpolation/Make/files               |  22 +-
 .../cyclicAMIFvPatch/cyclicAMIFvPatch.C       |   0
 .../cyclicAMIFvPatch/cyclicAMIFvPatch.H       |   0
 .../cyclicAMIFvPatchField.C                   |   0
 .../cyclicAMIFvPatchField.H                   |   0
 .../cyclicAMIFvPatchFields.C                  |   0
 .../cyclicAMIFvPatchFields.H                  |   0
 .../cyclicAMIFvPatchFieldsFwd.H               |   0
 .../cyclicAMIFvsPatchField.C                  |   0
 .../cyclicAMIFvsPatchField.H                  |   0
 .../cyclicAMIFvsPatchFields.C                 |   0
 .../cyclicAMIFvsPatchFields.H                 |   0
 .../cyclicAMIFvsPatchFieldsFwd.H              |   0
 .../cyclicAMILduInterface.C                   |   0
 .../cyclicAMILduInterface.H                   |   0
 .../cyclicAMILduInterfaceField.C              |   0
 .../cyclicAMILduInterfaceField.H              |   0
 .../cyclicAMIPointPatch/cyclicAMIPointPatch.C |   0
 .../cyclicAMIPointPatch/cyclicAMIPointPatch.H |   0
 .../cyclicAMIPolyPatch/cyclicAMIPolyPatch.C   |   0
 .../cyclicAMIPolyPatch/cyclicAMIPolyPatch.H   |   0
 .../cyclicAMIPolyPatch/cyclicAMIPolyPatchI.H  |   0
 .../cyclicAMIPolyPatchTemplates.C             |   0
 .../mappedFixedInternalValueFvPatchField.C    | 167 +++
 .../mappedFixedInternalValueFvPatchField.H    | 150 +++
 .../mappedFixedInternalValueFvPatchFields.C   |  43 +
 .../mappedFixedInternalValueFvPatchFields.H   |  49 +
 ...mappedFixedInternalValueFvPatchFieldsFwd.H |  50 +
 ...ppedFixedPushedInternalValueFvPatchField.C | 125 +++
 ...ppedFixedPushedInternalValueFvPatchField.H | 157 +++
 ...pedFixedPushedInternalValueFvPatchFields.C |  43 +
 ...pedFixedPushedInternalValueFvPatchFields.H |  49 +
 ...FixedPushedInternalValueFvPatchFieldsFwd.H |  50 +
 .../mappedFixedValueFvPatchField.C            | 411 ++++++++
 .../mappedFixedValueFvPatchField.H            | 196 ++++
 .../mappedFixedValueFvPatchFields.C           |  43 +
 .../mappedFixedValueFvPatchFields.H           |  49 +
 .../mappedFixedValueFvPatchFieldsFwd.H        |  50 +
 .../mapped/mappedFvPatch/mappedFvPatch.C      |  37 +
 .../mapped/mappedFvPatch/mappedFvPatch.H      |  79 ++
 .../mapped/mappedPolyPatch/mappedPatchBase.C  | 982 ++++++++++++++++++
 .../mapped/mappedPolyPatch/mappedPatchBase.H  | 372 +++++++
 .../mapped/mappedPolyPatch/mappedPolyPatch.C  | 222 ++++
 .../mapped/mappedPolyPatch/mappedPolyPatch.H  | 233 +++++
 44 files changed, 3572 insertions(+), 7 deletions(-)
 rename src/AMIInterpolation/patches/{ => cyclic}/cyclicAMIFvPatch/cyclicAMIFvPatch.C (100%)
 rename src/AMIInterpolation/patches/{ => cyclic}/cyclicAMIFvPatch/cyclicAMIFvPatch.H (100%)
 rename src/AMIInterpolation/patches/{ => cyclic}/cyclicAMIFvPatchField/cyclicAMIFvPatchField.C (100%)
 rename src/AMIInterpolation/patches/{ => cyclic}/cyclicAMIFvPatchField/cyclicAMIFvPatchField.H (100%)
 rename src/AMIInterpolation/patches/{ => cyclic}/cyclicAMIFvPatchField/cyclicAMIFvPatchFields.C (100%)
 rename src/AMIInterpolation/patches/{ => cyclic}/cyclicAMIFvPatchField/cyclicAMIFvPatchFields.H (100%)
 rename src/AMIInterpolation/patches/{ => cyclic}/cyclicAMIFvPatchField/cyclicAMIFvPatchFieldsFwd.H (100%)
 rename src/AMIInterpolation/patches/{ => cyclic}/cyclicAMIFvsPatchField/cyclicAMIFvsPatchField.C (100%)
 rename src/AMIInterpolation/patches/{ => cyclic}/cyclicAMIFvsPatchField/cyclicAMIFvsPatchField.H (100%)
 rename src/AMIInterpolation/patches/{ => cyclic}/cyclicAMIFvsPatchField/cyclicAMIFvsPatchFields.C (100%)
 rename src/AMIInterpolation/patches/{ => cyclic}/cyclicAMIFvsPatchField/cyclicAMIFvsPatchFields.H (100%)
 rename src/AMIInterpolation/patches/{ => cyclic}/cyclicAMIFvsPatchField/cyclicAMIFvsPatchFieldsFwd.H (100%)
 rename src/AMIInterpolation/patches/{ => cyclic}/cyclicAMILduInterfaceField/cyclicAMILduInterface.C (100%)
 rename src/AMIInterpolation/patches/{ => cyclic}/cyclicAMILduInterfaceField/cyclicAMILduInterface.H (100%)
 rename src/AMIInterpolation/patches/{ => cyclic}/cyclicAMILduInterfaceField/cyclicAMILduInterfaceField.C (100%)
 rename src/AMIInterpolation/patches/{ => cyclic}/cyclicAMILduInterfaceField/cyclicAMILduInterfaceField.H (100%)
 rename src/AMIInterpolation/patches/{ => cyclic}/cyclicAMIPointPatch/cyclicAMIPointPatch.C (100%)
 rename src/AMIInterpolation/patches/{ => cyclic}/cyclicAMIPointPatch/cyclicAMIPointPatch.H (100%)
 rename src/AMIInterpolation/patches/{ => cyclic}/cyclicAMIPolyPatch/cyclicAMIPolyPatch.C (100%)
 rename src/AMIInterpolation/patches/{ => cyclic}/cyclicAMIPolyPatch/cyclicAMIPolyPatch.H (100%)
 rename src/AMIInterpolation/patches/{ => cyclic}/cyclicAMIPolyPatch/cyclicAMIPolyPatchI.H (100%)
 rename src/AMIInterpolation/patches/{ => cyclic}/cyclicAMIPolyPatch/cyclicAMIPolyPatchTemplates.C (100%)
 create mode 100644 src/AMIInterpolation/patches/mapped/mappedFixedInternalValue/mappedFixedInternalValueFvPatchField.C
 create mode 100644 src/AMIInterpolation/patches/mapped/mappedFixedInternalValue/mappedFixedInternalValueFvPatchField.H
 create mode 100644 src/AMIInterpolation/patches/mapped/mappedFixedInternalValue/mappedFixedInternalValueFvPatchFields.C
 create mode 100644 src/AMIInterpolation/patches/mapped/mappedFixedInternalValue/mappedFixedInternalValueFvPatchFields.H
 create mode 100644 src/AMIInterpolation/patches/mapped/mappedFixedInternalValue/mappedFixedInternalValueFvPatchFieldsFwd.H
 create mode 100644 src/AMIInterpolation/patches/mapped/mappedFixedPushedInternalValue/mappedFixedPushedInternalValueFvPatchField.C
 create mode 100644 src/AMIInterpolation/patches/mapped/mappedFixedPushedInternalValue/mappedFixedPushedInternalValueFvPatchField.H
 create mode 100644 src/AMIInterpolation/patches/mapped/mappedFixedPushedInternalValue/mappedFixedPushedInternalValueFvPatchFields.C
 create mode 100644 src/AMIInterpolation/patches/mapped/mappedFixedPushedInternalValue/mappedFixedPushedInternalValueFvPatchFields.H
 create mode 100644 src/AMIInterpolation/patches/mapped/mappedFixedPushedInternalValue/mappedFixedPushedInternalValueFvPatchFieldsFwd.H
 create mode 100644 src/AMIInterpolation/patches/mapped/mappedFixedValue/mappedFixedValueFvPatchField.C
 create mode 100644 src/AMIInterpolation/patches/mapped/mappedFixedValue/mappedFixedValueFvPatchField.H
 create mode 100644 src/AMIInterpolation/patches/mapped/mappedFixedValue/mappedFixedValueFvPatchFields.C
 create mode 100644 src/AMIInterpolation/patches/mapped/mappedFixedValue/mappedFixedValueFvPatchFields.H
 create mode 100644 src/AMIInterpolation/patches/mapped/mappedFixedValue/mappedFixedValueFvPatchFieldsFwd.H
 create mode 100644 src/AMIInterpolation/patches/mapped/mappedFvPatch/mappedFvPatch.C
 create mode 100644 src/AMIInterpolation/patches/mapped/mappedFvPatch/mappedFvPatch.H
 create mode 100644 src/AMIInterpolation/patches/mapped/mappedPolyPatch/mappedPatchBase.C
 create mode 100644 src/AMIInterpolation/patches/mapped/mappedPolyPatch/mappedPatchBase.H
 create mode 100644 src/AMIInterpolation/patches/mapped/mappedPolyPatch/mappedPolyPatch.C
 create mode 100644 src/AMIInterpolation/patches/mapped/mappedPolyPatch/mappedPolyPatch.H

diff --git a/src/AMIInterpolation/Make/files b/src/AMIInterpolation/Make/files
index 1c4f231be8..92c760a4b2 100644
--- a/src/AMIInterpolation/Make/files
+++ b/src/AMIInterpolation/Make/files
@@ -1,13 +1,21 @@
 AMIInterpolationName.C
 faceAreaIntersect/faceAreaIntersect.C
 
-patches/cyclicAMILduInterfaceField/cyclicAMILduInterface.C
-patches/cyclicAMILduInterfaceField/cyclicAMILduInterfaceField.C
+CYCPATCHES=patches/cyclic
+$(CYCPATCHES)/cyclicAMILduInterfaceField/cyclicAMILduInterface.C
+$(CYCPATCHES)/cyclicAMILduInterfaceField/cyclicAMILduInterfaceField.C
+$(CYCPATCHES)/cyclicAMIPolyPatch/cyclicAMIPolyPatch.C
+$(CYCPATCHES)/cyclicAMIFvPatch/cyclicAMIFvPatch.C
+$(CYCPATCHES)/cyclicAMIFvPatchField/cyclicAMIFvPatchFields.C
+$(CYCPATCHES)/cyclicAMIFvsPatchField/cyclicAMIFvsPatchFields.C
+$(CYCPATCHES)/cyclicAMIPointPatch/cyclicAMIPointPatch.C
 
-patches/cyclicAMIPolyPatch/cyclicAMIPolyPatch.C
-patches/cyclicAMIFvPatch/cyclicAMIFvPatch.C
-patches/cyclicAMIFvPatchField/cyclicAMIFvPatchFields.C
-patches/cyclicAMIFvsPatchField/cyclicAMIFvsPatchFields.C
-patches/cyclicAMIPointPatch/cyclicAMIPointPatch.C
+MAPPATCHES=patches/mapped
+$(MAPPATCHES)/mappedPolyPatch/mappedPatchBase.C
+$(MAPPATCHES)/mappedPolyPatch/mappedPolyPatch.C
+$(MAPPATCHES)/mappedFvPatch/mappedFvPatch.C
+$(MAPPATCHES)/mappedFixedValue/mappedFixedValueFvPatchFields.C
+$(MAPPATCHES)/mappedFixedInternalValue/mappedFixedInternalValueFvPatchFields.C
+$(MAPPATCHES)/mappedFixedPushedInternalValue/mappedFixedPushedInternalValueFvPatchFields.C
 
 LIB = $(FOAM_USER_LIBBIN)/libAMIInterpolation
diff --git a/src/AMIInterpolation/patches/cyclicAMIFvPatch/cyclicAMIFvPatch.C b/src/AMIInterpolation/patches/cyclic/cyclicAMIFvPatch/cyclicAMIFvPatch.C
similarity index 100%
rename from src/AMIInterpolation/patches/cyclicAMIFvPatch/cyclicAMIFvPatch.C
rename to src/AMIInterpolation/patches/cyclic/cyclicAMIFvPatch/cyclicAMIFvPatch.C
diff --git a/src/AMIInterpolation/patches/cyclicAMIFvPatch/cyclicAMIFvPatch.H b/src/AMIInterpolation/patches/cyclic/cyclicAMIFvPatch/cyclicAMIFvPatch.H
similarity index 100%
rename from src/AMIInterpolation/patches/cyclicAMIFvPatch/cyclicAMIFvPatch.H
rename to src/AMIInterpolation/patches/cyclic/cyclicAMIFvPatch/cyclicAMIFvPatch.H
diff --git a/src/AMIInterpolation/patches/cyclicAMIFvPatchField/cyclicAMIFvPatchField.C b/src/AMIInterpolation/patches/cyclic/cyclicAMIFvPatchField/cyclicAMIFvPatchField.C
similarity index 100%
rename from src/AMIInterpolation/patches/cyclicAMIFvPatchField/cyclicAMIFvPatchField.C
rename to src/AMIInterpolation/patches/cyclic/cyclicAMIFvPatchField/cyclicAMIFvPatchField.C
diff --git a/src/AMIInterpolation/patches/cyclicAMIFvPatchField/cyclicAMIFvPatchField.H b/src/AMIInterpolation/patches/cyclic/cyclicAMIFvPatchField/cyclicAMIFvPatchField.H
similarity index 100%
rename from src/AMIInterpolation/patches/cyclicAMIFvPatchField/cyclicAMIFvPatchField.H
rename to src/AMIInterpolation/patches/cyclic/cyclicAMIFvPatchField/cyclicAMIFvPatchField.H
diff --git a/src/AMIInterpolation/patches/cyclicAMIFvPatchField/cyclicAMIFvPatchFields.C b/src/AMIInterpolation/patches/cyclic/cyclicAMIFvPatchField/cyclicAMIFvPatchFields.C
similarity index 100%
rename from src/AMIInterpolation/patches/cyclicAMIFvPatchField/cyclicAMIFvPatchFields.C
rename to src/AMIInterpolation/patches/cyclic/cyclicAMIFvPatchField/cyclicAMIFvPatchFields.C
diff --git a/src/AMIInterpolation/patches/cyclicAMIFvPatchField/cyclicAMIFvPatchFields.H b/src/AMIInterpolation/patches/cyclic/cyclicAMIFvPatchField/cyclicAMIFvPatchFields.H
similarity index 100%
rename from src/AMIInterpolation/patches/cyclicAMIFvPatchField/cyclicAMIFvPatchFields.H
rename to src/AMIInterpolation/patches/cyclic/cyclicAMIFvPatchField/cyclicAMIFvPatchFields.H
diff --git a/src/AMIInterpolation/patches/cyclicAMIFvPatchField/cyclicAMIFvPatchFieldsFwd.H b/src/AMIInterpolation/patches/cyclic/cyclicAMIFvPatchField/cyclicAMIFvPatchFieldsFwd.H
similarity index 100%
rename from src/AMIInterpolation/patches/cyclicAMIFvPatchField/cyclicAMIFvPatchFieldsFwd.H
rename to src/AMIInterpolation/patches/cyclic/cyclicAMIFvPatchField/cyclicAMIFvPatchFieldsFwd.H
diff --git a/src/AMIInterpolation/patches/cyclicAMIFvsPatchField/cyclicAMIFvsPatchField.C b/src/AMIInterpolation/patches/cyclic/cyclicAMIFvsPatchField/cyclicAMIFvsPatchField.C
similarity index 100%
rename from src/AMIInterpolation/patches/cyclicAMIFvsPatchField/cyclicAMIFvsPatchField.C
rename to src/AMIInterpolation/patches/cyclic/cyclicAMIFvsPatchField/cyclicAMIFvsPatchField.C
diff --git a/src/AMIInterpolation/patches/cyclicAMIFvsPatchField/cyclicAMIFvsPatchField.H b/src/AMIInterpolation/patches/cyclic/cyclicAMIFvsPatchField/cyclicAMIFvsPatchField.H
similarity index 100%
rename from src/AMIInterpolation/patches/cyclicAMIFvsPatchField/cyclicAMIFvsPatchField.H
rename to src/AMIInterpolation/patches/cyclic/cyclicAMIFvsPatchField/cyclicAMIFvsPatchField.H
diff --git a/src/AMIInterpolation/patches/cyclicAMIFvsPatchField/cyclicAMIFvsPatchFields.C b/src/AMIInterpolation/patches/cyclic/cyclicAMIFvsPatchField/cyclicAMIFvsPatchFields.C
similarity index 100%
rename from src/AMIInterpolation/patches/cyclicAMIFvsPatchField/cyclicAMIFvsPatchFields.C
rename to src/AMIInterpolation/patches/cyclic/cyclicAMIFvsPatchField/cyclicAMIFvsPatchFields.C
diff --git a/src/AMIInterpolation/patches/cyclicAMIFvsPatchField/cyclicAMIFvsPatchFields.H b/src/AMIInterpolation/patches/cyclic/cyclicAMIFvsPatchField/cyclicAMIFvsPatchFields.H
similarity index 100%
rename from src/AMIInterpolation/patches/cyclicAMIFvsPatchField/cyclicAMIFvsPatchFields.H
rename to src/AMIInterpolation/patches/cyclic/cyclicAMIFvsPatchField/cyclicAMIFvsPatchFields.H
diff --git a/src/AMIInterpolation/patches/cyclicAMIFvsPatchField/cyclicAMIFvsPatchFieldsFwd.H b/src/AMIInterpolation/patches/cyclic/cyclicAMIFvsPatchField/cyclicAMIFvsPatchFieldsFwd.H
similarity index 100%
rename from src/AMIInterpolation/patches/cyclicAMIFvsPatchField/cyclicAMIFvsPatchFieldsFwd.H
rename to src/AMIInterpolation/patches/cyclic/cyclicAMIFvsPatchField/cyclicAMIFvsPatchFieldsFwd.H
diff --git a/src/AMIInterpolation/patches/cyclicAMILduInterfaceField/cyclicAMILduInterface.C b/src/AMIInterpolation/patches/cyclic/cyclicAMILduInterfaceField/cyclicAMILduInterface.C
similarity index 100%
rename from src/AMIInterpolation/patches/cyclicAMILduInterfaceField/cyclicAMILduInterface.C
rename to src/AMIInterpolation/patches/cyclic/cyclicAMILduInterfaceField/cyclicAMILduInterface.C
diff --git a/src/AMIInterpolation/patches/cyclicAMILduInterfaceField/cyclicAMILduInterface.H b/src/AMIInterpolation/patches/cyclic/cyclicAMILduInterfaceField/cyclicAMILduInterface.H
similarity index 100%
rename from src/AMIInterpolation/patches/cyclicAMILduInterfaceField/cyclicAMILduInterface.H
rename to src/AMIInterpolation/patches/cyclic/cyclicAMILduInterfaceField/cyclicAMILduInterface.H
diff --git a/src/AMIInterpolation/patches/cyclicAMILduInterfaceField/cyclicAMILduInterfaceField.C b/src/AMIInterpolation/patches/cyclic/cyclicAMILduInterfaceField/cyclicAMILduInterfaceField.C
similarity index 100%
rename from src/AMIInterpolation/patches/cyclicAMILduInterfaceField/cyclicAMILduInterfaceField.C
rename to src/AMIInterpolation/patches/cyclic/cyclicAMILduInterfaceField/cyclicAMILduInterfaceField.C
diff --git a/src/AMIInterpolation/patches/cyclicAMILduInterfaceField/cyclicAMILduInterfaceField.H b/src/AMIInterpolation/patches/cyclic/cyclicAMILduInterfaceField/cyclicAMILduInterfaceField.H
similarity index 100%
rename from src/AMIInterpolation/patches/cyclicAMILduInterfaceField/cyclicAMILduInterfaceField.H
rename to src/AMIInterpolation/patches/cyclic/cyclicAMILduInterfaceField/cyclicAMILduInterfaceField.H
diff --git a/src/AMIInterpolation/patches/cyclicAMIPointPatch/cyclicAMIPointPatch.C b/src/AMIInterpolation/patches/cyclic/cyclicAMIPointPatch/cyclicAMIPointPatch.C
similarity index 100%
rename from src/AMIInterpolation/patches/cyclicAMIPointPatch/cyclicAMIPointPatch.C
rename to src/AMIInterpolation/patches/cyclic/cyclicAMIPointPatch/cyclicAMIPointPatch.C
diff --git a/src/AMIInterpolation/patches/cyclicAMIPointPatch/cyclicAMIPointPatch.H b/src/AMIInterpolation/patches/cyclic/cyclicAMIPointPatch/cyclicAMIPointPatch.H
similarity index 100%
rename from src/AMIInterpolation/patches/cyclicAMIPointPatch/cyclicAMIPointPatch.H
rename to src/AMIInterpolation/patches/cyclic/cyclicAMIPointPatch/cyclicAMIPointPatch.H
diff --git a/src/AMIInterpolation/patches/cyclicAMIPolyPatch/cyclicAMIPolyPatch.C b/src/AMIInterpolation/patches/cyclic/cyclicAMIPolyPatch/cyclicAMIPolyPatch.C
similarity index 100%
rename from src/AMIInterpolation/patches/cyclicAMIPolyPatch/cyclicAMIPolyPatch.C
rename to src/AMIInterpolation/patches/cyclic/cyclicAMIPolyPatch/cyclicAMIPolyPatch.C
diff --git a/src/AMIInterpolation/patches/cyclicAMIPolyPatch/cyclicAMIPolyPatch.H b/src/AMIInterpolation/patches/cyclic/cyclicAMIPolyPatch/cyclicAMIPolyPatch.H
similarity index 100%
rename from src/AMIInterpolation/patches/cyclicAMIPolyPatch/cyclicAMIPolyPatch.H
rename to src/AMIInterpolation/patches/cyclic/cyclicAMIPolyPatch/cyclicAMIPolyPatch.H
diff --git a/src/AMIInterpolation/patches/cyclicAMIPolyPatch/cyclicAMIPolyPatchI.H b/src/AMIInterpolation/patches/cyclic/cyclicAMIPolyPatch/cyclicAMIPolyPatchI.H
similarity index 100%
rename from src/AMIInterpolation/patches/cyclicAMIPolyPatch/cyclicAMIPolyPatchI.H
rename to src/AMIInterpolation/patches/cyclic/cyclicAMIPolyPatch/cyclicAMIPolyPatchI.H
diff --git a/src/AMIInterpolation/patches/cyclicAMIPolyPatch/cyclicAMIPolyPatchTemplates.C b/src/AMIInterpolation/patches/cyclic/cyclicAMIPolyPatch/cyclicAMIPolyPatchTemplates.C
similarity index 100%
rename from src/AMIInterpolation/patches/cyclicAMIPolyPatch/cyclicAMIPolyPatchTemplates.C
rename to src/AMIInterpolation/patches/cyclic/cyclicAMIPolyPatch/cyclicAMIPolyPatchTemplates.C
diff --git a/src/AMIInterpolation/patches/mapped/mappedFixedInternalValue/mappedFixedInternalValueFvPatchField.C b/src/AMIInterpolation/patches/mapped/mappedFixedInternalValue/mappedFixedInternalValueFvPatchField.C
new file mode 100644
index 0000000000..6acae6a705
--- /dev/null
+++ b/src/AMIInterpolation/patches/mapped/mappedFixedInternalValue/mappedFixedInternalValueFvPatchField.C
@@ -0,0 +1,167 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "mappedFixedInternalValueFvPatchField.H"
+#include "UIndirectList.H"
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+template<class Type>
+Foam::mappedFixedInternalValueFvPatchField<Type>::
+mappedFixedInternalValueFvPatchField
+(
+    const fvPatch& p,
+    const DimensionedField<Type, volMesh>& iF
+)
+:
+    mappedFixedValueFvPatchField<Type>(p, iF)
+{}
+
+
+template<class Type>
+Foam::mappedFixedInternalValueFvPatchField<Type>::
+mappedFixedInternalValueFvPatchField
+(
+    const mappedFixedInternalValueFvPatchField<Type>& ptf,
+    const fvPatch& p,
+    const DimensionedField<Type, volMesh>& iF,
+    const fvPatchFieldMapper& mapper
+)
+:
+    mappedFixedValueFvPatchField<Type>(ptf, p, iF, mapper)
+{}
+
+
+template<class Type>
+Foam::mappedFixedInternalValueFvPatchField<Type>::
+mappedFixedInternalValueFvPatchField
+(
+    const fvPatch& p,
+    const DimensionedField<Type, volMesh>& iF,
+    const dictionary& dict
+)
+:
+    mappedFixedValueFvPatchField<Type>(p, iF, dict)
+{}
+
+
+template<class Type>
+Foam::mappedFixedInternalValueFvPatchField<Type>::
+mappedFixedInternalValueFvPatchField
+(
+    const mappedFixedInternalValueFvPatchField<Type>& ptf
+)
+:
+    mappedFixedValueFvPatchField<Type>(ptf)
+{}
+
+
+template<class Type>
+Foam::mappedFixedInternalValueFvPatchField<Type>::
+mappedFixedInternalValueFvPatchField
+(
+    const mappedFixedInternalValueFvPatchField<Type>& ptf,
+    const DimensionedField<Type, volMesh>& iF
+)
+:
+    mappedFixedValueFvPatchField<Type>(ptf, iF)
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+template<class Type>
+void Foam::mappedFixedInternalValueFvPatchField<Type>::updateCoeffs()
+{
+    typedef GeometricField<Type, fvPatchField, volMesh> FieldType;
+
+    if (this->updated())
+    {
+        return;
+    }
+
+    // Retrieve the neighbour values and assign to this patch boundary field
+    mappedFixedValueFvPatchField<Type>::updateCoeffs();
+
+    // Get the coupling information from the mappedPatchBase
+    const mappedPatchBase& mpp =
+        refCast<const mappedPatchBase>(this->patch().patch());
+    const fvMesh& nbrMesh = refCast<const fvMesh>(mpp.sampleMesh());
+    const label samplePatchI = mpp.samplePolyPatch().index();
+    const fvPatch& nbrPatch = nbrMesh.boundary()[samplePatchI];
+
+
+    // Retrieve the neighbour field
+    const fvPatchField<Type>& nbrField =
+        nbrPatch.template lookupPatchField<FieldType, Type>
+        (
+            this->dimensionedInternalField().name()
+        );
+
+    // Retrieve the neighbour patch internal field
+    Field<Type> nbrIntFld(nbrField.patchInternalField());
+
+    switch (mpp.mode())
+    {
+        case (mappedPatchBase::NEARESTPATCHFACEAMI):
+        {
+            // Retrieve the neighbour patch internal field
+            nbrIntFld = mpp.AMI().interpolateToSource(nbrIntFld);
+            break;
+        }
+        default:
+        {
+            const mapDistribute& distMap = mpp.map();
+
+            mapDistribute::distribute
+            (
+                Pstream::defaultCommsType,
+                distMap.schedule(),
+                distMap.constructSize(),
+                distMap.subMap(),           // what to send
+                distMap.constructMap(),     // what to receive
+                nbrIntFld
+            );
+            break;
+        }
+    }
+
+    // Assign (this) patch internal field to its neighbour values
+    Field<Type>& intFld = const_cast<Field<Type>&>(this->internalField());
+    UIndirectList<Type>(intFld, this->patch().faceCells()) = nbrIntFld;
+}
+
+
+template<class Type>
+void Foam::mappedFixedInternalValueFvPatchField<Type>::write
+(
+    Ostream& os
+) const
+{
+    mappedFixedValueFvPatchField<Type>::write(os);
+}
+
+
+// ************************************************************************* //
diff --git a/src/AMIInterpolation/patches/mapped/mappedFixedInternalValue/mappedFixedInternalValueFvPatchField.H b/src/AMIInterpolation/patches/mapped/mappedFixedInternalValue/mappedFixedInternalValueFvPatchField.H
new file mode 100644
index 0000000000..56ab904529
--- /dev/null
+++ b/src/AMIInterpolation/patches/mapped/mappedFixedInternalValue/mappedFixedInternalValueFvPatchField.H
@@ -0,0 +1,150 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::mappedFixedInternalValueFvPatchField
+
+Description
+    Recycles the boundary and internal values of a neighbour patch field to
+    the boundary and internal values of *this.
+
+SourceFiles
+    mappedFixedInternalValueFvPatchField.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef mappedFixedInternalValueFvPatchField_H
+#define mappedFixedInternalValueFvPatchField_H
+
+#include "mappedFixedValueFvPatchField.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+         Class mappedFixedInternalValueFvPatchField Declaration
+\*---------------------------------------------------------------------------*/
+
+template<class Type>
+class mappedFixedInternalValueFvPatchField
+:
+    public mappedFixedValueFvPatchField<Type>
+{
+
+public:
+
+    //- Runtime type information
+    TypeName("mappedFixedInternalValue");
+
+
+    // Constructors
+
+        //- Construct from patch and internal field
+        mappedFixedInternalValueFvPatchField
+        (
+            const fvPatch&,
+            const DimensionedField<Type, volMesh>&
+        );
+
+        //- Construct from patch, internal field and dictionary
+        mappedFixedInternalValueFvPatchField
+        (
+            const fvPatch&,
+            const DimensionedField<Type, volMesh>&,
+            const dictionary&
+        );
+
+        //- Construct by mapping given
+        // mappedFixedInternalValueFvPatchField  onto a new patch
+        mappedFixedInternalValueFvPatchField
+        (
+            const mappedFixedInternalValueFvPatchField<Type>&,
+            const fvPatch&,
+            const DimensionedField<Type, volMesh>&,
+            const fvPatchFieldMapper&
+        );
+
+        //- Construct as copy
+        mappedFixedInternalValueFvPatchField
+        (
+            const mappedFixedInternalValueFvPatchField<Type>&
+        );
+
+        //- Construct and return a clone
+        virtual tmp<fvPatchField<Type> > clone() const
+        {
+            return tmp<fvPatchField<Type> >
+            (
+                new mappedFixedInternalValueFvPatchField<Type>(*this)
+            );
+        }
+
+        //- Construct as copy setting internal field reference
+        mappedFixedInternalValueFvPatchField
+        (
+            const mappedFixedInternalValueFvPatchField<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 mappedFixedInternalValueFvPatchField<Type>(*this, iF)
+            );
+        }
+
+
+    // Member functions
+
+        // Evaluation functions
+
+            //- Update the coefficients associated with the patch field
+            virtual void updateCoeffs();
+
+        //- Write
+        virtual void write(Ostream&) const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+#   include "mappedFixedInternalValueFvPatchField.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/AMIInterpolation/patches/mapped/mappedFixedInternalValue/mappedFixedInternalValueFvPatchFields.C b/src/AMIInterpolation/patches/mapped/mappedFixedInternalValue/mappedFixedInternalValueFvPatchFields.C
new file mode 100644
index 0000000000..33038a58d2
--- /dev/null
+++ b/src/AMIInterpolation/patches/mapped/mappedFixedInternalValue/mappedFixedInternalValueFvPatchFields.C
@@ -0,0 +1,43 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "mappedFixedInternalValueFvPatchFields.H"
+#include "volMesh.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+makePatchFields(mappedFixedInternalValue);
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// ************************************************************************* //
diff --git a/src/AMIInterpolation/patches/mapped/mappedFixedInternalValue/mappedFixedInternalValueFvPatchFields.H b/src/AMIInterpolation/patches/mapped/mappedFixedInternalValue/mappedFixedInternalValueFvPatchFields.H
new file mode 100644
index 0000000000..0fb922801c
--- /dev/null
+++ b/src/AMIInterpolation/patches/mapped/mappedFixedInternalValue/mappedFixedInternalValueFvPatchFields.H
@@ -0,0 +1,49 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef mappedFixedInternalValueFvPatchFields_H
+#define mappedFixedInternalValueFvPatchFields_H
+
+#include "mappedFixedInternalValueFvPatchField.H"
+#include "fieldTypes.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+makePatchTypeFieldTypedefs(mappedFixedInternalValue)
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/AMIInterpolation/patches/mapped/mappedFixedInternalValue/mappedFixedInternalValueFvPatchFieldsFwd.H b/src/AMIInterpolation/patches/mapped/mappedFixedInternalValue/mappedFixedInternalValueFvPatchFieldsFwd.H
new file mode 100644
index 0000000000..fbb85edd04
--- /dev/null
+++ b/src/AMIInterpolation/patches/mapped/mappedFixedInternalValue/mappedFixedInternalValueFvPatchFieldsFwd.H
@@ -0,0 +1,50 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef mappedFixedInternalValueFvPatchFieldsFwd_H
+#define mappedFixedInternalValueFvPatchFieldsFwd_H
+
+#include "fieldTypes.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+template<class Type> class mappedFixedInternalValueFvPatchField;
+
+makePatchTypeFieldTypedefs(mappedFixedInternalValue)
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/AMIInterpolation/patches/mapped/mappedFixedPushedInternalValue/mappedFixedPushedInternalValueFvPatchField.C b/src/AMIInterpolation/patches/mapped/mappedFixedPushedInternalValue/mappedFixedPushedInternalValueFvPatchField.C
new file mode 100644
index 0000000000..599ecc6cfc
--- /dev/null
+++ b/src/AMIInterpolation/patches/mapped/mappedFixedPushedInternalValue/mappedFixedPushedInternalValueFvPatchField.C
@@ -0,0 +1,125 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "mappedFixedPushedInternalValueFvPatchField.H"
+#include "UIndirectList.H"
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+template<class Type>
+Foam::mappedFixedPushedInternalValueFvPatchField<Type>::
+mappedFixedPushedInternalValueFvPatchField
+(
+    const fvPatch& p,
+    const DimensionedField<Type, volMesh>& iF
+)
+:
+    mappedFixedValueFvPatchField<Type>(p, iF)
+{}
+
+
+template<class Type>
+Foam::mappedFixedPushedInternalValueFvPatchField<Type>::
+mappedFixedPushedInternalValueFvPatchField
+(
+    const mappedFixedPushedInternalValueFvPatchField<Type>& ptf,
+    const fvPatch& p,
+    const DimensionedField<Type, volMesh>& iF,
+    const fvPatchFieldMapper& mapper
+)
+:
+    mappedFixedValueFvPatchField<Type>(ptf, p, iF, mapper)
+{}
+
+
+template<class Type>
+Foam::mappedFixedPushedInternalValueFvPatchField<Type>::
+mappedFixedPushedInternalValueFvPatchField
+(
+    const fvPatch& p,
+    const DimensionedField<Type, volMesh>& iF,
+    const dictionary& dict
+)
+:
+    mappedFixedValueFvPatchField<Type>(p, iF, dict)
+{}
+
+
+template<class Type>
+Foam::mappedFixedPushedInternalValueFvPatchField<Type>::
+mappedFixedPushedInternalValueFvPatchField
+(
+    const mappedFixedPushedInternalValueFvPatchField<Type>& ptf
+)
+:
+    mappedFixedValueFvPatchField<Type>(ptf)
+{}
+
+
+template<class Type>
+Foam::mappedFixedPushedInternalValueFvPatchField<Type>::
+mappedFixedPushedInternalValueFvPatchField
+(
+    const mappedFixedPushedInternalValueFvPatchField<Type>& ptf,
+    const DimensionedField<Type, volMesh>& iF
+)
+:
+    mappedFixedValueFvPatchField<Type>(ptf, iF)
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+template<class Type>
+void
+Foam::mappedFixedPushedInternalValueFvPatchField<Type>::updateCoeffs()
+{
+    typedef GeometricField<Type, fvPatchField, volMesh> FieldType;
+
+    if (this->updated())
+    {
+        return;
+    }
+
+    // Retrieve the neighbour values and assign to this patch boundary field
+    mappedFixedValueFvPatchField<Type>::updateCoeffs();
+
+    // Assign the patch internal field to its boundary value
+    Field<Type>& intFld = const_cast<Field<Type>&>(this->internalField());
+    UIndirectList<Type>(intFld, this->patch().faceCells()) = *this;
+}
+
+
+template<class Type>
+void Foam::mappedFixedPushedInternalValueFvPatchField<Type>::write
+(
+    Ostream& os
+) const
+{
+    mappedFixedValueFvPatchField<Type>::write(os);
+}
+
+
+// ************************************************************************* //
diff --git a/src/AMIInterpolation/patches/mapped/mappedFixedPushedInternalValue/mappedFixedPushedInternalValueFvPatchField.H b/src/AMIInterpolation/patches/mapped/mappedFixedPushedInternalValue/mappedFixedPushedInternalValueFvPatchField.H
new file mode 100644
index 0000000000..a3dc0b67ac
--- /dev/null
+++ b/src/AMIInterpolation/patches/mapped/mappedFixedPushedInternalValue/mappedFixedPushedInternalValueFvPatchField.H
@@ -0,0 +1,157 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::mappedFixedPushedInternalValueFvPatchField
+
+Description
+    Recycles the boundary values of a neighbour patch field to the boundary
+    and internal values of *this.
+
+SourceFiles
+    mappedFixedPushedInternalValueFvPatchField.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef mappedFixedPushedInternalValueFvPatchField_H
+#define mappedFixedPushedInternalValueFvPatchField_H
+
+#include "mappedFixedValueFvPatchField.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+      Class mappedFixedPushedInternalValueFvPatchField Declaration
+\*---------------------------------------------------------------------------*/
+
+template<class Type>
+class mappedFixedPushedInternalValueFvPatchField
+:
+    public mappedFixedValueFvPatchField<Type>
+{
+
+public:
+
+    //- Runtime type information
+    TypeName("mappedFixedPushedInternalValue");
+
+
+    // Constructors
+
+        //- Construct from patch and internal field
+        mappedFixedPushedInternalValueFvPatchField
+        (
+            const fvPatch&,
+            const DimensionedField<Type, volMesh>&
+        );
+
+        //- Construct from patch, internal field and dictionary
+        mappedFixedPushedInternalValueFvPatchField
+        (
+            const fvPatch&,
+            const DimensionedField<Type, volMesh>&,
+            const dictionary&
+        );
+
+        //- Construct by mapping given a
+        //  mappedFixedPushedInternalValueFvPatchField  onto a new patch
+        mappedFixedPushedInternalValueFvPatchField
+        (
+            const mappedFixedPushedInternalValueFvPatchField<Type>&,
+            const fvPatch&,
+            const DimensionedField<Type, volMesh>&,
+            const fvPatchFieldMapper&
+        );
+
+        //- Construct as copy
+        mappedFixedPushedInternalValueFvPatchField
+        (
+            const mappedFixedPushedInternalValueFvPatchField<Type>&
+        );
+
+        //- Construct and return a clone
+        virtual tmp<fvPatchField<Type> > clone() const
+        {
+            return tmp<fvPatchField<Type> >
+            (
+                new mappedFixedPushedInternalValueFvPatchField<Type>
+                (
+                    *this
+                )
+            );
+        }
+
+        //- Construct as copy setting internal field reference
+        mappedFixedPushedInternalValueFvPatchField
+        (
+            const mappedFixedPushedInternalValueFvPatchField<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 mappedFixedPushedInternalValueFvPatchField<Type>
+                (
+                    *this,
+                    iF
+                )
+            );
+        }
+
+
+    // Member functions
+
+        // Evaluation functions
+
+            //- Update the coefficients associated with the patch field
+            virtual void updateCoeffs();
+
+        //- Write
+        virtual void write(Ostream&) const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+#   include "mappedFixedPushedInternalValueFvPatchField.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/AMIInterpolation/patches/mapped/mappedFixedPushedInternalValue/mappedFixedPushedInternalValueFvPatchFields.C b/src/AMIInterpolation/patches/mapped/mappedFixedPushedInternalValue/mappedFixedPushedInternalValueFvPatchFields.C
new file mode 100644
index 0000000000..87f88dc5cd
--- /dev/null
+++ b/src/AMIInterpolation/patches/mapped/mappedFixedPushedInternalValue/mappedFixedPushedInternalValueFvPatchFields.C
@@ -0,0 +1,43 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "mappedFixedPushedInternalValueFvPatchFields.H"
+#include "volMesh.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+makePatchFields(mappedFixedPushedInternalValue);
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// ************************************************************************* //
diff --git a/src/AMIInterpolation/patches/mapped/mappedFixedPushedInternalValue/mappedFixedPushedInternalValueFvPatchFields.H b/src/AMIInterpolation/patches/mapped/mappedFixedPushedInternalValue/mappedFixedPushedInternalValueFvPatchFields.H
new file mode 100644
index 0000000000..60cf231fe0
--- /dev/null
+++ b/src/AMIInterpolation/patches/mapped/mappedFixedPushedInternalValue/mappedFixedPushedInternalValueFvPatchFields.H
@@ -0,0 +1,49 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef mappedFixedPushedInternalValueFvPatchFields_H
+#define mappedFixedPushedInternalValueFvPatchFields_H
+
+#include "mappedFixedPushedInternalValueFvPatchField.H"
+#include "fieldTypes.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+makePatchTypeFieldTypedefs(mappedFixedPushedInternalValue)
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/AMIInterpolation/patches/mapped/mappedFixedPushedInternalValue/mappedFixedPushedInternalValueFvPatchFieldsFwd.H b/src/AMIInterpolation/patches/mapped/mappedFixedPushedInternalValue/mappedFixedPushedInternalValueFvPatchFieldsFwd.H
new file mode 100644
index 0000000000..f1100a7a6c
--- /dev/null
+++ b/src/AMIInterpolation/patches/mapped/mappedFixedPushedInternalValue/mappedFixedPushedInternalValueFvPatchFieldsFwd.H
@@ -0,0 +1,50 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef mappedFixedPushedInternalValueFvPatchFieldsFwd_H
+#define mappedFixedPushedInternalValueFvPatchFieldsFwd_H
+
+#include "fieldTypes.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+template<class Type> class mappedFixedPushedInternalValueFvPatchField;
+
+makePatchTypeFieldTypedefs(mappedFixedInternalValue)
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/AMIInterpolation/patches/mapped/mappedFixedValue/mappedFixedValueFvPatchField.C b/src/AMIInterpolation/patches/mapped/mappedFixedValue/mappedFixedValueFvPatchField.C
new file mode 100644
index 0000000000..55734e58b0
--- /dev/null
+++ b/src/AMIInterpolation/patches/mapped/mappedFixedValue/mappedFixedValueFvPatchField.C
@@ -0,0 +1,411 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "mappedFixedValueFvPatchField.H"
+#include "mappedPatchBase.H"
+#include "volFields.H"
+#include "interpolationCell.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+template<class Type>
+mappedFixedValueFvPatchField<Type>::mappedFixedValueFvPatchField
+(
+    const fvPatch& p,
+    const DimensionedField<Type, volMesh>& iF
+)
+:
+    fixedValueFvPatchField<Type>(p, iF),
+    fieldName_(iF.name()),
+    setAverage_(false),
+    average_(pTraits<Type>::zero),
+    interpolationScheme_(interpolationCell<Type>::typeName)
+{}
+
+
+template<class Type>
+mappedFixedValueFvPatchField<Type>::mappedFixedValueFvPatchField
+(
+    const mappedFixedValueFvPatchField<Type>& ptf,
+    const fvPatch& p,
+    const DimensionedField<Type, volMesh>& iF,
+    const fvPatchFieldMapper& mapper
+)
+:
+    fixedValueFvPatchField<Type>(ptf, p, iF, mapper),
+    fieldName_(ptf.fieldName_),
+    setAverage_(ptf.setAverage_),
+    average_(ptf.average_),
+    interpolationScheme_(ptf.interpolationScheme_)
+{
+    if (!isA<mappedPatchBase>(this->patch().patch()))
+    {
+        FatalErrorIn
+        (
+            "mappedFixedValueFvPatchField<Type>::"
+            "mappedFixedValueFvPatchField\n"
+            "(\n"
+            "    const mappedFixedValueFvPatchField<Type>&,\n"
+            "    const fvPatch&,\n"
+            "    const Field<Type>&,\n"
+            "    const fvPatchFieldMapper&\n"
+            ")\n"
+        )   << "\n    patch type '" << p.type()
+            << "' not type '" << mappedPatchBase::typeName << "'"
+            << "\n    for patch " << p.name()
+            << " of field " << this->dimensionedInternalField().name()
+            << " in file " << this->dimensionedInternalField().objectPath()
+            << exit(FatalError);
+    }
+}
+
+
+template<class Type>
+mappedFixedValueFvPatchField<Type>::mappedFixedValueFvPatchField
+(
+    const fvPatch& p,
+    const DimensionedField<Type, volMesh>& iF,
+    const dictionary& dict
+)
+:
+    fixedValueFvPatchField<Type>(p, iF, dict),
+    fieldName_(dict.lookupOrDefault<word>("fieldName", iF.name())),
+    setAverage_(readBool(dict.lookup("setAverage"))),
+    average_(pTraits<Type>(dict.lookup("average"))),
+    interpolationScheme_(interpolationCell<Type>::typeName)
+{
+    if (!isA<mappedPatchBase>(this->patch().patch()))
+    {
+        FatalErrorIn
+        (
+            "mappedFixedValueFvPatchField<Type>::"
+            "mappedFixedValueFvPatchField\n"
+            "(\n"
+            "    const fvPatch& p,\n"
+            "    const DimensionedField<Type, volMesh>& iF,\n"
+            "    const dictionary& dict\n"
+            ")\n"
+        )   << "\n    patch type '" << p.type()
+            << "' not type '" << mappedPatchBase::typeName << "'"
+            << "\n    for patch " << p.name()
+            << " of field " << this->dimensionedInternalField().name()
+            << " in file " << this->dimensionedInternalField().objectPath()
+            << exit(FatalError);
+    }
+
+    const mappedPatchBase& mpp = refCast<const mappedPatchBase>
+    (
+        mappedFixedValueFvPatchField<Type>::patch().patch()
+    );
+    if (mpp.mode() == mappedPatchBase::NEARESTCELL)
+    {
+        dict.lookup("interpolationScheme") >> interpolationScheme_;
+    }
+}
+
+
+template<class Type>
+mappedFixedValueFvPatchField<Type>::mappedFixedValueFvPatchField
+(
+    const mappedFixedValueFvPatchField<Type>& ptf
+)
+:
+    fixedValueFvPatchField<Type>(ptf),
+    fieldName_(ptf.fieldName_),
+    setAverage_(ptf.setAverage_),
+    average_(ptf.average_),
+    interpolationScheme_(ptf.interpolationScheme_)
+{}
+
+
+template<class Type>
+mappedFixedValueFvPatchField<Type>::mappedFixedValueFvPatchField
+(
+    const mappedFixedValueFvPatchField<Type>& ptf,
+    const DimensionedField<Type, volMesh>& iF
+)
+:
+    fixedValueFvPatchField<Type>(ptf, iF),
+    fieldName_(ptf.fieldName_),
+    setAverage_(ptf.setAverage_),
+    average_(ptf.average_),
+    interpolationScheme_(ptf.interpolationScheme_)
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+template<class Type>
+const GeometricField<Type, fvPatchField, volMesh>&
+mappedFixedValueFvPatchField<Type>::sampleField() const
+{
+    typedef GeometricField<Type, fvPatchField, volMesh> fieldType;
+
+    const mappedPatchBase& mpp = refCast<const mappedPatchBase>
+    (
+        mappedFixedValueFvPatchField<Type>::patch().patch()
+    );
+    const fvMesh& nbrMesh = refCast<const fvMesh>(mpp.sampleMesh());
+
+    if (mpp.sameRegion())
+    {
+        if (fieldName_ == this->dimensionedInternalField().name())
+        {
+            // Optimisation: bypass field lookup
+            return
+                dynamic_cast<const fieldType&>
+                (
+                    this->dimensionedInternalField()
+                );
+        }
+        else
+        {
+            const fvMesh& thisMesh = this->patch().boundaryMesh().mesh();
+            return thisMesh.lookupObject<fieldType>(fieldName_);
+        }
+    }
+    else
+    {
+        return nbrMesh.lookupObject<fieldType>(fieldName_);
+    }
+}
+
+
+template<class Type>
+const interpolation<Type>&
+mappedFixedValueFvPatchField<Type>::interpolator() const
+{
+    if (!interpolator_.valid())
+    {
+        interpolator_ = interpolation<Type>::New
+        (
+            interpolationScheme_,
+            sampleField()
+        );
+    }
+    return interpolator_();
+}
+
+
+template<class Type>
+void mappedFixedValueFvPatchField<Type>::updateCoeffs()
+{
+    if (this->updated())
+    {
+        return;
+    }
+
+    typedef GeometricField<Type, fvPatchField, volMesh> fieldType;
+
+    // Get the scheduling information from the mappedPatchBase
+    const mappedPatchBase& mpp = refCast<const mappedPatchBase>
+    (
+        mappedFixedValueFvPatchField<Type>::patch().patch()
+    );
+
+    const fvMesh& thisMesh = this->patch().boundaryMesh().mesh();
+    const fvMesh& nbrMesh = refCast<const fvMesh>(mpp.sampleMesh());
+
+    // Result of obtaining remote values
+    Field<Type> newValues;
+
+    switch (mpp.mode())
+    {
+        case mappedPatchBase::NEARESTCELL:
+        {
+            const mapDistribute& distMap = mpp.map();
+
+            if (interpolationScheme_ != interpolationCell<Type>::typeName)
+            {
+                // Send back sample points to the processor that holds the cell
+                vectorField samples(mpp.samplePoints());
+                distMap.reverseDistribute
+                (
+                    (mpp.sameRegion() ? thisMesh.nCells() : nbrMesh.nCells()),
+                    point::max,
+                    samples
+                );
+
+                const interpolation<Type>& interp = interpolator();
+
+                newValues.setSize(samples.size(), pTraits<Type>::max);
+                forAll(samples, cellI)
+                {
+                    if (samples[cellI] != point::max)
+                    {
+                        newValues[cellI] = interp.interpolate
+                        (
+                            samples[cellI],
+                            cellI
+                        );
+                    }
+                }
+            }
+            else
+            {
+                newValues = sampleField();
+            }
+
+            distMap.distribute(newValues);
+
+            break;
+        }
+        case mappedPatchBase::NEARESTPATCHFACE:
+        {
+            const mapDistribute& distMap = mpp.map();
+
+            const label nbrPatchID =
+                nbrMesh.boundaryMesh().findPatchID(mpp.samplePatch());
+
+            if (nbrPatchID < 0)
+            {
+                FatalErrorIn
+                (
+                    "void mappedFixedValueFvPatchField<Type>::updateCoeffs()"
+                )<< "Unable to find sample patch " << mpp.samplePatch()
+                 << " in region " << mpp.sampleRegion()
+                 << " for patch " << this->patch().name() << nl
+                 << abort(FatalError);
+            }
+
+            const fieldType& nbrField = sampleField();
+
+            newValues = nbrField.boundaryField()[nbrPatchID];
+            distMap.distribute(newValues);
+
+            break;
+        }
+        case mappedPatchBase::NEARESTPATCHFACEAMI:
+        {
+            const label nbrPatchID =
+                nbrMesh.boundaryMesh().findPatchID(mpp.samplePatch());
+
+            if (nbrPatchID < 0)
+            {
+                FatalErrorIn
+                (
+                    "void mappedFixedValueFvPatchField<Type>::updateCoeffs()"
+                )<< "Unable to find sample patch " << mpp.samplePatch()
+                 << " in region " << mpp.sampleRegion()
+                 << " for patch " << this->patch().name() << nl
+                 << abort(FatalError);
+            }
+
+            const fieldType& nbrField = sampleField();
+
+            newValues = mpp.AMI().interpolateToSource(nbrField);
+            break;
+        }
+        case mappedPatchBase::NEARESTFACE:
+        {
+            const mapDistribute& distMap = mpp.map();
+
+            Field<Type> allValues(nbrMesh.nFaces(), pTraits<Type>::zero);
+
+            const fieldType& nbrField = sampleField();
+
+            forAll(nbrField.boundaryField(), patchI)
+            {
+                const fvPatchField<Type>& pf =
+                    nbrField.boundaryField()[patchI];
+                label faceStart = pf.patch().start();
+
+                forAll(pf, faceI)
+                {
+                    allValues[faceStart++] = pf[faceI];
+                }
+            }
+
+            distMap.distribute(allValues);
+            newValues.transfer(allValues);
+
+            break;
+        }
+        default:
+        {
+            FatalErrorIn
+            (
+                "mappedFixedValueFvPatchField<Type>::updateCoeffs()"
+            )<< "Unknown sampling mode: " << mpp.mode()
+             << nl << abort(FatalError);
+        }
+    }
+
+    if (setAverage_)
+    {
+        Type averagePsi =
+            gSum(this->patch().magSf()*newValues)
+           /gSum(this->patch().magSf());
+
+        if (mag(averagePsi)/mag(average_) > 0.5)
+        {
+            newValues *= mag(average_)/mag(averagePsi);
+        }
+        else
+        {
+            newValues += (average_ - averagePsi);
+        }
+    }
+
+    this->operator==(newValues);
+
+    if (debug)
+    {
+        Info<< "mapped on field:"
+            << this->dimensionedInternalField().name()
+            << " patch:" << this->patch().name()
+            << "  avg:" << gAverage(*this)
+            << "  min:" << gMin(*this)
+            << "  max:" << gMax(*this)
+            << endl;
+    }
+
+    fixedValueFvPatchField<Type>::updateCoeffs();
+}
+
+
+template<class Type>
+void mappedFixedValueFvPatchField<Type>::write(Ostream& os) const
+{
+    fvPatchField<Type>::write(os);
+    os.writeKeyword("fieldName") << fieldName_ << token::END_STATEMENT << nl;
+    os.writeKeyword("setAverage") << setAverage_ << token::END_STATEMENT << nl;
+    os.writeKeyword("average") << average_ << token::END_STATEMENT << nl;
+    os.writeKeyword("interpolationScheme") << interpolationScheme_
+        << token::END_STATEMENT << nl;
+    this->writeEntry("value", os);
+}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// ************************************************************************* //
diff --git a/src/AMIInterpolation/patches/mapped/mappedFixedValue/mappedFixedValueFvPatchField.H b/src/AMIInterpolation/patches/mapped/mappedFixedValue/mappedFixedValueFvPatchField.H
new file mode 100644
index 0000000000..a890ffbd27
--- /dev/null
+++ b/src/AMIInterpolation/patches/mapped/mappedFixedValue/mappedFixedValueFvPatchField.H
@@ -0,0 +1,196 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::mappedFixedValueFvPatchField
+
+Description
+    Recycles the value at a set of cells or patch faces back to *this. Can not
+    sample internal faces (since volField not defined on faces).
+
+    mode = NEARESTCELL : sample nearest cell
+    mode = NEARESTPATCHFACE : sample nearest face on selected patch
+    mode = NEARESTFACE : sample nearest face on any patch. Note: does not
+           warn if nearest actually is on internal face!
+    mode = NEARESTPATCHFACEAMI : sample nearest face on selected patch
+           patches can be non-conformal - method uses AMI interpolation
+
+    For NEARESTCELL you have to provide an 'interpolationScheme' entry
+    which can be any one of the interpolation schemes (cell, cellPoint, etc.)
+    In case of interpolation (so scheme != cell) the limitation is that
+    there is only one value per cell. So e.g. if you have a cell with two
+    boundary faces and both faces sample into the cell both faces will get
+    the same value.
+
+    See directMappedPatchBase for options on sampling.
+
+    Optional 'fieldName' entry to supply a different filename
+
+SourceFiles
+    mappedFixedValueFvPatchField.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef mappedFixedValueFvPatchField_H
+#define mappedFixedValueFvPatchField_H
+
+#include "fixedValueFvPatchFields.H"
+#include "interpolation.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                  Class mappedFixedValueFvPatch Declaration
+\*---------------------------------------------------------------------------*/
+
+template<class Type>
+class mappedFixedValueFvPatchField
+:
+    public fixedValueFvPatchField<Type>
+{
+    // Private data
+
+        //- Name of field to sample - defaults to field associated with this
+        //  patchField if not specified
+        word fieldName_;
+
+        //- If true adjust the mapped field to maintain average value average_
+        const bool setAverage_;
+
+        //- Average value the mapped field is adjusted to maintain if
+        //  setAverage_ is set true
+        const Type average_;
+
+        //- Interpolation scheme to use for nearestcell mode
+        word interpolationScheme_;
+
+        mutable autoPtr<interpolation<Type> > interpolator_;
+
+
+    // Private Member Functions
+
+        //- Field to sample. Either on my or nbr mesh
+        const GeometricField<Type, fvPatchField, volMesh>& sampleField() const;
+
+        //- Access the interpolation method
+        const interpolation<Type>& interpolator() const;
+
+
+public:
+
+    //- Runtime type information
+    TypeName("mapped");
+
+
+    // Constructors
+
+        //- Construct from patch and internal field
+        mappedFixedValueFvPatchField
+        (
+            const fvPatch&,
+            const DimensionedField<Type, volMesh>&
+        );
+
+        //- Construct from patch, internal field and dictionary
+        mappedFixedValueFvPatchField
+        (
+            const fvPatch&,
+            const DimensionedField<Type, volMesh>&,
+            const dictionary&
+        );
+
+        //- Construct by mapping given mappedFixedValueFvPatchField
+        //  onto a new patch
+        mappedFixedValueFvPatchField
+        (
+            const mappedFixedValueFvPatchField<Type>&,
+            const fvPatch&,
+            const DimensionedField<Type, volMesh>&,
+            const fvPatchFieldMapper&
+        );
+
+        //- Construct as copy
+        mappedFixedValueFvPatchField
+        (
+            const mappedFixedValueFvPatchField<Type>&
+        );
+
+        //- Construct and return a clone
+        virtual tmp<fvPatchField<Type> > clone() const
+        {
+            return tmp<fvPatchField<Type> >
+            (
+                new mappedFixedValueFvPatchField<Type>(*this)
+            );
+        }
+
+        //- Construct as copy setting internal field reference
+        mappedFixedValueFvPatchField
+        (
+            const mappedFixedValueFvPatchField<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 mappedFixedValueFvPatchField<Type>(*this, iF)
+            );
+        }
+
+
+    // Member functions
+
+        // Evaluation functions
+
+            //- Update the coefficients associated with the patch field
+            virtual void updateCoeffs();
+
+        //- Write
+        virtual void write(Ostream&) const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+#   include "mappedFixedValueFvPatchField.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/AMIInterpolation/patches/mapped/mappedFixedValue/mappedFixedValueFvPatchFields.C b/src/AMIInterpolation/patches/mapped/mappedFixedValue/mappedFixedValueFvPatchFields.C
new file mode 100644
index 0000000000..59e02276e3
--- /dev/null
+++ b/src/AMIInterpolation/patches/mapped/mappedFixedValue/mappedFixedValueFvPatchFields.C
@@ -0,0 +1,43 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "mappedFixedValueFvPatchFields.H"
+#include "volMesh.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+makePatchFields(mappedFixedValue);
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// ************************************************************************* //
diff --git a/src/AMIInterpolation/patches/mapped/mappedFixedValue/mappedFixedValueFvPatchFields.H b/src/AMIInterpolation/patches/mapped/mappedFixedValue/mappedFixedValueFvPatchFields.H
new file mode 100644
index 0000000000..8b49a15750
--- /dev/null
+++ b/src/AMIInterpolation/patches/mapped/mappedFixedValue/mappedFixedValueFvPatchFields.H
@@ -0,0 +1,49 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef mappedFixedValueFvPatchFields_H
+#define mappedFixedValueFvPatchFields_H
+
+#include "mappedFixedValueFvPatchField.H"
+#include "fieldTypes.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+makePatchTypeFieldTypedefs(mappedFixedValue);
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/AMIInterpolation/patches/mapped/mappedFixedValue/mappedFixedValueFvPatchFieldsFwd.H b/src/AMIInterpolation/patches/mapped/mappedFixedValue/mappedFixedValueFvPatchFieldsFwd.H
new file mode 100644
index 0000000000..2f0697d71d
--- /dev/null
+++ b/src/AMIInterpolation/patches/mapped/mappedFixedValue/mappedFixedValueFvPatchFieldsFwd.H
@@ -0,0 +1,50 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef mappedFixedValueFvPatchFieldsFwd_H
+#define mappedFixedValueFvPatchFieldsFwd_H
+
+#include "fieldTypes.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+template<class Type> class mappedFixedValueFvPatchField;
+
+makePatchTypeFieldTypedefs(mappedFixedValue);
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/AMIInterpolation/patches/mapped/mappedFvPatch/mappedFvPatch.C b/src/AMIInterpolation/patches/mapped/mappedFvPatch/mappedFvPatch.C
new file mode 100644
index 0000000000..6ea246b444
--- /dev/null
+++ b/src/AMIInterpolation/patches/mapped/mappedFvPatch/mappedFvPatch.C
@@ -0,0 +1,37 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "mappedFvPatch.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(mappedFvPatch, 0);
+    addToRunTimeSelectionTable(fvPatch, mappedFvPatch, polyPatch);
+}
+
+// ************************************************************************* //
diff --git a/src/AMIInterpolation/patches/mapped/mappedFvPatch/mappedFvPatch.H b/src/AMIInterpolation/patches/mapped/mappedFvPatch/mappedFvPatch.H
new file mode 100644
index 0000000000..f44c4057cf
--- /dev/null
+++ b/src/AMIInterpolation/patches/mapped/mappedFvPatch/mappedFvPatch.H
@@ -0,0 +1,79 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::mappedFvPatch
+
+Description
+    Foam::mappedFvPatch
+
+SourceFiles
+    mappedFvPatch.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef mappedFvPatch_H
+#define mappedFvPatch_H
+
+#include "fvPatch.H"
+#include "mappedPolyPatch.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                       Class mappedFvPatch Declaration
+\*---------------------------------------------------------------------------*/
+
+class mappedFvPatch
+:
+    public fvPatch
+{
+
+public:
+
+    //- Runtime type information
+    TypeName(mappedPolyPatch::typeName_());
+
+
+    // Constructors
+
+        //- Construct from components
+        mappedFvPatch(const polyPatch& patch, const fvBoundaryMesh& bm)
+        :
+            fvPatch(patch, bm)
+        {}
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/AMIInterpolation/patches/mapped/mappedPolyPatch/mappedPatchBase.C b/src/AMIInterpolation/patches/mapped/mappedPolyPatch/mappedPatchBase.C
new file mode 100644
index 0000000000..084560d9a6
--- /dev/null
+++ b/src/AMIInterpolation/patches/mapped/mappedPolyPatch/mappedPatchBase.C
@@ -0,0 +1,982 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "mappedPatchBase.H"
+#include "addToRunTimeSelectionTable.H"
+#include "ListListOps.H"
+#include "meshSearch.H"
+#include "meshTools.H"
+#include "OFstream.H"
+#include "Random.H"
+#include "treeDataFace.H"
+#include "indexedOctree.H"
+#include "polyMesh.H"
+#include "polyPatch.H"
+#include "Time.H"
+#include "mapDistribute.H"
+#include "SubField.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(mappedPatchBase, 0);
+
+    template<>
+    const char* Foam::NamedEnum
+    <
+        Foam::mappedPatchBase::sampleMode,
+        3
+    >::names[] =
+    {
+        "nearestCell",
+        "nearestPatchFace",
+        "nearestFace"
+    };
+
+    template<>
+    const char* Foam::NamedEnum
+    <
+        Foam::mappedPatchBase::offsetMode,
+        3
+    >::names[] =
+    {
+        "uniform",
+        "nonuniform",
+        "normal"
+    };
+}
+
+
+const Foam::NamedEnum<Foam::mappedPatchBase::sampleMode, 3>
+    Foam::mappedPatchBase::sampleModeNames_;
+
+const Foam::NamedEnum<Foam::mappedPatchBase::offsetMode, 3>
+    Foam::mappedPatchBase::offsetModeNames_;
+
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+void Foam::mappedPatchBase::collectSamples
+(
+    pointField& samples,
+    labelList& patchFaceProcs,
+    labelList& patchFaces,
+    pointField& patchFc
+) const
+{
+
+    // Collect all sample points and the faces they come from.
+    List<pointField> globalFc(Pstream::nProcs());
+    List<pointField> globalSamples(Pstream::nProcs());
+    labelListList globalFaces(Pstream::nProcs());
+
+    globalFc[Pstream::myProcNo()] = patch_.faceCentres();
+    globalSamples[Pstream::myProcNo()] = samplePoints();
+    globalFaces[Pstream::myProcNo()] = identity(patch_.size());
+
+    // Distribute to all processors
+    Pstream::gatherList(globalSamples);
+    Pstream::scatterList(globalSamples);
+    Pstream::gatherList(globalFaces);
+    Pstream::scatterList(globalFaces);
+    Pstream::gatherList(globalFc);
+    Pstream::scatterList(globalFc);
+
+    // Rework into straight list
+    samples = ListListOps::combine<pointField>
+    (
+        globalSamples,
+        accessOp<pointField>()
+    );
+    patchFaces = ListListOps::combine<labelList>
+    (
+        globalFaces,
+        accessOp<labelList>()
+    );
+    patchFc = ListListOps::combine<pointField>
+    (
+        globalFc,
+        accessOp<pointField>()
+    );
+
+    patchFaceProcs.setSize(patchFaces.size());
+    labelList nPerProc
+    (
+        ListListOps::subSizes
+        (
+            globalFaces,
+            accessOp<labelList>()
+        )
+    );
+    label sampleI = 0;
+    forAll(nPerProc, procI)
+    {
+        for (label i = 0; i < nPerProc[procI]; i++)
+        {
+            patchFaceProcs[sampleI++] = procI;
+        }
+    }
+}
+
+
+// Find the processor/cell containing the samples. Does not account
+// for samples being found in two processors.
+void Foam::mappedPatchBase::findSamples
+(
+    const pointField& samples,
+    labelList& sampleProcs,
+    labelList& sampleIndices,
+    pointField& sampleLocations
+) const
+{
+    // Lookup the correct region
+    const polyMesh& mesh = sampleMesh();
+
+    // All the info for nearest. Construct to miss
+    List<nearInfo> nearest(samples.size());
+
+    switch (mode_)
+    {
+        case NEARESTCELL:
+        {
+            if (samplePatch_.size() && samplePatch_ != "none")
+            {
+                FatalErrorIn
+                (
+                    "mappedPatchBase::findSamples(const pointField&,"
+                    " labelList&, labelList&, pointField&) const"
+                )   << "No need to supply a patch name when in "
+                    << sampleModeNames_[mode_] << " mode." << exit(FatalError);
+            }
+
+            // Octree based search engine
+            meshSearch meshSearchEngine(mesh, false);
+
+            forAll(samples, sampleI)
+            {
+                const point& sample = samples[sampleI];
+
+                label cellI = meshSearchEngine.findCell(sample);
+
+                if (cellI == -1)
+                {
+                    nearest[sampleI].second().first() = Foam::sqr(GREAT);
+                    nearest[sampleI].second().second() = Pstream::myProcNo();
+                }
+                else
+                {
+                    const point& cc = mesh.cellCentres()[cellI];
+
+                    nearest[sampleI].first() = pointIndexHit
+                    (
+                        true,
+                        cc,
+                        cellI
+                    );
+                    nearest[sampleI].second().first() = magSqr(cc-sample);
+                    nearest[sampleI].second().second() = Pstream::myProcNo();
+                }
+            }
+            break;
+        }
+
+        case NEARESTPATCHFACE:
+        {
+            Random rndGen(123456);
+
+            const polyPatch& pp = samplePolyPatch();
+
+            if (pp.empty())
+            {
+                forAll(samples, sampleI)
+                {
+                    nearest[sampleI].second().first() = Foam::sqr(GREAT);
+                    nearest[sampleI].second().second() = Pstream::myProcNo();
+                }
+            }
+            else
+            {
+                // patch faces
+                const labelList patchFaces(identity(pp.size()) + pp.start());
+
+                treeBoundBox patchBb
+                (
+                    treeBoundBox(pp.points(), pp.meshPoints()).extend
+                    (
+                        rndGen,
+                        1E-4
+                    )
+                );
+                patchBb.min() -= point(ROOTVSMALL, ROOTVSMALL, ROOTVSMALL);
+                patchBb.max() += point(ROOTVSMALL, ROOTVSMALL, ROOTVSMALL);
+
+                indexedOctree<treeDataFace> boundaryTree
+                (
+                    treeDataFace    // all information needed to search faces
+                    (
+                        false,      // do not cache bb
+                        mesh,
+                        patchFaces  // boundary faces only
+                    ),
+                    patchBb,        // overall search domain
+                    8,              // maxLevel
+                    10,             // leafsize
+                    3.0             // duplicity
+                );
+
+                forAll(samples, sampleI)
+                {
+                    const point& sample = samples[sampleI];
+
+                    pointIndexHit& nearInfo = nearest[sampleI].first();
+                    nearInfo = boundaryTree.findNearest
+                    (
+                        sample,
+                        magSqr(patchBb.span())
+                    );
+
+                    if (!nearInfo.hit())
+                    {
+                        nearest[sampleI].second().first() = Foam::sqr(GREAT);
+                        nearest[sampleI].second().second() =
+                            Pstream::myProcNo();
+                    }
+                    else
+                    {
+                        point fc(pp[nearInfo.index()].centre(pp.points()));
+                        nearInfo.setPoint(fc);
+                        nearest[sampleI].second().first() = magSqr(fc-sample);
+                        nearest[sampleI].second().second() =
+                            Pstream::myProcNo();
+                    }
+                }
+            }
+            break;
+        }
+
+        case NEARESTFACE:
+        {
+            if (samplePatch_.size() && samplePatch_ != "none")
+            {
+                FatalErrorIn
+                (
+                    "mappedPatchBase::findSamples(const pointField&,"
+                    " labelList&, labelList&, pointField&) const"
+                )   << "No need to supply a patch name when in "
+                    << sampleModeNames_[mode_] << " mode." << exit(FatalError);
+            }
+
+            // Octree based search engine
+            meshSearch meshSearchEngine(mesh, false);
+
+            forAll(samples, sampleI)
+            {
+                const point& sample = samples[sampleI];
+
+                label faceI = meshSearchEngine.findNearestFace(sample);
+
+                if (faceI == -1)
+                {
+                    nearest[sampleI].second().first() = Foam::sqr(GREAT);
+                    nearest[sampleI].second().second() = Pstream::myProcNo();
+                }
+                else
+                {
+                    const point& fc = mesh.faceCentres()[faceI];
+
+                    nearest[sampleI].first() = pointIndexHit
+                    (
+                        true,
+                        fc,
+                        faceI
+                    );
+                    nearest[sampleI].second().first() = magSqr(fc-sample);
+                    nearest[sampleI].second().second() = Pstream::myProcNo();
+                }
+            }
+            break;
+        }
+
+        case NEARESTPATCHFACEAMI:
+        {
+            // nothing to do here
+            return;
+        }
+
+        default:
+        {
+            FatalErrorIn("mappedPatchBase::findSamples(..)")
+                << "problem." << abort(FatalError);
+        }
+    }
+
+
+    // Find nearest
+    Pstream::listCombineGather(nearest, nearestEqOp());
+    Pstream::listCombineScatter(nearest);
+
+    if (debug)
+    {
+        Info<< "mappedPatchBase::findSamples on mesh " << sampleRegion_
+            << " : " << endl;
+        forAll(nearest, sampleI)
+        {
+            label procI = nearest[sampleI].second().second();
+            label localI = nearest[sampleI].first().index();
+
+            Info<< "    " << sampleI << " coord:"<< samples[sampleI]
+                << " found on processor:" << procI
+                << " in local cell/face:" << localI
+                << " with cc:" << nearest[sampleI].first().rawPoint() << endl;
+        }
+    }
+
+    // Check for samples not being found
+    forAll(nearest, sampleI)
+    {
+        if (!nearest[sampleI].first().hit())
+        {
+            FatalErrorIn
+            (
+                "mappedPatchBase::findSamples"
+                "(const pointField&, labelList&"
+                ", labelList&, pointField&)"
+            )   << "Did not find sample " << samples[sampleI]
+                << " on any processor of region " << sampleRegion_
+                << exit(FatalError);
+        }
+    }
+
+
+    // Convert back into proc+local index
+    sampleProcs.setSize(samples.size());
+    sampleIndices.setSize(samples.size());
+    sampleLocations.setSize(samples.size());
+
+    forAll(nearest, sampleI)
+    {
+        sampleProcs[sampleI] = nearest[sampleI].second().second();
+        sampleIndices[sampleI] = nearest[sampleI].first().index();
+        sampleLocations[sampleI] = nearest[sampleI].first().hitPoint();
+    }
+}
+
+
+void Foam::mappedPatchBase::calcMapping() const
+{
+    if (mapPtr_.valid())
+    {
+        FatalErrorIn("mappedPatchBase::calcMapping() const")
+            << "Mapping already calculated" << exit(FatalError);
+    }
+
+    // Do a sanity check
+    // Am I sampling my own patch? This only makes sense for a non-zero
+    // offset.
+    bool sampleMyself =
+    (
+        mode_ == NEARESTPATCHFACE
+     && sampleRegion_ == patch_.boundaryMesh().mesh().name()
+     && samplePatch_ == patch_.name()
+    );
+
+    // Check offset
+    vectorField d(samplePoints()-patch_.faceCentres());
+    if (sampleMyself && gAverage(mag(d)) <= ROOTVSMALL)
+    {
+        WarningIn
+        (
+            "mappedPatchBase::mappedPatchBase\n"
+            "(\n"
+            "    const polyPatch& pp,\n"
+            "    const word& sampleRegion,\n"
+            "    const sampleMode mode,\n"
+            "    const word& samplePatch,\n"
+            "    const vector& offset\n"
+            ")\n"
+        )   << "Invalid offset " << d << endl
+            << "Offset is the vector added to the patch face centres to"
+            << " find the patch face supplying the data." << endl
+            << "Setting it to " << d
+            << " on the same patch, on the same region"
+            << " will find the faces themselves which does not make sense"
+            << " for anything but testing." << endl
+            << "patch_:" << patch_.name() << endl
+            << "sampleRegion_:" << sampleRegion_ << endl
+            << "mode_:" << sampleModeNames_[mode_] << endl
+            << "samplePatch_:" << samplePatch_ << endl
+            << "offsetMode_:" << offsetModeNames_[offsetMode_] << endl;
+    }
+
+
+
+    // Get global list of all samples and the processor and face they come from.
+    pointField samples;
+    labelList patchFaceProcs;
+    labelList patchFaces;
+    pointField patchFc;
+    collectSamples(samples, patchFaceProcs, patchFaces, patchFc);
+
+    // Find processor and cell/face samples are in and actual location.
+    labelList sampleProcs;
+    labelList sampleIndices;
+    pointField sampleLocations;
+    findSamples(samples, sampleProcs, sampleIndices, sampleLocations);
+
+
+    // Now we have all the data we need:
+    // - where sample originates from (so destination when mapping):
+    //   patchFaces, patchFaceProcs.
+    // - cell/face sample is in (so source when mapping)
+    //   sampleIndices, sampleProcs.
+
+    //forAll(samples, i)
+    //{
+    //    Info<< i << " need data in region "
+    //        << patch_.boundaryMesh().mesh().name()
+    //        << " for proc:" << patchFaceProcs[i]
+    //        << " face:" << patchFaces[i]
+    //        << " at:" << patchFc[i] << endl
+    //        << "Found data in region " << sampleRegion_
+    //        << " at proc:" << sampleProcs[i]
+    //        << " face:" << sampleIndices[i]
+    //        << " at:" << sampleLocations[i]
+    //        << nl << endl;
+    //}
+
+
+
+    if (debug && Pstream::master())
+    {
+        OFstream str
+        (
+            patch_.boundaryMesh().mesh().time().path()
+          / patch_.name()
+          + "_mapped.obj"
+        );
+        Pout<< "Dumping mapping as lines from patch faceCentres to"
+            << " sampled cell/faceCentres to file " << str.name() << endl;
+
+        label vertI = 0;
+
+        forAll(patchFc, i)
+        {
+            meshTools::writeOBJ(str, patchFc[i]);
+            vertI++;
+            meshTools::writeOBJ(str, sampleLocations[i]);
+            vertI++;
+            str << "l " << vertI-1 << ' ' << vertI << nl;
+        }
+    }
+
+
+    // Determine schedule.
+    mapPtr_.reset(new mapDistribute(sampleProcs, patchFaceProcs));
+
+    // Rework the schedule from indices into samples to cell data to send,
+    // face data to receive.
+
+    labelListList& subMap = mapPtr_().subMap();
+    labelListList& constructMap = mapPtr_().constructMap();
+
+    forAll(subMap, procI)
+    {
+        subMap[procI] = UIndirectList<label>
+        (
+            sampleIndices,
+            subMap[procI]
+        );
+        constructMap[procI] = UIndirectList<label>
+        (
+            patchFaces,
+            constructMap[procI]
+        );
+
+        //if (debug)
+        //{
+        //    Pout<< "To proc:" << procI << " sending values of cells/faces:"
+        //        << subMap[procI] << endl;
+        //    Pout<< "From proc:" << procI
+        //        << " receiving values of patch faces:"
+        //        << constructMap[procI] << endl;
+        //}
+    }
+
+    // Redo constructSize
+    mapPtr_().constructSize() = patch_.size();
+
+    if (debug)
+    {
+        // Check that all elements get a value.
+        PackedBoolList used(patch_.size());
+        forAll(constructMap, procI)
+        {
+            const labelList& map = constructMap[procI];
+
+            forAll(map, i)
+            {
+                label faceI = map[i];
+
+                if (used[faceI] == 0)
+                {
+                    used[faceI] = 1;
+                }
+                else
+                {
+                    FatalErrorIn("mappedPatchBase::calcMapping() const")
+                        << "On patch " << patch_.name()
+                        << " patchface " << faceI
+                        << " is assigned to more than once."
+                        << abort(FatalError);
+                }
+            }
+        }
+        forAll(used, faceI)
+        {
+            if (used[faceI] == 0)
+            {
+                FatalErrorIn("mappedPatchBase::calcMapping() const")
+                    << "On patch " << patch_.name()
+                    << " patchface " << faceI
+                    << " is never assigned to."
+                    << abort(FatalError);
+            }
+        }
+    }
+}
+
+
+const Foam::autoPtr<Foam::searchableSurface>& Foam::mappedPatchBase::surfPtr()
+const
+{
+    word surfType(surfDict_.lookup("type"));
+
+    if (!surfPtr_.valid() && surfType != "none")
+    {
+        word surfName(surfDict_.lookupOrDefault("name", patch_.name()));
+
+        const polyMesh& mesh = patch_.boundaryMesh().mesh();
+
+        surfPtr_ =
+            searchableSurface::New
+            (
+                surfType,
+                IOobject
+                (
+                    surfName,
+                    mesh.time().constant(),
+                    "triSurface",
+                    mesh,
+                    IOobject::MUST_READ,
+                    IOobject::NO_WRITE
+                ),
+                surfDict_
+            );
+    }
+
+    return surfPtr_;
+}
+
+
+void Foam::mappedPatchBase::calcAMI() const
+{
+    if (AMIPtr_.valid())
+    {
+        FatalErrorIn("mappedPatchBase::calcAMI() const")
+            << "AMI already calculated" << exit(FatalError);
+    }
+
+    AMIPtr_.clear();
+
+    const polyPatch& nbr = samplePolyPatch();
+    pointField nbrPoints(samplePoints());
+
+    if (debug)
+    {
+        OFstream os(patch_.name() + "_neighbourPatch-org.obj");
+        meshTools::writeOBJ(os, samplePolyPatch().localFaces(), nbrPoints);
+    }
+
+    // transform neighbour patch to local system
+    primitivePatch nbrPatch0
+    (
+        SubList<face>
+        (
+            nbr.localFaces(),
+            nbr.size()
+        ),
+        nbrPoints
+    );
+
+    if (debug)
+    {
+        OFstream osN(patch_.name() + "_neighbourPatch-trans.obj");
+        meshTools::writeOBJ(osN, nbrPatch0, nbrPoints);
+
+        OFstream osO(patch_.name() + "_ownerPatch.obj");
+        meshTools::writeOBJ(osO, patch_.localFaces(), patch_.localPoints());
+    }
+
+    // Construct/apply AMI interpolation to determine addressing and weights
+    AMIPtr_.reset
+    (
+        new AMIPatchToPatchInterpolation
+        (
+            patch_,
+            nbrPatch0,
+            surfPtr(),
+            faceAreaIntersect::tmMesh
+        )
+    );
+}
+
+
+// * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * * * * * //
+
+Foam::mappedPatchBase::mappedPatchBase
+(
+    const polyPatch& pp
+)
+:
+    patch_(pp),
+    sampleRegion_(patch_.boundaryMesh().mesh().name()),
+    mode_(NEARESTPATCHFACE),
+    samplePatch_("none"),
+    offsetMode_(UNIFORM),
+    offset_(vector::zero),
+    offsets_(pp.size(), offset_),
+    distance_(0),
+    sameRegion_(sampleRegion_ == patch_.boundaryMesh().mesh().name()),
+    mapPtr_(NULL)
+{}
+
+
+Foam::mappedPatchBase::mappedPatchBase
+(
+    const polyPatch& pp,
+    const word& sampleRegion,
+    const sampleMode mode,
+    const word& samplePatch,
+    const vectorField& offsets
+)
+:
+    patch_(pp),
+    sampleRegion_(sampleRegion),
+    mode_(mode),
+    samplePatch_(samplePatch),
+    offsetMode_(NONUNIFORM),
+    offset_(vector::zero),
+    offsets_(offsets),
+    distance_(0),
+    sameRegion_(sampleRegion_ == patch_.boundaryMesh().mesh().name()),
+    mapPtr_(NULL)
+{}
+
+
+Foam::mappedPatchBase::mappedPatchBase
+(
+    const polyPatch& pp,
+    const word& sampleRegion,
+    const sampleMode mode,
+    const word& samplePatch,
+    const vector& offset
+)
+:
+    patch_(pp),
+    sampleRegion_(sampleRegion),
+    mode_(mode),
+    samplePatch_(samplePatch),
+    offsetMode_(UNIFORM),
+    offset_(offset),
+    offsets_(0),
+    distance_(0),
+    sameRegion_(sampleRegion_ == patch_.boundaryMesh().mesh().name()),
+    mapPtr_(NULL)
+{}
+
+
+Foam::mappedPatchBase::mappedPatchBase
+(
+    const polyPatch& pp,
+    const word& sampleRegion,
+    const sampleMode mode,
+    const word& samplePatch,
+    const scalar distance
+)
+:
+    patch_(pp),
+    sampleRegion_(sampleRegion),
+    mode_(mode),
+    samplePatch_(samplePatch),
+    offsetMode_(NORMAL),
+    offset_(vector::zero),
+    offsets_(0),
+    distance_(distance),
+    sameRegion_(sampleRegion_ == patch_.boundaryMesh().mesh().name()),
+    mapPtr_(NULL)
+{}
+
+
+Foam::mappedPatchBase::mappedPatchBase
+(
+    const polyPatch& pp,
+    const dictionary& dict
+)
+:
+    patch_(pp),
+    sampleRegion_
+    (
+        dict.lookupOrDefault
+        (
+            "sampleRegion",
+            patch_.boundaryMesh().mesh().name()
+        )
+    ),
+    mode_(sampleModeNames_.read(dict.lookup("sampleMode"))),
+    samplePatch_(dict.lookup("samplePatch")),
+    offsetMode_(UNIFORM),
+    offset_(vector::zero),
+    offsets_(0),
+    distance_(0.0),
+    sameRegion_(sampleRegion_ == patch_.boundaryMesh().mesh().name()),
+    mapPtr_(NULL),
+    AMIPtr_(NULL),
+    surfPtr_(NULL),
+    surfDict_(dict.subOrEmptyDict("surface"))
+{
+    if (dict.found("offsetMode"))
+    {
+        offsetMode_ = offsetModeNames_.read(dict.lookup("offsetMode"));
+
+        switch(offsetMode_)
+        {
+            case UNIFORM:
+            {
+                offset_ = point(dict.lookup("offset"));
+            }
+            break;
+
+            case NONUNIFORM:
+            {
+                offsets_ = pointField(dict.lookup("offsets"));
+            }
+            break;
+
+            case NORMAL:
+            {
+                distance_ = readScalar(dict.lookup("distance"));
+            }
+            break;
+        }
+    }
+    else if (dict.found("offset"))
+    {
+        offsetMode_ = UNIFORM;
+        offset_ = point(dict.lookup("offset"));
+    }
+    else if (dict.found("offsets"))
+    {
+        offsetMode_ = NONUNIFORM;
+        offsets_ = pointField(dict.lookup("offsets"));
+    }
+    else
+    {
+        FatalIOErrorIn
+        (
+            "mappedPatchBase::mappedPatchBase\n"
+            "(\n"
+            "    const polyPatch& pp,\n"
+            "    const dictionary& dict\n"
+            ")\n",
+            dict
+        )   << "Please supply the offsetMode as one of "
+            << NamedEnum<offsetMode, 3>::words()
+            << exit(FatalIOError);
+    }
+}
+
+
+Foam::mappedPatchBase::mappedPatchBase
+(
+    const polyPatch& pp,
+    const mappedPatchBase& dmp
+)
+:
+    patch_(pp),
+    sampleRegion_(dmp.sampleRegion_),
+    mode_(dmp.mode_),
+    samplePatch_(dmp.samplePatch_),
+    offsetMode_(dmp.offsetMode_),
+    offset_(dmp.offset_),
+    offsets_(dmp.offsets_),
+    distance_(dmp.distance_),
+    sameRegion_(dmp.sameRegion_),
+    mapPtr_(NULL),
+    AMIPtr_(NULL),
+    surfPtr_(NULL),
+    surfDict_(dmp.surfDict_)
+{}
+
+
+Foam::mappedPatchBase::mappedPatchBase
+(
+    const polyPatch& pp,
+    const mappedPatchBase& dmp,
+    const labelUList& mapAddressing
+)
+:
+    patch_(pp),
+    sampleRegion_(dmp.sampleRegion_),
+    mode_(dmp.mode_),
+    samplePatch_(dmp.samplePatch_),
+    offsetMode_(dmp.offsetMode_),
+    offset_(dmp.offset_),
+    offsets_(dmp.offsets_, mapAddressing),
+    distance_(dmp.distance_),
+    sameRegion_(dmp.sameRegion_),
+    mapPtr_(NULL),
+    AMIPtr_(NULL),
+    surfPtr_(NULL),
+    surfDict_(dmp.surfDict_)
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::mappedPatchBase::~mappedPatchBase()
+{
+    clearOut();
+}
+
+
+void Foam::mappedPatchBase::clearOut()
+{
+    mapPtr_.clear();
+}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+const Foam::polyMesh& Foam::mappedPatchBase::sampleMesh() const
+{
+    return patch_.boundaryMesh().mesh().time().lookupObject<polyMesh>
+    (
+        sampleRegion_
+    );
+}
+
+
+const Foam::polyPatch& Foam::mappedPatchBase::samplePolyPatch() const
+{
+    const polyMesh& nbrMesh = sampleMesh();
+
+    const label patchI = nbrMesh.boundaryMesh().findPatchID(samplePatch_);
+
+    if (patchI == -1)
+    {
+        FatalErrorIn("mappedPatchBase::samplePolyPatch() ")
+            << "Cannot find patch " << samplePatch_
+            << " in region " << sampleRegion_ << endl
+            << "Valid patches are " << nbrMesh.boundaryMesh().names()
+            << exit(FatalError);
+    }
+
+    return nbrMesh.boundaryMesh()[patchI];
+}
+
+
+Foam::tmp<Foam::pointField> Foam::mappedPatchBase::samplePoints() const
+{
+    tmp<pointField> tfld(new pointField(patch_.faceCentres()));
+    pointField& fld = tfld();
+
+    switch(offsetMode_)
+    {
+        case UNIFORM:
+        {
+            fld += offset_;
+        }
+        break;
+
+        case NONUNIFORM:
+        {
+            fld += offsets_;
+        }
+        break;
+
+        case NORMAL:
+        {
+            // Get outwards pointing normal
+            vectorField n(patch_.faceAreas());
+            n /= mag(n);
+
+            fld += distance_*n;
+        }
+        break;
+    }
+
+    return tfld;
+}
+
+
+void Foam::mappedPatchBase::write(Ostream& os) const
+{
+    os.writeKeyword("sampleMode") << sampleModeNames_[mode_]
+        << token::END_STATEMENT << nl;
+    os.writeKeyword("sampleRegion") << sampleRegion_
+        << token::END_STATEMENT << nl;
+    os.writeKeyword("samplePatch") << samplePatch_
+        << token::END_STATEMENT << nl;
+
+    os.writeKeyword("offsetMode") << offsetModeNames_[offsetMode_]
+        << token::END_STATEMENT << nl;
+
+    switch(offsetMode_)
+    {
+        case UNIFORM:
+        {
+            os.writeKeyword("offset") << offset_ << token::END_STATEMENT << nl;
+        }
+        break;
+
+        case NONUNIFORM:
+        {
+            os.writeKeyword("offsets") << offsets_ << token::END_STATEMENT
+                << nl;
+        }
+        break;
+
+        case NORMAL:
+        {
+            os.writeKeyword("distance") << distance_ << token::END_STATEMENT
+                << nl;
+        }
+        break;
+    }
+}
+
+
+// ************************************************************************* //
diff --git a/src/AMIInterpolation/patches/mapped/mappedPolyPatch/mappedPatchBase.H b/src/AMIInterpolation/patches/mapped/mappedPolyPatch/mappedPatchBase.H
new file mode 100644
index 0000000000..449c176aa6
--- /dev/null
+++ b/src/AMIInterpolation/patches/mapped/mappedPolyPatch/mappedPatchBase.H
@@ -0,0 +1,372 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::mappedPatchBase
+
+Description
+    Determines a mapping between patch face centres and mesh cell or face
+    centres and processors they're on.
+
+    If constructed from dictionary:
+        // Region to sample (default is region0)
+        sampleRegion region0;
+
+        // What to sample:
+        // - nearestCell : sample nearest cell
+        // - nearestPatchFace : nearest face on selected patch
+        // - nearestFace : nearest boundary face on any patch
+        sampleMode nearestCell;
+
+        // If sampleMod is nearestPatchFace : patch to find faces of
+        samplePatch movingWall;
+
+        // How to supply offset (w.r.t. my patch face centres):
+        // - uniform : single offset vector
+        // - nonuniform : per-face offset vector
+        // - normal : using supplied distance and face normal
+        offsetMode uniform;
+
+        // According to offsetMode (see above) supply one of
+        // offset, offsets or distance
+        offset  (1 0 0);
+
+    Note: if offsetMode is 'normal' it uses outwards pointing normals. So
+    supply a negative distance if sampling inside the domain.
+
+
+Note
+    Storage is not optimal. It temporary collects all (patch)face centres
+    on all processors to keep the addressing calculation simple.
+
+SourceFiles
+    mappedPatchBase.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef mappedPatchBase_H
+#define mappedPatchBase_H
+
+#include "pointField.H"
+#include "Tuple2.H"
+#include "pointIndexHit.H"
+#include "AMIPatchToPatchInterpolation.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+class polyPatch;
+class polyMesh;
+class mapDistribute;
+
+/*---------------------------------------------------------------------------*\
+                    Class mappedPatchBase Declaration
+\*---------------------------------------------------------------------------*/
+
+class mappedPatchBase
+{
+
+public:
+
+    // Type enumerations
+
+        //- Mesh items to sample
+        enum sampleMode
+        {
+            NEARESTCELL,        // nearest cell
+            NEARESTPATCHFACE,   // faces on selected patch
+            NEARESTFACE,        // nearest face
+            NEARESTPATCHFACEAMI // nearest patch face + AMI interpolation
+        };
+
+        //- How to project face centres
+        enum offsetMode
+        {
+            UNIFORM,            // single offset vector
+            NONUNIFORM,         // per-face offset vector
+            NORMAL              // use face normal + distance
+        };
+
+
+    //- Helper class for finding nearest
+    // Nearest:
+    //  - point+local index
+    //  - sqr(distance)
+    //  - processor
+    typedef Tuple2<pointIndexHit, Tuple2<scalar, label> > nearInfo;
+
+    class nearestEqOp
+    {
+
+    public:
+
+        void operator()(nearInfo& x, const nearInfo& y) const
+        {
+            if (y.first().hit())
+            {
+                if (!x.first().hit())
+                {
+                    x = y;
+                }
+                else if (y.second().first() < x.second().first())
+                {
+                    x = y;
+                }
+            }
+        }
+    };
+
+
+private:
+
+    // Private data
+
+        static const NamedEnum<sampleMode, 3> sampleModeNames_;
+
+        static const NamedEnum<offsetMode, 3> offsetModeNames_;
+
+        //- Patch to sample
+        const polyPatch& patch_;
+
+        //- Region to sample
+        const word sampleRegion_;
+
+        //- What to sample
+        const sampleMode mode_;
+
+        //- Patch (only if NEARESTPATCHFACE)
+        const word samplePatch_;
+
+        //- How to obtain samples
+        offsetMode offsetMode_;
+
+        //- Offset vector (uniform)
+        vector offset_;
+
+        //- Offset vector (nonuniform)
+        vectorField offsets_;
+
+        //- Offset distance (normal)
+        scalar distance_;
+
+        //- Same region
+        const bool sameRegion_;
+
+
+        // Derived information
+
+            //- Communication schedule:
+            //  - Cells/faces to sample per processor
+            //  - Patch faces to receive per processor
+            //  - schedule
+            mutable autoPtr<mapDistribute> mapPtr_;
+
+
+        // AMI interpolator
+
+            //- Pointer to AMI interpolator
+            mutable autoPtr<AMIPatchToPatchInterpolation> AMIPtr_;
+
+            //- Pointer to projection surface employed by AMI interpolator
+            mutable autoPtr<searchableSurface> surfPtr_;
+
+            //- Dictionary storing projection surface description
+            dictionary surfDict_;
+
+
+    // Private Member Functions
+
+        //- Collect single list of samples and originating processor+face.
+        void collectSamples
+        (
+            pointField&,
+            labelList& patchFaceProcs,
+            labelList& patchFaces,
+            pointField& patchFc
+        ) const;
+
+        //- Find cells/faces containing samples
+        void findSamples
+        (
+            const pointField&,
+            labelList& sampleProcs,     // processor containing sample
+            labelList& sampleIndices,   // local index of cell/face
+            pointField& sampleLocations // actual representative location
+        ) const;
+
+        //- Calculate mapping
+        void calcMapping() const;
+
+        //- Calculate AMI interpolator
+        void calcAMI() const;
+
+
+public:
+
+    //- Runtime type information
+    TypeName("mappedPatchBase");
+
+
+    // Constructors
+
+        //- Construct from patch
+        mappedPatchBase(const polyPatch&);
+
+        //- Construct with offsetMode=non-uniform
+        mappedPatchBase
+        (
+            const polyPatch& pp,
+            const word& sampleRegion,
+            const sampleMode sampleMode,
+            const word& samplePatch,
+            const vectorField& offsets
+        );
+
+        //- Construct from offsetMode=uniform
+        mappedPatchBase
+        (
+            const polyPatch& pp,
+            const word& sampleRegion,
+            const sampleMode sampleMode,
+            const word& samplePatch,
+            const vector& offset
+        );
+
+        //- Construct from offsetMode=normal and distance
+        mappedPatchBase
+        (
+            const polyPatch& pp,
+            const word& sampleRegion,
+            const sampleMode sampleMode,
+            const word& samplePatch,
+            const scalar distance
+        );
+
+        //- Construct from dictionary
+        mappedPatchBase(const polyPatch&, const dictionary&);
+
+        //- Construct as copy, resetting patch
+        mappedPatchBase(const polyPatch&, const mappedPatchBase&);
+
+        //- Construct as copy, resetting patch, map original data
+        mappedPatchBase
+        (
+            const polyPatch&,
+            const mappedPatchBase&,
+            const labelUList& mapAddressing
+        );
+
+
+    //- Destructor
+    virtual ~mappedPatchBase();
+
+
+    // Member functions
+
+        void clearOut();
+
+        //- What to sample
+        const sampleMode& mode() const
+        {
+            return mode_;
+        }
+
+        //- Region to sample
+        const word& sampleRegion() const
+        {
+            return sampleRegion_;
+        }
+
+        //- Patch (only if NEARESTPATCHFACE)
+        const word& samplePatch() const
+        {
+            return samplePatch_;
+        }
+
+        //- Offset vector (from patch faces to destination mesh objects)
+        const vector& offset() const
+        {
+            return offset_;
+        }
+
+        //- Offset vector (from patch faces to destination mesh objects)
+        const vectorField& offsets() const
+        {
+            return offsets_;
+        }
+
+        //- Return reference to the parallel distribution map
+        const mapDistribute& map() const
+        {
+            if (mapPtr_.empty())
+            {
+                calcMapping();
+            }
+            return mapPtr_();
+        }
+
+        //- Return reference to the AMI interpolator
+        const AMIPatchToPatchInterpolation& AMI(bool forceUpdate = false) const
+        {
+            if (forceUpdate || AMIPtr_.empty())
+            {
+                calcAMI();
+            }
+
+            return AMIPtr_();
+        }
+
+        //- Return a pointer to the AMI projection surface
+        const autoPtr<Foam::searchableSurface>& surfPtr() const;
+
+        //- Cached sampleRegion != mesh.name()
+        bool sameRegion() const
+        {
+            return sameRegion_;
+        }
+
+        //- Get the region mesh
+        const polyMesh& sampleMesh() const;
+
+        //- Get the patch on the region
+        const polyPatch& samplePolyPatch() const;
+
+        //- Get the sample points
+        tmp<pointField> samplePoints() const;
+
+        //- Write as a dictionary
+        virtual void write(Ostream&) const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/AMIInterpolation/patches/mapped/mappedPolyPatch/mappedPolyPatch.C b/src/AMIInterpolation/patches/mapped/mappedPolyPatch/mappedPolyPatch.C
new file mode 100644
index 0000000000..c87303cb0e
--- /dev/null
+++ b/src/AMIInterpolation/patches/mapped/mappedPolyPatch/mappedPolyPatch.C
@@ -0,0 +1,222 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "mappedPolyPatch.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(mappedPolyPatch, 0);
+
+    addToRunTimeSelectionTable(polyPatch, mappedPolyPatch, word);
+    addToRunTimeSelectionTable(polyPatch, mappedPolyPatch, dictionary);
+}
+
+
+// * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * * * * * //
+
+Foam::mappedPolyPatch::mappedPolyPatch
+(
+    const word& name,
+    const label size,
+    const label start,
+    const label index,
+    const polyBoundaryMesh& bm
+)
+:
+    polyPatch(name, size, start, index, bm),
+    mappedPatchBase(static_cast<const polyPatch&>(*this))
+{}
+
+
+Foam::mappedPolyPatch::mappedPolyPatch
+(
+    const word& name,
+    const label size,
+    const label start,
+    const label index,
+    const word& sampleRegion,
+    const mappedPatchBase::sampleMode mode,
+    const word& samplePatch,
+    const vectorField& offset,
+    const polyBoundaryMesh& bm
+)
+:
+    polyPatch(name, size, start, index, bm),
+    mappedPatchBase
+    (
+        static_cast<const polyPatch&>(*this),
+        sampleRegion,
+        mode,
+        samplePatch,
+        offset
+    )
+{}
+
+
+Foam::mappedPolyPatch::mappedPolyPatch
+(
+    const word& name,
+    const label size,
+    const label start,
+    const label index,
+    const word& sampleRegion,
+    const mappedPatchBase::sampleMode mode,
+    const word& samplePatch,
+    const vector& offset,
+    const polyBoundaryMesh& bm
+)
+:
+    polyPatch(name, size, start, index, bm),
+    mappedPatchBase
+    (
+        static_cast<const polyPatch&>(*this),
+        sampleRegion,
+        mode,
+        samplePatch,
+        offset
+    )
+{}
+
+
+Foam::mappedPolyPatch::mappedPolyPatch
+(
+    const word& name,
+    const dictionary& dict,
+    const label index,
+    const polyBoundaryMesh& bm
+)
+:
+    polyPatch(name, dict, index, bm),
+    mappedPatchBase(*this, dict)
+{}
+
+
+Foam::mappedPolyPatch::mappedPolyPatch
+(
+    const mappedPolyPatch& pp,
+    const polyBoundaryMesh& bm
+)
+:
+    polyPatch(pp, bm),
+    mappedPatchBase(*this, pp)
+{}
+
+
+Foam::mappedPolyPatch::mappedPolyPatch
+(
+    const mappedPolyPatch& pp,
+    const polyBoundaryMesh& bm,
+    const label index,
+    const label newSize,
+    const label newStart
+)
+:
+    polyPatch(pp, bm, index, newSize, newStart),
+    mappedPatchBase(*this, pp)
+{}
+
+
+Foam::mappedPolyPatch::mappedPolyPatch
+(
+    const mappedPolyPatch& pp,
+    const polyBoundaryMesh& bm,
+    const label index,
+    const labelUList& mapAddressing,
+    const label newStart
+)
+:
+    polyPatch(pp, bm, index, mapAddressing, newStart),
+    mappedPatchBase(*this, pp, mapAddressing)
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::mappedPolyPatch::~mappedPolyPatch()
+{
+    mappedPatchBase::clearOut();
+}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+void Foam::mappedPolyPatch::initGeometry(PstreamBuffers& pBufs)
+{
+    polyPatch::initGeometry(pBufs);
+}
+
+
+void Foam::mappedPolyPatch::calcGeometry(PstreamBuffers& pBufs)
+{
+    polyPatch::calcGeometry(pBufs);
+    mappedPatchBase::clearOut();
+}
+
+
+void Foam::mappedPolyPatch::initMovePoints
+(
+    PstreamBuffers& pBufs,
+    const pointField& p
+)
+{
+    polyPatch::initMovePoints(pBufs, p);
+}
+
+
+void Foam::mappedPolyPatch::movePoints
+(
+    PstreamBuffers& pBufs,
+    const pointField& p
+)
+{
+    polyPatch::movePoints(pBufs, p);
+    mappedPatchBase::clearOut();
+}
+
+
+void Foam::mappedPolyPatch::initUpdateMesh(PstreamBuffers& pBufs)
+{
+    polyPatch::initUpdateMesh(pBufs);
+}
+
+
+void Foam::mappedPolyPatch::updateMesh(PstreamBuffers& pBufs)
+{
+    polyPatch::updateMesh(pBufs);
+    mappedPatchBase::clearOut();
+}
+
+
+void Foam::mappedPolyPatch::write(Ostream& os) const
+{
+    polyPatch::write(os);
+    mappedPatchBase::write(os);
+}
+
+
+// ************************************************************************* //
diff --git a/src/AMIInterpolation/patches/mapped/mappedPolyPatch/mappedPolyPatch.H b/src/AMIInterpolation/patches/mapped/mappedPolyPatch/mappedPolyPatch.H
new file mode 100644
index 0000000000..32cbd1a29a
--- /dev/null
+++ b/src/AMIInterpolation/patches/mapped/mappedPolyPatch/mappedPolyPatch.H
@@ -0,0 +1,233 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::mappedPolyPatch
+
+Description
+    Determines a mapping between patch face centres and mesh cell or face
+    centres and processors they're on.
+
+Note
+    Storage is not optimal. It stores all face centres and cells on all
+    processors to keep the addressing calculation simple.
+
+SourceFiles
+    mappedPolyPatch.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef mappedPolyPatch_H
+#define mappedPolyPatch_H
+
+#include "polyPatch.H"
+#include "mappedPatchBase.H"
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+class polyMesh;
+
+/*---------------------------------------------------------------------------*\
+                      Class mappedPolyPatch Declaration
+\*---------------------------------------------------------------------------*/
+
+class mappedPolyPatch
+:
+    public polyPatch,
+    public mappedPatchBase
+{
+
+protected:
+
+        //- 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("mappedPatch");
+
+
+    // Constructors
+
+        //- Construct from components
+        mappedPolyPatch
+        (
+            const word& name,
+            const label size,
+            const label start,
+            const label index,
+            const polyBoundaryMesh& bm
+        );
+
+        //- Construct from components
+        mappedPolyPatch
+        (
+            const word& name,
+            const label size,
+            const label start,
+            const label index,
+            const word& sampleRegion,
+            const mappedPatchBase::sampleMode mode,
+            const word& samplePatch,
+            const vectorField& offset,
+            const polyBoundaryMesh& bm
+        );
+
+        //- Construct from components. Uniform offset.
+        mappedPolyPatch
+        (
+            const word& name,
+            const label size,
+            const label start,
+            const label index,
+            const word& sampleRegion,
+            const mappedPatchBase::sampleMode mode,
+            const word& samplePatch,
+            const vector& offset,
+            const polyBoundaryMesh& bm
+        );
+
+        //- Construct from dictionary
+        mappedPolyPatch
+        (
+            const word& name,
+            const dictionary& dict,
+            const label index,
+            const polyBoundaryMesh& bm
+        );
+
+        //- Construct as copy, resetting the boundary mesh
+        mappedPolyPatch
+        (
+            const mappedPolyPatch&,
+            const polyBoundaryMesh&
+        );
+
+        //- Construct given the original patch and resetting the
+        //  face list and boundary mesh information
+        mappedPolyPatch
+        (
+            const mappedPolyPatch& pp,
+            const polyBoundaryMesh& bm,
+            const label index,
+            const label newSize,
+            const label newStart
+        );
+
+        //- Construct given the original patch and a map
+        mappedPolyPatch
+        (
+            const mappedPolyPatch& 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 mappedPolyPatch(*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 mappedPolyPatch(*this, bm, index, newSize, newStart)
+            );
+        }
+
+        //- 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 mappedPolyPatch
+                (
+                    *this,
+                    bm,
+                    index,
+                    mapAddressing,
+                    newStart
+                )
+            );
+        }
+
+
+    //- Destructor
+    virtual ~mappedPolyPatch();
+
+
+    // Member functions
+
+        //- Write the polyPatch data as a dictionary
+        virtual void write(Ostream&) const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

From c9ac85756c787dbd7de2454abe653b3bf0dd21b3 Mon Sep 17 00:00:00 2001
From: andy <andy>
Date: Fri, 2 Sep 2011 18:03:32 +0100
Subject: [PATCH 30/45] ENH: Relocated AMIInterpolation class

---
 src/AMIInterpolation/{ => AMIInterpolation}/AMIInterpolation.C  | 0
 src/AMIInterpolation/{ => AMIInterpolation}/AMIInterpolation.H  | 0
 src/AMIInterpolation/{ => AMIInterpolation}/AMIInterpolationI.H | 0
 .../{ => AMIInterpolation}/AMIInterpolationName.C               | 0
 .../{ => AMIInterpolation}/AMIPatchToPatchInterpolation.H       | 0
 src/AMIInterpolation/Make/files                                 | 2 +-
 6 files changed, 1 insertion(+), 1 deletion(-)
 rename src/AMIInterpolation/{ => AMIInterpolation}/AMIInterpolation.C (100%)
 rename src/AMIInterpolation/{ => AMIInterpolation}/AMIInterpolation.H (100%)
 rename src/AMIInterpolation/{ => AMIInterpolation}/AMIInterpolationI.H (100%)
 rename src/AMIInterpolation/{ => AMIInterpolation}/AMIInterpolationName.C (100%)
 rename src/AMIInterpolation/{ => AMIInterpolation}/AMIPatchToPatchInterpolation.H (100%)

diff --git a/src/AMIInterpolation/AMIInterpolation.C b/src/AMIInterpolation/AMIInterpolation/AMIInterpolation.C
similarity index 100%
rename from src/AMIInterpolation/AMIInterpolation.C
rename to src/AMIInterpolation/AMIInterpolation/AMIInterpolation.C
diff --git a/src/AMIInterpolation/AMIInterpolation.H b/src/AMIInterpolation/AMIInterpolation/AMIInterpolation.H
similarity index 100%
rename from src/AMIInterpolation/AMIInterpolation.H
rename to src/AMIInterpolation/AMIInterpolation/AMIInterpolation.H
diff --git a/src/AMIInterpolation/AMIInterpolationI.H b/src/AMIInterpolation/AMIInterpolation/AMIInterpolationI.H
similarity index 100%
rename from src/AMIInterpolation/AMIInterpolationI.H
rename to src/AMIInterpolation/AMIInterpolation/AMIInterpolationI.H
diff --git a/src/AMIInterpolation/AMIInterpolationName.C b/src/AMIInterpolation/AMIInterpolation/AMIInterpolationName.C
similarity index 100%
rename from src/AMIInterpolation/AMIInterpolationName.C
rename to src/AMIInterpolation/AMIInterpolation/AMIInterpolationName.C
diff --git a/src/AMIInterpolation/AMIPatchToPatchInterpolation.H b/src/AMIInterpolation/AMIInterpolation/AMIPatchToPatchInterpolation.H
similarity index 100%
rename from src/AMIInterpolation/AMIPatchToPatchInterpolation.H
rename to src/AMIInterpolation/AMIInterpolation/AMIPatchToPatchInterpolation.H
diff --git a/src/AMIInterpolation/Make/files b/src/AMIInterpolation/Make/files
index 92c760a4b2..ef587c3e5c 100644
--- a/src/AMIInterpolation/Make/files
+++ b/src/AMIInterpolation/Make/files
@@ -1,4 +1,4 @@
-AMIInterpolationName.C
+AMIInterpolation/AMIInterpolationName.C
 faceAreaIntersect/faceAreaIntersect.C
 
 CYCPATCHES=patches/cyclic

From e2ad344e2f279b5a61b1a1d4062424bb5522a0c9 Mon Sep 17 00:00:00 2001
From: andy <andy>
Date: Fri, 2 Sep 2011 18:05:25 +0100
Subject: [PATCH 31/45] ENH: Added new AMIInterpolation constructor

---
 .../AMIInterpolation/AMIInterpolation.C       | 28 +++++++++++++++++++
 .../AMIInterpolation/AMIInterpolation.H       |  8 ++++++
 2 files changed, 36 insertions(+)

diff --git a/src/AMIInterpolation/AMIInterpolation/AMIInterpolation.C b/src/AMIInterpolation/AMIInterpolation/AMIInterpolation.C
index ca265b4e25..a0bf7fc15f 100644
--- a/src/AMIInterpolation/AMIInterpolation/AMIInterpolation.C
+++ b/src/AMIInterpolation/AMIInterpolation/AMIInterpolation.C
@@ -1023,6 +1023,34 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::normaliseWeights
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
+template<class SourcePatch, class TargetPatch>
+Foam::AMIInterpolation<SourcePatch, TargetPatch>::AMIInterpolation
+(
+    const SourcePatch& srcPatch,
+    const TargetPatch& tgtPatch,
+    const faceAreaIntersect::triangulationMode& triMode
+)
+:
+    srcAddress_(),
+    srcWeights_(),
+    tgtAddress_(),
+    tgtWeights_(),
+    startSeedI_(0),
+    triMode_(triMode),
+    srcMapPtr_(NULL),
+    tgtMapPtr_(NULL)
+{
+    label srcSize = returnReduce(srcPatch.size(), sumOp<label>());
+    label tgtSize = returnReduce(tgtPatch.size(), sumOp<label>());
+
+    Info<< "AMI: Creating addressing and weights between "
+        << srcSize << " source faces and " << tgtSize << " target faces"
+        << endl;
+
+    update(srcPatch, tgtPatch);
+}
+
+
 template<class SourcePatch, class TargetPatch>
 Foam::AMIInterpolation<SourcePatch, TargetPatch>::AMIInterpolation
 (
diff --git a/src/AMIInterpolation/AMIInterpolation/AMIInterpolation.H b/src/AMIInterpolation/AMIInterpolation/AMIInterpolation.H
index 3e7e93831a..8ad3be39ba 100644
--- a/src/AMIInterpolation/AMIInterpolation/AMIInterpolation.H
+++ b/src/AMIInterpolation/AMIInterpolation/AMIInterpolation.H
@@ -284,6 +284,14 @@ public:
 
         //- Construct from components
         AMIInterpolation
+        (
+            const SourcePatch& srcPatch,
+            const TargetPatch& tgtPatch,
+            const faceAreaIntersect::triangulationMode& triMode
+        );
+
+        //- Construct from components, with projection surface
+        AMIInterpolation
         (
             const SourcePatch& srcPatch,
             const TargetPatch& tgtPatch,

From ac3e55e1b41e28d66259cdaefbeae4bf41d49e79 Mon Sep 17 00:00:00 2001
From: andy <andy>
Date: Fri, 2 Sep 2011 18:07:08 +0100
Subject: [PATCH 32/45] STYLE: limit to 80 char width

---
 .../cyclic/cyclicAMIFvPatchField/cyclicAMIFvPatchField.H       | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/AMIInterpolation/patches/cyclic/cyclicAMIFvPatchField/cyclicAMIFvPatchField.H b/src/AMIInterpolation/patches/cyclic/cyclicAMIFvPatchField/cyclicAMIFvPatchField.H
index 653d50ed37..9a4e5f6b4c 100644
--- a/src/AMIInterpolation/patches/cyclic/cyclicAMIFvPatchField/cyclicAMIFvPatchField.H
+++ b/src/AMIInterpolation/patches/cyclic/cyclicAMIFvPatchField/cyclicAMIFvPatchField.H
@@ -170,7 +170,8 @@ public:
             //- Does the patch field perform the transformation
             virtual bool doTransform() const
             {
-                return !(cyclicAMIPatch_.parallel() || pTraits<Type>::rank == 0);
+                return
+                    !(cyclicAMIPatch_.parallel() || pTraits<Type>::rank == 0);
             }
 
             //- Return face transformation tensor

From f3a9281c47794e3436891f1f963061ac5c5fa65f Mon Sep 17 00:00:00 2001
From: andy <andy>
Date: Mon, 5 Sep 2011 11:27:12 +0100
Subject: [PATCH 33/45] ENH: Added further mapped boundary conditions

---
 src/AMIInterpolation/Make/files               |   6 +
 .../mappedField/mappedFieldFvPatchField.C     | 340 ++++++++++++++++++
 .../mappedField/mappedFieldFvPatchField.H     | 201 +++++++++++
 .../mappedField/mappedFieldFvPatchFields.C    |  43 +++
 .../mappedField/mappedFieldFvPatchFields.H    |  49 +++
 .../mappedField/mappedFieldFvPatchFieldsFwd.H |  50 +++
 .../mappedFixedValueFvPatchField.C            |   4 +-
 .../mapped/mappedFvPatch/mappedWallFvPatch.C  |  37 ++
 .../mapped/mappedFvPatch/mappedWallFvPatch.H  |  83 +++++
 .../mapped/mappedPolyPatch/mappedPatchBase.C  |  18 +-
 .../mapped/mappedPolyPatch/mappedPatchBase.H  |  28 +-
 .../mappedVariableThicknessWallPolyPatch.C    | 172 +++++++++
 .../mappedVariableThicknessWallPolyPatch.H    | 236 ++++++++++++
 .../mappedPolyPatch/mappedWallPointPatch.C    |  51 +++
 .../mappedPolyPatch/mappedWallPointPatch.H    |  83 +++++
 .../mappedPolyPatch/mappedWallPolyPatch.C     | 227 ++++++++++++
 .../mappedPolyPatch/mappedWallPolyPatch.H     | 240 +++++++++++++
 17 files changed, 1854 insertions(+), 14 deletions(-)
 create mode 100644 src/AMIInterpolation/patches/mapped/mappedField/mappedFieldFvPatchField.C
 create mode 100644 src/AMIInterpolation/patches/mapped/mappedField/mappedFieldFvPatchField.H
 create mode 100644 src/AMIInterpolation/patches/mapped/mappedField/mappedFieldFvPatchFields.C
 create mode 100644 src/AMIInterpolation/patches/mapped/mappedField/mappedFieldFvPatchFields.H
 create mode 100644 src/AMIInterpolation/patches/mapped/mappedField/mappedFieldFvPatchFieldsFwd.H
 create mode 100644 src/AMIInterpolation/patches/mapped/mappedFvPatch/mappedWallFvPatch.C
 create mode 100644 src/AMIInterpolation/patches/mapped/mappedFvPatch/mappedWallFvPatch.H
 create mode 100644 src/AMIInterpolation/patches/mapped/mappedPolyPatch/mappedVariableThicknessWallPolyPatch.C
 create mode 100644 src/AMIInterpolation/patches/mapped/mappedPolyPatch/mappedVariableThicknessWallPolyPatch.H
 create mode 100644 src/AMIInterpolation/patches/mapped/mappedPolyPatch/mappedWallPointPatch.C
 create mode 100644 src/AMIInterpolation/patches/mapped/mappedPolyPatch/mappedWallPointPatch.H
 create mode 100644 src/AMIInterpolation/patches/mapped/mappedPolyPatch/mappedWallPolyPatch.C
 create mode 100644 src/AMIInterpolation/patches/mapped/mappedPolyPatch/mappedWallPolyPatch.H

diff --git a/src/AMIInterpolation/Make/files b/src/AMIInterpolation/Make/files
index ef587c3e5c..3470ea45d0 100644
--- a/src/AMIInterpolation/Make/files
+++ b/src/AMIInterpolation/Make/files
@@ -13,9 +13,15 @@ $(CYCPATCHES)/cyclicAMIPointPatch/cyclicAMIPointPatch.C
 MAPPATCHES=patches/mapped
 $(MAPPATCHES)/mappedPolyPatch/mappedPatchBase.C
 $(MAPPATCHES)/mappedPolyPatch/mappedPolyPatch.C
+$(MAPPATCHES)/mappedPolyPatch/mappedWallPolyPatch.C
+$(MAPPATCHES)/mappedPolyPatch/mappedVariableThicknessWallPolyPatch.C
+$(MAPPATCHES)/mappedPolyPatch/mappedWallPointPatch.C
 $(MAPPATCHES)/mappedFvPatch/mappedFvPatch.C
+$(MAPPATCHES)/mappedFvPatch/mappedWallFvPatch.C
 $(MAPPATCHES)/mappedFixedValue/mappedFixedValueFvPatchFields.C
 $(MAPPATCHES)/mappedFixedInternalValue/mappedFixedInternalValueFvPatchFields.C
 $(MAPPATCHES)/mappedFixedPushedInternalValue/mappedFixedPushedInternalValueFvPatchFields.C
 
+$(MAPPATCHES)/mappedField/mappedFieldFvPatchFields.C
+
 LIB = $(FOAM_USER_LIBBIN)/libAMIInterpolation
diff --git a/src/AMIInterpolation/patches/mapped/mappedField/mappedFieldFvPatchField.C b/src/AMIInterpolation/patches/mapped/mappedField/mappedFieldFvPatchField.C
new file mode 100644
index 0000000000..b6056eb444
--- /dev/null
+++ b/src/AMIInterpolation/patches/mapped/mappedField/mappedFieldFvPatchField.C
@@ -0,0 +1,340 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "mappedFieldFvPatchField.H"
+
+#include "volFields.H"
+#include "interpolationCell.H"
+#include "mapDistribute.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+template<class Type>
+mappedFieldFvPatchField<Type>::mappedFieldFvPatchField
+(
+    const fvPatch& p,
+    const DimensionedField<Type, volMesh>& iF
+)
+:
+    mappedPatchBase(p.patch()),
+    fixedValueFvPatchField<Type>(p, iF),
+    fieldName_(iF.name()),
+    setAverage_(false),
+    average_(pTraits<Type>::zero)
+{}
+
+
+template<class Type>
+mappedFieldFvPatchField<Type>::mappedFieldFvPatchField
+(
+    const mappedFieldFvPatchField<Type>& ptf,
+    const fvPatch& p,
+    const DimensionedField<Type, volMesh>& iF,
+    const fvPatchFieldMapper& mapper
+)
+:
+    mappedPatchBase(p.patch(), ptf),
+    fixedValueFvPatchField<Type>(ptf, p, iF, mapper),
+    fieldName_(ptf.fieldName_),
+    setAverage_(ptf.setAverage_),
+    average_(ptf.average_)
+{}
+
+
+template<class Type>
+mappedFieldFvPatchField<Type>::mappedFieldFvPatchField
+(
+    const fvPatch& p,
+    const DimensionedField<Type, volMesh>& iF,
+    const dictionary& dict
+)
+:
+    mappedPatchBase(p.patch(), dict),
+    fixedValueFvPatchField<Type>(p, iF, dict),
+    fieldName_(dict.template lookupOrDefault<word>("fieldName", iF.name())),
+    setAverage_(readBool(dict.lookup("setAverage"))),
+    average_(pTraits<Type>(dict.lookup("average")))
+{}
+
+
+template<class Type>
+mappedFieldFvPatchField<Type>::mappedFieldFvPatchField
+(
+    const fvPatch& p,
+    const DimensionedField<Type, volMesh>& iF,
+
+    // mappedPatchBase
+    const word& sampleRegion,
+    const sampleMode sampleMode,
+    const word& samplePatch,
+    const scalar distance,
+
+    // My settings
+    const word& fieldName,
+    const bool setAverage,
+    const Type average
+)
+:
+    mappedPatchBase
+    (
+        p.patch(),
+        sampleRegion,
+        sampleMode,
+        samplePatch,
+        distance
+    ),
+    fixedValueFvPatchField<Type>(p, iF),
+    fieldName_(fieldName),
+    setAverage_(setAverage),
+    average_(average)
+{}
+
+
+template<class Type>
+mappedFieldFvPatchField<Type>::mappedFieldFvPatchField
+(
+    const mappedFieldFvPatchField<Type>& ptf
+)
+:
+    mappedPatchBase(ptf.patch().patch(), ptf),
+    fixedValueFvPatchField<Type>(ptf),
+    fieldName_(ptf.fieldName_),
+    setAverage_(ptf.setAverage_),
+    average_(ptf.average_)
+{}
+
+
+template<class Type>
+mappedFieldFvPatchField<Type>::mappedFieldFvPatchField
+(
+    const mappedFieldFvPatchField<Type>& ptf,
+    const DimensionedField<Type, volMesh>& iF
+)
+:
+    mappedPatchBase(ptf.patch().patch(), ptf),
+    fixedValueFvPatchField<Type>(ptf, iF),
+    fieldName_(ptf.fieldName_),
+    setAverage_(ptf.setAverage_),
+    average_(ptf.average_)
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+template<class Type>
+const GeometricField<Type, fvPatchField, volMesh>&
+mappedFieldFvPatchField<Type>::sampleField() const
+{
+    typedef GeometricField<Type, fvPatchField, volMesh> fieldType;
+
+    const fvMesh& nbrMesh = refCast<const fvMesh>(sampleMesh());
+
+    if (sameRegion())
+    {
+        if (fieldName_ == this->dimensionedInternalField().name())
+        {
+            // Optimisation: bypass field lookup
+            return
+                dynamic_cast<const fieldType&>
+                (
+                    this->dimensionedInternalField()
+                );
+        }
+        else
+        {
+            const fvMesh& thisMesh = this->patch().boundaryMesh().mesh();
+            return thisMesh.template lookupObject<fieldType>(fieldName_);
+        }
+    }
+    else
+    {
+        return nbrMesh.template lookupObject<fieldType>(fieldName_);
+    }
+}
+
+
+template<class Type>
+void mappedFieldFvPatchField<Type>::updateCoeffs()
+{
+    if (this->updated())
+    {
+        return;
+    }
+
+    typedef GeometricField<Type, fvPatchField, volMesh> fieldType;
+
+    const fvMesh& nbrMesh = refCast<const fvMesh>(sampleMesh());
+
+    // Result of obtaining remote values
+    Field<Type> newValues;
+
+    switch (mode())
+    {
+        case NEARESTCELL:
+        {
+            const mapDistribute& distMap = mappedPatchBase::map();
+            newValues = sampleField();
+
+            distMap.distribute(newValues);
+
+            break;
+        }
+        case NEARESTPATCHFACE:
+        {
+            const label nbrPatchID =
+                nbrMesh.boundaryMesh().findPatchID(samplePatch());
+            if (nbrPatchID < 0)
+            {
+                FatalErrorIn
+                (
+                    "void mappedFieldFvPatchField<Type>::updateCoeffs()"
+                )<< "Unable to find sample patch " << samplePatch()
+                 << " in region " << sampleRegion()
+                 << " for patch " << this->patch().name() << nl
+                 << abort(FatalError);
+            }
+
+            const fieldType& nbrField = sampleField();
+
+            const mapDistribute& distMap = mappedPatchBase::map();
+            newValues = nbrField.boundaryField()[nbrPatchID];
+            distMap.distribute(newValues);
+
+            break;
+        }
+        case mappedPatchBase::NEARESTPATCHFACEAMI:
+        {
+            const label nbrPatchID =
+                nbrMesh.boundaryMesh().findPatchID(samplePatch());
+
+            if (nbrPatchID < 0)
+            {
+                FatalErrorIn
+                (
+                    "void mappedFixedValueFvPatchField<Type>::updateCoeffs()"
+                )<< "Unable to find sample patch " << samplePatch()
+                 << " in region " << sampleRegion()
+                 << " for patch " << this->patch().name() << nl
+                 << abort(FatalError);
+            }
+
+//            const fieldType& nbrField = sampleField();
+//            newValues = mpp.AMI().interpolateToSource(nbrField);
+
+            notImplemented
+            (
+                "void mappedFieldFvPatchField<Type>::updateCoeffs() "
+                "with mappedPatchBase::NEARESTPATCHFACEAMI"
+            );
+
+            break;
+        }
+        case NEARESTFACE:
+        {
+            Field<Type> allValues(nbrMesh.nFaces(), pTraits<Type>::zero);
+
+            const fieldType& nbrField = sampleField();
+
+            forAll(nbrField.boundaryField(), patchI)
+            {
+                const fvPatchField<Type>& pf =
+                    nbrField.boundaryField()[patchI];
+                label faceStart = pf.patch().patch().start();
+
+                forAll(pf, faceI)
+                {
+                    allValues[faceStart++] = pf[faceI];
+                }
+            }
+
+            const mapDistribute& distMap = mappedPatchBase::map();
+            distMap.distribute(allValues);
+
+            newValues.transfer(allValues);
+
+            break;
+        }
+        default:
+        {
+            FatalErrorIn("mappedFieldFvPatchField<Type>::updateCoeffs()")
+                << "Unknown sampling mode: " << mode()
+                << nl << abort(FatalError);
+        }
+    }
+
+    if (setAverage_)
+    {
+        Type averagePsi =
+            gSum(this->patch().magSf()*newValues)
+           /gSum(this->patch().magSf());
+
+        if (mag(averagePsi)/mag(average_) > 0.5)
+        {
+            newValues *= mag(average_)/mag(averagePsi);
+        }
+        else
+        {
+            newValues += (average_ - averagePsi);
+        }
+    }
+
+    this->operator==(newValues);
+
+    if (debug)
+    {
+        Info<< "operating on field:" << this->dimensionedInternalField().name()
+            << " patch:" << this->patch().name()
+            << "  avg:" << gAverage(*this)
+            << "  min:" << gMin(*this)
+            << "  max:" << gMax(*this)
+            << endl;
+    }
+
+    fixedValueFvPatchField<Type>::updateCoeffs();
+}
+
+
+template<class Type>
+void mappedFieldFvPatchField<Type>::write(Ostream& os) const
+{
+    fvPatchField<Type>::write(os);
+    mappedPatchBase::write(os);
+    os.writeKeyword("fieldName") << fieldName_ << token::END_STATEMENT << nl;
+    os.writeKeyword("setAverage") << setAverage_ << token::END_STATEMENT << nl;
+    os.writeKeyword("average") << average_ << token::END_STATEMENT << nl;
+    this->writeEntry("value", os);
+}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// ************************************************************************* //
diff --git a/src/AMIInterpolation/patches/mapped/mappedField/mappedFieldFvPatchField.H b/src/AMIInterpolation/patches/mapped/mappedField/mappedFieldFvPatchField.H
new file mode 100644
index 0000000000..cc75b17361
--- /dev/null
+++ b/src/AMIInterpolation/patches/mapped/mappedField/mappedFieldFvPatchField.H
@@ -0,0 +1,201 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::mappedFieldFvPatchField
+
+Description
+    Self-contained version of mapped. Does not use information on
+    patch, instead holds it locally (and possibly duplicate) so use
+    normal mapped in preference and only use this if you cannot
+    change the underlying patch type to mapped.
+
+SourceFiles
+    mappedFieldFvPatchField.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef mappedFieldFvPatchField_H
+#define mappedFieldFvPatchField_H
+
+#include "mappedPatchBase.H"
+#include "fixedValueFvPatchFields.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                 Class mappedFieldFvPatchField Declaration
+\*---------------------------------------------------------------------------*/
+
+template<class Type>
+class mappedFieldFvPatchField
+:
+    public mappedPatchBase,
+    public fixedValueFvPatchField<Type>
+{
+    // Private data
+
+        //- Name of field to sample - defaults to field associated with this
+        //  patchField if not specified
+        word fieldName_;
+
+        //- If true adjust the mapped field to maintain average value average_
+        const bool setAverage_;
+
+        //- Average value the mapped field is adjusted to maintain if
+        //  setAverage_ is set true
+        const Type average_;
+
+
+    // Private Member Functions
+
+        //- Field to sample. Either on my or nbr mesh
+        const GeometricField<Type, fvPatchField, volMesh>& sampleField() const;
+
+
+public:
+
+    //- Runtime type information
+    TypeName("mappedField");
+
+
+    // Constructors
+
+        //- Construct from patch and internal field
+        mappedFieldFvPatchField
+        (
+            const fvPatch&,
+            const DimensionedField<Type, volMesh>&
+        );
+
+        //- Construct from patch, internal field and dictionary
+        mappedFieldFvPatchField
+        (
+            const fvPatch&,
+            const DimensionedField<Type, volMesh>&,
+            const dictionary&
+        );
+
+        //- Construct from patch, internal field and distance for normal type
+        //  sampling
+        mappedFieldFvPatchField
+        (
+            const fvPatch&,
+            const DimensionedField<Type, volMesh>&,
+
+            // mappedPatchBase
+            const word& sampleRegion,
+            const sampleMode sampleMode,
+            const word& samplePatch,
+            const scalar distance,
+
+            // My settings
+            const word& fieldName,
+            const bool setAverage,
+            const Type average
+        );
+
+        //- Construct by mapping given
+        //  mappedFieldFvPatchField
+        //  onto a new patch
+        mappedFieldFvPatchField
+        (
+            const mappedFieldFvPatchField<Type>&,
+            const fvPatch&,
+            const DimensionedField<Type, volMesh>&,
+            const fvPatchFieldMapper&
+        );
+
+        //- Construct as copy
+        mappedFieldFvPatchField
+        (
+            const mappedFieldFvPatchField<Type>&
+        );
+
+        //- Construct and return a clone
+        virtual tmp<fvPatchField<Type> > clone() const
+        {
+            return tmp<fvPatchField<Type> >
+            (
+                new mappedFieldFvPatchField<Type>
+                (
+                    *this
+                )
+            );
+        }
+
+        //- Construct as copy setting internal field reference
+        mappedFieldFvPatchField
+        (
+            const mappedFieldFvPatchField<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 mappedFieldFvPatchField<Type>
+                (
+                    *this,
+                    iF
+                )
+            );
+        }
+
+
+    // Member functions
+
+        // Evaluation functions
+
+            //- Update the coefficients associated with the patch field
+            virtual void updateCoeffs();
+
+
+        //- Write
+        virtual void write(Ostream&) const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+#   include "mappedFieldFvPatchField.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/AMIInterpolation/patches/mapped/mappedField/mappedFieldFvPatchFields.C b/src/AMIInterpolation/patches/mapped/mappedField/mappedFieldFvPatchFields.C
new file mode 100644
index 0000000000..5810193951
--- /dev/null
+++ b/src/AMIInterpolation/patches/mapped/mappedField/mappedFieldFvPatchFields.C
@@ -0,0 +1,43 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "mappedFieldFvPatchFields.H"
+#include "volMesh.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+makePatchFields(mappedField);
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// ************************************************************************* //
diff --git a/src/AMIInterpolation/patches/mapped/mappedField/mappedFieldFvPatchFields.H b/src/AMIInterpolation/patches/mapped/mappedField/mappedFieldFvPatchFields.H
new file mode 100644
index 0000000000..34c91ae019
--- /dev/null
+++ b/src/AMIInterpolation/patches/mapped/mappedField/mappedFieldFvPatchFields.H
@@ -0,0 +1,49 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef mappedFieldFvPatchFields_H
+#define mappedFieldFvPatchFields_H
+
+#include "mappedFieldFvPatchField.H"
+#include "fieldTypes.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+makePatchTypeFieldTypedefs(mappedField)
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/AMIInterpolation/patches/mapped/mappedField/mappedFieldFvPatchFieldsFwd.H b/src/AMIInterpolation/patches/mapped/mappedField/mappedFieldFvPatchFieldsFwd.H
new file mode 100644
index 0000000000..42401aab70
--- /dev/null
+++ b/src/AMIInterpolation/patches/mapped/mappedField/mappedFieldFvPatchFieldsFwd.H
@@ -0,0 +1,50 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef mappedFieldFvPatchFieldsFwd_H
+#define mappedFieldFvPatchFieldsFwd_H
+
+#include "fieldTypes.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+template<class Type> class mappedFieldFvPatchField;
+
+makePatchTypeFieldTypedefs(mappedField)
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/AMIInterpolation/patches/mapped/mappedFixedValue/mappedFixedValueFvPatchField.C b/src/AMIInterpolation/patches/mapped/mappedFixedValue/mappedFixedValueFvPatchField.C
index 55734e58b0..1f46bf8dbb 100644
--- a/src/AMIInterpolation/patches/mapped/mappedFixedValue/mappedFixedValueFvPatchField.C
+++ b/src/AMIInterpolation/patches/mapped/mappedFixedValue/mappedFixedValueFvPatchField.C
@@ -319,8 +319,10 @@ void mappedFixedValueFvPatchField<Type>::updateCoeffs()
             }
 
             const fieldType& nbrField = sampleField();
+            newValues = nbrField.boundaryField()[nbrPatchID];
+
+            newValues = mpp.AMI().interpolateToSource(newValues);
 
-            newValues = mpp.AMI().interpolateToSource(nbrField);
             break;
         }
         case mappedPatchBase::NEARESTFACE:
diff --git a/src/AMIInterpolation/patches/mapped/mappedFvPatch/mappedWallFvPatch.C b/src/AMIInterpolation/patches/mapped/mappedFvPatch/mappedWallFvPatch.C
new file mode 100644
index 0000000000..419b47a7bc
--- /dev/null
+++ b/src/AMIInterpolation/patches/mapped/mappedFvPatch/mappedWallFvPatch.C
@@ -0,0 +1,37 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "mappedWallFvPatch.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(mappedWallFvPatch, 0);
+    addToRunTimeSelectionTable(fvPatch, mappedWallFvPatch, polyPatch);
+}
+
+// ************************************************************************* //
diff --git a/src/AMIInterpolation/patches/mapped/mappedFvPatch/mappedWallFvPatch.H b/src/AMIInterpolation/patches/mapped/mappedFvPatch/mappedWallFvPatch.H
new file mode 100644
index 0000000000..4bc0c0d7fc
--- /dev/null
+++ b/src/AMIInterpolation/patches/mapped/mappedFvPatch/mappedWallFvPatch.H
@@ -0,0 +1,83 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::mappedWallFvPatch
+
+Description
+    Foam::mappedWallFvPatch
+
+SourceFiles
+    mappedWallFvPatch.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef mappedWallFvPatch_H
+#define mappedWallFvPatch_H
+
+#include "wallFvPatch.H"
+#include "mappedWallPolyPatch.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                     Class mappedWallFvPatch Declaration
+\*---------------------------------------------------------------------------*/
+
+class mappedWallFvPatch
+:
+    public wallFvPatch
+{
+
+public:
+
+    //- Runtime type information
+    TypeName(mappedWallPolyPatch::typeName_());
+
+
+    // Constructors
+
+        //- Construct from components
+        mappedWallFvPatch
+        (
+            const polyPatch& patch,
+            const fvBoundaryMesh& bm
+        )
+        :
+            wallFvPatch(patch, bm)
+        {}
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/AMIInterpolation/patches/mapped/mappedPolyPatch/mappedPatchBase.C b/src/AMIInterpolation/patches/mapped/mappedPolyPatch/mappedPatchBase.C
index 084560d9a6..bd5dce024f 100644
--- a/src/AMIInterpolation/patches/mapped/mappedPolyPatch/mappedPatchBase.C
+++ b/src/AMIInterpolation/patches/mapped/mappedPolyPatch/mappedPatchBase.C
@@ -48,11 +48,12 @@ namespace Foam
     const char* Foam::NamedEnum
     <
         Foam::mappedPatchBase::sampleMode,
-        3
+        4
     >::names[] =
     {
         "nearestCell",
         "nearestPatchFace",
+        "nearestPatchFaceAMI",
         "nearestFace"
     };
 
@@ -70,7 +71,7 @@ namespace Foam
 }
 
 
-const Foam::NamedEnum<Foam::mappedPatchBase::sampleMode, 3>
+const Foam::NamedEnum<Foam::mappedPatchBase::sampleMode, 4>
     Foam::mappedPatchBase::sampleModeNames_;
 
 const Foam::NamedEnum<Foam::mappedPatchBase::offsetMode, 3>
@@ -432,7 +433,6 @@ void Foam::mappedPatchBase::calcMapping() const
     }
 
 
-
     // Get global list of all samples and the processor and face they come from.
     pointField samples;
     labelList patchFaceProcs;
@@ -572,7 +572,7 @@ void Foam::mappedPatchBase::calcMapping() const
 const Foam::autoPtr<Foam::searchableSurface>& Foam::mappedPatchBase::surfPtr()
 const
 {
-    word surfType(surfDict_.lookup("type"));
+    const word surfType(surfDict_.lookupOrDefault<word>("type", "none"));
 
     if (!surfPtr_.valid() && surfType != "none")
     {
@@ -610,9 +610,11 @@ void Foam::mappedPatchBase::calcAMI() const
     }
 
     AMIPtr_.clear();
-
+/*
     const polyPatch& nbr = samplePolyPatch();
-    pointField nbrPoints(samplePoints());
+
+//    pointField nbrPoints(samplePoints());
+    pointField nbrPoints(nbr.localPoints());
 
     if (debug)
     {
@@ -639,14 +641,14 @@ void Foam::mappedPatchBase::calcAMI() const
         OFstream osO(patch_.name() + "_ownerPatch.obj");
         meshTools::writeOBJ(osO, patch_.localFaces(), patch_.localPoints());
     }
-
+*/
     // Construct/apply AMI interpolation to determine addressing and weights
     AMIPtr_.reset
     (
         new AMIPatchToPatchInterpolation
         (
             patch_,
-            nbrPatch0,
+            samplePolyPatch(), // nbrPatch0,
             surfPtr(),
             faceAreaIntersect::tmMesh
         )
diff --git a/src/AMIInterpolation/patches/mapped/mappedPolyPatch/mappedPatchBase.H b/src/AMIInterpolation/patches/mapped/mappedPolyPatch/mappedPatchBase.H
index 449c176aa6..7d91ffb06d 100644
--- a/src/AMIInterpolation/patches/mapped/mappedPolyPatch/mappedPatchBase.H
+++ b/src/AMIInterpolation/patches/mapped/mappedPolyPatch/mappedPatchBase.H
@@ -95,10 +95,10 @@ public:
         //- Mesh items to sample
         enum sampleMode
         {
-            NEARESTCELL,        // nearest cell
-            NEARESTPATCHFACE,   // faces on selected patch
-            NEARESTFACE,        // nearest face
-            NEARESTPATCHFACEAMI // nearest patch face + AMI interpolation
+            NEARESTCELL,         // nearest cell
+            NEARESTPATCHFACE,    // faces on selected patch
+            NEARESTPATCHFACEAMI, // nearest patch face + AMI interpolation
+            NEARESTFACE          // nearest face
         };
 
         //- How to project face centres
@@ -143,7 +143,7 @@ private:
 
     // Private data
 
-        static const NamedEnum<sampleMode, 3> sampleModeNames_;
+        static const NamedEnum<sampleMode, 4> sampleModeNames_;
 
         static const NamedEnum<offsetMode, 3> offsetModeNames_;
 
@@ -317,6 +317,24 @@ public:
             return offsets_;
         }
 
+        template<class Type>
+        void distribute(List<Type>& lst) const
+        {
+            switch (mode_)
+            {
+                case NEARESTPATCHFACEAMI:
+                {
+                    lst = AMI().interpolateToSource(Field<Type>(lst.xfer()));
+                    break;
+                }
+                default:
+                {
+                    map().distribute(lst);
+                }
+            }
+        }
+  
+
         //- Return reference to the parallel distribution map
         const mapDistribute& map() const
         {
diff --git a/src/AMIInterpolation/patches/mapped/mappedPolyPatch/mappedVariableThicknessWallPolyPatch.C b/src/AMIInterpolation/patches/mapped/mappedPolyPatch/mappedVariableThicknessWallPolyPatch.C
new file mode 100644
index 0000000000..fb286890b0
--- /dev/null
+++ b/src/AMIInterpolation/patches/mapped/mappedPolyPatch/mappedVariableThicknessWallPolyPatch.C
@@ -0,0 +1,172 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "mappedVariableThicknessWallPolyPatch.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(mappedVariableThicknessWallPolyPatch, 0);
+
+    addToRunTimeSelectionTable
+    (
+        polyPatch,
+        mappedVariableThicknessWallPolyPatch,
+        word
+    );
+
+    addToRunTimeSelectionTable
+    (
+        polyPatch,
+        mappedVariableThicknessWallPolyPatch,
+        dictionary
+    );
+}
+
+
+// * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * * * * * //
+
+Foam::mappedVariableThicknessWallPolyPatch::mappedVariableThicknessWallPolyPatch
+(
+    const word& name,
+    const label size,
+    const label start,
+    const label index,
+    const polyBoundaryMesh& bm
+)
+:
+    mappedWallPolyPatch(name, size, start, index, bm),
+    thickness_(size)
+{}
+
+
+Foam::mappedVariableThicknessWallPolyPatch::mappedVariableThicknessWallPolyPatch
+(
+    const word& name,
+    const label size,
+    const label start,
+    const label index,
+    const word& sampleRegion,
+    const mappedPatchBase::sampleMode mode,
+    const word& samplePatch,
+    const vectorField& offset,
+    const polyBoundaryMesh& bm
+)
+:
+    mappedWallPolyPatch(name, size, start, index, bm),
+    thickness_(size)
+{}
+
+
+Foam::mappedVariableThicknessWallPolyPatch::mappedVariableThicknessWallPolyPatch
+(
+    const word& name,
+    const label size,
+    const label start,
+    const label index,
+    const word& sampleRegion,
+    const mappedPatchBase::sampleMode mode,
+    const word& samplePatch,
+    const vector& offset,
+    const polyBoundaryMesh& bm
+)
+:
+    mappedWallPolyPatch(name, size, start, index, bm),
+    thickness_(size)
+{}
+
+
+Foam::mappedVariableThicknessWallPolyPatch::mappedVariableThicknessWallPolyPatch
+(
+    const word& name,
+    const dictionary& dict,
+    const label index,
+    const polyBoundaryMesh& bm
+)
+:
+    mappedWallPolyPatch(name, dict, index, bm),
+    thickness_(scalarField("thickness", dict, this->size()))
+{}
+
+
+Foam::mappedVariableThicknessWallPolyPatch::
+mappedVariableThicknessWallPolyPatch
+(
+    const mappedVariableThicknessWallPolyPatch& pp,
+    const polyBoundaryMesh& bm
+)
+:
+    mappedWallPolyPatch(pp, bm),
+    thickness_(pp.thickness_)
+{}
+
+
+Foam::mappedVariableThicknessWallPolyPatch::mappedVariableThicknessWallPolyPatch
+(
+    const mappedVariableThicknessWallPolyPatch& pp,
+    const polyBoundaryMesh& bm,
+    const label index,
+    const label newSize,
+    const label newStart
+)
+:
+    mappedWallPolyPatch(pp, bm, index, newSize, newStart),
+    thickness_(newSize)
+{}
+
+
+Foam::mappedVariableThicknessWallPolyPatch::mappedVariableThicknessWallPolyPatch
+(
+    const mappedVariableThicknessWallPolyPatch& pp,
+    const polyBoundaryMesh& bm,
+    const label index,
+    const labelUList& mapAddressing,
+    const label newStart
+)
+:
+    mappedWallPolyPatch(pp, bm, index, mapAddressing, newStart),
+    thickness_(pp.size())
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::mappedVariableThicknessWallPolyPatch::
+~mappedVariableThicknessWallPolyPatch()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+void Foam::mappedVariableThicknessWallPolyPatch::
+write(Foam::Ostream& os) const
+{
+    os.writeKeyword("thickness") << thickness_ << token::END_STATEMENT << nl;
+}
+
+
+// ************************************************************************* //
diff --git a/src/AMIInterpolation/patches/mapped/mappedPolyPatch/mappedVariableThicknessWallPolyPatch.H b/src/AMIInterpolation/patches/mapped/mappedPolyPatch/mappedVariableThicknessWallPolyPatch.H
new file mode 100644
index 0000000000..4a5912da5e
--- /dev/null
+++ b/src/AMIInterpolation/patches/mapped/mappedPolyPatch/mappedVariableThicknessWallPolyPatch.H
@@ -0,0 +1,236 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::mappedVariableThicknessWallPolyPatch
+
+Description
+    Foam::mappedVariableThicknessWallPolyPatch
+
+SourceFiles
+    mappedVariableThicknessWallPolyPatch.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef mappedVariableThicknessWallPolyPatch_H
+#define mappedVariableThicknessWallPolyPatch_H
+
+#include "wallPolyPatch.H"
+#include "mappedWallPolyPatch.H"
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+class polyMesh;
+
+/*---------------------------------------------------------------------------*\
+           Class mappedVariableThicknessWallPolyPatch Declaration
+\*---------------------------------------------------------------------------*/
+
+class mappedVariableThicknessWallPolyPatch
+:
+    public mappedWallPolyPatch
+{
+
+    // Private data
+
+        //- Thickness
+        scalarList thickness_;
+
+
+public:
+
+    //- Runtime type information
+    TypeName("mappedWallVariableThickness");
+
+
+    // Constructors
+
+        //- Construct from components
+        mappedVariableThicknessWallPolyPatch
+        (
+            const word& name,
+            const label size,
+            const label start,
+            const label index,
+            const polyBoundaryMesh& bm
+        );
+
+        //- Construct from components
+        mappedVariableThicknessWallPolyPatch
+        (
+            const word& name,
+            const label size,
+            const label start,
+            const label index,
+            const word& sampleRegion,
+            const mappedPatchBase::sampleMode mode,
+            const word& samplePatch,
+            const vectorField& offset,
+            const polyBoundaryMesh& bm
+        );
+
+        //- Construct from components. Uniform offset.
+        mappedVariableThicknessWallPolyPatch
+        (
+            const word& name,
+            const label size,
+            const label start,
+            const label index,
+            const word& sampleRegion,
+            const mappedPatchBase::sampleMode mode,
+            const word& samplePatch,
+            const vector& offset,
+            const polyBoundaryMesh& bm
+        );
+
+        //- Construct from dictionary
+        mappedVariableThicknessWallPolyPatch
+        (
+            const word& name,
+            const dictionary& dict,
+            const label index,
+            const polyBoundaryMesh& bm
+        );
+
+        //- Construct as copy, resetting the boundary mesh
+        mappedVariableThicknessWallPolyPatch
+        (
+            const mappedVariableThicknessWallPolyPatch&,
+            const polyBoundaryMesh&
+        );
+
+        //- Construct given the original patch and resetting the
+        //  face list and boundary mesh information
+        mappedVariableThicknessWallPolyPatch
+        (
+            const mappedVariableThicknessWallPolyPatch& pp,
+            const polyBoundaryMesh& bm,
+            const label index,
+            const label newSize,
+            const label newStart
+        );
+
+        //- Construct given the original patch and a map
+        mappedVariableThicknessWallPolyPatch
+        (
+            const mappedVariableThicknessWallPolyPatch& 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 mappedVariableThicknessWallPolyPatch(*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 mappedVariableThicknessWallPolyPatch
+                (
+                    *this,
+                    bm,
+                    index,
+                    newSize,
+                    newStart
+                )
+            );
+        }
+
+        //- 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 mappedVariableThicknessWallPolyPatch
+                (
+                    *this,
+                    bm,
+                    index,
+                    mapAddressing,
+                    newStart
+                )
+            );
+        }
+
+
+    //- Destructor
+    virtual ~mappedVariableThicknessWallPolyPatch();
+
+
+    // Member functions
+
+        //- Return non const thickness
+        scalarList& thickness()
+        {
+            return thickness_;
+        }
+
+
+        //- Return const thickness
+        const scalarList& thickness() const
+        {
+            return thickness_;
+        }
+
+
+        //- Write the polyPatch data as a dictionary
+        void write(Ostream&) const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/AMIInterpolation/patches/mapped/mappedPolyPatch/mappedWallPointPatch.C b/src/AMIInterpolation/patches/mapped/mappedPolyPatch/mappedWallPointPatch.C
new file mode 100644
index 0000000000..58c7f0add1
--- /dev/null
+++ b/src/AMIInterpolation/patches/mapped/mappedPolyPatch/mappedWallPointPatch.C
@@ -0,0 +1,51 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "mappedWallPointPatch.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+defineTypeNameAndDebug(mappedWallPointPatch, 0);
+
+// Add the patch constructor functions to the hash tables
+addToRunTimeSelectionTable
+(
+    facePointPatch,
+    mappedWallPointPatch,
+    polyPatch
+);
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// ************************************************************************* //
diff --git a/src/AMIInterpolation/patches/mapped/mappedPolyPatch/mappedWallPointPatch.H b/src/AMIInterpolation/patches/mapped/mappedPolyPatch/mappedWallPointPatch.H
new file mode 100644
index 0000000000..8676cec5e7
--- /dev/null
+++ b/src/AMIInterpolation/patches/mapped/mappedPolyPatch/mappedWallPointPatch.H
@@ -0,0 +1,83 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::mappedWallPointPatch
+
+Description
+    mappedWallPointPatch patch.
+
+SourceFiles
+    mappedWallPointPatch.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef mappedWallPointPatch_H
+#define mappedWallPointPatch_H
+
+#include "wallPointPatch.H"
+#include "mappedWallPolyPatch.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                    Class mappedWallPointPatch Declaration
+\*---------------------------------------------------------------------------*/
+
+class mappedWallPointPatch
+:
+    public wallPointPatch
+{
+
+public:
+
+    //- Runtime type information
+    TypeName(mappedWallPolyPatch::typeName_());
+
+
+    // Constructors
+
+        //- Construct from polyPatch
+        mappedWallPointPatch
+        (
+            const polyPatch& patch,
+            const pointBoundaryMesh& bm
+        )
+        :
+            wallPointPatch(patch, bm)
+        {}
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/AMIInterpolation/patches/mapped/mappedPolyPatch/mappedWallPolyPatch.C b/src/AMIInterpolation/patches/mapped/mappedPolyPatch/mappedWallPolyPatch.C
new file mode 100644
index 0000000000..9894474e47
--- /dev/null
+++ b/src/AMIInterpolation/patches/mapped/mappedPolyPatch/mappedWallPolyPatch.C
@@ -0,0 +1,227 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "mappedWallPolyPatch.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(mappedWallPolyPatch, 0);
+
+    addToRunTimeSelectionTable(polyPatch, mappedWallPolyPatch, word);
+    addToRunTimeSelectionTable
+    (
+        polyPatch,
+        mappedWallPolyPatch,
+        dictionary
+    );
+}
+
+
+// * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * * * * * //
+
+Foam::mappedWallPolyPatch::mappedWallPolyPatch
+(
+    const word& name,
+    const label size,
+    const label start,
+    const label index,
+    const polyBoundaryMesh& bm
+)
+:
+    wallPolyPatch(name, size, start, index, bm),
+    mappedPatchBase(static_cast<const polyPatch&>(*this))
+{}
+
+
+Foam::mappedWallPolyPatch::mappedWallPolyPatch
+(
+    const word& name,
+    const label size,
+    const label start,
+    const label index,
+    const word& sampleRegion,
+    const mappedPatchBase::sampleMode mode,
+    const word& samplePatch,
+    const vectorField& offset,
+    const polyBoundaryMesh& bm
+)
+:
+    wallPolyPatch(name, size, start, index, bm),
+    mappedPatchBase
+    (
+        static_cast<const polyPatch&>(*this),
+        sampleRegion,
+        mode,
+        samplePatch,
+        offset
+    )
+{}
+
+
+Foam::mappedWallPolyPatch::mappedWallPolyPatch
+(
+    const word& name,
+    const label size,
+    const label start,
+    const label index,
+    const word& sampleRegion,
+    const mappedPatchBase::sampleMode mode,
+    const word& samplePatch,
+    const vector& offset,
+    const polyBoundaryMesh& bm
+)
+:
+    wallPolyPatch(name, size, start, index, bm),
+    mappedPatchBase
+    (
+        static_cast<const polyPatch&>(*this),
+        sampleRegion,
+        mode,
+        samplePatch,
+        offset
+    )
+{}
+
+
+Foam::mappedWallPolyPatch::mappedWallPolyPatch
+(
+    const word& name,
+    const dictionary& dict,
+    const label index,
+    const polyBoundaryMesh& bm
+)
+:
+    wallPolyPatch(name, dict, index, bm),
+    mappedPatchBase(*this, dict)
+{}
+
+
+Foam::mappedWallPolyPatch::mappedWallPolyPatch
+(
+    const mappedWallPolyPatch& pp,
+    const polyBoundaryMesh& bm
+)
+:
+    wallPolyPatch(pp, bm),
+    mappedPatchBase(*this, pp)
+{}
+
+
+Foam::mappedWallPolyPatch::mappedWallPolyPatch
+(
+    const mappedWallPolyPatch& pp,
+    const polyBoundaryMesh& bm,
+    const label index,
+    const label newSize,
+    const label newStart
+)
+:
+    wallPolyPatch(pp, bm, index, newSize, newStart),
+    mappedPatchBase(*this, pp)
+{}
+
+
+Foam::mappedWallPolyPatch::mappedWallPolyPatch
+(
+    const mappedWallPolyPatch& pp,
+    const polyBoundaryMesh& bm,
+    const label index,
+    const labelUList& mapAddressing,
+    const label newStart
+)
+:
+    wallPolyPatch(pp, bm, index, mapAddressing, newStart),
+    mappedPatchBase(*this, pp, mapAddressing)
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::mappedWallPolyPatch::~mappedWallPolyPatch()
+{
+    mappedPatchBase::clearOut();
+}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+void Foam::mappedWallPolyPatch::initGeometry(PstreamBuffers& pBufs)
+{
+    wallPolyPatch::initGeometry(pBufs);
+}
+
+
+void Foam::mappedWallPolyPatch::calcGeometry(PstreamBuffers& pBufs)
+{
+    wallPolyPatch::calcGeometry(pBufs);
+    mappedPatchBase::clearOut();
+}
+
+
+void Foam::mappedWallPolyPatch::initMovePoints
+(
+    PstreamBuffers& pBufs,
+    const pointField& p
+)
+{
+    wallPolyPatch::initMovePoints(pBufs, p);
+}
+
+
+void Foam::mappedWallPolyPatch::movePoints
+(
+    PstreamBuffers& pBufs,
+    const pointField& p
+)
+{
+    wallPolyPatch::movePoints(pBufs, p);
+    mappedPatchBase::clearOut();
+}
+
+
+void Foam::mappedWallPolyPatch::initUpdateMesh(PstreamBuffers& pBufs)
+{
+    wallPolyPatch::initUpdateMesh(pBufs);
+}
+
+
+void Foam::mappedWallPolyPatch::updateMesh(PstreamBuffers& pBufs)
+{
+    wallPolyPatch::updateMesh(pBufs);
+    mappedPatchBase::clearOut();
+}
+
+
+void Foam::mappedWallPolyPatch::write(Ostream& os) const
+{
+    wallPolyPatch::write(os);
+    mappedPatchBase::write(os);
+}
+
+
+// ************************************************************************* //
diff --git a/src/AMIInterpolation/patches/mapped/mappedPolyPatch/mappedWallPolyPatch.H b/src/AMIInterpolation/patches/mapped/mappedPolyPatch/mappedWallPolyPatch.H
new file mode 100644
index 0000000000..8590eeb246
--- /dev/null
+++ b/src/AMIInterpolation/patches/mapped/mappedPolyPatch/mappedWallPolyPatch.H
@@ -0,0 +1,240 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::mappedWallPolyPatch
+
+Description
+    Determines a mapping between patch face centres and mesh cell or face
+    centres and processors they're on.
+
+Note
+    Storage is not optimal. It stores all face centres and cells on all
+    processors to keep the addressing calculation simple.
+
+SourceFiles
+    mappedWallPolyPatch.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef mappedWallPolyPatch_H
+#define mappedWallPolyPatch_H
+
+#include "wallPolyPatch.H"
+#include "mappedPatchBase.H"
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+class polyMesh;
+
+/*---------------------------------------------------------------------------*\
+                      Class mappedWallPolyPatch Declaration
+\*---------------------------------------------------------------------------*/
+
+class mappedWallPolyPatch
+:
+    public wallPolyPatch,
+    public mappedPatchBase
+{
+
+protected:
+
+        //- 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("mappedWall");
+
+
+    // Constructors
+
+        //- Construct from components
+        mappedWallPolyPatch
+        (
+            const word& name,
+            const label size,
+            const label start,
+            const label index,
+            const polyBoundaryMesh& bm
+        );
+
+        //- Construct from components
+        mappedWallPolyPatch
+        (
+            const word& name,
+            const label size,
+            const label start,
+            const label index,
+            const word& sampleRegion,
+            const mappedPatchBase::sampleMode mode,
+            const word& samplePatch,
+            const vectorField& offset,
+            const polyBoundaryMesh& bm
+        );
+
+        //- Construct from components. Uniform offset.
+        mappedWallPolyPatch
+        (
+            const word& name,
+            const label size,
+            const label start,
+            const label index,
+            const word& sampleRegion,
+            const mappedPatchBase::sampleMode mode,
+            const word& samplePatch,
+            const vector& offset,
+            const polyBoundaryMesh& bm
+        );
+
+        //- Construct from dictionary
+        mappedWallPolyPatch
+        (
+            const word& name,
+            const dictionary& dict,
+            const label index,
+            const polyBoundaryMesh& bm
+        );
+
+        //- Construct as copy, resetting the boundary mesh
+        mappedWallPolyPatch
+        (
+            const mappedWallPolyPatch&,
+            const polyBoundaryMesh&
+        );
+
+        //- Construct given the original patch and resetting the
+        //  face list and boundary mesh information
+        mappedWallPolyPatch
+        (
+            const mappedWallPolyPatch& pp,
+            const polyBoundaryMesh& bm,
+            const label index,
+            const label newSize,
+            const label newStart
+        );
+
+        //- Construct given the original patch and a map
+        mappedWallPolyPatch
+        (
+            const mappedWallPolyPatch& 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 mappedWallPolyPatch(*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 mappedWallPolyPatch
+                (
+                    *this,
+                    bm,
+                    index,
+                    newSize,
+                    newStart
+                )
+            );
+        }
+
+        //- 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 mappedWallPolyPatch
+                (
+                    *this,
+                    bm,
+                    index,
+                    mapAddressing,
+                    newStart
+                )
+            );
+        }
+
+
+    //- Destructor
+    virtual ~mappedWallPolyPatch();
+
+
+    // Member functions
+
+        //- Write the polyPatch data as a dictionary
+        virtual void write(Ostream&) const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

From 13b1749d5e2b91f89aef32addecff69d0f5078dd Mon Sep 17 00:00:00 2001
From: andy <andy>
Date: Mon, 5 Sep 2011 17:34:39 +0100
Subject: [PATCH 34/45] STYLE: corrected/updated various comments/formatting

---
 .../AMIInterpolation/AMIInterpolation.C       | 20 ++++----
 .../mappedFixedInternalValueFvPatchField.C    |  2 +-
 .../mapped/mappedPolyPatch/mappedPatchBase.C  | 46 +++++++++++--------
 .../mapped/mappedPolyPatch/mappedPatchBase.H  | 13 ++++--
 4 files changed, 49 insertions(+), 32 deletions(-)

diff --git a/src/AMIInterpolation/AMIInterpolation/AMIInterpolation.C b/src/AMIInterpolation/AMIInterpolation/AMIInterpolation.C
index a0bf7fc15f..031291cce7 100644
--- a/src/AMIInterpolation/AMIInterpolation/AMIInterpolation.C
+++ b/src/AMIInterpolation/AMIInterpolation/AMIInterpolation.C
@@ -995,7 +995,7 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::normaliseWeights
         scalar s = sum(wght[faceI]);
         wghtSum[faceI] = s;
 
-        scalar t = s/patch[faceI].mag(patch.points());
+        scalar t = s/patch[faceI].mag(patch.localPoints());
         if (t < minBound)
         {
             minBound = t;
@@ -1309,9 +1309,11 @@ Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolateToSource
         FatalErrorIn
         (
             "AMIInterpolation::interpolateToSource(const Field<Type>) const"
-        )   << "Supplied field size is not equal to target patch size. "
-            << "Target patch = " << tgtAddress_.size() << ", supplied field = "
-            << fld.size() << abort(FatalError);
+        )   << "Supplied field size is not equal to target patch size" << nl
+            << "    source patch   = " << srcAddress_.size() << nl
+            << "    target patch   = " << tgtAddress_.size() << nl
+            << "    supplied field = " << fld.size()
+            << abort(FatalError);
     }
 
     tmp<Field<Type> > tresult
@@ -1386,10 +1388,12 @@ Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolateToTarget
     {
         FatalErrorIn
         (
-            "AMIInterpolation::interpolateToSource(const Field<Type>&) const"
-        )   << "Supplied field size is not equal to source patch size. "
-            << "Source patch = " << srcAddress_.size() << ", supplied field = "
-            << fld.size() << abort(FatalError);
+            "AMIInterpolation::interpolateToTarget(const Field<Type>&) const"
+        )   << "Supplied field size is not equal to source patch size" << nl
+            << "    source patch   = " << srcAddress_.size() << nl
+            << "    target patch   = " << tgtAddress_.size() << nl
+            << "    supplied field = " << fld.size()
+            << abort(FatalError);
     }
 
     tmp<Field<Type> > tresult
diff --git a/src/AMIInterpolation/patches/mapped/mappedFixedInternalValue/mappedFixedInternalValueFvPatchField.C b/src/AMIInterpolation/patches/mapped/mappedFixedInternalValue/mappedFixedInternalValueFvPatchField.C
index 6acae6a705..7f0c0e6cd2 100644
--- a/src/AMIInterpolation/patches/mapped/mappedFixedInternalValue/mappedFixedInternalValueFvPatchField.C
+++ b/src/AMIInterpolation/patches/mapped/mappedFixedInternalValue/mappedFixedInternalValueFvPatchField.C
@@ -148,7 +148,7 @@ void Foam::mappedFixedInternalValueFvPatchField<Type>::updateCoeffs()
         }
     }
 
-    // Assign (this) patch internal field to its neighbour values
+    // Assign to (this) patch internal field its neighbour values
     Field<Type>& intFld = const_cast<Field<Type>&>(this->internalField());
     UIndirectList<Type>(intFld, this->patch().faceCells()) = nbrIntFld;
 }
diff --git a/src/AMIInterpolation/patches/mapped/mappedPolyPatch/mappedPatchBase.C b/src/AMIInterpolation/patches/mapped/mappedPolyPatch/mappedPatchBase.C
index bd5dce024f..ff39e152b8 100644
--- a/src/AMIInterpolation/patches/mapped/mappedPolyPatch/mappedPatchBase.C
+++ b/src/AMIInterpolation/patches/mapped/mappedPolyPatch/mappedPatchBase.C
@@ -672,7 +672,10 @@ Foam::mappedPatchBase::mappedPatchBase
     offsets_(pp.size(), offset_),
     distance_(0),
     sameRegion_(sampleRegion_ == patch_.boundaryMesh().mesh().name()),
-    mapPtr_(NULL)
+    mapPtr_(NULL),
+    AMIPtr_(NULL),
+    surfPtr_(NULL),
+    surfDict_(dictionary::null)
 {}
 
 
@@ -694,7 +697,10 @@ Foam::mappedPatchBase::mappedPatchBase
     offsets_(offsets),
     distance_(0),
     sameRegion_(sampleRegion_ == patch_.boundaryMesh().mesh().name()),
-    mapPtr_(NULL)
+    mapPtr_(NULL),
+    AMIPtr_(NULL),
+    surfPtr_(NULL),
+    surfDict_(dictionary::null)
 {}
 
 
@@ -716,7 +722,10 @@ Foam::mappedPatchBase::mappedPatchBase
     offsets_(0),
     distance_(0),
     sameRegion_(sampleRegion_ == patch_.boundaryMesh().mesh().name()),
-    mapPtr_(NULL)
+    mapPtr_(NULL),
+    AMIPtr_(NULL),
+    surfPtr_(NULL),
+    surfDict_(dictionary::null)
 {}
 
 
@@ -738,7 +747,10 @@ Foam::mappedPatchBase::mappedPatchBase
     offsets_(0),
     distance_(distance),
     sameRegion_(sampleRegion_ == patch_.boundaryMesh().mesh().name()),
-    mapPtr_(NULL)
+    mapPtr_(NULL),
+    AMIPtr_(NULL),
+    surfPtr_(NULL),
+    surfDict_(dictionary::null)
 {}
 
 
@@ -810,8 +822,8 @@ Foam::mappedPatchBase::mappedPatchBase
         (
             "mappedPatchBase::mappedPatchBase\n"
             "(\n"
-            "    const polyPatch& pp,\n"
-            "    const dictionary& dict\n"
+            "    const polyPatch&,\n"
+            "    const dictionary&\n"
             ")\n",
             dict
         )   << "Please supply the offsetMode as one of "
@@ -899,7 +911,7 @@ const Foam::polyPatch& Foam::mappedPatchBase::samplePolyPatch() const
 
     if (patchI == -1)
     {
-        FatalErrorIn("mappedPatchBase::samplePolyPatch() ")
+        FatalErrorIn("mappedPatchBase::samplePolyPatch()")
             << "Cannot find patch " << samplePatch_
             << " in region " << sampleRegion_ << endl
             << "Valid patches are " << nbrMesh.boundaryMesh().names()
@@ -915,20 +927,18 @@ Foam::tmp<Foam::pointField> Foam::mappedPatchBase::samplePoints() const
     tmp<pointField> tfld(new pointField(patch_.faceCentres()));
     pointField& fld = tfld();
 
-    switch(offsetMode_)
+    switch (offsetMode_)
     {
         case UNIFORM:
         {
             fld += offset_;
+            break;
         }
-        break;
-
         case NONUNIFORM:
         {
             fld += offsets_;
+            break;
         }
-        break;
-
         case NORMAL:
         {
             // Get outwards pointing normal
@@ -936,8 +946,8 @@ Foam::tmp<Foam::pointField> Foam::mappedPatchBase::samplePoints() const
             n /= mag(n);
 
             fld += distance_*n;
+            break;
         }
-        break;
     }
 
     return tfld;
@@ -956,27 +966,25 @@ void Foam::mappedPatchBase::write(Ostream& os) const
     os.writeKeyword("offsetMode") << offsetModeNames_[offsetMode_]
         << token::END_STATEMENT << nl;
 
-    switch(offsetMode_)
+    switch (offsetMode_)
     {
         case UNIFORM:
         {
             os.writeKeyword("offset") << offset_ << token::END_STATEMENT << nl;
+            break;
         }
-        break;
-
         case NONUNIFORM:
         {
             os.writeKeyword("offsets") << offsets_ << token::END_STATEMENT
                 << nl;
+            break;
         }
-        break;
-
         case NORMAL:
         {
             os.writeKeyword("distance") << distance_ << token::END_STATEMENT
                 << nl;
+            break;
         }
-        break;
     }
 }
 
diff --git a/src/AMIInterpolation/patches/mapped/mappedPolyPatch/mappedPatchBase.H b/src/AMIInterpolation/patches/mapped/mappedPolyPatch/mappedPatchBase.H
index 7d91ffb06d..4f5194a0a8 100644
--- a/src/AMIInterpolation/patches/mapped/mappedPolyPatch/mappedPatchBase.H
+++ b/src/AMIInterpolation/patches/mapped/mappedPolyPatch/mappedPatchBase.H
@@ -33,9 +33,12 @@ Description
         sampleRegion region0;
 
         // What to sample:
-        // - nearestCell : sample nearest cell
-        // - nearestPatchFace : nearest face on selected patch
-        // - nearestFace : nearest boundary face on any patch
+        // - nearestCell         : sample nearest cell
+        // - nearestPatchFace    : nearest face on selected patch
+        // - nearestPatchFaceAMI : nearest face on selected patch
+                                   - patches need not conform
+                                   - uses AMI interpolation
+        // - nearestFace         : nearest boundary face on any patch
         sampleMode nearestCell;
 
         // If sampleMod is nearestPatchFace : patch to find faces of
@@ -82,7 +85,7 @@ class polyMesh;
 class mapDistribute;
 
 /*---------------------------------------------------------------------------*\
-                    Class mappedPatchBase Declaration
+                       Class mappedPatchBase Declaration
 \*---------------------------------------------------------------------------*/
 
 class mappedPatchBase
@@ -317,6 +320,7 @@ public:
             return offsets_;
         }
 
+        //- Wrapper around map/interpolate data distribution
         template<class Type>
         void distribute(List<Type>& lst) const
         {
@@ -342,6 +346,7 @@ public:
             {
                 calcMapping();
             }
+
             return mapPtr_();
         }
 

From aa6fe2733a7ba60c159c2558f38a0d85a9ff638b Mon Sep 17 00:00:00 2001
From: andy <andy>
Date: Wed, 7 Sep 2011 13:10:30 +0100
Subject: [PATCH 35/45] ENH: Moved AMI lib from user-libbin to main libbin

---
 src/AMIInterpolation/Make/files                                | 2 +-
 .../mappedFixedPushedInternalValueFvPatchField.C               | 3 +--
 2 files changed, 2 insertions(+), 3 deletions(-)

diff --git a/src/AMIInterpolation/Make/files b/src/AMIInterpolation/Make/files
index 3470ea45d0..3b1ab86881 100644
--- a/src/AMIInterpolation/Make/files
+++ b/src/AMIInterpolation/Make/files
@@ -24,4 +24,4 @@ $(MAPPATCHES)/mappedFixedPushedInternalValue/mappedFixedPushedInternalValueFvPat
 
 $(MAPPATCHES)/mappedField/mappedFieldFvPatchFields.C
 
-LIB = $(FOAM_USER_LIBBIN)/libAMIInterpolation
+LIB = $(FOAM_LIBBIN)/libAMIInterpolation
diff --git a/src/AMIInterpolation/patches/mapped/mappedFixedPushedInternalValue/mappedFixedPushedInternalValueFvPatchField.C b/src/AMIInterpolation/patches/mapped/mappedFixedPushedInternalValue/mappedFixedPushedInternalValueFvPatchField.C
index 599ecc6cfc..2cea02cd9c 100644
--- a/src/AMIInterpolation/patches/mapped/mappedFixedPushedInternalValue/mappedFixedPushedInternalValueFvPatchField.C
+++ b/src/AMIInterpolation/patches/mapped/mappedFixedPushedInternalValue/mappedFixedPushedInternalValueFvPatchField.C
@@ -93,8 +93,7 @@ mappedFixedPushedInternalValueFvPatchField
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
 template<class Type>
-void
-Foam::mappedFixedPushedInternalValueFvPatchField<Type>::updateCoeffs()
+void Foam::mappedFixedPushedInternalValueFvPatchField<Type>::updateCoeffs()
 {
     typedef GeometricField<Type, fvPatchField, volMesh> FieldType;
 

From 44414c0d0b922edb9554ba74a767e2787f7e40f1 Mon Sep 17 00:00:00 2001
From: andy <andy>
Date: Wed, 7 Sep 2011 13:11:29 +0100
Subject: [PATCH 36/45] ENH: Updated region models to reflect AMI additions

---
 src/regionModels/pyrolysisModels/Make/options | 20 ++++++++---
 .../pyrolysisModel/pyrolysisModel.C           |  6 ++--
 .../reactingOneDim/reactingOneDim.C           |  2 --
 src/regionModels/regionCoupling/Make/options  |  2 ++
 ...ysisTemperatureCoupledFvPatchScalarField.C |  4 +--
 ...rolysisVelocityCoupledFvPatchVectorField.C |  4 +--
 src/regionModels/regionModel/Make/files       |  2 +-
 src/regionModels/regionModel/Make/options     | 10 ++++--
 .../mappedVariableThicknessWallFvPatch.C}     | 20 ++++-------
 .../mappedVariableThicknessWallFvPatch.H}     | 19 +++++-----
 .../regionModel/regionModel/regionModel.C     | 21 ++++++-----
 .../regionModel/regionModel/regionModel.H     |  7 ++--
 .../regionModel/regionModel/regionModelI.H    |  2 +-
 .../singleLayerRegion/singleLayerRegion.C     |  1 -
 .../singleLayerRegionTemplates.C              |  9 +++--
 .../surfaceFilmModels/Make/options            | 20 ++++++++---
 ...alphatFilmWallFunctionFvPatchScalarField.C |  6 ++--
 .../mutkFilmWallFunctionFvPatchScalarField.C  |  6 ++--
 .../kinematicSingleLayer.C                    | 24 ++++++++-----
 .../mappedConvectiveHeatTransfer.H            |  2 +-
 .../thermoSingleLayer/thermoSingleLayer.C     | 36 +++++++++++--------
 .../thermoBaffleModels/Make/options           |  2 ++
 ...emperatureThermoBaffleFvPatchScalarField.C |  4 +--
 .../thermoBaffleModel/thermoBaffleModel.C     | 14 ++++----
 24 files changed, 137 insertions(+), 106 deletions(-)
 rename src/regionModels/regionModel/derivedFvPatches/{directMappedVariableThicknessWall/directMappedVariableThicknessWallFvPatch.C => mappedVariableThicknessWall/mappedVariableThicknessWallFvPatch.C} (79%)
 rename src/regionModels/regionModel/derivedFvPatches/{directMappedVariableThicknessWall/directMappedVariableThicknessWallFvPatch.H => mappedVariableThicknessWall/mappedVariableThicknessWallFvPatch.H} (83%)

diff --git a/src/regionModels/pyrolysisModels/Make/options b/src/regionModels/pyrolysisModels/Make/options
index 30a5fa428b..b892a00590 100644
--- a/src/regionModels/pyrolysisModels/Make/options
+++ b/src/regionModels/pyrolysisModels/Make/options
@@ -1,5 +1,7 @@
 EXE_INC = \
     -I$(LIB_SRC)/finiteVolume/lnInclude \
+    -I$(LIB_SRC)/sampling/lnInclude \
+    -I$(LIB_SRC)/AMIInterpolation/lnInclude \
     -I$(LIB_SRC)/meshTools/lnInclude \
     -I$(LIB_SRC)/thermophysicalModels/chemistryModel/lnInclude \
     -I$(LIB_SRC)/thermophysicalModels/specie/lnInclude \
@@ -14,11 +16,19 @@ EXE_INC = \
     -I$(LIB_SRC)/turbulenceModels/LES/LESdeltas/lnInclude \
     -I$(LIB_SRC)/regionModels/regionModel/lnInclude
 
-
 LIB_LIBS = \
-    -lregionModels \
-    -lsolidChemistryModel \
-    -lbasicSolidThermo \
     -lfiniteVolume \
+    -lsampling \
+    -lAMIInterpolation \
     -lmeshTools \
-    -lcompressibleLESModels
+    -lchemistryModel \
+    -lspecie \
+    -lspecie \
+    -lsolid \
+    -lbasicThermophysicalModels \
+    -lsolidChemistryModel \
+    -lcompressibleTurbulenceModel \
+    -lcompressibleRASModels \
+    -lcompressibleLESModels \
+    -lLESdeltas \
+    -lregionModels
diff --git a/src/regionModels/pyrolysisModels/pyrolysisModel/pyrolysisModel.C b/src/regionModels/pyrolysisModels/pyrolysisModel/pyrolysisModel.C
index 05c684c043..7dd0080e8b 100644
--- a/src/regionModels/pyrolysisModels/pyrolysisModel/pyrolysisModel.C
+++ b/src/regionModels/pyrolysisModels/pyrolysisModel/pyrolysisModel.C
@@ -25,7 +25,7 @@ License
 
 #include "pyrolysisModel.H"
 #include "fvMesh.H"
-#include "directMappedFieldFvPatchField.H"
+#include "mappedFieldFvPatchField.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -70,7 +70,7 @@ void pyrolysisModel::constructMeshObjects()
         forAll(filmDelta.boundaryField(), patchI)
         {
             const fvPatchField<scalar>& fvp = filmDelta.boundaryField()[patchI];
-            if (isA<directMappedFieldFvPatchField<scalar> >(fvp))
+            if (isA<mappedFieldFvPatchField<scalar> >(fvp))
             {
                 foundCoupledPatch = true;
                 break;
@@ -81,7 +81,7 @@ void pyrolysisModel::constructMeshObjects()
         {
             WarningIn("void pyrolysisModels::constructMeshObjects()")
                 << "filmCoupled flag set to true, but no "
-                << directMappedFieldFvPatchField<scalar>::typeName
+                << mappedFieldFvPatchField<scalar>::typeName
                 << " patches found on " << filmDelta.name() << " field"
                 << endl;
         }
diff --git a/src/regionModels/pyrolysisModels/reactingOneDim/reactingOneDim.C b/src/regionModels/pyrolysisModels/reactingOneDim/reactingOneDim.C
index 942094d838..95214ac92e 100644
--- a/src/regionModels/pyrolysisModels/reactingOneDim/reactingOneDim.C
+++ b/src/regionModels/pyrolysisModels/reactingOneDim/reactingOneDim.C
@@ -25,8 +25,6 @@ License
 
 #include "reactingOneDim.H"
 #include "addToRunTimeSelectionTable.H"
-#include "directMappedPatchBase.H"
-#include "mapDistribute.H"
 #include "zeroGradientFvPatchFields.H"
 #include "surfaceInterpolate.H"
 #include "fvm.H"
diff --git a/src/regionModels/regionCoupling/Make/options b/src/regionModels/regionCoupling/Make/options
index 5201314345..9182aa4de1 100644
--- a/src/regionModels/regionCoupling/Make/options
+++ b/src/regionModels/regionCoupling/Make/options
@@ -1,5 +1,7 @@
 EXE_INC = \
     -I$(LIB_SRC)/finiteVolume/lnInclude \
+    -I$(LIB_SRC)/sampling/lnInclude \
+    -I$(LIB_SRC)/AMIInterpolation/lnInclude \
     -I$(LIB_SRC)/meshTools/lnInclude \
     -I$(LIB_SRC)/thermophysicalModels/chemistryModel/lnInclude \
     -I$(LIB_SRC)/thermophysicalModels/specie/lnInclude \
diff --git a/src/regionModels/regionCoupling/derivedFvPatchFields/filmPyrolysisTemperatureCoupled/filmPyrolysisTemperatureCoupledFvPatchScalarField.C b/src/regionModels/regionCoupling/derivedFvPatchFields/filmPyrolysisTemperatureCoupled/filmPyrolysisTemperatureCoupledFvPatchScalarField.C
index 0908509b4d..a48cc3232e 100644
--- a/src/regionModels/regionCoupling/derivedFvPatchFields/filmPyrolysisTemperatureCoupled/filmPyrolysisTemperatureCoupledFvPatchScalarField.C
+++ b/src/regionModels/regionCoupling/derivedFvPatchFields/filmPyrolysisTemperatureCoupled/filmPyrolysisTemperatureCoupledFvPatchScalarField.C
@@ -146,7 +146,7 @@ void Foam::filmPyrolysisTemperatureCoupledFvPatchScalarField::updateCoeffs()
 
     const label filmPatchI = filmModel.regionPatchID(patchI);
 
-    const mapDistribute& filmMap = filmModel.mappedPatches()[filmPatchI].map();
+    const mappedPatchBase& filmMap = filmModel.mappedPatches()[filmPatchI];
 
     scalarField deltaFilm = filmModel.delta().boundaryField()[filmPatchI];
     filmMap.distribute(deltaFilm);
@@ -161,7 +161,7 @@ void Foam::filmPyrolysisTemperatureCoupledFvPatchScalarField::updateCoeffs()
 
     const label pyrPatchI = pyrModel.regionPatchID(patchI);
 
-    const mapDistribute& pyrMap = pyrModel.mappedPatches()[pyrPatchI].map();
+    const mappedPatchBase& pyrMap = pyrModel.mappedPatches()[pyrPatchI];
 
     scalarField TPyr = pyrModel.T().boundaryField()[pyrPatchI];
     pyrMap.distribute(TPyr);
diff --git a/src/regionModels/regionCoupling/derivedFvPatchFields/filmPyrolysisVelocityCoupled/filmPyrolysisVelocityCoupledFvPatchVectorField.C b/src/regionModels/regionCoupling/derivedFvPatchFields/filmPyrolysisVelocityCoupled/filmPyrolysisVelocityCoupledFvPatchVectorField.C
index 23154894bd..6f9b6b5819 100644
--- a/src/regionModels/regionCoupling/derivedFvPatchFields/filmPyrolysisVelocityCoupled/filmPyrolysisVelocityCoupledFvPatchVectorField.C
+++ b/src/regionModels/regionCoupling/derivedFvPatchFields/filmPyrolysisVelocityCoupled/filmPyrolysisVelocityCoupledFvPatchVectorField.C
@@ -149,7 +149,7 @@ void Foam::filmPyrolysisVelocityCoupledFvPatchVectorField::updateCoeffs()
 
     const label filmPatchI = filmModel.regionPatchID(patchI);
 
-    const mapDistribute& filmMap = filmModel.mappedPatches()[filmPatchI].map();
+    const mappedPatchBase& filmMap = filmModel.mappedPatches()[filmPatchI];
 
     scalarField deltaFilm = filmModel.delta().boundaryField()[filmPatchI];
     filmMap.distribute(deltaFilm);
@@ -167,7 +167,7 @@ void Foam::filmPyrolysisVelocityCoupledFvPatchVectorField::updateCoeffs()
 
     const label pyrPatchI = pyrModel.regionPatchID(patchI);
 
-    const mapDistribute& pyrMap = pyrModel.mappedPatches()[pyrPatchI].map();
+    const mappedPatchBase& pyrMap = pyrModel.mappedPatches()[pyrPatchI];
 
     scalarField phiPyr = pyrModel.phiGas().boundaryField()[pyrPatchI];
     pyrMap.distribute(phiPyr);
diff --git a/src/regionModels/regionModel/Make/files b/src/regionModels/regionModel/Make/files
index 7a62c0c570..570b357b11 100644
--- a/src/regionModels/regionModel/Make/files
+++ b/src/regionModels/regionModel/Make/files
@@ -4,6 +4,6 @@ singleLayerRegion/singleLayerRegion.C
 regionModel1D/regionModel1D.C
 
 /* Boundary conditions */
-derivedFvPatches/directMappedVariableThicknessWall/directMappedVariableThicknessWallFvPatch.C
+derivedFvPatches/mappedVariableThicknessWall/mappedVariableThicknessWallFvPatch.C
 
 LIB = $(FOAM_LIBBIN)/libregionModels
diff --git a/src/regionModels/regionModel/Make/options b/src/regionModels/regionModel/Make/options
index a3ae8da833..f82c3cc9a9 100644
--- a/src/regionModels/regionModel/Make/options
+++ b/src/regionModels/regionModel/Make/options
@@ -1,7 +1,11 @@
 EXE_INC = \
     -I$(LIB_SRC)/finiteVolume/lnInclude \
-    -I$(LIB_SRC)/meshTools/lnInclude
-
+    -I$(LIB_SRC)/meshTools/lnInclude \
+    -I$(LIB_SRC)/sampling/lnInclude \
+    -I$(LIB_SRC)/AMIInterpolation/lnInclude
+    
 LIB_LIBS = \
     -lfiniteVolume \
-    -lmeshTools
+    -lmeshTools \
+    -lsampling \
+    -lAMIInterpolation
diff --git a/src/regionModels/regionModel/derivedFvPatches/directMappedVariableThicknessWall/directMappedVariableThicknessWallFvPatch.C b/src/regionModels/regionModel/derivedFvPatches/mappedVariableThicknessWall/mappedVariableThicknessWallFvPatch.C
similarity index 79%
rename from src/regionModels/regionModel/derivedFvPatches/directMappedVariableThicknessWall/directMappedVariableThicknessWallFvPatch.C
rename to src/regionModels/regionModel/derivedFvPatches/mappedVariableThicknessWall/mappedVariableThicknessWallFvPatch.C
index 3f358d0051..01828d085a 100644
--- a/src/regionModels/regionModel/derivedFvPatches/directMappedVariableThicknessWall/directMappedVariableThicknessWallFvPatch.C
+++ b/src/regionModels/regionModel/derivedFvPatches/mappedVariableThicknessWall/mappedVariableThicknessWallFvPatch.C
@@ -23,7 +23,7 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-#include "directMappedVariableThicknessWallFvPatch.H"
+#include "mappedVariableThicknessWallFvPatch.H"
 #include "addToRunTimeSelectionTable.H"
 #include "regionModel1D.H"
 
@@ -31,11 +31,11 @@ License
 
 namespace Foam
 {
-    defineTypeNameAndDebug(directMappedVariableThicknessWallFvPatch, 0);
+    defineTypeNameAndDebug(mappedVariableThicknessWallFvPatch, 0);
     addToRunTimeSelectionTable
     (
         fvPatch,
-        directMappedVariableThicknessWallFvPatch,
+        mappedVariableThicknessWallFvPatch,
         polyPatch
     );
 }
@@ -43,19 +43,13 @@ namespace Foam
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
-void Foam::directMappedVariableThicknessWallFvPatch::
+void Foam::mappedVariableThicknessWallFvPatch::
 makeDeltaCoeffs(scalarField& dc) const
 {
-    const directMappedVariableThicknessWallPolyPatch& pp =
-        refCast<const directMappedVariableThicknessWallPolyPatch>
-        (
-            patch()
-        );
+    const mappedVariableThicknessWallPolyPatch& pp =
+        refCast<const mappedVariableThicknessWallPolyPatch>(patch());
 
-    const directMappedPatchBase& mpp = refCast<const directMappedPatchBase>
-    (
-        patch()
-    );
+    const mappedPatchBase& mpp = refCast<const mappedPatchBase>(patch());
 
     const polyMesh& nbrMesh = mpp.sampleMesh();
 
diff --git a/src/regionModels/regionModel/derivedFvPatches/directMappedVariableThicknessWall/directMappedVariableThicknessWallFvPatch.H b/src/regionModels/regionModel/derivedFvPatches/mappedVariableThicknessWall/mappedVariableThicknessWallFvPatch.H
similarity index 83%
rename from src/regionModels/regionModel/derivedFvPatches/directMappedVariableThicknessWall/directMappedVariableThicknessWallFvPatch.H
rename to src/regionModels/regionModel/derivedFvPatches/mappedVariableThicknessWall/mappedVariableThicknessWallFvPatch.H
index 20926b7967..a203fc0169 100644
--- a/src/regionModels/regionModel/derivedFvPatches/directMappedVariableThicknessWall/directMappedVariableThicknessWallFvPatch.H
+++ b/src/regionModels/regionModel/derivedFvPatches/mappedVariableThicknessWall/mappedVariableThicknessWallFvPatch.H
@@ -22,7 +22,7 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Class
-    Foam::directMappedVariableThicknessWallFvPatch
+    Foam::mappedVariableThicknessWallFvPatch
 
 Description
     Take thickness field and number of layers and returns deltaCoeffs
@@ -30,15 +30,15 @@ Description
     To be used with 1D thermo baffle.
 
 SourceFiles
-    directMappedVariableThicknessWallFvPatch.C
+    mappedVariableThicknessWallFvPatch.C
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef directMappedWallFvPatch_H
-#define directMappedWallFvPatch_H
+#ifndef mappedWallFvPatch_H
+#define mappedWallFvPatch_H
 
 #include "wallFvPatch.H"
-#include "directMappedVariableThicknessWallPolyPatch.H"
+#include "mappedVariableThicknessWallPolyPatch.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -46,10 +46,10 @@ namespace Foam
 {
 
 /*---------------------------------------------------------------------------*\
-        Class directMappedVariableThicknessWallFvPatch Declaration
+            Class mappedVariableThicknessWallFvPatch Declaration
 \*---------------------------------------------------------------------------*/
 
-class directMappedVariableThicknessWallFvPatch
+class mappedVariableThicknessWallFvPatch
 :
     public wallFvPatch
 {
@@ -65,13 +65,13 @@ protected:
 public:
 
     //- Runtime type information
-    TypeName(directMappedVariableThicknessWallPolyPatch::typeName_());
+    TypeName(mappedVariableThicknessWallPolyPatch::typeName_());
 
 
     // Constructors
 
         //- Construct from components
-        directMappedVariableThicknessWallFvPatch
+        mappedVariableThicknessWallFvPatch
         (
             const polyPatch& patch,
             const fvBoundaryMesh& bm
@@ -79,7 +79,6 @@ public:
         :
             wallFvPatch(patch, bm)
         {}
-
 };
 
 
diff --git a/src/regionModels/regionModel/regionModel/regionModel.C b/src/regionModels/regionModel/regionModel/regionModel.C
index 40e9580398..1d74a9c646 100644
--- a/src/regionModels/regionModel/regionModel/regionModel.C
+++ b/src/regionModels/regionModel/regionModel/regionModel.C
@@ -26,7 +26,7 @@ License
 #include "regionModel.H"
 #include "fvMesh.H"
 #include "Time.H"
-#include "directMappedWallPolyPatch.H"
+#include "mappedWallPolyPatch.H"
 #include "zeroGradientFvPatchFields.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
@@ -99,11 +99,11 @@ void Foam::regionModels::regionModel::initialise()
     forAll(rbm, patchI)
     {
         const polyPatch& regionPatch = rbm[patchI];
-        if (isA<directMappedWallPolyPatch>(regionPatch))
+        if (isA<mappedWallPolyPatch>(regionPatch))
         {
             if (debug)
             {
-                Pout<< "found " << directMappedWallPolyPatch::typeName
+                Pout<< "found " << mappedWallPolyPatch::typeName
                     <<  " " << regionPatch.name() << endl;
             }
 
@@ -111,20 +111,20 @@ void Foam::regionModels::regionModel::initialise()
 
             nBoundaryFaces += regionPatch.faceCells().size();
 
-            const directMappedWallPolyPatch& dmp =
-                refCast<const directMappedWallPolyPatch>(regionPatch);
+            const mappedWallPolyPatch& mapPatch =
+                refCast<const mappedWallPolyPatch>(regionPatch);
 
-            const label primaryPatchI = dmp.samplePolyPatch().index();
+            const label primaryPatchI = mapPatch.samplePolyPatch().index();
             primaryPatchIDs.append(primaryPatchI);
 
             mappedPatches_.set
             (
                 patchI,
-                new directMappedPatchBase
+                new mappedPatchBase
                 (
                     pbm[primaryPatchI],
                     regionMesh().name(),
-                    directMappedPatchBase::NEARESTPATCHFACE,
+                    mapPatch.mode(),
                     regionPatch.name(),
                     vector::zero
                 )
@@ -134,13 +134,12 @@ void Foam::regionModels::regionModel::initialise()
 
     primaryPatchIDs_.transfer(primaryPatchIDs);
     intCoupledPatchIDs_.transfer(intCoupledPatchIDs);
-//    mappedPatches_.resize(nCoupledPatches);
 
     if (nBoundaryFaces == 0)
     {
         WarningIn("regionModel::initialise()")
-            << "Region model being applied without direct mapped boundary "
-            << "conditions" << endl;
+            << "Region model has no mapped boundary conditions - transfer "
+            << "between regions will not be possible" << endl;
     }
 }
 
diff --git a/src/regionModels/regionModel/regionModel/regionModel.H b/src/regionModels/regionModel/regionModel/regionModel.H
index 47b0e44e21..bc9fb54a33 100644
--- a/src/regionModels/regionModel/regionModel/regionModel.H
+++ b/src/regionModels/regionModel/regionModel/regionModel.H
@@ -40,7 +40,7 @@ SourceFiles
 #include "Switch.H"
 #include "labelList.H"
 #include "volFields.H"
-#include "directMappedPatchBase.H"
+#include "mappedPatchBase.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -118,7 +118,7 @@ protected:
             labelList intCoupledPatchIDs_;
 
             //- List of patch map info
-            PtrList<directMappedPatchBase> mappedPatches_;
+            PtrList<mappedPatchBase> mappedPatches_;
 
 
     // Protected member functions
@@ -213,8 +213,7 @@ public:
                 inline const labelList& intCoupledPatchIDs() const;
 
                 //- Return the list of patch map info
-                inline const PtrList<directMappedPatchBase>&
-                    mappedPatches() const;
+                inline const PtrList<mappedPatchBase>& mappedPatches() const;
 
                 //- Return region ID corresponding to primaryPatchID
                 inline label regionPatchID(const label primaryPatchID) const;
diff --git a/src/regionModels/regionModel/regionModel/regionModelI.H b/src/regionModels/regionModel/regionModel/regionModelI.H
index 61b4cdb2d1..197e663d50 100644
--- a/src/regionModels/regionModel/regionModel/regionModelI.H
+++ b/src/regionModels/regionModel/regionModel/regionModelI.H
@@ -132,7 +132,7 @@ Foam::regionModels::regionModel::intCoupledPatchIDs() const
 }
 
 
-inline const Foam::PtrList<Foam::directMappedPatchBase>&
+inline const Foam::PtrList<Foam::mappedPatchBase>&
 Foam::regionModels::regionModel::mappedPatches() const
 {
     return mappedPatches_;
diff --git a/src/regionModels/regionModel/singleLayerRegion/singleLayerRegion.C b/src/regionModels/regionModel/singleLayerRegion/singleLayerRegion.C
index 87118d9d2e..9a8d4db4e0 100644
--- a/src/regionModels/regionModel/singleLayerRegion/singleLayerRegion.C
+++ b/src/regionModels/regionModel/singleLayerRegion/singleLayerRegion.C
@@ -26,7 +26,6 @@ License
 #include "singleLayerRegion.H"
 #include "fvMesh.H"
 #include "Time.H"
-#include "directMappedWallPolyPatch.H"
 #include "zeroGradientFvPatchFields.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
diff --git a/src/regionModels/regionModel/singleLayerRegion/singleLayerRegionTemplates.C b/src/regionModels/regionModel/singleLayerRegion/singleLayerRegionTemplates.C
index f3252c00a8..1f0ae5700b 100644
--- a/src/regionModels/regionModel/singleLayerRegion/singleLayerRegionTemplates.C
+++ b/src/regionModels/regionModel/singleLayerRegion/singleLayerRegionTemplates.C
@@ -25,8 +25,8 @@ License
 
 #include "singleLayerRegion.H"
 #include "zeroGradientFvPatchFields.H"
-#include "directMappedFixedInternalValueFvPatchFields.H"
-#include "directMappedFixedPushedInternalValueFvPatchFields.H"
+#include "mappedFixedInternalValueFvPatchFields.H"
+#include "mappedFixedPushedInternalValueFvPatchFields.H"
 
 // * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * * //
 
@@ -41,8 +41,7 @@ Foam::regionModels::singleLayerRegion::mappedFieldAndInternalPatchTypes() const
     forAll(intCoupledPatchIDs_, i)
     {
         const label patchI = intCoupledPatchIDs_[i];
-        bTypes[patchI] =
-            directMappedFixedInternalValueFvPatchField<Type>::typeName;
+        bTypes[patchI] = mappedFixedInternalValueFvPatchField<Type>::typeName;
     }
 
     return bTypes;
@@ -61,7 +60,7 @@ Foam::regionModels::singleLayerRegion::mappedPushedFieldPatchTypes() const
     {
         const label patchI = intCoupledPatchIDs_[i];
         bTypes[patchI] =
-            directMappedFixedPushedInternalValueFvPatchField<Type>::typeName;
+            mappedFixedPushedInternalValueFvPatchField<Type>::typeName;
     }
 
     return bTypes;
diff --git a/src/regionModels/surfaceFilmModels/Make/options b/src/regionModels/surfaceFilmModels/Make/options
index 1db0d316db..1ef8337c6c 100644
--- a/src/regionModels/surfaceFilmModels/Make/options
+++ b/src/regionModels/surfaceFilmModels/Make/options
@@ -1,5 +1,7 @@
 EXE_INC = \
     -I$(LIB_SRC)/finiteVolume/lnInclude \
+    -I$(LIB_SRC)/sampling/lnInclude \
+    -I$(LIB_SRC)/AMIInterpolation/lnInclude \
     -I$(LIB_SRC)/meshTools/lnInclude \
     -I$(LIB_SRC)/thermophysicalModels/basic/lnInclude \
     -I$(LIB_SRC)/thermophysicalModels/specie/lnInclude \
@@ -11,15 +13,25 @@ EXE_INC = \
     -I$(LIB_SRC)/thermophysicalModels/SLGThermo/lnInclude \
     -I$(LIB_SRC)/lagrangian/distributionModels/lnInclude \
     -I$(LIB_SRC)/turbulenceModels \
-    -I$(LIB_SRC)/turbulenceModels/compressible/turbulenceModel \
+    -I$(LIB_SRC)/turbulenceModels/compressible/LES/lnInclude \
     -I$(LIB_SRC)/turbulenceModels/compressible/RAS/lnInclude \
     -I$(LIB_SRC)/regionModels/regionModel/lnInclude
 
 LIB_LIBS = \
-    -lregionModels \
-    -lSLGThermo \
     -lfiniteVolume \
+    -lsampling \
+    -lAMIInterpolation \
     -lmeshTools \
+    -lbasicThermophysicalModels \
+    -lspecie \
+    -lliquidProperties \
+    -lliquidMixtureProperties \
+    -lsolidProperties \
+    -lsolidMixtureProperties \
+    -lreactionThermophysicalModels \
+    -lSLGThermo \
     -ldistributionModels \
+    -lcompressibleTurbulenceModel \
     -lcompressibleRASModels \
-    -lcompressibleLESModels
+    -lcompressibleLESModels \
+    -lregionModels
diff --git a/src/regionModels/surfaceFilmModels/derivedFvPatchFields/wallFunctions/alphatFilmWallFunction/alphatFilmWallFunctionFvPatchScalarField.C b/src/regionModels/surfaceFilmModels/derivedFvPatchFields/wallFunctions/alphatFilmWallFunction/alphatFilmWallFunctionFvPatchScalarField.C
index 8960467fbd..63db76ed68 100644
--- a/src/regionModels/surfaceFilmModels/derivedFvPatchFields/wallFunctions/alphatFilmWallFunction/alphatFilmWallFunctionFvPatchScalarField.C
+++ b/src/regionModels/surfaceFilmModels/derivedFvPatchFields/wallFunctions/alphatFilmWallFunction/alphatFilmWallFunctionFvPatchScalarField.C
@@ -29,7 +29,7 @@ License
 #include "fvPatchFieldMapper.H"
 #include "volFields.H"
 #include "addToRunTimeSelectionTable.H"
-#include "directMappedWallPolyPatch.H"
+#include "mappedWallPolyPatch.H"
 #include "mapDistribute.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@@ -153,11 +153,11 @@ void alphatFilmWallFunctionFvPatchScalarField::updateCoeffs()
 
     const label filmPatchI = filmModel.regionPatchID(patchI);
 
-    const mapDistribute& distMap = filmModel.mappedPatches()[filmPatchI].map();
+    const mappedPatchBase& filmMap = filmModel.mappedPatches()[filmPatchI];
 
     tmp<volScalarField> mDotFilm(filmModel.primaryMassTrans());
     scalarField mDotFilmp = mDotFilm().boundaryField()[filmPatchI];
-    distMap.distribute(mDotFilmp);
+    filmMap.distribute(mDotFilmp);
 
     // Retrieve RAS turbulence model
     const RASModel& rasModel = db().lookupObject<RASModel>("RASProperties");
diff --git a/src/regionModels/surfaceFilmModels/derivedFvPatchFields/wallFunctions/mutkFilmWallFunction/mutkFilmWallFunctionFvPatchScalarField.C b/src/regionModels/surfaceFilmModels/derivedFvPatchFields/wallFunctions/mutkFilmWallFunction/mutkFilmWallFunctionFvPatchScalarField.C
index 348821df9b..8cd0aaf5aa 100644
--- a/src/regionModels/surfaceFilmModels/derivedFvPatchFields/wallFunctions/mutkFilmWallFunction/mutkFilmWallFunctionFvPatchScalarField.C
+++ b/src/regionModels/surfaceFilmModels/derivedFvPatchFields/wallFunctions/mutkFilmWallFunction/mutkFilmWallFunctionFvPatchScalarField.C
@@ -29,7 +29,7 @@ License
 #include "RASModel.H"
 #include "addToRunTimeSelectionTable.H"
 #include "surfaceFilmModel.H"
-#include "directMappedWallPolyPatch.H"
+#include "mappedWallPolyPatch.H"
 #include "mapDistribute.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@@ -70,11 +70,11 @@ tmp<scalarField> mutkFilmWallFunctionFvPatchScalarField::calcUTau
 
     const label filmPatchI = filmModel.regionPatchID(patchI);
 
-    const mapDistribute& distMap = filmModel.mappedPatches()[filmPatchI].map();
+    const mappedPatchBase& filmMap = filmModel.mappedPatches()[filmPatchI];
 
     tmp<volScalarField> mDotFilm(filmModel.primaryMassTrans());
     scalarField mDotFilmp = mDotFilm().boundaryField()[filmPatchI];
-    distMap.distribute(mDotFilmp);
+    filmMap.distribute(mDotFilmp);
 
 
     // Retrieve RAS turbulence model
diff --git a/src/regionModels/surfaceFilmModels/kinematicSingleLayer/kinematicSingleLayer.C b/src/regionModels/surfaceFilmModels/kinematicSingleLayer/kinematicSingleLayer.C
index b3f7b1a991..461fbd10ae 100644
--- a/src/regionModels/surfaceFilmModels/kinematicSingleLayer/kinematicSingleLayer.C
+++ b/src/regionModels/surfaceFilmModels/kinematicSingleLayer/kinematicSingleLayer.C
@@ -31,7 +31,7 @@ License
 #include "fvcReconstruct.H"
 #include "fvcVolumeIntegrate.H"
 #include "addToRunTimeSelectionTable.H"
-#include "directMappedWallPolyPatch.H"
+#include "mappedWallPolyPatch.H"
 #include "mapDistribute.H"
 
 #include "cachedRandom.H"
@@ -90,7 +90,7 @@ void kinematicSingleLayer::correctThermoFields()
             "void Foam::surfaceFilmModels::kinematicSingleLayer::"
             "correctThermo()"
         )   << "Kinematic surface film must use "
-            << thermoModelTypeNames_[thermoModel_] << "thermodynamics" << endl;
+            << thermoModelTypeNames_[tmConstant] << "thermodynamics" << endl;
     }
 }
 
@@ -115,6 +115,7 @@ void kinematicSingleLayer::transferPrimaryRegionThermoFields()
         Info<< "kinematicSingleLayer::"
             << "transferPrimaryRegionThermoFields()" << endl;
     }
+
     // Update fields from primary region via direct mapped
     // (coupled) boundary conditions
     UPrimary_.correctBoundaryConditions();
@@ -132,6 +133,18 @@ void kinematicSingleLayer::transferPrimaryRegionSourceFields()
             << "transferPrimaryRegionSourceFields()" << endl;
     }
 
+    // Convert accummulated source terms into per unit area per unit time
+    const scalar deltaT = time_.deltaTValue();
+    forAll(rhoSpPrimary_.boundaryField(), patchI)
+    {
+        const scalarField& priMagSf =
+            primaryMesh().magSf().boundaryField()[patchI];
+
+        rhoSpPrimary_.boundaryField()[patchI] /= priMagSf*deltaT;
+        USpPrimary_.boundaryField()[patchI] /= priMagSf*deltaT;
+        pSpPrimary_.boundaryField()[patchI] /= priMagSf*deltaT;
+    }
+
     // Retrieve the source fields from the primary region via direct mapped
     // (coupled) boundary conditions
     // - fields require transfer of values for both patch AND to push the
@@ -139,13 +152,6 @@ void kinematicSingleLayer::transferPrimaryRegionSourceFields()
     rhoSp_.correctBoundaryConditions();
     USp_.correctBoundaryConditions();
     pSp_.correctBoundaryConditions();
-
-    // Convert accummulated source terms into per unit area per unit time
-    // Note: boundary values will still have original (neat) values
-    const scalar deltaT = time_.deltaTValue();
-    rhoSp_.field() /= magSf()*deltaT;
-    USp_.field() /= magSf()*deltaT;
-    pSp_.field() /= magSf()*deltaT;
 }
 
 
diff --git a/src/regionModels/surfaceFilmModels/submodels/thermo/heatTransferModel/mappedConvectiveHeatTransfer/mappedConvectiveHeatTransfer.H b/src/regionModels/surfaceFilmModels/submodels/thermo/heatTransferModel/mappedConvectiveHeatTransfer/mappedConvectiveHeatTransfer.H
index 13e21759a7..f94ea58c21 100644
--- a/src/regionModels/surfaceFilmModels/submodels/thermo/heatTransferModel/mappedConvectiveHeatTransfer/mappedConvectiveHeatTransfer.H
+++ b/src/regionModels/surfaceFilmModels/submodels/thermo/heatTransferModel/mappedConvectiveHeatTransfer/mappedConvectiveHeatTransfer.H
@@ -65,7 +65,7 @@ private:
 
         //- Heat transfer coefficient - film region [W/m2/K]
         //  Assumes that the primary regtion to film region boundaries are
-        //  described as directMappedPushed types
+        //  described as mappedPushed types
         volScalarField htcConvFilm_;
 
 
diff --git a/src/regionModels/surfaceFilmModels/thermoSingleLayer/thermoSingleLayer.C b/src/regionModels/surfaceFilmModels/thermoSingleLayer/thermoSingleLayer.C
index c0c211444b..c6c373500f 100644
--- a/src/regionModels/surfaceFilmModels/thermoSingleLayer/thermoSingleLayer.C
+++ b/src/regionModels/surfaceFilmModels/thermoSingleLayer/thermoSingleLayer.C
@@ -29,7 +29,7 @@ License
 #include "fvm.H"
 #include "addToRunTimeSelectionTable.H"
 #include "zeroGradientFvPatchFields.H"
-#include "directMappedFieldFvPatchField.H"
+#include "mappedFieldFvPatchField.H"
 #include "mapDistribute.H"
 
 // Sub-models
@@ -59,7 +59,7 @@ wordList thermoSingleLayer::hsBoundaryTypes()
     wordList bTypes(T_.boundaryField().types());
     forAll(bTypes, patchI)
     {
-        if (bTypes[patchI] == directMappedFieldFvPatchField<scalar>::typeName)
+        if (bTypes[patchI] == mappedFieldFvPatchField<scalar>::typeName)
         {
             bTypes[patchI] = fixedValueFvPatchField<scalar>::typeName;
         }
@@ -150,7 +150,7 @@ void thermoSingleLayer::correctHsForMappedT()
     forAll(T_.boundaryField(), patchI)
     {
         const fvPatchField<scalar>& Tp = T_.boundaryField()[patchI];
-        if (isA<directMappedFieldFvPatchField<scalar> >(Tp))
+        if (isA<mappedFieldFvPatchField<scalar> >(Tp))
         {
             hs_.boundaryField()[patchI] == hs(Tp, patchI);
         }
@@ -206,17 +206,22 @@ void thermoSingleLayer::transferPrimaryRegionSourceFields()
 
     kinematicSingleLayer::transferPrimaryRegionSourceFields();
 
+    // Convert accummulated source terms into per unit area per unit time
+    const scalar deltaT = time_.deltaTValue();
+    forAll(hsSpPrimary_.boundaryField(), patchI)
+    {
+        const scalarField& priMagSf =
+            primaryMesh().magSf().boundaryField()[patchI];
+
+        hsSpPrimary_.boundaryField()[patchI] /= priMagSf*deltaT;
+    }
+
     // Retrieve the source fields from the primary region via direct mapped
     // (coupled) boundary conditions
     // - fields require transfer of values for both patch AND to push the
     //   values into the first layer of internal cells
     hsSp_.correctBoundaryConditions();
 
-    // Convert accummulated source terms into per unit area per unit time
-    // Note: boundary values will still have original (neat) values
-    const scalar deltaT = time_.deltaTValue();
-    hsSp_.field() /= magSf()*deltaT;
-
     // Apply enthalpy source as difference between incoming and actual states
     hsSp_ -= rhoSp_*hs_;
 }
@@ -700,11 +705,12 @@ tmp<DimensionedField<scalar, volMesh> > thermoSingleLayer::Srho() const
     forAll(intCoupledPatchIDs(), i)
     {
         const label filmPatchI = intCoupledPatchIDs()[i];
-        const mapDistribute& distMap = mappedPatches_[filmPatchI].map();
+        const mappedPatchBase& filmMap = mappedPatches_[filmPatchI];
 
         scalarField patchMass =
             primaryMassPCTrans_.boundaryField()[filmPatchI];
-        distMap.distribute(patchMass);
+
+        filmMap.distribute(patchMass);
 
         const label primaryPatchI = primaryPatchIDs()[i];
         const unallocLabelList& cells =
@@ -755,11 +761,12 @@ tmp<DimensionedField<scalar, volMesh> > thermoSingleLayer::Srho
         forAll(intCoupledPatchIDs_, i)
         {
             const label filmPatchI = intCoupledPatchIDs_[i];
-            const mapDistribute& distMap = mappedPatches_[filmPatchI].map();
+            const mappedPatchBase& filmMap = mappedPatches_[filmPatchI];
 
             scalarField patchMass =
                 primaryMassPCTrans_.boundaryField()[filmPatchI];
-            distMap.distribute(patchMass);
+
+            filmMap.distribute(patchMass);
 
             const label primaryPatchI = primaryPatchIDs()[i];
             const unallocLabelList& cells =
@@ -805,11 +812,12 @@ tmp<DimensionedField<scalar, volMesh> > thermoSingleLayer::Sh() const
     forAll(intCoupledPatchIDs_, i)
     {
         const label filmPatchI = intCoupledPatchIDs_[i];
-        const mapDistribute& distMap = mappedPatches_[filmPatchI].map();
+        const mappedPatchBase& filmMap = mappedPatches_[filmPatchI];
 
         scalarField patchEnergy =
             primaryEnergyPCTrans_.boundaryField()[filmPatchI];
-        distMap.distribute(patchEnergy);
+
+        filmMap.distribute(patchEnergy);
 
         const label primaryPatchI = primaryPatchIDs()[i];
         const unallocLabelList& cells =
diff --git a/src/regionModels/thermoBaffleModels/Make/options b/src/regionModels/thermoBaffleModels/Make/options
index 44ab48e425..ad043bc32e 100644
--- a/src/regionModels/thermoBaffleModels/Make/options
+++ b/src/regionModels/thermoBaffleModels/Make/options
@@ -4,6 +4,8 @@ EXE_INC = \
     -I$(LIB_SRC)/thermophysicalModels/solid/lnInclude \
     -I$(LIB_SRC)/finiteVolume/lnInclude \
     -I$(LIB_SRC)/meshTools/lnInclude \
+    -I$(LIB_SRC)/sampling/lnInclude \
+    -I$(LIB_SRC)/AMIInterpolation/lnInclude \
     -I$(LIB_SRC)/thermophysicalModels/basic/lnInclude \
     -I$(LIB_SRC)/thermophysicalModels/specie/lnInclude \
     -I$(LIB_SRC)/turbulenceModels/compressible/turbulenceModel/lnInclude
diff --git a/src/regionModels/thermoBaffleModels/derivedFvPatchFields/temperatureThermoBaffle/temperatureThermoBaffleFvPatchScalarField.C b/src/regionModels/thermoBaffleModels/derivedFvPatchFields/temperatureThermoBaffle/temperatureThermoBaffleFvPatchScalarField.C
index f3b420dd27..ae7552ae15 100644
--- a/src/regionModels/thermoBaffleModels/derivedFvPatchFields/temperatureThermoBaffle/temperatureThermoBaffleFvPatchScalarField.C
+++ b/src/regionModels/thermoBaffleModels/derivedFvPatchFields/temperatureThermoBaffle/temperatureThermoBaffleFvPatchScalarField.C
@@ -85,7 +85,7 @@ temperatureThermoBaffleFvPatchScalarField
     baffle_(),
     solidThermoType_()
 {
-    if (!isA<directMappedPatchBase>(patch().patch()))
+    if (!isA<mappedPatchBase>(patch().patch()))
     {
         FatalErrorIn
         (
@@ -97,7 +97,7 @@ temperatureThermoBaffleFvPatchScalarField
             "    const dictionary& dict\n"
             ")\n"
         )   << "\n    patch type '" << patch().type()
-            << "' not type '" << directMappedPatchBase::typeName << "'"
+            << "' not type '" << mappedPatchBase::typeName << "'"
             << "\n    for patch " << patch().name()
             << " of field " << dimensionedInternalField().name()
             << " in file " << dimensionedInternalField().objectPath()
diff --git a/src/regionModels/thermoBaffleModels/thermoBaffleModel/thermoBaffleModel.C b/src/regionModels/thermoBaffleModels/thermoBaffleModel/thermoBaffleModel.C
index b47ec3436f..7764366004 100644
--- a/src/regionModels/thermoBaffleModels/thermoBaffleModel/thermoBaffleModel.C
+++ b/src/regionModels/thermoBaffleModels/thermoBaffleModel/thermoBaffleModel.C
@@ -25,7 +25,7 @@ License
 
 #include "thermoBaffleModel.H"
 #include "fvMesh.H"
-#include "directMappedVariableThicknessWallPolyPatch.H"
+#include "mappedVariableThicknessWallPolyPatch.H"
 #include "wedgePolyPatch.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@@ -101,7 +101,7 @@ void thermoBaffleModel::init()
             const polyPatch& pp = rbm[patchI];
 
             if  (
-                    !isA<directMappedVariableThicknessWallPolyPatch>(pp)
+                    !isA<mappedVariableThicknessWallPolyPatch>(pp)
                  && oneD_
                  && !constantThickness_
                 )
@@ -115,13 +115,13 @@ void thermoBaffleModel::init()
                     ")"
                 )   << "\n    patch type '" << pp.type()
                     << "' not type '"
-                    << directMappedVariableThicknessWallPolyPatch::typeName
+                    << mappedVariableThicknessWallPolyPatch::typeName
                     << "'. This is necessary for 1D solution "
                     << " and variable thickness"
                     << "\n    for patch. " << pp.name()
                     << exit(FatalError);
             }
-            else if (!isA<directMappedWallPolyPatch>(pp))
+            else if (!isA<mappedWallPolyPatch>(pp))
             {
                 FatalErrorIn
                 (
@@ -132,7 +132,7 @@ void thermoBaffleModel::init()
                     ")"
                 )   << "\n    patch type '" << pp.type()
                     << "' not type '"
-                    << directMappedWallPolyPatch::typeName
+                    << mappedWallPolyPatch::typeName
                     << "'. This is necessary for 3D solution"
                     << "\n    for patch. " << pp.name()
                     << exit(FatalError);
@@ -143,10 +143,10 @@ void thermoBaffleModel::init()
         {
             const label patchI = intCoupledPatchIDs_[0];
             const polyPatch& pp = rbm[patchI];
-            const directMappedVariableThicknessWallPolyPatch& ppCoupled =
+            const mappedVariableThicknessWallPolyPatch& ppCoupled =
                 refCast
                 <
-                    const directMappedVariableThicknessWallPolyPatch
+                    const mappedVariableThicknessWallPolyPatch
                 >(pp);
 
             thickness_ = ppCoupled.thickness();

From 129a418ca4f0e04e1b09d449628d2f3b4ece41f0 Mon Sep 17 00:00:00 2001
From: andy <andy>
Date: Wed, 7 Sep 2011 13:11:56 +0100
Subject: [PATCH 37/45] ENH: Updated lagrangian libs to reflect AMI additions

---
 src/lagrangian/coalCombustion/Make/options    | 15 ++++++++--
 src/lagrangian/intermediate/Make/options      | 20 ++++++++-----
 .../SurfaceFilmModel/SurfaceFilmModel.C       | 20 ++++++-------
 .../SurfaceFilmModel/SurfaceFilmModel.H       |  4 +--
 .../ThermoSurfaceFilm/ThermoSurfaceFilm.C     | 13 +++++----
 .../ThermoSurfaceFilm/ThermoSurfaceFilm.H     |  2 +-
 src/lagrangian/spray/Make/options             | 29 +++++++++++--------
 7 files changed, 60 insertions(+), 43 deletions(-)

diff --git a/src/lagrangian/coalCombustion/Make/options b/src/lagrangian/coalCombustion/Make/options
index 7253a9073d..eecaa8d170 100644
--- a/src/lagrangian/coalCombustion/Make/options
+++ b/src/lagrangian/coalCombustion/Make/options
@@ -1,5 +1,7 @@
 EXE_INC = \
     -I$(LIB_SRC)/finiteVolume/lnInclude \
+    -I$(LIB_SRC)/sampling/lnInclude \
+    -I$(LIB_SRC)/AMIInterpolation/lnInclude \
     -I$(LIB_SRC)/meshTools/lnInclude \
     -I$(LIB_SRC)/lagrangian/basic/lnInclude \
     -I$(LIB_SRC)/lagrangian/intermediate/lnInclude \
@@ -14,16 +16,18 @@ EXE_INC = \
     -I$(LIB_SRC)/thermophysicalModels/SLGThermo/lnInclude \
     -I$(LIB_SRC)/thermophysicalModels/radiationModels/lnInclude \
     -I$(LIB_SRC)/turbulenceModels \
-    -I$(LIB_SRC)/turbulenceModels/compressible/turbulenceModel \
+    -I$(LIB_SRC)/turbulenceModels/compressible/turbulenceModel/lnInclude \
     -I$(LIB_SRC)/turbulenceModels/compressible/RAS/lnInclude \
     -I$(LIB_SRC)/turbulenceModels/LES/LESdeltas/lnInclude \
     -I$(LIB_SRC)/turbulenceModels/compressible/LES/lnInclude \
     -I$(LIB_SRC)/regionModels/regionModel/lnInclude \
     -I$(LIB_SRC)/regionModels/surfaceFilmModels/lnInclude \
-    -I$(LIB_SRC)/sampling/lnInclude
+    -I$(LIB_SRC)/dynamicFvMesh/lnInclude \
 
 LIB_LIBS = \
     -lfiniteVolume \
+    -lsampling \
+    -lAMIInterpolation \
     -lmeshTools \
     -llagrangian \
     -llagrangianIntermediate \
@@ -36,7 +40,12 @@ LIB_LIBS = \
     -lsolidMixtureProperties \
     -lreactionThermophysicalModels \
     -lSLGThermo \
+    -lradiationModels \
+    -lcompressibleTurbulenceModel \
     -lcompressibleRASModels \
     -lcompressibleLESModels \
+    -lLESdeltas \
     -lregionModels \
-    -lsurfaceFilmModels
+    -lsurfaceFilmModels \
+    -ldynamicFvMesh
+
diff --git a/src/lagrangian/intermediate/Make/options b/src/lagrangian/intermediate/Make/options
index 951d16cf58..8f4cd312f4 100644
--- a/src/lagrangian/intermediate/Make/options
+++ b/src/lagrangian/intermediate/Make/options
@@ -1,5 +1,7 @@
 EXE_INC = \
     -I$(LIB_SRC)/finiteVolume/lnInclude \
+    -I$(LIB_SRC)/sampling/lnInclude \
+    -I$(LIB_SRC)/AMIInterpolation/lnInclude \
     -I$(LIB_SRC)/meshTools/lnInclude \
     -I$(LIB_SRC)/lagrangian/basic/lnInclude \
     -I$(LIB_SRC)/lagrangian/distributionModels/lnInclude \
@@ -13,33 +15,35 @@ EXE_INC = \
     -I$(LIB_SRC)/thermophysicalModels/SLGThermo/lnInclude \
     -I$(LIB_SRC)/thermophysicalModels/radiationModels/lnInclude \
     -I$(LIB_SRC)/turbulenceModels \
-    -I$(LIB_SRC)/turbulenceModels/compressible/turbulenceModel \
+    -I$(LIB_SRC)/turbulenceModels/compressible/turbulenceModel/lnInclude \
     -I$(LIB_SRC)/turbulenceModels/compressible/RAS/lnInclude \
     -I$(LIB_SRC)/turbulenceModels/LES/LESdeltas/lnInclude \
     -I$(LIB_SRC)/turbulenceModels/compressible/LES/lnInclude \
     -I$(LIB_SRC)/regionModels/regionModel/lnInclude \
     -I$(LIB_SRC)/regionModels/surfaceFilmModels/lnInclude \
     -I$(LIB_SRC)/dynamicFvMesh/lnInclude \
-    -I$(LIB_SRC)/sampling/lnInclude
 
 LIB_LIBS = \
     -lfiniteVolume \
+    -lsampling \
+    -lAMIInterpolation \
     -lmeshTools \
     -llagrangian \
     -ldistributionModels \
+    -lspecie \
+    -lbasicThermophysicalModels \
     -lliquidProperties \
     -lliquidMixtureProperties \
     -lsolidProperties \
     -lsolidMixtureProperties \
-    -lspecie \
-    -lbasicThermophysicalModels \
     -lreactionThermophysicalModels \
     -lSLGThermo \
-    -lchemistryModel \
     -lradiationModels \
-    -lODE \
+    -lcompressibleTurbulenceModel \
     -lcompressibleRASModels \
     -lcompressibleLESModels \
-    -ldynamicFvMesh \
-    -lsurfaceFilmModels
+    -lLESdeltas \
+    -lregionModels \
+    -lsurfaceFilmModels \
+    -ldynamicFvMesh
 
diff --git a/src/lagrangian/intermediate/submodels/Kinematic/SurfaceFilmModel/SurfaceFilmModel/SurfaceFilmModel.C b/src/lagrangian/intermediate/submodels/Kinematic/SurfaceFilmModel/SurfaceFilmModel/SurfaceFilmModel.C
index 30387baa1d..36dca28f6a 100644
--- a/src/lagrangian/intermediate/submodels/Kinematic/SurfaceFilmModel/SurfaceFilmModel/SurfaceFilmModel.C
+++ b/src/lagrangian/intermediate/submodels/Kinematic/SurfaceFilmModel/SurfaceFilmModel/SurfaceFilmModel.C
@@ -26,7 +26,7 @@ License
 #include "SurfaceFilmModel.H"
 #include "surfaceFilmModel.H"
 #include "mathematicalConstants.H"
-#include "directMappedWallPolyPatch.H"
+#include "mappedPatchBase.H"
 
 using namespace Foam::constant;
 
@@ -156,13 +156,11 @@ void Foam::SurfaceFilmModel<CloudType>::inject(TrackData& td)
         const label filmPatchI = filmPatches[i];
         const label primaryPatchI = primaryPatches[i];
 
-        const directMappedPatchBase& mapPatch =
-            filmModel.mappedPatches()[filmPatchI];
-        const mapDistribute& distMap = mapPatch.map();
+        const mappedPatchBase& mapPatch = filmModel.mappedPatches()[filmPatchI];
 
         const labelList& injectorCellsPatch = pbm[primaryPatchI].faceCells();
 
-        cacheFilmFields(filmPatchI, primaryPatchI, distMap, filmModel);
+        cacheFilmFields(filmPatchI, primaryPatchI, mapPatch, filmModel);
 
         const vectorField& Cf = mesh.C().boundaryField()[primaryPatchI];
         const vectorField& Sf = mesh.Sf().boundaryField()[primaryPatchI];
@@ -229,26 +227,26 @@ void Foam::SurfaceFilmModel<CloudType>::cacheFilmFields
 (
     const label filmPatchI,
     const label primaryPatchI,
-    const mapDistribute& distMap,
+    const mappedPatchBase& mapPatch,
     const regionModels::surfaceFilmModels::surfaceFilmModel& filmModel
 )
 {
     massParcelPatch_ = filmModel.cloudMassTrans().boundaryField()[filmPatchI];
-    distMap.distribute(massParcelPatch_);
+    mapPatch.distribute(massParcelPatch_);
 
     diameterParcelPatch_ =
         filmModel.cloudDiameterTrans().boundaryField()[filmPatchI];
-    distMap.distribute(diameterParcelPatch_);
+    mapPatch.distribute(diameterParcelPatch_);
 
     UFilmPatch_ = filmModel.Us().boundaryField()[filmPatchI];
-    distMap.distribute(UFilmPatch_);
+    mapPatch.distribute(UFilmPatch_);
 
     rhoFilmPatch_ = filmModel.rho().boundaryField()[filmPatchI];
-    distMap.distribute(rhoFilmPatch_);
+    mapPatch.distribute(rhoFilmPatch_);
 
     deltaFilmPatch_[primaryPatchI] =
         filmModel.delta().boundaryField()[filmPatchI];
-    distMap.distribute(deltaFilmPatch_[primaryPatchI]);
+    mapPatch.distribute(deltaFilmPatch_[primaryPatchI]);
 }
 
 
diff --git a/src/lagrangian/intermediate/submodels/Kinematic/SurfaceFilmModel/SurfaceFilmModel/SurfaceFilmModel.H b/src/lagrangian/intermediate/submodels/Kinematic/SurfaceFilmModel/SurfaceFilmModel/SurfaceFilmModel.H
index c8c6b03a12..ae35db7ec5 100644
--- a/src/lagrangian/intermediate/submodels/Kinematic/SurfaceFilmModel/SurfaceFilmModel/SurfaceFilmModel.H
+++ b/src/lagrangian/intermediate/submodels/Kinematic/SurfaceFilmModel/SurfaceFilmModel/SurfaceFilmModel.H
@@ -55,7 +55,7 @@ namespace regionModels
     }
 }
 
-class mapDistribute;
+class mappedPatchBase;
 
 /*---------------------------------------------------------------------------*\
                       Class SurfaceFilmModel Declaration
@@ -116,7 +116,7 @@ protected:
         (
             const label filmPatchI,
             const label primaryPatchI,
-            const mapDistribute& distMap,
+            const mappedPatchBase& mapPatch,
             const regionModels::surfaceFilmModels::surfaceFilmModel& filmModel
         );
 
diff --git a/src/lagrangian/intermediate/submodels/Thermodynamic/SurfaceFilmModel/ThermoSurfaceFilm/ThermoSurfaceFilm.C b/src/lagrangian/intermediate/submodels/Thermodynamic/SurfaceFilmModel/ThermoSurfaceFilm/ThermoSurfaceFilm.C
index 27818af43f..c6f4b4054a 100644
--- a/src/lagrangian/intermediate/submodels/Thermodynamic/SurfaceFilmModel/ThermoSurfaceFilm/ThermoSurfaceFilm.C
+++ b/src/lagrangian/intermediate/submodels/Thermodynamic/SurfaceFilmModel/ThermoSurfaceFilm/ThermoSurfaceFilm.C
@@ -620,8 +620,9 @@ bool Foam::ThermoSurfaceFilm<CloudType>::transferParcel
                 (
                     "bool ThermoSurfaceFilm<CloudType>::transferParcel"
                     "("
-                        "const parcelType&, "
-                        "const label"
+                        "parcelType&, "
+                        "const polyPatch&, "
+                        "bool&"
                     ")"
                 )   << "Unknown interaction type enumeration"
                     << abort(FatalError);
@@ -642,7 +643,7 @@ void Foam::ThermoSurfaceFilm<CloudType>::cacheFilmFields
 (
     const label filmPatchI,
     const label primaryPatchI,
-    const mapDistribute& distMap,
+    const mappedPatchBase& mapPatch,
     const regionModels::surfaceFilmModels::surfaceFilmModel& filmModel
 )
 {
@@ -650,15 +651,15 @@ void Foam::ThermoSurfaceFilm<CloudType>::cacheFilmFields
     (
         filmPatchI,
         primaryPatchI,
-        distMap,
+        mapPatch,
         filmModel
     );
 
     TFilmPatch_ = filmModel.Ts().boundaryField()[filmPatchI];
-    distMap.distribute(TFilmPatch_);
+    mapPatch.distribute(TFilmPatch_);
 
     CpFilmPatch_ = filmModel.Cp().boundaryField()[filmPatchI];
-    distMap.distribute(CpFilmPatch_);
+    mapPatch.distribute(CpFilmPatch_);
 }
 
 
diff --git a/src/lagrangian/intermediate/submodels/Thermodynamic/SurfaceFilmModel/ThermoSurfaceFilm/ThermoSurfaceFilm.H b/src/lagrangian/intermediate/submodels/Thermodynamic/SurfaceFilmModel/ThermoSurfaceFilm/ThermoSurfaceFilm.H
index 76f0679abe..66bd139568 100644
--- a/src/lagrangian/intermediate/submodels/Thermodynamic/SurfaceFilmModel/ThermoSurfaceFilm/ThermoSurfaceFilm.H
+++ b/src/lagrangian/intermediate/submodels/Thermodynamic/SurfaceFilmModel/ThermoSurfaceFilm/ThermoSurfaceFilm.H
@@ -227,7 +227,7 @@ protected:
             (
                 const label filmPatchI,
                 const label primaryPatchI,
-                const mapDistribute& distMap,
+                const mappedPatchBase& distMap,
                 const regionModels::surfaceFilmModels::surfaceFilmModel&
                     filmModel
             );
diff --git a/src/lagrangian/spray/Make/options b/src/lagrangian/spray/Make/options
index 0d8cf66e84..eecaa8d170 100644
--- a/src/lagrangian/spray/Make/options
+++ b/src/lagrangian/spray/Make/options
@@ -1,6 +1,11 @@
 EXE_INC = \
     -I$(LIB_SRC)/finiteVolume/lnInclude \
+    -I$(LIB_SRC)/sampling/lnInclude \
+    -I$(LIB_SRC)/AMIInterpolation/lnInclude \
     -I$(LIB_SRC)/meshTools/lnInclude \
+    -I$(LIB_SRC)/lagrangian/basic/lnInclude \
+    -I$(LIB_SRC)/lagrangian/intermediate/lnInclude \
+    -I$(LIB_SRC)/lagrangian/distributionModels/lnInclude \
     -I$(LIB_SRC)/thermophysicalModels/specie/lnInclude \
     -I$(LIB_SRC)/thermophysicalModels/basic/lnInclude \
     -I$(LIB_SRC)/thermophysicalModels/properties/liquidProperties/lnInclude \
@@ -10,37 +15,37 @@ EXE_INC = \
     -I$(LIB_SRC)/thermophysicalModels/reactionThermo/lnInclude \
     -I$(LIB_SRC)/thermophysicalModels/SLGThermo/lnInclude \
     -I$(LIB_SRC)/thermophysicalModels/radiationModels/lnInclude \
-    -I$(LIB_SRC)/lagrangian/distributionModels/lnInclude \
-    -I$(LIB_SRC)/lagrangian/basic/lnInclude \
-    -I$(LIB_SRC)/lagrangian/intermediate/lnInclude \
     -I$(LIB_SRC)/turbulenceModels \
-    -I$(LIB_SRC)/turbulenceModels/compressible/turbulenceModel \
+    -I$(LIB_SRC)/turbulenceModels/compressible/turbulenceModel/lnInclude \
     -I$(LIB_SRC)/turbulenceModels/compressible/RAS/lnInclude \
     -I$(LIB_SRC)/turbulenceModels/LES/LESdeltas/lnInclude \
     -I$(LIB_SRC)/turbulenceModels/compressible/LES/lnInclude \
     -I$(LIB_SRC)/regionModels/regionModel/lnInclude \
     -I$(LIB_SRC)/regionModels/surfaceFilmModels/lnInclude \
     -I$(LIB_SRC)/dynamicFvMesh/lnInclude \
-    -I$(LIB_SRC)/sampling/lnInclude
 
 LIB_LIBS = \
     -lfiniteVolume \
+    -lsampling \
+    -lAMIInterpolation \
     -lmeshTools \
-    -ldistributionModels \
     -llagrangian \
     -llagrangianIntermediate \
+    -ldistributionModels \
+    -lspecie \
+    -lbasicThermophysicalModels \
     -lliquidProperties \
     -lliquidMixtureProperties \
     -lsolidProperties \
     -lsolidMixtureProperties \
-    -lspecie \
-    -lbasicThermophysicalModels \
     -lreactionThermophysicalModels \
     -lSLGThermo \
-    -lchemistryModel \
     -lradiationModels \
-    -lODE \
+    -lcompressibleTurbulenceModel \
     -lcompressibleRASModels \
     -lcompressibleLESModels \
-    -ldynamicFvMesh \
-    -lsurfaceFilmModels
+    -lLESdeltas \
+    -lregionModels \
+    -lsurfaceFilmModels \
+    -ldynamicFvMesh
+

From f8256175ebb7ccce71f4d74e663264b1c8577ebb Mon Sep 17 00:00:00 2001
From: andy <andy>
Date: Wed, 7 Sep 2011 13:12:31 +0100
Subject: [PATCH 38/45] ENH: Removed unnecessary libs entry from tutorial file

---
 .../pimpleDyMFoam/mixerVesselAMI2D/system/controlDict           | 2 --
 1 file changed, 2 deletions(-)

diff --git a/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/system/controlDict b/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/system/controlDict
index aa73ebeb25..e550f81b7d 100644
--- a/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/system/controlDict
+++ b/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/system/controlDict
@@ -15,8 +15,6 @@ FoamFile
 }
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-libs            ("libAMIInterpolation.so");
-
 application     pimpleDyMFoam;
 
 startFrom       startTime; // latestTime;

From 3efe53ce5d2930ecff70f028614711a34c76ff5e Mon Sep 17 00:00:00 2001
From: andy <andy>
Date: Wed, 7 Sep 2011 13:12:50 +0100
Subject: [PATCH 39/45] ENH: Updated solvers to reflect new AMI functionality

---
 applications/solvers/combustion/fireFoam/Make/options           | 1 +
 .../solvers/heatTransfer/buoyantBaffleSimpleFoam/Make/options   | 2 ++
 .../solvers/lagrangian/LTSReactingParcelFoam/Make/options       | 1 +
 applications/solvers/lagrangian/coalChemistryFoam/Make/options  | 1 +
 .../lagrangian/icoUncoupledKinematicParcelDyMFoam/Make/options  | 1 +
 .../lagrangian/icoUncoupledKinematicParcelFoam/Make/options     | 1 +
 .../porousExplicitSourceReactingParcelFoam/Make/options         | 1 +
 .../solvers/lagrangian/reactingParcelFilmFoam/Make/options      | 1 +
 applications/solvers/lagrangian/reactingParcelFoam/Make/options | 1 +
 applications/solvers/lagrangian/sprayFoam/Make/options          | 1 +
 .../lagrangian/uncoupledKinematicParcelFoam/Make/options        | 1 +
 11 files changed, 12 insertions(+)

diff --git a/applications/solvers/combustion/fireFoam/Make/options b/applications/solvers/combustion/fireFoam/Make/options
index cf5b4b0976..a13be9eb16 100644
--- a/applications/solvers/combustion/fireFoam/Make/options
+++ b/applications/solvers/combustion/fireFoam/Make/options
@@ -1,6 +1,7 @@
 EXE_INC = \
     -I$(LIB_SRC)/finiteVolume/lnInclude \
     -I${LIB_SRC}/meshTools/lnInclude \
+    -I${LIB_SRC}/AMIInterpolation/lnInclude \
     -I$(LIB_SRC)/turbulenceModels/compressible/turbulenceModel \
     -I$(LIB_SRC)/lagrangian/distributionModels/lnInclude \
     -I$(LIB_SRC)/thermophysicalModels/specie/lnInclude \
diff --git a/applications/solvers/heatTransfer/buoyantBaffleSimpleFoam/Make/options b/applications/solvers/heatTransfer/buoyantBaffleSimpleFoam/Make/options
index 0c40e89430..94bad3527b 100644
--- a/applications/solvers/heatTransfer/buoyantBaffleSimpleFoam/Make/options
+++ b/applications/solvers/heatTransfer/buoyantBaffleSimpleFoam/Make/options
@@ -3,6 +3,8 @@ EXE_INC = \
     -I$(LIB_SRC)/thermophysicalModels/basicSolidThermo/lnInclude \
     -I$(LIB_SRC)/thermophysicalModels/specie/lnInclude \
     -I$(LIB_SRC)/meshTools/lnInclude \
+    -I$(LIB_SRC)/sampling/lnInclude \
+    -I$(LIB_SRC)/AMIInterpolation/lnInclude \
     -I$(LIB_SRC)/turbulenceModels \
     -I$(LIB_SRC)/turbulenceModels/compressible/RAS/lnInclude \
     -I$(LIB_SRC)/finiteVolume/cfdTools \
diff --git a/applications/solvers/lagrangian/LTSReactingParcelFoam/Make/options b/applications/solvers/lagrangian/LTSReactingParcelFoam/Make/options
index 36e9c44270..0a39f85de5 100644
--- a/applications/solvers/lagrangian/LTSReactingParcelFoam/Make/options
+++ b/applications/solvers/lagrangian/LTSReactingParcelFoam/Make/options
@@ -1,6 +1,7 @@
 EXE_INC = \
     -I$(LIB_SRC)/finiteVolume/lnInclude \
     -I${LIB_SRC}/meshTools/lnInclude \
+    -I${LIB_SRC}/AMIInterpolation/lnInclude \
     -I$(LIB_SRC)/turbulenceModels/compressible/turbulenceModel \
     -I$(LIB_SRC)/lagrangian/basic/lnInclude \
     -I$(LIB_SRC)/lagrangian/intermediate/lnInclude \
diff --git a/applications/solvers/lagrangian/coalChemistryFoam/Make/options b/applications/solvers/lagrangian/coalChemistryFoam/Make/options
index e8a8718373..249770edda 100644
--- a/applications/solvers/lagrangian/coalChemistryFoam/Make/options
+++ b/applications/solvers/lagrangian/coalChemistryFoam/Make/options
@@ -1,6 +1,7 @@
 EXE_INC = \
     -I$(LIB_SRC)/finiteVolume/lnInclude \
     -I${LIB_SRC}/meshTools/lnInclude \
+    -I${LIB_SRC}/AMIInterpolation/lnInclude \
     -I$(LIB_SRC)/turbulenceModels/compressible/turbulenceModel \
     -I$(LIB_SRC)/lagrangian/basic/lnInclude \
     -I$(LIB_SRC)/lagrangian/intermediate/lnInclude \
diff --git a/applications/solvers/lagrangian/icoUncoupledKinematicParcelDyMFoam/Make/options b/applications/solvers/lagrangian/icoUncoupledKinematicParcelDyMFoam/Make/options
index 0786933541..028b94748a 100644
--- a/applications/solvers/lagrangian/icoUncoupledKinematicParcelDyMFoam/Make/options
+++ b/applications/solvers/lagrangian/icoUncoupledKinematicParcelDyMFoam/Make/options
@@ -11,6 +11,7 @@ EXE_INC = \
     -I$(LIB_SRC)/transportModels/incompressible/singlePhaseTransportModel \
     -I$(LIB_SRC)/finiteVolume/lnInclude \
     -I$(LIB_SRC)/meshTools/lnInclude \
+    -I$(LIB_SRC)/AMIInterpolation/lnInclude \
     -I$(LIB_SRC)/regionModels/regionModel/lnInclude \
     -I$(LIB_SRC)/regionModels/surfaceFilmModels/lnInclude \
     -I$(LIB_SRC)/dynamicMesh/lnInclude \
diff --git a/applications/solvers/lagrangian/icoUncoupledKinematicParcelFoam/Make/options b/applications/solvers/lagrangian/icoUncoupledKinematicParcelFoam/Make/options
index 58d80278f8..a78bf84fb8 100644
--- a/applications/solvers/lagrangian/icoUncoupledKinematicParcelFoam/Make/options
+++ b/applications/solvers/lagrangian/icoUncoupledKinematicParcelFoam/Make/options
@@ -10,6 +10,7 @@ EXE_INC = \
     -I$(LIB_SRC)/transportModels/incompressible/singlePhaseTransportModel \
     -I$(LIB_SRC)/finiteVolume/lnInclude \
     -I$(LIB_SRC)/meshTools/lnInclude \
+    -I$(LIB_SRC)/AMIInterpolation/lnInclude \
     -I$(LIB_SRC)/regionModels/regionModel/lnInclude \
     -I$(LIB_SRC)/regionModels/surfaceFilmModels/lnInclude \
     -I$(LIB_SRC)/sampling/lnInclude
diff --git a/applications/solvers/lagrangian/porousExplicitSourceReactingParcelFoam/Make/options b/applications/solvers/lagrangian/porousExplicitSourceReactingParcelFoam/Make/options
index 1abdd72178..baeb756a8c 100644
--- a/applications/solvers/lagrangian/porousExplicitSourceReactingParcelFoam/Make/options
+++ b/applications/solvers/lagrangian/porousExplicitSourceReactingParcelFoam/Make/options
@@ -1,6 +1,7 @@
 EXE_INC = \
     -I$(LIB_SRC)/finiteVolume/lnInclude \
     -I${LIB_SRC}/meshTools/lnInclude \
+    -I${LIB_SRC}/AMIInterpolation/lnInclude \
     -I$(LIB_SRC)/turbulenceModels/compressible/turbulenceModel \
     -I$(LIB_SRC)/lagrangian/basic/lnInclude \
     -I$(LIB_SRC)/lagrangian/intermediate/lnInclude \
diff --git a/applications/solvers/lagrangian/reactingParcelFilmFoam/Make/options b/applications/solvers/lagrangian/reactingParcelFilmFoam/Make/options
index 3f762b6bd0..2e838974ac 100644
--- a/applications/solvers/lagrangian/reactingParcelFilmFoam/Make/options
+++ b/applications/solvers/lagrangian/reactingParcelFilmFoam/Make/options
@@ -1,6 +1,7 @@
 EXE_INC = \
     -I$(LIB_SRC)/finiteVolume/lnInclude \
     -I${LIB_SRC}/meshTools/lnInclude \
+    -I${LIB_SRC}/AMIInterpolation/lnInclude \
     -I$(LIB_SRC)/turbulenceModels/compressible/turbulenceModel \
     -I$(LIB_SRC)/lagrangian/distributionModels/lnInclude \
     -I$(LIB_SRC)/thermophysicalModels/specie/lnInclude \
diff --git a/applications/solvers/lagrangian/reactingParcelFoam/Make/options b/applications/solvers/lagrangian/reactingParcelFoam/Make/options
index e406727104..90f455bf4c 100644
--- a/applications/solvers/lagrangian/reactingParcelFoam/Make/options
+++ b/applications/solvers/lagrangian/reactingParcelFoam/Make/options
@@ -1,6 +1,7 @@
 EXE_INC = \
     -I$(LIB_SRC)/finiteVolume/lnInclude \
     -I${LIB_SRC}/meshTools/lnInclude \
+    -I${LIB_SRC}/AMIInterpolation/lnInclude \
     -I$(LIB_SRC)/turbulenceModels/compressible/turbulenceModel \
     -I$(LIB_SRC)/lagrangian/basic/lnInclude \
     -I$(LIB_SRC)/lagrangian/intermediate/lnInclude \
diff --git a/applications/solvers/lagrangian/sprayFoam/Make/options b/applications/solvers/lagrangian/sprayFoam/Make/options
index f4c66f06f9..a7faafdf69 100644
--- a/applications/solvers/lagrangian/sprayFoam/Make/options
+++ b/applications/solvers/lagrangian/sprayFoam/Make/options
@@ -1,6 +1,7 @@
 EXE_INC = \
     -I$(LIB_SRC)/finiteVolume/lnInclude \
     -I${LIB_SRC}/meshTools/lnInclude \
+    -I${LIB_SRC}/AMIInterpolation/lnInclude \
     -I$(LIB_SRC)/turbulenceModels/compressible/turbulenceModel \
     -I$(LIB_SRC)/lagrangian/basic/lnInclude \
     -I$(LIB_SRC)/lagrangian/intermediate/lnInclude \
diff --git a/applications/solvers/lagrangian/uncoupledKinematicParcelFoam/Make/options b/applications/solvers/lagrangian/uncoupledKinematicParcelFoam/Make/options
index 7a7ddc0432..0926a980e1 100644
--- a/applications/solvers/lagrangian/uncoupledKinematicParcelFoam/Make/options
+++ b/applications/solvers/lagrangian/uncoupledKinematicParcelFoam/Make/options
@@ -8,6 +8,7 @@ EXE_INC = \
     -I$(LIB_SRC)/turbulenceModels/compressible/turbulenceModel \
     -I$(LIB_SRC)/finiteVolume/lnInclude \
     -I$(LIB_SRC)/meshTools/lnInclude \
+    -I$(LIB_SRC)/AMIInterpolation/lnInclude \
     -I$(LIB_SRC)/regionModels/regionModel/lnInclude \
     -I$(LIB_SRC)/regionModels/surfaceFilmModels/lnInclude \
     -I$(LIB_SRC)/sampling/lnInclude

From dca1a75c97eca7816e5be05c95d5589985357b22 Mon Sep 17 00:00:00 2001
From: andy <andy>
Date: Wed, 7 Sep 2011 13:15:10 +0100
Subject: [PATCH 40/45] ENH: Added AMI lib to link options for pimpleDyMFoam
 solver

---
 .../incompressible/pimpleFoam/pimpleDyMFoam/Make/options       | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/applications/solvers/incompressible/pimpleFoam/pimpleDyMFoam/Make/options b/applications/solvers/incompressible/pimpleFoam/pimpleDyMFoam/Make/options
index 6af3735d63..8d15f96a68 100644
--- a/applications/solvers/incompressible/pimpleFoam/pimpleDyMFoam/Make/options
+++ b/applications/solvers/incompressible/pimpleFoam/pimpleDyMFoam/Make/options
@@ -16,4 +16,5 @@ EXE_LIBS = \
     -lincompressibleTransportModels \
     -lincompressibleRASModels \
     -lincompressibleLESModels \
-    -lfiniteVolume
+    -lfiniteVolume \
+    -lAMIInterpolation

From 24931318109d8efe5973697f85bc378305687278 Mon Sep 17 00:00:00 2001
From: andy <andy>
Date: Wed, 7 Sep 2011 14:39:50 +0100
Subject: [PATCH 41/45] ENH: Added default to AMI surface type (polyPatch)

---
 .../patches/cyclic/cyclicAMIPolyPatch/cyclicAMIPolyPatch.C      | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/AMIInterpolation/patches/cyclic/cyclicAMIPolyPatch/cyclicAMIPolyPatch.C b/src/AMIInterpolation/patches/cyclic/cyclicAMIPolyPatch/cyclicAMIPolyPatch.C
index c046f23ac5..9f80e7f2b4 100644
--- a/src/AMIInterpolation/patches/cyclic/cyclicAMIPolyPatch/cyclicAMIPolyPatch.C
+++ b/src/AMIInterpolation/patches/cyclic/cyclicAMIPolyPatch/cyclicAMIPolyPatch.C
@@ -580,7 +580,7 @@ bool Foam::cyclicAMIPolyPatch::owner() const
 const Foam::autoPtr<Foam::searchableSurface>&
 Foam::cyclicAMIPolyPatch::surfPtr()
 {
-    word surfType(surfDict_.lookup("type"));
+    const word surfType(surfDict_.lookupOrDefault<word>("type", "none"));
 
     if (!surfPtr_.valid() && owner() && surfType != "none")
     {

From 72b63eff7596b872dc50e780a57d4d3528ca1913 Mon Sep 17 00:00:00 2001
From: andy <andy>
Date: Wed, 7 Sep 2011 14:40:21 +0100
Subject: [PATCH 42/45] ENH: Added output of 'value' entry for AMI fvPatchField
 type

---
 .../patches/cyclic/cyclicAMIFvPatchField/cyclicAMIFvPatchField.C | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/AMIInterpolation/patches/cyclic/cyclicAMIFvPatchField/cyclicAMIFvPatchField.C b/src/AMIInterpolation/patches/cyclic/cyclicAMIFvPatchField/cyclicAMIFvPatchField.C
index 121dc2d088..5642e9a36a 100644
--- a/src/AMIInterpolation/patches/cyclic/cyclicAMIFvPatchField/cyclicAMIFvPatchField.C
+++ b/src/AMIInterpolation/patches/cyclic/cyclicAMIFvPatchField/cyclicAMIFvPatchField.C
@@ -210,6 +210,7 @@ template<class Type>
 void Foam::cyclicAMIFvPatchField<Type>::write(Ostream& os) const
 {
     fvPatchField<Type>::write(os);
+    this->writeEntry("value", os);
 }
 
 

From 5f57bab77efbc0a8175aaaf83cbf883553167f61 Mon Sep 17 00:00:00 2001
From: andy <andy>
Date: Wed, 7 Sep 2011 14:40:53 +0100
Subject: [PATCH 43/45] BUG: AMI - using points() instead of localPoints()

---
 src/AMIInterpolation/AMIInterpolation/AMIInterpolation.C | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/AMIInterpolation/AMIInterpolation/AMIInterpolation.C b/src/AMIInterpolation/AMIInterpolation/AMIInterpolation.C
index 031291cce7..dc056cc9ce 100644
--- a/src/AMIInterpolation/AMIInterpolation/AMIInterpolation.C
+++ b/src/AMIInterpolation/AMIInterpolation/AMIInterpolation.C
@@ -995,7 +995,7 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::normaliseWeights
         scalar s = sum(wght[faceI]);
         wghtSum[faceI] = s;
 
-        scalar t = s/patch[faceI].mag(patch.localPoints());
+        scalar t = s/patch[faceI].mag(patch.points());
         if (t < minBound)
         {
             minBound = t;

From 6b12073a6bdb9c1189d047025cee772c322c5d63 Mon Sep 17 00:00:00 2001
From: andy <andy>
Date: Wed, 7 Sep 2011 14:41:13 +0100
Subject: [PATCH 44/45] ENH: Updated AMI tutorial case

---
 .../pimpleDyMFoam/mixerVesselAMI2D/0/U        |  2 ++
 .../pimpleDyMFoam/mixerVesselAMI2D/0/epsilon  |  2 ++
 .../pimpleDyMFoam/mixerVesselAMI2D/0/k        |  2 ++
 .../pimpleDyMFoam/mixerVesselAMI2D/0/nut      |  2 ++
 .../pimpleDyMFoam/mixerVesselAMI2D/0/p        |  2 ++
 .../constant/polyMesh/boundary                | 24 ++++++++++---------
 6 files changed, 23 insertions(+), 11 deletions(-)

diff --git a/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/0/U b/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/0/U
index 50bd4d0f7d..1904f895ce 100644
--- a/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/0/U
+++ b/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/0/U
@@ -45,11 +45,13 @@ boundaryField
     AMI1
     {
         type            cyclicAMI;
+        value           $internalField;
     }
 
     AMI2
     {
         type            cyclicAMI;
+        value           $internalField;
     }
 }
 
diff --git a/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/0/epsilon b/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/0/epsilon
index 194592df48..a07beadefa 100644
--- a/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/0/epsilon
+++ b/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/0/epsilon
@@ -46,11 +46,13 @@ boundaryField
     AMI1
     {
         type            cyclicAMI;
+        value           $internalField;
     }
 
     AMI2
     {
         type            cyclicAMI;
+        value           $internalField;
     }
 }
 
diff --git a/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/0/k b/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/0/k
index 85b3438cca..722a31a750 100644
--- a/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/0/k
+++ b/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/0/k
@@ -46,11 +46,13 @@ boundaryField
     AMI1
     {
         type            cyclicAMI;
+        value           $internalField;
     }
 
     AMI2
     {
         type            cyclicAMI;
+        value           $internalField;
     }
 }
 
diff --git a/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/0/nut b/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/0/nut
index 4f141eadcd..7976d3f70e 100644
--- a/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/0/nut
+++ b/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/0/nut
@@ -46,11 +46,13 @@ boundaryField
     AMI1
     {
         type            cyclicAMI;
+        value           $internalField;
     }
 
     AMI2
     {
         type            cyclicAMI;
+        value           $internalField;
     }
 }
 
diff --git a/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/0/p b/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/0/p
index f6a25dfd5b..db4b0f6a54 100644
--- a/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/0/p
+++ b/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/0/p
@@ -43,11 +43,13 @@ boundaryField
     AMI1
     {
         type            cyclicAMI;
+        value           $internalField;
     }
 
     AMI2
     {
         type            cyclicAMI;
+        value           $internalField;
     }
 }
 
diff --git a/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/constant/polyMesh/boundary b/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/constant/polyMesh/boundary
index edd458d6b3..49d194b96c 100644
--- a/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/constant/polyMesh/boundary
+++ b/tutorials/incompressible/pimpleDyMFoam/mixerVesselAMI2D/constant/polyMesh/boundary
@@ -1,7 +1,7 @@
 /*--------------------------------*- C++ -*----------------------------------*\
 | =========                 |                                                 |
 | \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
-|  \\    /   O peration     | Version:  dev                                   |
+|  \\    /   O peration     | Version:  dev.olesenm                           |
 |   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
 |    \\/     M anipulation  |                                                 |
 \*---------------------------------------------------------------------------*/
@@ -36,12 +36,13 @@ FoamFile
         startFace       6240;
         matchTolerance  0.0001;
         neighbourPatch  AMI2;
-        transform       translational;
-        separationVector (0 0 0);
-        surface         
+        transform       noOrdering;
+        surface
         {
-            type            triSurfaceMesh;
-            name            projectionSurface.stl;
+            type            searchableCylinder; // none
+            point1          (0 0 -1);
+            point2          (0 0 1);
+            radius          0.5;
         }
     }
     AMI2
@@ -51,12 +52,13 @@ FoamFile
         startFace       6336;
         matchTolerance  0.0001;
         neighbourPatch  AMI1;
-        transform       translational;
-        separationVector (0 0 0);
-        surface         
+        transform       noOrdering;
+        surface
         {
-            type            triSurfaceMesh;
-            name            projectionSurface.stl;
+            type            searchableCylinder; // none
+            point1          (0 0 -1);
+            point2          (0 0 1);
+            radius          0.5;
         }
     }
     front

From e6497d144a600b6eea1f5ac594fd0bea908ce537 Mon Sep 17 00:00:00 2001
From: andy <andy>
Date: Wed, 7 Sep 2011 14:48:16 +0100
Subject: [PATCH 45/45] ENH: Added Pstream tags to mapped field types

---
 .../patches/mapped/mappedField/mappedFieldFvPatchField.C  | 8 ++++++++
 .../mappedFixedInternalValueFvPatchField.C                | 8 ++++++++
 .../mappedFixedValue/mappedFixedValueFvPatchField.C       | 8 ++++++++
 3 files changed, 24 insertions(+)

diff --git a/src/AMIInterpolation/patches/mapped/mappedField/mappedFieldFvPatchField.C b/src/AMIInterpolation/patches/mapped/mappedField/mappedFieldFvPatchField.C
index b6056eb444..e02fa12ef2 100644
--- a/src/AMIInterpolation/patches/mapped/mappedField/mappedFieldFvPatchField.C
+++ b/src/AMIInterpolation/patches/mapped/mappedField/mappedFieldFvPatchField.C
@@ -190,6 +190,11 @@ void mappedFieldFvPatchField<Type>::updateCoeffs()
 
     typedef GeometricField<Type, fvPatchField, volMesh> fieldType;
 
+    // Since we're inside initEvaluate/evaluate there might be processor
+    // comms underway. Change the tag we use.
+    int oldTag = UPstream::msgType();
+    UPstream::msgType() = oldTag + 1;
+
     const fvMesh& nbrMesh = refCast<const fvMesh>(sampleMesh());
 
     // Result of obtaining remote values
@@ -317,6 +322,9 @@ void mappedFieldFvPatchField<Type>::updateCoeffs()
             << endl;
     }
 
+    // Restore tag
+    UPstream::msgType() = oldTag;
+
     fixedValueFvPatchField<Type>::updateCoeffs();
 }
 
diff --git a/src/AMIInterpolation/patches/mapped/mappedFixedInternalValue/mappedFixedInternalValueFvPatchField.C b/src/AMIInterpolation/patches/mapped/mappedFixedInternalValue/mappedFixedInternalValueFvPatchField.C
index 7f0c0e6cd2..8920d39502 100644
--- a/src/AMIInterpolation/patches/mapped/mappedFixedInternalValue/mappedFixedInternalValueFvPatchField.C
+++ b/src/AMIInterpolation/patches/mapped/mappedFixedInternalValue/mappedFixedInternalValueFvPatchField.C
@@ -102,6 +102,11 @@ void Foam::mappedFixedInternalValueFvPatchField<Type>::updateCoeffs()
         return;
     }
 
+    // Since we're inside initEvaluate/evaluate there might be processor
+    // comms underway. Change the tag we use.
+    int oldTag = UPstream::msgType();
+    UPstream::msgType() = oldTag + 1;
+
     // Retrieve the neighbour values and assign to this patch boundary field
     mappedFixedValueFvPatchField<Type>::updateCoeffs();
 
@@ -148,6 +153,9 @@ void Foam::mappedFixedInternalValueFvPatchField<Type>::updateCoeffs()
         }
     }
 
+    // Restore tag
+    UPstream::msgType() = oldTag;
+
     // Assign to (this) patch internal field its neighbour values
     Field<Type>& intFld = const_cast<Field<Type>&>(this->internalField());
     UIndirectList<Type>(intFld, this->patch().faceCells()) = nbrIntFld;
diff --git a/src/AMIInterpolation/patches/mapped/mappedFixedValue/mappedFixedValueFvPatchField.C b/src/AMIInterpolation/patches/mapped/mappedFixedValue/mappedFixedValueFvPatchField.C
index 1f46bf8dbb..ffe8960fa7 100644
--- a/src/AMIInterpolation/patches/mapped/mappedFixedValue/mappedFixedValueFvPatchField.C
+++ b/src/AMIInterpolation/patches/mapped/mappedFixedValue/mappedFixedValueFvPatchField.C
@@ -224,6 +224,11 @@ void mappedFixedValueFvPatchField<Type>::updateCoeffs()
 
     typedef GeometricField<Type, fvPatchField, volMesh> fieldType;
 
+    // Since we're inside initEvaluate/evaluate there might be processor
+    // comms underway. Change the tag we use.
+    int oldTag = UPstream::msgType();
+    UPstream::msgType() = oldTag + 1;
+
     // Get the scheduling information from the mappedPatchBase
     const mappedPatchBase& mpp = refCast<const mappedPatchBase>
     (
@@ -389,6 +394,9 @@ void mappedFixedValueFvPatchField<Type>::updateCoeffs()
             << endl;
     }
 
+    // Restore tag
+    UPstream::msgType() = oldTag;
+
     fixedValueFvPatchField<Type>::updateCoeffs();
 }