Merge branch 'ACMI'

src/finiteVolume/Make/files

@@ -18,6 +18,7 @@ $(basicFvPatches)/generic/genericFvPatch.C
 constraintFvPatches = $(fvPatches)/constraint
 $(constraintFvPatches)/cyclic/cyclicFvPatch.C
 $(constraintFvPatches)/cyclicAMI/cyclicAMIFvPatch.C
+$(constraintFvPatches)/cyclicACMI/cyclicACMIFvPatch.C
 $(constraintFvPatches)/cyclicSlip/cyclicSlipFvPatch.C
 $(constraintFvPatches)/empty/emptyFvPatch.C
 $(constraintFvPatches)/nonuniformTransformCyclic/nonuniformTransformCyclicFvPatch.C
@@ -109,6 +110,7 @@ $(basicFvPatchFields)/zeroGradient/zeroGradientFvPatchFields.C
 constraintFvPatchFields = $(fvPatchFields)/constraint
 $(constraintFvPatchFields)/cyclic/cyclicFvPatchFields.C
 $(constraintFvPatchFields)/cyclicAMI/cyclicAMIFvPatchFields.C
+$(constraintFvPatchFields)/cyclicACMI/cyclicACMIFvPatchFields.C
 $(constraintFvPatchFields)/cyclicSlip/cyclicSlipFvPatchFields.C
 $(constraintFvPatchFields)/empty/emptyFvPatchFields.C
 $(constraintFvPatchFields)/jumpCyclic/jumpCyclicFvPatchFields.C
@@ -203,6 +205,7 @@ $(basicFvsPatchFields)/sliced/slicedFvsPatchFields.C
 constraintFvsPatchFields = $(fvsPatchFields)/constraint
 $(constraintFvsPatchFields)/cyclic/cyclicFvsPatchFields.C
 $(constraintFvsPatchFields)/cyclicAMI/cyclicAMIFvsPatchFields.C
+$(constraintFvsPatchFields)/cyclicACMI/cyclicACMIFvsPatchFields.C
 $(constraintFvsPatchFields)/cyclicSlip/cyclicSlipFvsPatchFields.C
 $(constraintFvsPatchFields)/empty/emptyFvsPatchFields.C
 $(constraintFvsPatchFields)/nonuniformTransformCyclic/nonuniformTransformCyclicFvsPatchFields.C

src/finiteVolume/fields/fvPatchFields/constraint/cyclicACMI/cyclicACMIFvPatchField.C

@@ -0,0 +1,387 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "cyclicACMIFvPatchField.H"
+#include "transformField.H"
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+template<class Type>
+Foam::cyclicACMIFvPatchField<Type>::cyclicACMIFvPatchField
+(
+    const fvPatch& p,
+    const DimensionedField<Type, volMesh>& iF
+)
+:
+    cyclicACMILduInterfaceField(),
+    coupledFvPatchField<Type>(p, iF),
+    cyclicACMIPatch_(refCast<const cyclicACMIFvPatch>(p))
+{}
+
+
+template<class Type>
+Foam::cyclicACMIFvPatchField<Type>::cyclicACMIFvPatchField
+(
+    const cyclicACMIFvPatchField<Type>& ptf,
+    const fvPatch& p,
+    const DimensionedField<Type, volMesh>& iF,
+    const fvPatchFieldMapper& mapper
+)
+:
+    cyclicACMILduInterfaceField(),
+    coupledFvPatchField<Type>(ptf, p, iF, mapper),
+    cyclicACMIPatch_(refCast<const cyclicACMIFvPatch>(p))
+{
+    if (!isA<cyclicACMIFvPatch>(this->patch()))
+    {
+        FatalErrorIn
+        (
+            "cyclicACMIFvPatchField<Type>::cyclicACMIFvPatchField"
+            "("
+                "const cyclicACMIFvPatchField<Type>& ,"
+                "const fvPatch&, "
+                "const DimensionedField<Type, volMesh>&, "
+                "const fvPatchFieldMapper&"
+            ")"
+        )   << "    patch type '" << p.type()
+            << "' not constraint type '" << typeName << "'"
+            << "\n    for patch " << p.name()
+            << " of field " << this->dimensionedInternalField().name()
+            << " in file " << this->dimensionedInternalField().objectPath()
+            << exit(FatalIOError);
+    }
+}
+
+
+template<class Type>
+Foam::cyclicACMIFvPatchField<Type>::cyclicACMIFvPatchField
+(
+    const fvPatch& p,
+    const DimensionedField<Type, volMesh>& iF,
+    const dictionary& dict
+)
+:
+    cyclicACMILduInterfaceField(),
+    coupledFvPatchField<Type>(p, iF, dict),
+    cyclicACMIPatch_(refCast<const cyclicACMIFvPatch>(p))
+{
+    if (!isA<cyclicACMIFvPatch>(p))
+    {
+        FatalIOErrorIn
+        (
+            "cyclicACMIFvPatchField<Type>::cyclicACMIFvPatchField"
+            "("
+                "const fvPatch&, "
+                "const DimensionedField<Type, volMesh>&, "
+                "const dictionary&"
+            ")",
+            dict
+        )   << "    patch type '" << p.type()
+            << "' not constraint type '" << typeName << "'"
+            << "\n    for patch " << p.name()
+            << " of field " << this->dimensionedInternalField().name()
+            << " in file " << this->dimensionedInternalField().objectPath()
+            << exit(FatalIOError);
+    }
+
+    if (!dict.found("value") && this->coupled())
+    {
+        this->evaluate(Pstream::blocking);
+    }
+}
+
+
+template<class Type>
+Foam::cyclicACMIFvPatchField<Type>::cyclicACMIFvPatchField
+(
+    const cyclicACMIFvPatchField<Type>& ptf
+)
+:
+    cyclicACMILduInterfaceField(),
+    coupledFvPatchField<Type>(ptf),
+    cyclicACMIPatch_(ptf.cyclicACMIPatch_)
+{}
+
+
+template<class Type>
+Foam::cyclicACMIFvPatchField<Type>::cyclicACMIFvPatchField
+(
+    const cyclicACMIFvPatchField<Type>& ptf,
+    const DimensionedField<Type, volMesh>& iF
+)
+:
+    cyclicACMILduInterfaceField(),
+    coupledFvPatchField<Type>(ptf, iF),
+    cyclicACMIPatch_(ptf.cyclicACMIPatch_)
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+template<class Type>
+bool Foam::cyclicACMIFvPatchField<Type>::coupled() const
+{
+    return cyclicACMIPatch_.coupled();
+}
+
+
+template<class Type>
+Foam::tmp<Foam::Field<Type> >
+Foam::cyclicACMIFvPatchField<Type>::patchNeighbourField() const
+{
+    const Field<Type>& iField = this->internalField();
+    const labelUList& nbrFaceCellsCoupled =
+        cyclicACMIPatch_.cyclicACMIPatch().neighbPatch().faceCells();
+    const labelUList& nbrFaceCellsNonOverlap =
+        cyclicACMIPatch_.cyclicACMIPatch().nonOverlapPatch().faceCells();
+
+    Field<Type> pnfCoupled(iField, nbrFaceCellsCoupled);
+    Field<Type> pnfNonOverlap(iField, nbrFaceCellsNonOverlap);
+
+    tmp<Field<Type> > tpnf
+    (
+        new Field<Type>
+        (
+            cyclicACMIPatch_.interpolate
+            (
+                pnfCoupled,
+                pnfNonOverlap
+            )
+        )
+    );
+
+    if (doTransform())
+    {
+        tpnf() = transform(forwardT(), tpnf());
+    }
+
+    return tpnf;
+}
+
+
+template<class Type>
+const Foam::cyclicACMIFvPatchField<Type>&
+Foam::cyclicACMIFvPatchField<Type>::neighbourPatchField() const
+{
+    const GeometricField<Type, fvPatchField, volMesh>& fld =
+        static_cast<const GeometricField<Type, fvPatchField, volMesh>&>
+        (
+            this->internalField()
+        );
+
+    return refCast<const cyclicACMIFvPatchField<Type> >
+    (
+        fld.boundaryField()[cyclicACMIPatch_.neighbPatchID()]
+    );
+}
+
+
+template<class Type>
+const Foam::fvPatchField<Type>&
+Foam::cyclicACMIFvPatchField<Type>::nonOverlapPatchField() const
+{
+    const GeometricField<Type, fvPatchField, volMesh>& fld =
+        static_cast<const GeometricField<Type, fvPatchField, volMesh>&>
+        (
+            this->internalField()
+        );
+
+    return fld.boundaryField()[cyclicACMIPatch_.nonOverlapPatchID()];
+}
+
+
+template<class Type>
+void Foam::cyclicACMIFvPatchField<Type>::updateInterfaceMatrix
+(
+    scalarField& result,
+    const scalarField& psiInternal,
+    const scalarField& coeffs,
+    const direction cmpt,
+    const Pstream::commsTypes
+) const
+{
+    // note: only applying coupled contribution
+
+    const labelUList& nbrFaceCellsCoupled =
+        cyclicACMIPatch_.cyclicACMIPatch().neighbPatch().faceCells();
+
+    scalarField pnf(psiInternal, nbrFaceCellsCoupled);
+
+    // Transform according to the transformation tensors
+    transformCoupleField(pnf, cmpt);
+
+    const labelUList& faceCells = cyclicACMIPatch_.faceCells();
+
+    pnf = cyclicACMIPatch_.interpolate(pnf);
+
+    forAll(faceCells, elemI)
+    {
+        result[faceCells[elemI]] -= coeffs[elemI]*pnf[elemI];
+    }
+}
+
+
+template<class Type>
+void Foam::cyclicACMIFvPatchField<Type>::updateInterfaceMatrix
+(
+    Field<Type>& result,
+    const Field<Type>& psiInternal,
+    const scalarField& coeffs,
+    const Pstream::commsTypes
+) const
+{
+    // note: only applying coupled contribution
+
+    const labelUList& nbrFaceCellsCoupled =
+        cyclicACMIPatch_.cyclicACMIPatch().neighbPatch().faceCells();
+
+    Field<Type> pnf(psiInternal, nbrFaceCellsCoupled);
+
+    // Transform according to the transformation tensors
+    transformCoupleField(pnf);
+
+    const labelUList& faceCells = cyclicACMIPatch_.faceCells();
+
+    pnf = cyclicACMIPatch_.interpolate(pnf);
+
+    forAll(faceCells, elemI)
+    {
+        result[faceCells[elemI]] -= coeffs[elemI]*pnf[elemI];
+    }
+}
+
+
+template<class Type>
+Foam::tmp<Foam::Field<Type> > Foam::cyclicACMIFvPatchField<Type>::snGrad
+(
+    const scalarField& deltaCoeffs
+) const
+{
+    // note: only applying coupled contribution
+    return coupledFvPatchField<Type>::snGrad(deltaCoeffs);
+}
+
+
+template<class Type>
+void Foam::cyclicACMIFvPatchField<Type>::evaluate
+(
+    const Pstream::commsTypes comms
+)
+{
+    // blend contrubutions from the coupled and non-overlap patches
+    const fvPatchField<Type>& npf = nonOverlapPatchField();
+    const_cast<fvPatchField<Type>&>(npf).evaluate();
+
+    coupledFvPatchField<Type>::evaluate(comms);
+    const Field<Type>& cpf = *this;
+
+    const scalarField& mask = cyclicACMIPatch_.cyclicACMIPatch().mask();
+    Field<Type>::operator=(mask*cpf + (1.0 - mask)*npf);
+
+    fvPatchField<Type>::evaluate();
+}
+
+
+template<class Type>
+Foam::tmp<Foam::Field<Type> >
+Foam::cyclicACMIFvPatchField<Type>::valueInternalCoeffs
+(
+    const tmp<scalarField>& w
+) const
+{
+    // note: do not blend based on mask field
+    // - when applied this is scaled by the areas which area already scaled
+    return coupledFvPatchField<Type>::valueInternalCoeffs(w);
+}
+
+
+template<class Type>
+Foam::tmp<Foam::Field<Type> >
+Foam::cyclicACMIFvPatchField<Type>::valueBoundaryCoeffs
+(
+    const tmp<scalarField>& w
+) const
+{
+    // note: do not blend based on mask field
+    // - when applied this is scaled by the areas which area already scaled
+    return coupledFvPatchField<Type>::valueBoundaryCoeffs(w);
+}
+
+
+template<class Type>
+Foam::tmp<Foam::Field<Type> >
+Foam::cyclicACMIFvPatchField<Type>::gradientInternalCoeffs
+(
+    const scalarField& deltaCoeffs
+) const
+{
+    // note: do not blend based on mask field
+    // - when applied this is scaled by the areas which area already scaled
+    return coupledFvPatchField<Type>::gradientInternalCoeffs(deltaCoeffs);
+}
+
+
+template<class Type>
+Foam::tmp<Foam::Field<Type> >
+Foam::cyclicACMIFvPatchField<Type>::gradientInternalCoeffs() const
+{
+    // note: do not blend based on mask field
+    // - when applied this is scaled by the areas which area already scaled
+    return coupledFvPatchField<Type>::gradientInternalCoeffs();
+}
+
+
+template<class Type>
+Foam::tmp<Foam::Field<Type> >
+Foam::cyclicACMIFvPatchField<Type>::gradientBoundaryCoeffs
+(
+    const scalarField& deltaCoeffs
+) const
+{
+    // note: do not blend based on mask field
+    // - when applied this is scaled by the areas which area already scaled
+    return coupledFvPatchField<Type>::gradientBoundaryCoeffs(deltaCoeffs);
+}
+
+
+template<class Type>
+Foam::tmp<Foam::Field<Type> >
+Foam::cyclicACMIFvPatchField<Type>::gradientBoundaryCoeffs() const
+{
+    // note: do not blend based on mask field
+    // - when applied this is scaled by the areas which area already scaled
+    return coupledFvPatchField<Type>::gradientBoundaryCoeffs();
+}
+
+
+template<class Type>
+void Foam::cyclicACMIFvPatchField<Type>::write(Ostream& os) const
+{
+    fvPatchField<Type>::write(os);
+    this->writeEntry("value", os);
+}
+
+
+// ************************************************************************* //

src/finiteVolume/fields/fvPatchFields/constraint/cyclicACMI/cyclicACMIFvPatchField.H

@@ -0,0 +1,298 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::cyclicACMIFvPatchField
+
+Group
+    grpCoupledBoundaryConditions
+
+Description
+    This boundary condition enforces a cyclic condition between a pair of
+    boundaries, whereby communication between the patches is performed using
+    an arbitrarily coupled mesh interface (ACMI) interpolation.
+
+    \heading Patch usage
+
+    Example of the boundary condition specification:
+    \verbatim
+    myPatch
+    {
+        type            cyclicACMI;
+    }
+    \endverbatim
+
+SeeAlso
+    Foam::AMIInterpolation
+
+SourceFiles
+    cyclicACMIFvPatchField.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef cyclicACMIFvPatchField_H
+#define cyclicACMIFvPatchField_H
+
+#include "coupledFvPatchField.H"
+#include "cyclicACMILduInterfaceField.H"
+#include "cyclicACMIFvPatch.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                   Class cyclicACMIFvPatchField Declaration
+\*---------------------------------------------------------------------------*/
+
+template<class Type>
+class cyclicACMIFvPatchField
+:
+    virtual public cyclicACMILduInterfaceField,
+    public coupledFvPatchField<Type>
+{
+    // Private data
+
+        //- Local reference cast into the cyclic patch
+        const cyclicACMIFvPatch& cyclicACMIPatch_;
+
+
+    // Private Member Functions
+
+        //- Return neighbour side field given internal fields
+        template<class Type2>
+        tmp<Field<Type2> > neighbourSideField
+        (
+            const Field<Type2>&
+        ) const;
+
+
+public:
+
+    //- Runtime type information
+    TypeName(cyclicACMIFvPatch::typeName_());
+
+
+    // Constructors
+
+        //- Construct from patch and internal field
+        cyclicACMIFvPatchField
+        (
+            const fvPatch&,
+            const DimensionedField<Type, volMesh>&
+        );
+
+        //- Construct from patch, internal field and dictionary
+        cyclicACMIFvPatchField
+        (
+            const fvPatch&,
+            const DimensionedField<Type, volMesh>&,
+            const dictionary&
+        );
+
+        //- Construct by mapping given cyclicACMIFvPatchField onto a new patch
+        cyclicACMIFvPatchField
+        (
+            const cyclicACMIFvPatchField<Type>&,
+            const fvPatch&,
+            const DimensionedField<Type, volMesh>&,
+            const fvPatchFieldMapper&
+        );
+
+        //- Construct as copy
+        cyclicACMIFvPatchField(const cyclicACMIFvPatchField<Type>&);
+
+        //- Construct and return a clone
+        virtual tmp<fvPatchField<Type> > clone() const
+        {
+            return tmp<fvPatchField<Type> >
+            (
+                new cyclicACMIFvPatchField<Type>(*this)
+            );
+        }
+
+        //- Construct as copy setting internal field reference
+        cyclicACMIFvPatchField
+        (
+            const cyclicACMIFvPatchField<Type>&,
+            const DimensionedField<Type, volMesh>&
+        );
+
+        //- Construct and return a clone setting internal field reference
+        virtual tmp<fvPatchField<Type> > clone
+        (
+            const DimensionedField<Type, volMesh>& iF
+        ) const
+        {
+            return tmp<fvPatchField<Type> >
+            (
+                new cyclicACMIFvPatchField<Type>(*this, iF)
+            );
+        }
+
+
+    // Member functions
+
+        // Access
+
+            //- Return local reference cast into the cyclic AMI patch
+            const cyclicACMIFvPatch& cyclicACMIPatch() const
+            {
+                return cyclicACMIPatch_;
+            }
+
+
+        // Evaluation functions
+
+            //- Return true if coupled. Note that the underlying patch
+            //  is not coupled() - the points don't align.
+            virtual bool coupled() const;
+
+            //- Return neighbour coupled internal cell data
+            virtual tmp<Field<Type> > patchNeighbourField() const;
+
+            //- Return reference to neighbour patchField
+            const cyclicACMIFvPatchField<Type>& neighbourPatchField() const;
+
+            //- Return reference to non-overlapping patchField
+            const fvPatchField<Type>& nonOverlapPatchField() const;
+
+            //- Return patch-normal gradient
+            virtual tmp<Field<Type> > snGrad
+            (
+                const scalarField& deltaCoeffs
+            ) const;
+
+            //- Evaluate the patch field
+            virtual void evaluate
+            (
+                const Pstream::commsTypes commsType
+            );
+
+            //- Return the matrix diagonal coefficients corresponding to the
+            //  evaluation of the value of this patchField with given weights
+            virtual tmp<Field<Type> > valueInternalCoeffs
+            (
+                const tmp<scalarField>&
+            ) const;
+
+            //- Return the matrix source coefficients corresponding to the
+            //  evaluation of the value of this patchField with given weights
+            virtual tmp<Field<Type> > valueBoundaryCoeffs
+            (
+                const tmp<scalarField>&
+            ) const;
+
+            //- Return the matrix diagonal coefficients corresponding to the
+            //  evaluation of the gradient of this patchField
+            virtual tmp<Field<Type> > gradientInternalCoeffs
+            (
+                const scalarField& deltaCoeffs
+            ) const;
+
+            //- Return the matrix diagonal coefficients corresponding to the
+            //  evaluation of the gradient of this patchField
+            virtual tmp<Field<Type> > gradientInternalCoeffs() const;
+
+            //- Return the matrix source coefficients corresponding to the
+            //  evaluation of the gradient of this patchField
+            virtual tmp<Field<Type> > gradientBoundaryCoeffs
+            (
+                const scalarField& deltaCoeffs
+            ) const;
+
+            //- Return the matrix source coefficients corresponding to the
+            //  evaluation of the gradient of this patchField
+            virtual tmp<Field<Type> > gradientBoundaryCoeffs() const;
+
+            //- Update result field based on interface functionality
+            virtual void updateInterfaceMatrix
+            (
+                scalarField& result,
+                const scalarField& psiInternal,
+                const scalarField& coeffs,
+                const direction cmpt,
+                const Pstream::commsTypes commsType
+            ) const;
+
+            //- Update result field based on interface functionality
+            virtual void updateInterfaceMatrix
+            (
+                Field<Type>&,
+                const Field<Type>&,
+                const scalarField&,
+                const Pstream::commsTypes commsType
+            ) const;
+
+
+        // Cyclic AMI coupled interface functions
+
+            //- Does the patch field perform the transformation
+            virtual bool doTransform() const
+            {
+                return
+                    !(cyclicACMIPatch_.parallel() || pTraits<Type>::rank == 0);
+            }
+
+            //- Return face transformation tensor
+            virtual const tensorField& forwardT() const
+            {
+                return cyclicACMIPatch_.forwardT();
+            }
+
+            //- Return neighbour-cell transformation tensor
+            virtual const tensorField& reverseT() const
+            {
+                return cyclicACMIPatch_.reverseT();
+            }
+
+            //- Return rank of component for transform
+            virtual int rank() const
+            {
+                return pTraits<Type>::rank;
+            }
+
+
+        // I-O
+
+            //- Write
+            virtual void write(Ostream& os) const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+#   include "cyclicACMIFvPatchField.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/finiteVolume/fields/fvPatchFields/constraint/cyclicACMI/cyclicACMIFvPatchFields.C

@@ -0,0 +1,43 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "cyclicACMIFvPatchFields.H"
+#include "addToRunTimeSelectionTable.H"
+#include "volFields.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+makePatchFields(cyclicACMI);
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// ************************************************************************* //

src/finiteVolume/fields/fvPatchFields/constraint/cyclicACMI/cyclicACMIFvPatchFields.H

@@ -0,0 +1,49 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef cyclicACMIFvPatchFields_H
+#define cyclicACMIFvPatchFields_H
+
+#include "cyclicACMIFvPatchField.H"
+#include "fieldTypes.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+makePatchTypeFieldTypedefs(cyclicACMI);
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/finiteVolume/fields/fvPatchFields/constraint/cyclicACMI/cyclicACMIFvPatchFieldsFwd.H

@@ -0,0 +1,50 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef cyclicACMIFvPatchFieldsFwd_H
+#define cyclicACMIFvPatchFieldsFwd_H
+
+#include "fieldTypes.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+template<class Type> class cyclicACMIFvPatchField;
+
+makePatchTypeFieldTypedefs(cyclicACMI);
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/finiteVolume/fields/fvsPatchFields/constraint/cyclicACMI/cyclicACMIFvsPatchField.C

@@ -0,0 +1,149 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "cyclicACMIFvsPatchField.H"
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+template<class Type>
+Foam::cyclicACMIFvsPatchField<Type>::cyclicACMIFvsPatchField
+(
+    const fvPatch& p,
+    const DimensionedField<Type, surfaceMesh>& iF
+)
+:
+    coupledFvsPatchField<Type>(p, iF),
+    cyclicACMIPatch_(refCast<const cyclicACMIFvPatch>(p))
+{}
+
+
+template<class Type>
+Foam::cyclicACMIFvsPatchField<Type>::cyclicACMIFvsPatchField
+(
+    const cyclicACMIFvsPatchField<Type>& ptf,
+    const fvPatch& p,
+    const DimensionedField<Type, surfaceMesh>& iF,
+    const fvPatchFieldMapper& mapper
+)
+:
+    coupledFvsPatchField<Type>(ptf, p, iF, mapper),
+    cyclicACMIPatch_(refCast<const cyclicACMIFvPatch>(p))
+{
+    if (!isA<cyclicACMIFvPatch>(this->patch()))
+    {
+        FatalErrorIn
+        (
+            "cyclicACMIFvsPatchField<Type>::cyclicACMIFvsPatchField\n"
+            "("
+                "const cyclicACMIFvsPatchField<Type>&, "
+                "const fvPatch&, "
+                "const DimensionedField<Type, surfaceMesh>&, "
+                "const fvPatchFieldMapper&"
+            ")"
+        )   << "Field type does not correspond to patch type for patch "
+            << this->patch().index() << "." << endl
+            << "Field type: " << typeName << endl
+            << "Patch type: " << this->patch().type()
+            << exit(FatalError);
+    }
+}
+
+
+template<class Type>
+Foam::cyclicACMIFvsPatchField<Type>::cyclicACMIFvsPatchField
+(
+    const fvPatch& p,
+    const DimensionedField<Type, surfaceMesh>& iF,
+    const dictionary& dict
+)
+:
+    coupledFvsPatchField<Type>(p, iF, dict),
+    cyclicACMIPatch_(refCast<const cyclicACMIFvPatch>(p))
+{
+    if (!isA<cyclicACMIFvPatch>(p))
+    {
+        FatalIOErrorIn
+        (
+            "cyclicACMIFvsPatchField<Type>::cyclicACMIFvsPatchField"
+            "("
+                "const fvPatch&, "
+                "const Field<Type>&, "
+                "const dictionary&"
+            ")",
+            dict
+        )   << "patch " << this->patch().index() << " not cyclicACMI type. "
+            << "Patch type = " << p.type()
+            << exit(FatalIOError);
+    }
+}
+
+
+template<class Type>
+Foam::cyclicACMIFvsPatchField<Type>::cyclicACMIFvsPatchField
+(
+    const cyclicACMIFvsPatchField<Type>& ptf
+)
+:
+    coupledFvsPatchField<Type>(ptf),
+    cyclicACMIPatch_(ptf.cyclicACMIPatch_)
+{}
+
+
+template<class Type>
+Foam::cyclicACMIFvsPatchField<Type>::cyclicACMIFvsPatchField
+(
+    const cyclicACMIFvsPatchField<Type>& ptf,
+    const DimensionedField<Type, surfaceMesh>& iF
+)
+:
+    coupledFvsPatchField<Type>(ptf, iF),
+    cyclicACMIPatch_(ptf.cyclicACMIPatch_)
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+template<class Type>
+bool Foam::cyclicACMIFvsPatchField<Type>::coupled() const
+{
+    if
+    (
+        Pstream::parRun()
+     || (
+            this->cyclicACMIPatch_.size()
+         && this->cyclicACMIPatch_.cyclicACMIPatch().neighbPatch().size()
+        )
+    )
+    {
+        return true;
+    }
+    else
+    {
+        return false;
+    }
+}
+
+
+// ************************************************************************* //

src/finiteVolume/fields/fvsPatchFields/constraint/cyclicACMI/cyclicACMIFvsPatchField.H

@@ -0,0 +1,150 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::cyclicACMIFvsPatchField
+
+Description
+    Foam::cyclicACMIFvsPatchField
+
+SourceFiles
+    cyclicACMIFvsPatchField.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef cyclicACMIFvsPatchField_H
+#define cyclicACMIFvsPatchField_H
+
+#include "coupledFvsPatchField.H"
+#include "cyclicACMIFvPatch.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                   Class cyclicACMIFvsPatchField Declaration
+\*---------------------------------------------------------------------------*/
+
+template<class Type>
+class cyclicACMIFvsPatchField
+:
+    public coupledFvsPatchField<Type>
+{
+    // Private data
+
+        //- Local reference cast into the cyclic patch
+        const cyclicACMIFvPatch& cyclicACMIPatch_;
+
+
+public:
+
+    //- Runtime type information
+    TypeName(cyclicACMIFvPatch::typeName_());
+
+
+    // Constructors
+
+        //- Construct from patch and internal field
+        cyclicACMIFvsPatchField
+        (
+            const fvPatch&,
+            const DimensionedField<Type, surfaceMesh>&
+        );
+
+        //- Construct from patch, internal field and dictionary
+        cyclicACMIFvsPatchField
+        (
+            const fvPatch&,
+            const DimensionedField<Type, surfaceMesh>&,
+            const dictionary&
+        );
+
+        //- Construct by mapping given cyclicACMIFvsPatchField onto a new patch
+        cyclicACMIFvsPatchField
+        (
+            const cyclicACMIFvsPatchField<Type>&,
+            const fvPatch&,
+            const DimensionedField<Type, surfaceMesh>&,
+            const fvPatchFieldMapper&
+        );
+
+        //- Construct as copy
+        cyclicACMIFvsPatchField
+        (
+            const cyclicACMIFvsPatchField<Type>&
+        );
+
+        //- Construct and return a clone
+        virtual tmp<fvsPatchField<Type> > clone() const
+        {
+            return tmp<fvsPatchField<Type> >
+            (
+                new cyclicACMIFvsPatchField<Type>(*this)
+            );
+        }
+
+        //- Construct as copy setting internal field reference
+        cyclicACMIFvsPatchField
+        (
+            const cyclicACMIFvsPatchField<Type>&,
+            const DimensionedField<Type, surfaceMesh>&
+        );
+
+        //- Construct and return a clone setting internal field reference
+        virtual tmp<fvsPatchField<Type> > clone
+        (
+            const DimensionedField<Type, surfaceMesh>& iF
+        ) const
+        {
+            return tmp<fvsPatchField<Type> >
+            (
+                new cyclicACMIFvsPatchField<Type>(*this, iF)
+            );
+        }
+
+    // Member functions
+
+        // Access
+
+            //- Return true if running parallel
+            virtual bool coupled() const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+#   include "cyclicACMIFvsPatchField.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/finiteVolume/fields/fvsPatchFields/constraint/cyclicACMI/cyclicACMIFvsPatchFields.C

@@ -0,0 +1,43 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "cyclicACMIFvsPatchFields.H"
+#include "fvsPatchFields.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+makeFvsPatchFields(cyclicACMI);
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// ************************************************************************* //

src/finiteVolume/fields/fvsPatchFields/constraint/cyclicACMI/cyclicACMIFvsPatchFields.H

@@ -0,0 +1,49 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef cyclicACMIFvsPatchFields_H
+#define cyclicACMIFvsPatchFields_H
+
+#include "cyclicACMIFvsPatchField.H"
+#include "fieldTypes.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+makeFvsPatchTypeFieldTypedefs(cyclicACMI);
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/finiteVolume/fields/fvsPatchFields/constraint/cyclicACMI/cyclicACMIFvsPatchFieldsFwd.H

@@ -0,0 +1,50 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef cyclicACMIFvsPatchFieldsFwd_H
+#define cyclicACMIFvsPatchFieldsFwd_H
+
+#include "fieldTypes.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+template<class Type> class cyclicACMIFvsPatchField;
+
+makeFvsPatchTypeFieldTypedefs(cyclicACMI);
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/finiteVolume/fvMesh/fvPatches/constraint/cyclicACMI/cyclicACMIFvPatch.C

@@ -0,0 +1,202 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "cyclicACMIFvPatch.H"
+#include "addToRunTimeSelectionTable.H"
+#include "fvMesh.H"
+#include "transform.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(cyclicACMIFvPatch, 0);
+    addToRunTimeSelectionTable(fvPatch, cyclicACMIFvPatch, polyPatch);
+}
+
+// * * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * //
+
+void Foam::cyclicACMIFvPatch::updateAreas() const
+{
+    if (cyclicACMIPolyPatch_.updated())
+    {
+        // Set Sf and magSf for both sides' coupled and non-overlapping patches
+
+        // owner couple
+        const_cast<vectorField&>(Sf()) = patch().faceAreas();
+        const_cast<scalarField&>(magSf()) = mag(patch().faceAreas());
+
+        // owner non-overlapping
+        const fvPatch& nonOverlapPatch = this->nonOverlapPatch();
+        const_cast<vectorField&>(nonOverlapPatch.Sf()) =
+            nonOverlapPatch.patch().faceAreas();
+        const_cast<scalarField&>(nonOverlapPatch.magSf()) =
+            mag(nonOverlapPatch.patch().faceAreas());
+
+        // neighbour couple
+        const cyclicACMIFvPatch& nbrACMI = neighbPatch();
+        const_cast<vectorField&>(nbrACMI.Sf()) =
+            nbrACMI.patch().faceAreas();
+        const_cast<scalarField&>(nbrACMI.magSf()) =
+            mag(nbrACMI.patch().faceAreas());
+
+        // neighbour non-overlapping
+        const fvPatch& nbrNonOverlapPatch = nbrACMI.nonOverlapPatch();
+        const_cast<vectorField&>(nbrNonOverlapPatch.Sf()) =
+            nbrNonOverlapPatch.patch().faceAreas();
+        const_cast<scalarField&>(nbrNonOverlapPatch.magSf()) =
+            mag(nbrNonOverlapPatch.patch().faceAreas());
+
+        // set the updated flag
+        cyclicACMIPolyPatch_.setUpdated(false);
+    }
+}
+
+
+void Foam::cyclicACMIFvPatch::makeWeights(scalarField& w) const
+{
+    if (coupled())
+    {
+        const cyclicACMIFvPatch& nbrPatch = neighbFvPatch();
+        const fvPatch& nbrPatchNonOverlap = nonOverlapPatch();
+
+        const scalarField deltas(nf() & fvPatch::delta());
+
+        const scalarField nbrDeltas
+        (
+            interpolate
+            (
+                nbrPatch.nf() & nbrPatch.fvPatch::delta(),
+                nbrPatchNonOverlap.nf() & nbrPatchNonOverlap.delta()
+            )
+        );
+
+        forAll(deltas, faceI)
+        {
+            scalar di = deltas[faceI];
+            scalar dni = nbrDeltas[faceI];
+
+            w[faceI] = dni/(di + dni);
+        }
+    }
+    else
+    {
+        // Behave as uncoupled patch
+        fvPatch::makeWeights(w);
+    }
+}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+bool Foam::cyclicACMIFvPatch::coupled() const
+{
+    return Pstream::parRun() || (this->size() && neighbFvPatch().size());
+}
+
+
+Foam::tmp<Foam::vectorField> Foam::cyclicACMIFvPatch::delta() const
+{
+    if (coupled())
+    {
+        const cyclicACMIFvPatch& nbrPatchCoupled = neighbFvPatch();
+        const fvPatch& nbrPatchNonOverlap = nonOverlapPatch();
+
+        const vectorField patchD(fvPatch::delta());
+
+        vectorField nbrPatchD
+        (
+            interpolate
+            (
+                nbrPatchCoupled.fvPatch::delta(),
+                nbrPatchNonOverlap.delta()
+            )
+        );
+
+        const vectorField nbrPatchD0
+        (
+            interpolate
+            (
+                vectorField(nbrPatchCoupled.size(), vector::zero),
+                nbrPatchNonOverlap.delta()()
+            )
+        );
+
+        nbrPatchD -= nbrPatchD0;
+
+        tmp<vectorField> tpdv(new vectorField(patchD.size()));
+        vectorField& pdv = tpdv();
+
+        // do the transformation if necessary
+        if (parallel())
+        {
+            forAll(patchD, faceI)
+            {
+                const vector& ddi = patchD[faceI];
+                const vector& dni = nbrPatchD[faceI];
+
+                pdv[faceI] = ddi - dni;
+            }
+        }
+        else
+        {
+            forAll(patchD, faceI)
+            {
+                const vector& ddi = patchD[faceI];
+                const vector& dni = nbrPatchD[faceI];
+
+                pdv[faceI] = ddi - transform(forwardT()[0], dni);
+            }
+        }
+
+        return tpdv;
+    }
+    else
+    {
+        return fvPatch::delta();
+    }
+}
+
+
+Foam::tmp<Foam::labelField> Foam::cyclicACMIFvPatch::interfaceInternalField
+(
+    const labelUList& internalData
+) const
+{
+    return patchInternalField(internalData);
+}
+
+
+Foam::tmp<Foam::labelField> Foam::cyclicACMIFvPatch::internalFieldTransfer
+(
+    const Pstream::commsTypes commsType,
+    const labelUList& iF
+) const
+{
+    return neighbFvPatch().patchInternalField(iF);
+}
+
+
+// ************************************************************************* //

src/finiteVolume/fvMesh/fvPatches/constraint/cyclicACMI/cyclicACMIFvPatch.H

@@ -0,0 +1,268 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::cyclicACMIFvPatch
+
+Description
+    Cyclic patch for Arbitrarily Coupled Mesh Interface (ACMI)
+
+SourceFiles
+    cyclicACMIFvPatch.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef cyclicACMIFvPatch_H
+#define cyclicACMIFvPatch_H
+
+#include "coupledFvPatch.H"
+#include "cyclicACMILduInterface.H"
+#include "cyclicACMIPolyPatch.H"
+#include "fvBoundaryMesh.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                      Class cyclicACMIFvPatch Declaration
+\*---------------------------------------------------------------------------*/
+
+class cyclicACMIFvPatch
+:
+    public coupledFvPatch,
+    public cyclicACMILduInterface
+{
+    // Private data
+
+        const cyclicACMIPolyPatch& cyclicACMIPolyPatch_;
+
+
+protected:
+
+    // Protected Member functions
+
+        //- Update the patch areas after AMI update
+        void updateAreas() const;
+
+        //- Make patch weighting factors
+        void makeWeights(scalarField&) const;
+
+
+public:
+
+    //- Runtime type information
+    TypeName(cyclicACMIPolyPatch::typeName_());
+
+
+    // Constructors
+
+        //- Construct from polyPatch
+        cyclicACMIFvPatch(const polyPatch& patch, const fvBoundaryMesh& bm)
+        :
+            coupledFvPatch(patch, bm),
+            cyclicACMILduInterface(),
+            cyclicACMIPolyPatch_(refCast<const cyclicACMIPolyPatch>(patch))
+        {}
+
+
+    // Member functions
+
+        // Access
+
+            //- Return local reference cast into the cyclic patch
+            const cyclicACMIPolyPatch& cyclicACMIPatch() const
+            {
+                return cyclicACMIPolyPatch_;
+            }
+
+            //- Return neighbour
+            virtual label neighbPatchID() const
+            {
+                return cyclicACMIPolyPatch_.neighbPatchID();
+            }
+
+            virtual bool owner() const
+            {
+                return cyclicACMIPolyPatch_.owner();
+            }
+
+            //- Return neighbour fvPatch
+            virtual const cyclicACMIFvPatch& neighbPatch() const
+            {
+                return refCast<const cyclicACMIFvPatch>
+                (
+                    this->boundaryMesh()[cyclicACMIPolyPatch_.neighbPatchID()]
+                );
+            }
+
+            //- Return neighbour
+            virtual label nonOverlapPatchID() const
+            {
+                return cyclicACMIPolyPatch_.nonOverlapPatchID();
+            }
+
+            //- Return non-overlapping fvPatch
+            virtual const fvPatch& nonOverlapPatch() const
+            {
+                return this->boundaryMesh()[nonOverlapPatchID()];
+            }
+
+            //- Return a reference to the AMI interpolator
+            virtual const AMIPatchToPatchInterpolation& AMI() const
+            {
+                const AMIPatchToPatchInterpolation& AMI =
+                    cyclicACMIPolyPatch_.AMI();
+
+                updateAreas();
+
+                return AMI;
+            }
+
+            //- Are the cyclic planes parallel
+            virtual bool parallel() const
+            {
+                return cyclicACMIPolyPatch_.parallel();
+            }
+
+            //- Return face transformation tensor
+            virtual const tensorField& forwardT() const
+            {
+                return cyclicACMIPolyPatch_.forwardT();
+            }
+
+            //- Return neighbour-cell transformation tensor
+            virtual const tensorField& reverseT() const
+            {
+                return cyclicACMIPolyPatch_.reverseT();
+            }
+
+            const cyclicACMIFvPatch& neighbFvPatch() const
+            {
+                return refCast<const cyclicACMIFvPatch>
+                (
+                    this->boundaryMesh()[cyclicACMIPolyPatch_.neighbPatchID()]
+                );
+            }
+
+            //- Return true if this patch is coupled. This is equivalent
+            //  to the coupledPolyPatch::coupled() if parallel running or
+            //  both sides present, false otherwise
+            virtual bool coupled() const;
+
+            //- Return delta (P to N) vectors across coupled patch
+            virtual tmp<vectorField> delta() const;
+
+            template<class Type>
+            tmp<Field<Type> > interpolate
+            (
+                const Field<Type>& fldCoupled
+            ) const
+            {
+                updateAreas();
+
+                return
+                    cyclicACMIPolyPatch_.cyclicAMIPolyPatch::interpolate
+                    (
+                        fldCoupled
+                    );
+            }
+
+            template<class Type>
+            tmp<Field<Type> > interpolate
+            (
+                const tmp<Field<Type> >& tfldCoupled
+            ) const
+            {
+                updateAreas();
+
+                return
+                    cyclicACMIPolyPatch_.cyclicAMIPolyPatch::interpolate
+                    (
+                        tfldCoupled
+                    );
+            }
+
+            template<class Type>
+            tmp<Field<Type> > interpolate
+            (
+                const Field<Type>& fldCoupled,
+                const Field<Type>& fldNonOverlap
+            ) const
+            {
+                updateAreas();
+
+                return
+                    cyclicACMIPolyPatch_.interpolate
+                    (
+                        fldCoupled,
+                        fldNonOverlap
+                    );
+            }
+
+            template<class Type>
+            tmp<Field<Type> > interpolate
+            (
+                const tmp<Field<Type> >& tFldCoupled,
+                const tmp<Field<Type> >& tFldNonOverlap
+            ) const
+            {
+                updateAreas();
+
+                return
+                    cyclicACMIPolyPatch_.interpolate
+                    (
+                        tFldCoupled,
+                        tFldNonOverlap
+                    );
+            }
+
+
+        // Interface transfer functions
+
+            //- Return the values of the given internal data adjacent to
+            //  the interface as a field
+            virtual tmp<labelField> interfaceInternalField
+            (
+                const labelUList& internalData
+            ) const;
+
+            //- Return neighbour field
+            virtual tmp<labelField> internalFieldTransfer
+            (
+                const Pstream::commsTypes commsType,
+                const labelUList& internalData
+            ) const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/meshTools/AMIInterpolation/AMIInterpolation/AMIInterpolation.C

@@ -56,6 +56,11 @@ Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolationMethodToWord
             method = "faceAreaWeightAMI";
             break;
         }
+        case imPartialFaceAreaWeight:
+        {
+            method = "partialFaceAreaWeightAMI";
+            break;
+        }
         default:
         {
             FatalErrorIn
@@ -87,7 +92,15 @@ Foam::AMIInterpolation<SourcePatch, TargetPatch>::wordTointerpolationMethod
 
     wordList methods
     (
-        IStringStream("(directAMI mapNearestAMI faceAreaWeightAMI)")()
+        IStringStream
+        (
+            "("
+                "directAMI "
+                "mapNearestAMI "
+                "faceAreaWeightAMI "
+                "partialFaceAreaWeightAMI"
+            ")"
+        )()
     );
 
     if (im == "directAMI")
@@ -102,6 +115,10 @@ Foam::AMIInterpolation<SourcePatch, TargetPatch>::wordTointerpolationMethod
     {
         method = imFaceAreaWeight;
     }
+    else if (im == "partialFaceAreaWeightAMI")
+    {
+        method = imPartialFaceAreaWeight;
+    }
     else
     {
         FatalErrorIn
@@ -183,6 +200,7 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::normaliseWeights
     const labelListList& addr,
     scalarListList& wght,
     scalarField& wghtSum,
+    const bool conformal,
     const bool output
 )
 {
@@ -191,12 +209,19 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::normaliseWeights
     forAll(wght, faceI)
     {
         scalarList& w = wght[faceI];
+        scalar denom = patchAreas[faceI];
+
         scalar s = sum(w);
-        scalar t = s/patchAreas[faceI];
+        scalar t = s/denom;
+
+        if (conformal)
+        {
+            denom = s;
+        }
 
         forAll(w, i)
         {
-            w[i] /= s;
+            w[i] /= denom;
         }
 
         wghtSum[faceI] = t;
@@ -476,6 +501,7 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::agglomerate
         srcAddress,
         srcWeights,
         srcWeightsSum,
+        true,
         false
     );
 }
@@ -749,7 +775,6 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::update
         tgtMagSf_[faceI] = tgtPatch[faceI].mag(tgtPatch.points());
     }
 
-
     // Calculate if patches present on multiple processors
     singlePatchProc_ = calcDistribution(srcPatch, tgtPatch);
 
@@ -794,32 +819,28 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::update
                 newTgtPoints
             );
 
-
         // calculate AMI interpolation
-        {
+        autoPtr<AMIMethod<SourcePatch, TargetPatch> > AMIPtr
-            autoPtr<AMIMethod<SourcePatch, TargetPatch> > AMIPtr
+        (
+            AMIMethod<SourcePatch, TargetPatch>::New
             (
-                AMIMethod<SourcePatch, TargetPatch>::New
+                interpolationMethodToWord(method_),
-                (
+                srcPatch,
-                    interpolationMethodToWord(method_),
+                newTgtPatch,
-                    srcPatch,
+                srcMagSf_,
-                    newTgtPatch,
+                tgtMagSf_,
-                    srcMagSf_,
+                triMode_,
-                    tgtMagSf_,
+                reverseTarget_
-                    triMode_,
+            )
-                    reverseTarget_
+        );
-                )
-            );
-
-            AMIPtr->calculate
-            (
-                srcAddress_,
-                srcWeights_,
-                tgtAddress_,
-                tgtWeights_
-            );
-        }
 
+        AMIPtr->calculate
+        (
+            srcAddress_,
+            srcWeights_,
+            tgtAddress_,
+            tgtWeights_
+        );
 
         // Now
         // ~~~
@@ -886,6 +907,7 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::update
             srcAddress_,
             srcWeights_,
             srcWeightsSum_,
+            AMIPtr->conformal(),
             true
         );
         normaliseWeights
@@ -895,6 +917,7 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::update
             tgtAddress_,
             tgtWeights_,
             tgtWeightsSum_,
+            AMIPtr->conformal(),
             true
         );
 
@@ -903,7 +926,6 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::update
         srcMapPtr_.reset(new mapDistribute(globalSrcFaces, tgtAddress_, cMap));
         tgtMapPtr_.reset(new mapDistribute(globalTgtFaces, srcAddress_, cMap));
 
-
         if (debug)
         {
             writeFaceConnectivity(srcPatch, newTgtPatch, srcAddress_);
@@ -913,29 +935,27 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::update
     {
 
         // calculate AMI interpolation
-        {
+        autoPtr<AMIMethod<SourcePatch, TargetPatch> > AMIPtr
-            autoPtr<AMIMethod<SourcePatch, TargetPatch> > AMIPtr
+        (
+            AMIMethod<SourcePatch, TargetPatch>::New
             (
-                AMIMethod<SourcePatch, TargetPatch>::New
+                interpolationMethodToWord(method_),
-                (
+                srcPatch,
-                    interpolationMethodToWord(method_),
+                tgtPatch,
-                    srcPatch,
+                srcMagSf_,
-                    tgtPatch,
+                tgtMagSf_,
-                    srcMagSf_,
+                triMode_,
-                    tgtMagSf_,
+                reverseTarget_
-                    triMode_,
+            )
-                    reverseTarget_
+        );
-                )
-            );
 
-            AMIPtr->calculate
+        AMIPtr->calculate
-            (
+        (
-                srcAddress_,
+            srcAddress_,
-                srcWeights_,
+            srcWeights_,
-                tgtAddress_,
+            tgtAddress_,
-                tgtWeights_
+            tgtWeights_
-            );
+        );
-        }
 
         normaliseWeights
         (
@@ -944,6 +964,7 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::update
             srcAddress_,
             srcWeights_,
             srcWeightsSum_,
+            AMIPtr->conformal(),
             true
         );
         normaliseWeights
@@ -953,6 +974,7 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::update
             tgtAddress_,
             tgtWeights_,
             tgtWeightsSum_,
+            AMIPtr->conformal(),
             true
         );
     }

src/meshTools/AMIInterpolation/AMIInterpolation/AMIInterpolation.H

@@ -88,7 +88,8 @@ public:
         {
             imDirect,
             imMapNearest,
-            imFaceAreaWeight
+            imFaceAreaWeight,
+            imPartialFaceAreaWeight
         };
 
         //- Convert interpolationMethod to word representation
@@ -236,6 +237,7 @@ private:
                 const labelListList& addr,
                 scalarListList& wght,
                 scalarField& wghtSum,
+                const bool conformal,
                 const bool output
             );
 

src/meshTools/AMIInterpolation/AMIInterpolation/AMIMethod/AMIMethod/AMIMethod.C

@@ -41,24 +41,28 @@ void Foam::AMIMethod<SourcePatch, TargetPatch>::checkPatches() const
     }
 
 
-    const scalar maxBoundsError = 0.05;
+    if (conformal())
-
-    // check bounds of source and target
-    boundBox bbSrc(srcPatch_.points(), srcPatch_.meshPoints(), true);
-    boundBox bbTgt(tgtPatch_.points(), tgtPatch_.meshPoints(), true);
-
-    boundBox bbTgtInf(bbTgt);
-    bbTgtInf.inflate(maxBoundsError);
-
-    if (!bbTgtInf.contains(bbSrc))
     {
-        WarningIn("AMIMethod<SourcePatch, TargetPatch>::checkPatches()")
+        const scalar maxBoundsError = 0.05;
-            << "Source and target patch bounding boxes are not similar" << nl
+
-            << "    source box span     : " << bbSrc.span() << nl
+        // check bounds of source and target
-            << "    target box span     : " << bbTgt.span() << nl
+        boundBox bbSrc(srcPatch_.points(), srcPatch_.meshPoints(), true);
-            << "    source box          : " << bbSrc << nl
+        boundBox bbTgt(tgtPatch_.points(), tgtPatch_.meshPoints(), true);
-            << "    target box          : " << bbTgt << nl
+
-            << "    inflated target box : " << bbTgtInf << endl;
+        boundBox bbTgtInf(bbTgt);
+        bbTgtInf.inflate(maxBoundsError);
+
+        if (!bbTgtInf.contains(bbSrc))
+        {
+            WarningIn("AMIMethod<SourcePatch, TargetPatch>::checkPatches()")
+                << "Source and target patch bounding boxes are not similar"
+                << nl
+                << "    source box span     : " << bbSrc.span() << nl
+                << "    target box span     : " << bbTgt.span() << nl
+                << "    source box          : " << bbSrc << nl
+                << "    target box          : " << bbTgt << nl
+                << "    inflated target box : " << bbTgtInf << endl;
+        }
     }
 }
 
@@ -74,6 +78,8 @@ bool Foam::AMIMethod<SourcePatch, TargetPatch>::initialise
     label& tgtFaceI
 )
 {
+    checkPatches();
+
     // set initial sizes for weights and addressing - must be done even if
     // returns false below
     srcAddress.setSize(srcPatch_.size());
@@ -241,17 +247,16 @@ Foam::label Foam::AMIMethod<SourcePatch, TargetPatch>::findTargetFace
 
     pointIndexHit sample = treePtr_->findNearest(srcPt, 10.0*srcFaceArea);
 
-
-    if (debug)
-    {
-        Pout<< "Source point = " << srcPt << ", Sample point = "
-            << sample.hitPoint() << ", Sample index = " << sample.index()
-            << endl;
-    }
-
     if (sample.hit())
     {
         targetFaceI = sample.index();
+
+        if (debug)
+        {
+            Pout<< "Source point = " << srcPt << ", Sample point = "
+                << sample.hitPoint() << ", Sample index = " << sample.index()
+                << endl;
+        }
     }
 
     return targetFaceI;
@@ -334,8 +339,6 @@ Foam::AMIMethod<SourcePatch, TargetPatch>::AMIMethod
     srcNonOverlap_(),
     triMode_(triMode)
 {
-    checkPatches();
-
     label srcSize = returnReduce(srcPatch_.size(), sumOp<label>());
     label tgtSize = returnReduce(tgtPatch_.size(), sumOp<label>());
 
@@ -352,4 +355,13 @@ Foam::AMIMethod<SourcePatch, TargetPatch>::~AMIMethod()
 {}
 
 
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+template<class SourcePatch, class TargetPatch>
+bool Foam::AMIMethod<SourcePatch, TargetPatch>::conformal() const
+{
+    return true;
+}
+
+
 // ************************************************************************* //

src/meshTools/AMIInterpolation/AMIInterpolation/AMIMethod/AMIMethod/AMIMethod.H

@@ -207,6 +207,9 @@ public:
             //  Note: this should be empty for correct functioning
             inline const labelList& srcNonOverlap() const;
 
+            //- Flag to indicate that interpolation patches are conformal
+            virtual bool conformal() const;
+
 
         // Manipulation
 

src/meshTools/AMIInterpolation/AMIInterpolation/AMIMethod/faceAreaWeightAMI/faceAreaWeightAMI.C

@@ -25,7 +25,85 @@ License
 
 #include "faceAreaWeightAMI.H"
 
-// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+// * * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * //
+
+template<class SourcePatch, class TargetPatch>
+void Foam::faceAreaWeightAMI<SourcePatch, TargetPatch>::calcAddressing
+(
+    List<DynamicList<label> >& srcAddr,
+    List<DynamicList<scalar> >& srcWght,
+    List<DynamicList<label> >& tgtAddr,
+    List<DynamicList<scalar> >& tgtWght,
+    label srcFaceI,
+    label tgtFaceI
+)
+{
+    // construct weights and addressing
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    label nFacesRemaining = srcAddr.size();
+
+    // list of tgt face neighbour faces
+    DynamicList<label> nbrFaces(10);
+
+    // list of faces currently visited for srcFaceI to avoid multiple hits
+    DynamicList<label> visitedFaces(10);
+
+    // list to keep track of tgt faces used to seed src faces
+    labelList seedFaces(nFacesRemaining, -1);
+    seedFaces[srcFaceI] = tgtFaceI;
+
+    // list to keep track of whether src face can be mapped
+    boolList mapFlag(nFacesRemaining, true);
+
+    // reset starting seed
+    label startSeedI = 0;
+
+    DynamicList<label> nonOverlapFaces;
+    do
+    {
+        // Do advancing front starting from srcFaceI,tgtFaceI
+        bool faceProcessed = processSourceFace
+        (
+            srcFaceI,
+            tgtFaceI,
+
+            nbrFaces,
+            visitedFaces,
+
+            srcAddr,
+            srcWght,
+            tgtAddr,
+            tgtWght
+        );
+
+        mapFlag[srcFaceI] = false;
+
+        nFacesRemaining--;
+
+        if (!faceProcessed)
+        {
+            nonOverlapFaces.append(srcFaceI);
+        }
+
+        // choose new src face from current src face neighbour
+        if (nFacesRemaining > 0)
+        {
+            setNextFaces
+            (
+                startSeedI,
+                srcFaceI,
+                tgtFaceI,
+                mapFlag,
+                seedFaces,
+                visitedFaces
+            );
+        }
+    } while (nFacesRemaining > 0);
+
+    this->srcNonOverlap_.transfer(nonOverlapFaces);
+}
+
 
 template<class SourcePatch, class TargetPatch>
 bool Foam::faceAreaWeightAMI<SourcePatch, TargetPatch>::processSourceFace
@@ -45,6 +123,11 @@ bool Foam::faceAreaWeightAMI<SourcePatch, TargetPatch>::processSourceFace
     List<DynamicList<scalar> >& tgtWght
 )
 {
+    if (tgtStartFaceI == -1)
+    {
+        return false;
+    }
+
     nbrFaces.clear();
     visitedFaces.clear();
 
@@ -101,11 +184,15 @@ void Foam::faceAreaWeightAMI<SourcePatch, TargetPatch>::setNextFaces
     label& tgtFaceI,
     const boolList& mapFlag,
     labelList& seedFaces,
-    const DynamicList<label>& visitedFaces
+    const DynamicList<label>& visitedFaces,
+    bool errorOnNotFound
 ) const
 {
     const labelList& srcNbrFaces = this->srcPatch_.faceFaces()[srcFaceI];
 
+    // initialise tgtFaceI
+    tgtFaceI = -1;
+
     // set possible seeds for later use
     bool valuesSet = false;
     forAll(srcNbrFaces, i)
@@ -195,19 +282,23 @@ void Foam::faceAreaWeightAMI<SourcePatch, TargetPatch>::setNextFaces
             }
         }
 
-        FatalErrorIn
+        if (errorOnNotFound)
-        (
+        {
-            "void Foam::faceAreaWeightAMI<SourcePatch, TargetPatch>::"
+            FatalErrorIn
-            "setNextFaces"
+            (
-            "("
+                "void Foam::faceAreaWeightAMI<SourcePatch, TargetPatch>::"
-                "label&, "
+                "setNextFaces"
-                "label&, "
+                "("
-                "label&, "
+                    "label&, "
-                "const boolList&, "
+                    "label&, "
-                "labelList&, "
+                    "label&, "
-                "const DynamicList<label>&"
+                    "const boolList&, "
-            ") const"
+                    "labelList&, "
-        )  << "Unable to set source and target faces" << abort(FatalError);
+                    "const DynamicList<label>&, "
+                    "bool"
+                ") const"
+            )  << "Unable to set source and target faces" << abort(FatalError);
+        }
     }
 }
 
@@ -447,77 +538,21 @@ void Foam::faceAreaWeightAMI<SourcePatch, TargetPatch>::calculate
     List<DynamicList<label> > tgtAddr(this->tgtPatch_.size());
     List<DynamicList<scalar> > tgtWght(tgtAddr.size());
 
+    calcAddressing
+    (
+        srcAddr,
+        srcWght,
+        tgtAddr,
+        tgtWght,
+        srcFaceI,
+        tgtFaceI
+    );
 
-    // construct weights and addressing
+    if (this->srcNonOverlap_.size() != 0)
-    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-    label nFacesRemaining = srcAddr.size();
-
-    // list of tgt face neighbour faces
-    DynamicList<label> nbrFaces(10);
-
-    // list of faces currently visited for srcFaceI to avoid multiple hits
-    DynamicList<label> visitedFaces(10);
-
-    // list to keep track of tgt faces used to seed src faces
-    labelList seedFaces(nFacesRemaining, -1);
-    seedFaces[srcFaceI] = tgtFaceI;
-
-    // list to keep track of whether src face can be mapped
-    boolList mapFlag(nFacesRemaining, true);
-
-    // reset starting seed
-    label startSeedI = 0;
-
-    DynamicList<label> nonOverlapFaces;
-    do
     {
-        // Do advancing front starting from srcFaceI,tgtFaceI
+        Pout<< "    AMI: " << this->srcNonOverlap_.size()
-        bool faceProcessed = processSourceFace
-        (
-            srcFaceI,
-            tgtFaceI,
-
-            nbrFaces,
-            visitedFaces,
-
-            srcAddr,
-            srcWght,
-            tgtAddr,
-            tgtWght
-        );
-
-        mapFlag[srcFaceI] = false;
-
-        nFacesRemaining--;
-
-        if (!faceProcessed)
-        {
-            nonOverlapFaces.append(srcFaceI);
-        }
-
-        // choose new src face from current src face neighbour
-        if (nFacesRemaining > 0)
-        {
-            setNextFaces
-            (
-                startSeedI,
-                srcFaceI,
-                tgtFaceI,
-                mapFlag,
-                seedFaces,
-                visitedFaces
-            );
-        }
-    } while (nFacesRemaining > 0);
-
-    if (nonOverlapFaces.size() != 0)
-    {
-        Pout<< "    AMI: " << nonOverlapFaces.size()
             << " non-overlap faces identified"
             << endl;
-
-        this->srcNonOverlap_.transfer(nonOverlapFaces);
     }
 
 

src/meshTools/AMIInterpolation/AMIInterpolation/AMIMethod/faceAreaWeightAMI/faceAreaWeightAMI.H

@@ -52,9 +52,9 @@ class faceAreaWeightAMI
     public AMIMethod<SourcePatch, TargetPatch>
 {
 
-private:
+protected:
 
-    // Private Member Functions
+    // Protected Member Functions
 
         //- Disallow default bitwise copy construct
         faceAreaWeightAMI(const faceAreaWeightAMI&);
@@ -64,8 +64,19 @@ private:
 
         // Marching front
 
+            //- Calculate addressing and weights using temporary storage
+            virtual void calcAddressing
+            (
+                List<DynamicList<label> >& srcAddress,
+                List<DynamicList<scalar> >& srcWeights,
+                List<DynamicList<label> >& tgtAddress,
+                List<DynamicList<scalar> >& tgtWeights,
+                label srcFaceI,
+                label tgtFaceI
+            );
+
             //- Determine overlap contributions for source face srcFaceI
-            bool processSourceFace
+            virtual bool processSourceFace
             (
                 const label srcFaceI,
                 const label tgtStartFaceI,
@@ -78,7 +89,7 @@ private:
             );
 
             //- Attempt to re-evaluate source faces that have not been included
-            void restartUncoveredSourceFace
+            virtual void restartUncoveredSourceFace
             (
                 List<DynamicList<label> >& srcAddr,
                 List<DynamicList<scalar> >& srcWght,
@@ -87,21 +98,22 @@ private:
             );
 
             //- Set the source and target seed faces
-            void setNextFaces
+            virtual void setNextFaces
             (
                 label& startSeedI,
                 label& srcFaceI,
                 label& tgtFaceI,
                 const boolList& mapFlag,
                 labelList& seedFaces,
-                const DynamicList<label>& visitedFaces
+                const DynamicList<label>& visitedFaces,
+                bool errorOnNotFound = true
             ) const;
 
 
         // Evaluation
 
             //- Area of intersection between source and target faces
-            scalar interArea
+            virtual scalar interArea
             (
                 const label srcFaceI,
                 const label tgtFaceI

src/meshTools/AMIInterpolation/AMIInterpolation/AMIMethod/partialFaceAreaWeightAMI/partialFaceAreaWeightAMI.C

@@ -0,0 +1,155 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "partialFaceAreaWeightAMI.H"
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+template<class SourcePatch, class TargetPatch>
+void Foam::partialFaceAreaWeightAMI<SourcePatch, TargetPatch>::setNextFaces
+(
+    label& startSeedI,
+    label& srcFaceI,
+    label& tgtFaceI,
+    const boolList& mapFlag,
+    labelList& seedFaces,
+    const DynamicList<label>& visitedFaces,
+    const bool errorOnNotFound
+) const
+{
+    faceAreaWeightAMI<SourcePatch, TargetPatch>::setNextFaces
+    (
+        startSeedI,
+        srcFaceI,
+        tgtFaceI,
+        mapFlag,
+        seedFaces,
+        visitedFaces,
+        false // no error on not found
+    );
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+template<class SourcePatch, class TargetPatch>
+Foam::partialFaceAreaWeightAMI<SourcePatch, TargetPatch>::
+partialFaceAreaWeightAMI
+(
+    const SourcePatch& srcPatch,
+    const TargetPatch& tgtPatch,
+    const scalarField& srcMagSf,
+    const scalarField& tgtMagSf,
+    const faceAreaIntersect::triangulationMode& triMode,
+    const bool reverseTarget
+)
+:
+    faceAreaWeightAMI<SourcePatch, TargetPatch>
+    (
+        srcPatch,
+        tgtPatch,
+        srcMagSf,
+        tgtMagSf,
+        triMode,
+        reverseTarget
+    )
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
+
+template<class SourcePatch, class TargetPatch>
+Foam::partialFaceAreaWeightAMI<SourcePatch, TargetPatch>::
+~partialFaceAreaWeightAMI()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+template<class SourcePatch, class TargetPatch>
+bool Foam::partialFaceAreaWeightAMI<SourcePatch, TargetPatch>::conformal() const
+{
+    return false;
+}
+
+
+template<class SourcePatch, class TargetPatch>
+void Foam::partialFaceAreaWeightAMI<SourcePatch, TargetPatch>::calculate
+(
+    labelListList& srcAddress,
+    scalarListList& srcWeights,
+    labelListList& tgtAddress,
+    scalarListList& tgtWeights,
+    label srcFaceI,
+    label tgtFaceI
+)
+{
+    bool ok =
+        this->initialise
+        (
+            srcAddress,
+            srcWeights,
+            tgtAddress,
+            tgtWeights,
+            srcFaceI,
+            tgtFaceI
+        );
+
+    if (!ok)
+    {
+        return;
+    }
+
+    // temporary storage for addressing and weights
+    List<DynamicList<label> > srcAddr(this->srcPatch_.size());
+    List<DynamicList<scalar> > srcWght(srcAddr.size());
+    List<DynamicList<label> > tgtAddr(this->tgtPatch_.size());
+    List<DynamicList<scalar> > tgtWght(tgtAddr.size());
+
+    faceAreaWeightAMI<SourcePatch, TargetPatch>::calcAddressing
+    (
+        srcAddr,
+        srcWght,
+        tgtAddr,
+        tgtWght,
+        srcFaceI,
+        tgtFaceI
+    );
+
+    // transfer data to persistent storage
+    forAll(srcAddr, i)
+    {
+        srcAddress[i].transfer(srcAddr[i]);
+        srcWeights[i].transfer(srcWght[i]);
+    }
+    forAll(tgtAddr, i)
+    {
+        tgtAddress[i].transfer(tgtAddr[i]);
+        tgtWeights[i].transfer(tgtWght[i]);
+    }
+}
+
+
+// ************************************************************************* //

src/meshTools/AMIInterpolation/AMIInterpolation/AMIMethod/partialFaceAreaWeightAMI/partialFaceAreaWeightAMI.H

@@ -0,0 +1,141 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::partialFaceAreaWeightAMI
+
+Description
+    Partial face area weighted Arbitrary Mesh Interface (AMI) method
+
+SourceFiles
+    partialFaceAreaWeightAMI.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef partialFaceAreaWeightAMI_H
+#define partialFaceAreaWeightAMI_H
+
+#include "faceAreaWeightAMI.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                  Class partialFaceAreaWeightAMI Declaration
+\*---------------------------------------------------------------------------*/
+
+template<class SourcePatch, class TargetPatch>
+class partialFaceAreaWeightAMI
+:
+    public faceAreaWeightAMI<SourcePatch, TargetPatch>
+{
+
+private:
+
+    // Private Member Functions
+
+        //- Disallow default bitwise copy construct
+        partialFaceAreaWeightAMI(const partialFaceAreaWeightAMI&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const partialFaceAreaWeightAMI&);
+
+        // Marching front
+
+            //- Set the source and target seed faces
+            virtual void setNextFaces
+            (
+                label& startSeedI,
+                label& srcFaceI,
+                label& tgtFaceI,
+                const boolList& mapFlag,
+                labelList& seedFaces,
+                const DynamicList<label>& visitedFaces,
+                bool errorOnNotFound = true
+            ) const;
+
+
+public:
+
+    //- Runtime type information
+    TypeName("partialFaceAreaWeightAMI");
+
+
+    // Constructors
+
+        //- Construct from components
+        partialFaceAreaWeightAMI
+        (
+            const SourcePatch& srcPatch,
+            const TargetPatch& tgtPatch,
+            const scalarField& srcMagSf,
+            const scalarField& tgtMagSf,
+            const faceAreaIntersect::triangulationMode& triMode,
+            const bool reverseTarget = false
+        );
+
+
+    //- Destructor
+    virtual ~partialFaceAreaWeightAMI();
+
+
+    // Member Functions
+
+        // Access
+
+            //- Flag to indicate that interpolation patches are conformal
+            virtual bool conformal() const;
+
+
+        // Manipulation
+
+            //- Update addressing and weights
+            virtual void calculate
+            (
+                labelListList& srcAddress,
+                scalarListList& srcWeights,
+                labelListList& tgtAddress,
+                scalarListList& tgtWeights,
+                label srcFaceI = -1,
+                label tgtFaceI = -1
+            );
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+#   include "partialFaceAreaWeightAMI.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/meshTools/AMIInterpolation/AMIInterpolation/AMIPatchToPatchInterpolation.C

@@ -28,6 +28,7 @@ License
 #include "directAMI.H"
 #include "mapNearestAMI.H"
 #include "faceAreaWeightAMI.H"
+#include "partialFaceAreaWeightAMI.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -38,6 +39,7 @@ namespace Foam
     makeAMIMethodType(AMIPatchToPatchInterpolation, directAMI);
     makeAMIMethodType(AMIPatchToPatchInterpolation, mapNearestAMI);
     makeAMIMethodType(AMIPatchToPatchInterpolation, faceAreaWeightAMI);
+    makeAMIMethodType(AMIPatchToPatchInterpolation, partialFaceAreaWeightAMI);
 }
 
 

src/meshTools/AMIInterpolation/GAMG/interfaceFields/cyclicACMIGAMGInterfaceField/cyclicACMIGAMGInterfaceField.C

@@ -0,0 +1,129 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "cyclicACMIGAMGInterfaceField.H"
+#include "addToRunTimeSelectionTable.H"
+#include "lduMatrix.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(cyclicACMIGAMGInterfaceField, 0);
+    addToRunTimeSelectionTable
+    (
+        GAMGInterfaceField,
+        cyclicACMIGAMGInterfaceField,
+        lduInterface
+    );
+    addToRunTimeSelectionTable
+    (
+        GAMGInterfaceField,
+        cyclicACMIGAMGInterfaceField,
+        lduInterfaceField
+    );
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::cyclicACMIGAMGInterfaceField::cyclicACMIGAMGInterfaceField
+(
+    const GAMGInterface& GAMGCp,
+    const lduInterfaceField& fineInterface
+)
+:
+    GAMGInterfaceField(GAMGCp, fineInterface),
+    cyclicACMIInterface_(refCast<const cyclicACMIGAMGInterface>(GAMGCp)),
+    doTransform_(false),
+    rank_(0)
+{
+    const cyclicAMILduInterfaceField& p =
+        refCast<const cyclicAMILduInterfaceField>(fineInterface);
+
+    doTransform_ = p.doTransform();
+    rank_ = p.rank();
+}
+
+
+Foam::cyclicACMIGAMGInterfaceField::cyclicACMIGAMGInterfaceField
+(
+    const GAMGInterface& GAMGCp,
+    const bool doTransform,
+    const int rank
+)
+:
+    GAMGInterfaceField(GAMGCp, doTransform, rank),
+    cyclicACMIInterface_(refCast<const cyclicACMIGAMGInterface>(GAMGCp)),
+    doTransform_(doTransform),
+    rank_(rank)
+{}
+
+
+// * * * * * * * * * * * * * * * * Desstructor * * * * * * * * * * * * * * * //
+
+Foam::cyclicACMIGAMGInterfaceField::~cyclicACMIGAMGInterfaceField()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+void Foam::cyclicACMIGAMGInterfaceField::updateInterfaceMatrix
+(
+    scalarField& result,
+    const scalarField& psiInternal,
+    const scalarField& coeffs,
+    const direction cmpt,
+    const Pstream::commsTypes
+) const
+{
+    // Get neighbouring field
+    scalarField pnf
+    (
+        cyclicACMIInterface_.neighbPatch().interfaceInternalField(psiInternal)
+    );
+
+    // Transform according to the transformation tensors
+    transformCoupleField(pnf, cmpt);
+
+    if (cyclicACMIInterface_.owner())
+    {
+        pnf = cyclicACMIInterface_.AMI().interpolateToSource(pnf);
+    }
+    else
+    {
+        pnf = cyclicACMIInterface_.neighbPatch().AMI().interpolateToTarget(pnf);
+    }
+
+    const labelUList& faceCells = cyclicACMIInterface_.faceCells();
+
+    forAll(faceCells, elemI)
+    {
+        result[faceCells[elemI]] -= coeffs[elemI]*pnf[elemI];
+    }
+}
+
+
+// ************************************************************************* //

src/meshTools/AMIInterpolation/GAMG/interfaceFields/cyclicACMIGAMGInterfaceField/cyclicACMIGAMGInterfaceField.H

@@ -0,0 +1,166 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::cyclicACMIGAMGInterfaceField
+
+Description
+    GAMG agglomerated cyclic interface for Arbitrarily Coupled Mesh Interface
+    (ACMI) fields.
+
+SourceFiles
+    cyclicACMIGAMGInterfaceField.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef cyclicACMIGAMGInterfaceField_H
+#define cyclicACMIGAMGInterfaceField_H
+
+#include "GAMGInterfaceField.H"
+#include "cyclicACMIGAMGInterface.H"
+#include "cyclicACMILduInterfaceField.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                 Class cyclicACMIGAMGInterfaceField Declaration
+\*---------------------------------------------------------------------------*/
+
+class cyclicACMIGAMGInterfaceField
+:
+    public GAMGInterfaceField,
+    virtual public cyclicACMILduInterfaceField
+{
+    // Private data
+
+        //- Local reference cast into the cyclic interface
+        const cyclicACMIGAMGInterface& cyclicACMIInterface_;
+
+        //- Is the transform required
+        bool doTransform_;
+
+        //- Rank of component for transformation
+        int rank_;
+
+
+    // Private Member Functions
+
+        //- Disallow default bitwise copy construct
+        cyclicACMIGAMGInterfaceField(const cyclicACMIGAMGInterfaceField&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const cyclicACMIGAMGInterfaceField&);
+
+
+public:
+
+    //- Runtime type information
+    TypeName("cyclicACMI");
+
+
+    // Constructors
+
+        //- Construct from GAMG interface and fine level interface field
+        cyclicACMIGAMGInterfaceField
+        (
+            const GAMGInterface& GAMGCp,
+            const lduInterfaceField& fineInterfaceField
+        );
+
+        //- Construct from GAMG interface and fine level interface field
+        cyclicACMIGAMGInterfaceField
+        (
+            const GAMGInterface& GAMGCp,
+            const bool doTransform,
+            const int rank
+        );
+
+
+    //- Destructor
+    virtual ~cyclicACMIGAMGInterfaceField();
+
+
+    // Member Functions
+
+        // Access
+
+            //- Return size
+            label size() const
+            {
+                return cyclicACMIInterface_.size();
+            }
+
+
+        // Interface matrix update
+
+            //- Update result field based on interface functionality
+            virtual void updateInterfaceMatrix
+            (
+                scalarField& result,
+                const scalarField& psiInternal,
+                const scalarField& coeffs,
+                const direction cmpt,
+                const Pstream::commsTypes commsType
+            ) const;
+
+
+        //- Cyclic interface functions
+
+            //- Does the interface field perform the transfromation
+            virtual bool doTransform() const
+            {
+                return doTransform_;
+            }
+
+            //- Return face transformation tensor
+            virtual const tensorField& forwardT() const
+            {
+                return cyclicACMIInterface_.forwardT();
+            }
+
+            //- Return neighbour-cell transformation tensor
+            virtual const tensorField& reverseT() const
+            {
+                return cyclicACMIInterface_.reverseT();
+            }
+
+            //- Return rank of component for transform
+            virtual int rank() const
+            {
+                return rank_;
+            }
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/meshTools/AMIInterpolation/GAMG/interfaces/cyclicACMIGAMGInterface/cyclicACMIGAMGInterface.C

@@ -0,0 +1,198 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "AMIInterpolation.H"
+#include "cyclicACMIGAMGInterface.H"
+#include "addToRunTimeSelectionTable.H"
+#include "Map.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(cyclicACMIGAMGInterface, 0);
+    addToRunTimeSelectionTable
+    (
+        GAMGInterface,
+        cyclicACMIGAMGInterface,
+        lduInterface
+    );
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::cyclicACMIGAMGInterface::cyclicACMIGAMGInterface
+(
+    const label index,
+    const lduInterfacePtrsList& coarseInterfaces,
+    const lduInterface& fineInterface,
+    const labelField& localRestrictAddressing,
+    const labelField& neighbourRestrictAddressing,
+    const label fineLevelIndex,
+    const label coarseComm
+)
+:
+    GAMGInterface
+    (
+        index,
+        coarseInterfaces
+    ),
+    fineCyclicACMIInterface_
+    (
+        refCast<const cyclicACMILduInterface>(fineInterface)
+    )
+{
+    // Construct face agglomeration from cell agglomeration
+    {
+        // From coarse face to cell
+        DynamicList<label> dynFaceCells(localRestrictAddressing.size());
+
+        // From face to coarse face
+        DynamicList<label> dynFaceRestrictAddressing
+        (
+            localRestrictAddressing.size()
+        );
+
+        Map<label> masterToCoarseFace(localRestrictAddressing.size());
+
+        forAll(localRestrictAddressing, ffi)
+        {
+            label curMaster = localRestrictAddressing[ffi];
+
+            Map<label>::const_iterator fnd = masterToCoarseFace.find
+            (
+                curMaster
+            );
+
+            if (fnd == masterToCoarseFace.end())
+            {
+                // New coarse face
+                label coarseI = dynFaceCells.size();
+                dynFaceRestrictAddressing.append(coarseI);
+                dynFaceCells.append(curMaster);
+                masterToCoarseFace.insert(curMaster, coarseI);
+            }
+            else
+            {
+                // Already have coarse face
+                dynFaceRestrictAddressing.append(fnd());
+            }
+        }
+
+        faceCells_.transfer(dynFaceCells);
+        faceRestrictAddressing_.transfer(dynFaceRestrictAddressing);
+    }
+
+
+    // On the owner side construct the AMI
+
+    if (fineCyclicACMIInterface_.owner())
+    {
+        // Construct the neighbour side agglomeration (as the neighbour would
+        // do it so it the exact loop above using neighbourRestrictAddressing
+        // instead of localRestrictAddressing)
+
+        labelList nbrFaceRestrictAddressing;
+        {
+            // From face to coarse face
+            DynamicList<label> dynNbrFaceRestrictAddressing
+            (
+                neighbourRestrictAddressing.size()
+            );
+
+            Map<label> masterToCoarseFace(neighbourRestrictAddressing.size());
+
+            forAll(neighbourRestrictAddressing, ffi)
+            {
+                label curMaster = neighbourRestrictAddressing[ffi];
+
+                Map<label>::const_iterator fnd = masterToCoarseFace.find
+                (
+                    curMaster
+                );
+
+                if (fnd == masterToCoarseFace.end())
+                {
+                    // New coarse face
+                    label coarseI = masterToCoarseFace.size();
+                    dynNbrFaceRestrictAddressing.append(coarseI);
+                    masterToCoarseFace.insert(curMaster, coarseI);
+                }
+                else
+                {
+                    // Already have coarse face
+                    dynNbrFaceRestrictAddressing.append(fnd());
+                }
+            }
+
+            nbrFaceRestrictAddressing.transfer(dynNbrFaceRestrictAddressing);
+        }
+
+        amiPtr_.reset
+        (
+            new AMIPatchToPatchInterpolation
+            (
+                fineCyclicACMIInterface_.AMI(),
+                faceRestrictAddressing_,
+                nbrFaceRestrictAddressing
+            )
+        );
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * Desstructor * * * * * * * * * * * * * * * //
+
+Foam::cyclicACMIGAMGInterface::~cyclicACMIGAMGInterface()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+Foam::tmp<Foam::labelField>
+Foam::cyclicACMIGAMGInterface::internalFieldTransfer
+(
+    const Pstream::commsTypes,
+    const labelUList& iF
+) const
+{
+    const cyclicACMIGAMGInterface& nbr =
+        dynamic_cast<const cyclicACMIGAMGInterface&>(neighbPatch());
+    const labelUList& nbrFaceCells = nbr.faceCells();
+
+    tmp<labelField> tpnf(new labelField(nbrFaceCells.size()));
+    labelField& pnf = tpnf();
+
+    forAll(pnf, facei)
+    {
+        pnf[facei] = iF[nbrFaceCells[facei]];
+    }
+
+    return tpnf;
+}
+
+
+// ************************************************************************* //

src/meshTools/AMIInterpolation/GAMG/interfaces/cyclicACMIGAMGInterface/cyclicACMIGAMGInterface.H

@@ -0,0 +1,174 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::cyclicACMIGAMGInterface
+
+Description
+    GAMG agglomerated cyclic ACMI interface.
+
+SourceFiles
+    cyclicACMIGAMGInterface.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef cyclicACMIGAMGInterface_H
+#define cyclicACMIGAMGInterface_H
+
+#include "GAMGInterface.H"
+#include "cyclicACMILduInterface.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                   Class cyclicACMIGAMGInterface Declaration
+\*---------------------------------------------------------------------------*/
+
+class cyclicACMIGAMGInterface
+:
+    public GAMGInterface,
+    virtual public cyclicACMILduInterface
+{
+    // Private data
+
+        //- Reference for the cyclicLduInterface from which this is
+        //  agglomerated
+        const cyclicACMILduInterface& fineCyclicACMIInterface_;
+
+        //- AMI interface
+        autoPtr<AMIPatchToPatchInterpolation> amiPtr_;
+
+
+    // Private Member Functions
+
+        //- Disallow default bitwise copy construct
+        cyclicACMIGAMGInterface(const cyclicACMIGAMGInterface&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const cyclicACMIGAMGInterface&);
+
+
+public:
+
+    //- Runtime type information
+    TypeName("cyclicACMI");
+
+
+    // Constructors
+
+        //- Construct from fine level interface,
+        //  local and neighbour restrict addressing
+        cyclicACMIGAMGInterface
+        (
+            const label index,
+            const lduInterfacePtrsList& coarseInterfaces,
+            const lduInterface& fineInterface,
+            const labelField& restrictAddressing,
+            const labelField& neighbourRestrictAddressing,
+            const label fineLevelIndex,
+            const label coarseComm
+        );
+
+
+    //- Destructor
+    virtual ~cyclicACMIGAMGInterface();
+
+
+    // Member Functions
+
+        // Interface transfer functions
+
+            //- Transfer and return internal field adjacent to the interface
+            virtual tmp<labelField> internalFieldTransfer
+            (
+                const Pstream::commsTypes commsType,
+                const labelUList& iF
+            ) const;
+
+
+        //- Cyclic interface functions
+
+            //- Return neigbour processor number
+            virtual label neighbPatchID() const
+            {
+                return fineCyclicACMIInterface_.neighbPatchID();
+            }
+
+            virtual bool owner() const
+            {
+                return fineCyclicACMIInterface_.owner();
+            }
+
+            virtual const cyclicACMIGAMGInterface& neighbPatch() const
+            {
+                return dynamic_cast<const cyclicACMIGAMGInterface&>
+                (
+                    coarseInterfaces_[neighbPatchID()]
+                );
+            }
+
+            virtual const AMIPatchToPatchInterpolation& AMI() const
+            {
+                return amiPtr_();
+            }
+
+            //- Return face transformation tensor
+            virtual const tensorField& forwardT() const
+            {
+                return fineCyclicACMIInterface_.forwardT();
+            }
+
+            //- Return neighbour-cell transformation tensor
+            virtual const tensorField& reverseT() const
+            {
+                return fineCyclicACMIInterface_.reverseT();
+            }
+
+
+        // I/O
+
+            //- Write to stream
+            virtual void write(Ostream&) const
+            {
+                //TBD. How to serialise the AMI such that we can stream
+                // cyclicACMIGAMGInterface.
+                notImplemented
+                (
+                    "cyclicACMIGAMGInterface::write(Ostream&) const"
+                );
+            }
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/meshTools/AMIInterpolation/patches/cyclicACMI/cyclicACMILduInterfaceField/cyclicACMILduInterface.C

@@ -0,0 +1,42 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "cyclicACMILduInterface.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+defineTypeNameAndDebug(cyclicACMILduInterface, 0);
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::cyclicACMILduInterface::~cyclicACMILduInterface()
+{}
+
+
+// ************************************************************************* //

src/meshTools/AMIInterpolation/patches/cyclicACMI/cyclicACMILduInterfaceField/cyclicACMILduInterface.H

@@ -0,0 +1,80 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::cyclicACMILduInterface
+
+Description
+    An abstract base class for cyclic ACMI coupled interfaces
+
+SourceFiles
+    cyclicACMILduInterface.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef cyclicACMILduInterface_H
+#define cyclicACMILduInterface_H
+
+#include "cyclicAMILduInterface.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                   Class cyclicACMILduInterface Declaration
+\*---------------------------------------------------------------------------*/
+
+class cyclicACMILduInterface
+:
+    public cyclicAMILduInterface
+{
+
+public:
+
+    //- Runtime type information
+    TypeName("cyclicACMILduInterface");
+
+
+    // Constructors
+
+        //- Construct null
+        cyclicACMILduInterface()
+        {}
+
+
+    //- Destructor
+    virtual ~cyclicACMILduInterface();
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/meshTools/AMIInterpolation/patches/cyclicACMI/cyclicACMILduInterfaceField/cyclicACMILduInterfaceField.C

@@ -0,0 +1,55 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "cyclicACMILduInterfaceField.H"
+#include "diagTensorField.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+defineTypeNameAndDebug(cyclicACMILduInterfaceField, 0);
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::cyclicACMILduInterfaceField::~cyclicACMILduInterfaceField()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+void Foam::cyclicACMILduInterfaceField::transformCoupleField
+(
+    scalarField& f,
+    const direction cmpt
+) const
+{
+    cyclicAMILduInterfaceField::transformCoupleField(f, cmpt);
+}
+
+
+// ************************************************************************* //

src/meshTools/AMIInterpolation/patches/cyclicACMI/cyclicACMILduInterfaceField/cyclicACMILduInterfaceField.H

@@ -0,0 +1,108 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::cyclicACMILduInterfaceField
+
+Description
+    Abstract base class for cyclic ACMI coupled interfaces
+
+SourceFiles
+    cyclicACMILduInterfaceField.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef cyclicACMILduInterfaceField_H
+#define cyclicACMILduInterfaceField_H
+
+#include "cyclicAMILduInterfaceField.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                 Class cyclicACMILduInterfaceField Declaration
+\*---------------------------------------------------------------------------*/
+
+class cyclicACMILduInterfaceField
+:
+    public cyclicAMILduInterfaceField
+{
+
+public:
+
+    //- Runtime type information
+    TypeName("cyclicACMILduInterfaceField");
+
+
+    // Constructors
+
+        //- Construct null
+        cyclicACMILduInterfaceField()
+        {}
+
+
+    //- Destructor
+    virtual ~cyclicACMILduInterfaceField();
+
+
+    // Member Functions
+
+        //- Transform given patch field
+        template<class Type>
+        void transformCoupleField(Field<Type>& f) const;
+
+        //- Transform given patch internal field
+        void transformCoupleField
+        (
+            scalarField& psiInternal,
+            const direction cmpt
+        ) const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#include "tensorField.H"
+
+template<class Type>
+void Foam::cyclicACMILduInterfaceField::transformCoupleField
+(
+    Field<Type>& f
+) const
+{
+    cyclicAMILduInterfaceField::transformCoupleField(f);
+}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/meshTools/AMIInterpolation/patches/cyclicACMI/cyclicACMIPointPatch/cyclicACMIPointPatch.C

@@ -0,0 +1,99 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "cyclicACMIPointPatch.H"
+#include "pointBoundaryMesh.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(cyclicACMIPointPatch, 0);
+    addToRunTimeSelectionTable
+    (
+        facePointPatch,
+        cyclicACMIPointPatch,
+        polyPatch
+    );
+}
+
+
+// * * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * //
+
+void Foam::cyclicACMIPointPatch::initGeometry(PstreamBuffers&)
+{}
+
+
+void Foam::cyclicACMIPointPatch::calcGeometry(PstreamBuffers&)
+{}
+
+
+void Foam::cyclicACMIPointPatch::initMovePoints
+(
+    PstreamBuffers&,
+    const pointField&
+)
+{}
+
+
+void Foam::cyclicACMIPointPatch::movePoints(PstreamBuffers&, const pointField&)
+{}
+
+
+void Foam::cyclicACMIPointPatch::initUpdateMesh(PstreamBuffers& pBufs)
+{
+    facePointPatch::initUpdateMesh(pBufs);
+//    cyclicACMIPointPatch::initGeometry(pBufs);
+}
+
+
+void Foam::cyclicACMIPointPatch::updateMesh(PstreamBuffers& pBufs)
+{
+    facePointPatch::updateMesh(pBufs);
+//    cyclicACMIPointPatch::calcGeometry(pBufs);
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::cyclicACMIPointPatch::cyclicACMIPointPatch
+(
+    const polyPatch& patch,
+    const pointBoundaryMesh& bm
+)
+:
+    coupledFacePointPatch(patch, bm),
+    cyclicACMIPolyPatch_(refCast<const cyclicACMIPolyPatch>(patch))
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::cyclicACMIPointPatch::~cyclicACMIPointPatch()
+{}
+
+
+// ************************************************************************* //

src/meshTools/AMIInterpolation/patches/cyclicACMI/cyclicACMIPointPatch/cyclicACMIPointPatch.H

@@ -0,0 +1,170 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::cyclicACMIPointPatch
+
+Description
+    Cyclic AMI point patch - place holder only
+
+SourceFiles
+    cyclicACMIPointPatch.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef cyclicACMIPointPatch_H
+#define cyclicACMIPointPatch_H
+
+#include "coupledFacePointPatch.H"
+#include "cyclicACMIPolyPatch.H"
+#include "pointBoundaryMesh.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                    Class cyclicACMIPointPatch Declaration
+\*---------------------------------------------------------------------------*/
+
+class cyclicACMIPointPatch
+:
+    public coupledFacePointPatch
+{
+    // Private data
+
+        //- Local reference cast into the cyclic AMI patch
+        const cyclicACMIPolyPatch& cyclicACMIPolyPatch_;
+
+
+    // Private Member Functions
+
+        //- Disallow default construct as copy
+        cyclicACMIPointPatch(const cyclicACMIPointPatch&);
+
+        //- Disallow default assignment
+        void operator=(const cyclicACMIPointPatch&);
+
+
+protected:
+
+    // Protected Member Functions
+
+        //- Initialise the calculation of the patch geometry
+        virtual void initGeometry(PstreamBuffers&);
+
+        //- Calculate the patch geometry
+        virtual void calcGeometry(PstreamBuffers&);
+
+        //- Initialise the patches for moving points
+        virtual void initMovePoints(PstreamBuffers&, const pointField&);
+
+        //- Correct patches after moving points
+        virtual void movePoints(PstreamBuffers&, const pointField&);
+
+        //- Initialise the update of the patch topology
+        virtual void initUpdateMesh(PstreamBuffers&);
+
+        //- Update of the patch topology
+        virtual void updateMesh(PstreamBuffers&);
+
+
+public:
+
+    //- Runtime type information
+    TypeName(cyclicACMIPolyPatch::typeName_());
+
+
+    // Constructors
+
+        //- Construct from components
+        cyclicACMIPointPatch
+        (
+            const polyPatch& patch,
+            const pointBoundaryMesh& bm
+        );
+
+
+    //- Destructor
+    virtual ~cyclicACMIPointPatch();
+
+
+    // Member Functions
+
+        //- Is patch 'coupled'. Note that on AMI the geometry is not
+        //  coupled but the fields are!
+        virtual bool coupled() const
+        {
+            return false;
+        }
+
+        //- Return the constraint type this pointPatch implements.
+        virtual const word& constraintType() const
+        {
+            return type();
+        }
+
+        //- Return the underlying cyclicAMIPolyPatch
+        const cyclicACMIPolyPatch& cyclicACMIPatch() const
+        {
+            return cyclicACMIPolyPatch_;
+        }
+
+        //- Return neighbour point patch
+        const cyclicACMIPointPatch& neighbPatch() const
+        {
+            label patchI = cyclicACMIPolyPatch_.neighbPatchID();
+            const pointPatch& pp = this->boundaryMesh()[patchI];
+            return refCast<const cyclicACMIPointPatch>(pp);
+        }
+
+        //- Are the cyclic planes parallel
+        bool parallel() const
+        {
+            return cyclicACMIPolyPatch_.parallel();
+        }
+
+        //- Return face transformation tensor
+        const tensorField& forwardT() const
+        {
+            return cyclicACMIPolyPatch_.forwardT();
+        }
+
+        //- Return neighbour-cell transformation tensor
+        const tensorField& reverseT() const
+        {
+            return cyclicACMIPolyPatch_.reverseT();
+        }
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/meshTools/AMIInterpolation/patches/cyclicACMI/cyclicACMIPointPatchField/cyclicACMIPointPatchField.C

@@ -0,0 +1,210 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "cyclicACMIPointPatchField.H"
+#include "Swap.H"
+#include "transformField.H"
+#include "pointFields.H"
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+template<class Type>
+Foam::cyclicACMIPointPatchField<Type>::cyclicACMIPointPatchField
+(
+    const pointPatch& p,
+    const DimensionedField<Type, pointMesh>& iF
+)
+:
+    coupledPointPatchField<Type>(p, iF),
+    cyclicACMIPatch_(refCast<const cyclicACMIPointPatch>(p)),
+    ppiPtr_(NULL),
+    nbrPpiPtr_(NULL)
+{}
+
+
+template<class Type>
+Foam::cyclicACMIPointPatchField<Type>::cyclicACMIPointPatchField
+(
+    const pointPatch& p,
+    const DimensionedField<Type, pointMesh>& iF,
+    const dictionary& dict
+)
+:
+    coupledPointPatchField<Type>(p, iF, dict),
+    cyclicACMIPatch_(refCast<const cyclicACMIPointPatch>(p)),
+    ppiPtr_(NULL),
+    nbrPpiPtr_(NULL)
+{
+    if (!isType<cyclicACMIPointPatch>(p))
+    {
+        FatalIOErrorIn
+        (
+            "cyclicACMIPointPatchField<Type>::cyclicACMIPointPatchField\n"
+            "(\n"
+            "    const pointPatch&,\n"
+            "    const DimensionedField<Type, pointMesh>&,\n"
+            "    const dictionary&\n"
+            ")\n",
+            dict
+        )   << "patch " << this->patch().index() << " not cyclicACMI type. "
+            << "Patch type = " << p.type()
+            << exit(FatalIOError);
+    }
+}
+
+
+template<class Type>
+Foam::cyclicACMIPointPatchField<Type>::cyclicACMIPointPatchField
+(
+    const cyclicACMIPointPatchField<Type>& ptf,
+    const pointPatch& p,
+    const DimensionedField<Type, pointMesh>& iF,
+    const pointPatchFieldMapper& mapper
+)
+:
+    coupledPointPatchField<Type>(ptf, p, iF, mapper),
+    cyclicACMIPatch_(refCast<const cyclicACMIPointPatch>(p)),
+    ppiPtr_(NULL),
+    nbrPpiPtr_(NULL)
+{
+    if (!isType<cyclicACMIPointPatch>(this->patch()))
+    {
+        FatalErrorIn
+        (
+            "cyclicACMIPointPatchField<Type>::cyclicACMIPointPatchField\n"
+            "(\n"
+            "    const cyclicACMIPointPatchField<Type>&,\n"
+            "    const pointPatch&,\n"
+            "    const DimensionedField<Type, pointMesh>&,\n"
+            "    const pointPatchFieldMapper&\n"
+            ")\n"
+        )   << "Field type does not correspond to patch type for patch "
+            << this->patch().index() << "." << endl
+            << "Field type: " << typeName << endl
+            << "Patch type: " << this->patch().type()
+            << exit(FatalError);
+    }
+}
+
+
+template<class Type>
+Foam::cyclicACMIPointPatchField<Type>::cyclicACMIPointPatchField
+(
+    const cyclicACMIPointPatchField<Type>& ptf,
+    const DimensionedField<Type, pointMesh>& iF
+)
+:
+    coupledPointPatchField<Type>(ptf, iF),
+    cyclicACMIPatch_(ptf.cyclicACMIPatch_),
+    ppiPtr_(NULL),
+    nbrPpiPtr_(NULL)
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+template<class Type>
+void Foam::cyclicACMIPointPatchField<Type>::swapAddSeparated
+(
+    const Pstream::commsTypes,
+    Field<Type>& pField
+) const
+{
+    if (cyclicACMIPatch_.cyclicACMIPatch().owner())
+    {
+        // We inplace modify pField. To prevent the other side (which gets
+        // evaluated at a later date) using already changed values we do
+        // all swaps on the side that gets evaluated first.
+
+        // Get neighbouring pointPatch
+        const cyclicACMIPointPatch& nbrPatch = cyclicACMIPatch_.neighbPatch();
+
+        // Get neighbouring pointPatchField
+        const GeometricField<Type, pointPatchField, pointMesh>& fld =
+            refCast<const GeometricField<Type, pointPatchField, pointMesh> >
+            (
+                this->dimensionedInternalField()
+            );
+
+        const cyclicACMIPointPatchField<Type>& nbr =
+            refCast<const cyclicACMIPointPatchField<Type> >
+            (
+                fld.boundaryField()[nbrPatch.index()]
+            );
+
+
+        Field<Type> ptFld(this->patchInternalField(pField));
+        Field<Type> nbrPtFld(nbr.patchInternalField(pField));
+
+
+        if (doTransform())
+        {
+            const tensor& forwardT = this->forwardT()[0];
+            const tensor& reverseT = this->reverseT()[0];
+
+            transform(ptFld, reverseT, ptFld);
+            transform(nbrPtFld, forwardT, nbrPtFld);
+        }
+
+        // convert point field to face field, AMI interpolate, then
+        // face back to point
+        {
+            // add neighbour side contribution to owner
+            Field<Type> nbrFcFld(nbrPpi().pointToFaceInterpolate(nbrPtFld));
+
+            const cyclicAMIPolyPatch& cami = cyclicACMIPatch_.cyclicACMIPatch();
+
+            // interpolate to owner
+            nbrFcFld = cami.interpolate(nbrFcFld);
+
+            // add to internal field
+            this->addToInternalField
+            (
+                pField,
+                ppi().faceToPointInterpolate(nbrFcFld)()
+            );
+        }
+
+        {
+            // add owner side contribution to neighbour
+            Field<Type> fcFld(ppi().pointToFaceInterpolate(ptFld));
+
+            const cyclicAMIPolyPatch& cami = cyclicACMIPatch_.cyclicACMIPatch();
+
+            // interpolate to neighbour
+            fcFld = cami.neighbPatch().cyclicAMIPolyPatch::interpolate(fcFld);
+
+            // add to internal field
+            nbr.addToInternalField
+            (
+                pField,
+                nbrPpi().faceToPointInterpolate(fcFld)()
+            );
+        }
+    }
+}
+
+
+// ************************************************************************* //

src/meshTools/AMIInterpolation/patches/cyclicACMI/cyclicACMIPointPatchField/cyclicACMIPointPatchField.H

@@ -0,0 +1,241 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::cyclicACMIPointPatchField
+
+Description
+    Cyclic ACMI front and back plane patch field
+
+SourceFiles
+    cyclicACMIPointPatchField.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef cyclicACMIPointPatchField_H
+#define cyclicACMIPointPatchField_H
+
+#include "coupledPointPatchField.H"
+#include "cyclicACMIPointPatch.H"
+#include "PrimitivePatchInterpolation.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                  Class cyclicACMIPointPatchField Declaration
+\*---------------------------------------------------------------------------*/
+
+template<class Type>
+class cyclicACMIPointPatchField
+:
+    public coupledPointPatchField<Type>
+{
+    // Private data
+
+        //- Local reference cast into the cyclicACMI patch
+        const cyclicACMIPointPatch& cyclicACMIPatch_;
+
+        //- Owner side patch interpolation pointer
+        mutable autoPtr<PrimitivePatchInterpolation<primitivePatch> > ppiPtr_;
+
+        //- Neighbour side patch interpolation pointer
+        mutable autoPtr<PrimitivePatchInterpolation<primitivePatch> >
+            nbrPpiPtr_;
+
+
+    // Private Member Functions
+
+        //- Owner side patch interpolation
+        const PrimitivePatchInterpolation<primitivePatch>& ppi() const
+        {
+            if (!ppiPtr_.valid())
+            {
+                ppiPtr_.reset
+                (
+                    new PrimitivePatchInterpolation<primitivePatch>
+                    (
+                        cyclicACMIPatch_.cyclicACMIPatch()
+                    )
+                );
+            }
+
+            return ppiPtr_();
+        }
+
+        //- Neighbour side patch interpolation
+        const PrimitivePatchInterpolation<primitivePatch>& nbrPpi() const
+        {
+            if (!nbrPpiPtr_.valid())
+            {
+                nbrPpiPtr_.reset
+                (
+                    new PrimitivePatchInterpolation<primitivePatch>
+                    (
+                        cyclicACMIPatch_.cyclicACMIPatch().neighbPatch()
+                    )
+                );
+            }
+
+            return nbrPpiPtr_();
+        }
+
+
+public:
+
+    //- Runtime type information
+    TypeName(cyclicACMIPointPatch::typeName_());
+
+
+    // Constructors
+
+        //- Construct from patch and internal field
+        cyclicACMIPointPatchField
+        (
+            const pointPatch&,
+            const DimensionedField<Type, pointMesh>&
+        );
+
+        //- Construct from patch, internal field and dictionary
+        cyclicACMIPointPatchField
+        (
+            const pointPatch&,
+            const DimensionedField<Type, pointMesh>&,
+            const dictionary&
+        );
+
+        //- Construct by mapping given patchField<Type> onto a new patch
+        cyclicACMIPointPatchField
+        (
+            const cyclicACMIPointPatchField<Type>&,
+            const pointPatch&,
+            const DimensionedField<Type, pointMesh>&,
+            const pointPatchFieldMapper&
+        );
+
+        //- Construct and return a clone
+        virtual autoPtr<pointPatchField<Type> > clone() const
+        {
+            return autoPtr<pointPatchField<Type> >
+            (
+                new cyclicACMIPointPatchField<Type>
+                (
+                    *this
+                )
+            );
+        }
+
+        //- Construct as copy setting internal field reference
+        cyclicACMIPointPatchField
+        (
+            const cyclicACMIPointPatchField<Type>&,
+            const DimensionedField<Type, pointMesh>&
+        );
+
+        //- Construct and return a clone setting internal field reference
+        virtual autoPtr<pointPatchField<Type> > clone
+        (
+            const DimensionedField<Type, pointMesh>& iF
+        ) const
+        {
+            return autoPtr<pointPatchField<Type> >
+            (
+                new cyclicACMIPointPatchField<Type>
+                (
+                    *this, iF
+                )
+            );
+        }
+
+
+    // Member functions
+
+        // Constraint handling
+
+            //- Return the constraint type this pointPatchField implements
+            virtual const word& constraintType() const
+            {
+                return cyclicACMIPointPatch::typeName;
+            }
+
+
+        // Cyclic AMI coupled interface functions
+
+            //- Does the patch field perform the transfromation
+            virtual bool doTransform() const
+            {
+                return
+                   !(
+                        cyclicACMIPatch_.parallel()
+                     || pTraits<Type>::rank == 0
+                    );
+            }
+
+            //- Return face transformation tensor
+            virtual const tensorField& forwardT() const
+            {
+                return cyclicACMIPatch_.forwardT();
+            }
+
+            //- Return neighbour-cell transformation tensor
+            virtual const tensorField& reverseT() const
+            {
+                return cyclicACMIPatch_.reverseT();
+            }
+
+
+        // Evaluation functions
+
+            //- Evaluate the patch field
+            virtual void evaluate
+            (
+                const Pstream::commsTypes commsType=Pstream::blocking
+            )
+            {}
+
+            //- Complete swap of patch point values and add to local values
+            virtual void swapAddSeparated
+            (
+                const Pstream::commsTypes commsType,
+                Field<Type>&
+            ) const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+#    include "cyclicACMIPointPatchField.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/meshTools/AMIInterpolation/patches/cyclicACMI/cyclicACMIPointPatchField/cyclicACMIPointPatchFields.C

@@ -0,0 +1,43 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "cyclicACMIPointPatchFields.H"
+#include "pointPatchFields.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+makePointPatchFields(cyclicACMI);
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// ************************************************************************* //

src/meshTools/AMIInterpolation/patches/cyclicACMI/cyclicACMIPointPatchField/cyclicACMIPointPatchFields.H

@@ -0,0 +1,49 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef cyclicACMIPointPatchFields_H
+#define cyclicACMIPointPatchFields_H
+
+#include "cyclicACMIPointPatchField.H"
+#include "fieldTypes.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+makePointPatchFieldTypedefs(cyclicACMI);
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/meshTools/AMIInterpolation/patches/cyclicACMI/cyclicACMIPolyPatch/cyclicACMIPolyPatch.C

@@ -0,0 +1,441 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "cyclicACMIPolyPatch.H"
+#include "transformField.H"
+#include "SubField.H"
+#include "polyMesh.H"
+#include "Time.H"
+#include "faceAreaIntersect.H"
+#include "ops.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(cyclicACMIPolyPatch, 0);
+
+    addToRunTimeSelectionTable(polyPatch, cyclicACMIPolyPatch, word);
+    addToRunTimeSelectionTable(polyPatch, cyclicACMIPolyPatch, dictionary);
+}
+
+const Foam::scalar Foam::cyclicACMIPolyPatch::tolerance_ = 1e-6;
+
+// * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
+
+void Foam::cyclicACMIPolyPatch::initPatchFaceAreas() const
+{
+    if (!empty() && faceAreas0_.empty())
+    {
+        faceAreas0_ = faceAreas();
+    }
+
+    const cyclicACMIPolyPatch& nbrACMI =
+        refCast<const cyclicACMIPolyPatch>(this->neighbPatch());
+
+    if (!nbrACMI.empty() && nbrACMI.faceAreas0().empty())
+    {
+        nbrACMI.initPatchFaceAreas();
+    }
+}
+
+
+void Foam::cyclicACMIPolyPatch::resetAMI
+(
+    const AMIPatchToPatchInterpolation::interpolationMethod&
+) const
+{
+    if (owner())
+    {
+        const polyPatch& nonOverlapPatch = this->nonOverlapPatch();
+
+        initPatchFaceAreas();
+
+        // reset patch face areas based on original patch for AMI calculation
+        vectorField::subField Sf = faceAreas();
+        vectorField::subField noSf = nonOverlapPatch.faceAreas();
+
+        forAll(Sf, faceI)
+        {
+            Sf[faceI] = faceAreas0_[faceI];
+            noSf[faceI] = faceAreas0_[faceI];
+        }
+
+        // calculate the AMI using partial face-area-weighted
+        cyclicAMIPolyPatch::resetAMI
+        (
+            AMIPatchToPatchInterpolation::imPartialFaceAreaWeight
+        );
+
+        const scalarField& srcWeightSum = AMI().srcWeightsSum();
+
+        // set patch face areas based on sum of AMI weights per face
+        forAll(Sf, faceI)
+        {
+            scalar w = srcWeightSum[faceI];
+            w = min(1.0 - tolerance_, max(tolerance_, w));
+
+            Sf[faceI] *= w;
+            noSf[faceI] *= 1.0 - w;
+        }
+
+        setNeighbourFaceAreas();
+
+        // set the updated flag
+        updated_ = true;
+    }
+}
+
+
+void Foam::cyclicACMIPolyPatch::setNeighbourFaceAreas() const
+{
+    const cyclicACMIPolyPatch& cp =
+        refCast<const cyclicACMIPolyPatch>(this->neighbPatch());
+    const polyPatch& pp = cp.nonOverlapPatch();
+
+    const scalarField& tgtWeightSum = AMI().tgtWeightsSum();
+
+    const vectorField& faceAreas0 = cp.faceAreas0();
+
+    vectorField::subField Sf = cp.faceAreas();
+    vectorField::subField noSf = pp.faceAreas();
+
+    forAll(Sf, faceI)
+    {
+        scalar w = tgtWeightSum[faceI];
+        w = min(1.0 - tolerance_, max(tolerance_, w));
+
+        Sf[faceI] = w*faceAreas0[faceI];
+        noSf[faceI] = (1.0 - w)*faceAreas0[faceI];
+    }
+}
+
+
+void Foam::cyclicACMIPolyPatch::initGeometry(PstreamBuffers& pBufs)
+{
+    cyclicAMIPolyPatch::initGeometry(pBufs);
+}
+
+
+void Foam::cyclicACMIPolyPatch::calcGeometry(PstreamBuffers& pBufs)
+{
+    cyclicAMIPolyPatch::calcGeometry(pBufs);
+}
+
+
+void Foam::cyclicACMIPolyPatch::initMovePoints
+(
+    PstreamBuffers& pBufs,
+    const pointField& p
+)
+{
+    cyclicAMIPolyPatch::initMovePoints(pBufs, p);
+}
+
+
+void Foam::cyclicACMIPolyPatch::movePoints
+(
+    PstreamBuffers& pBufs,
+    const pointField& p
+)
+{
+    cyclicAMIPolyPatch::movePoints(pBufs, p);
+}
+
+
+void Foam::cyclicACMIPolyPatch::initUpdateMesh(PstreamBuffers& pBufs)
+{
+    cyclicAMIPolyPatch::initUpdateMesh(pBufs);
+}
+
+
+void Foam::cyclicACMIPolyPatch::updateMesh(PstreamBuffers& pBufs)
+{
+    cyclicAMIPolyPatch::updateMesh(pBufs);
+}
+
+
+void Foam::cyclicACMIPolyPatch::clearGeom()
+{
+    cyclicAMIPolyPatch::clearGeom();
+}
+
+
+// * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * * * //
+
+Foam::cyclicACMIPolyPatch::cyclicACMIPolyPatch
+(
+    const word& name,
+    const label size,
+    const label start,
+    const label index,
+    const polyBoundaryMesh& bm,
+    const word& patchType,
+    const transformType transform
+)
+:
+    cyclicAMIPolyPatch(name, size, start, index, bm, patchType, transform),
+    faceAreas0_(),
+    nonOverlapPatchName_(word::null),
+    nonOverlapPatchID_(-1),
+    updated_(false)
+{
+    // Non-overlapping patch might not be valid yet so cannot determine
+    // associated patchID
+}
+
+
+Foam::cyclicACMIPolyPatch::cyclicACMIPolyPatch
+(
+    const word& name,
+    const dictionary& dict,
+    const label index,
+    const polyBoundaryMesh& bm,
+    const word& patchType
+)
+:
+    cyclicAMIPolyPatch(name, dict, index, bm, patchType),
+    faceAreas0_(),
+    nonOverlapPatchName_(dict.lookup("nonOverlapPatch")),
+    nonOverlapPatchID_(-1),
+    updated_(false)
+{
+    if (nonOverlapPatchName_ == name)
+    {
+        FatalIOErrorIn
+        (
+            "cyclicACMIPolyPatch::cyclicACMIPolyPatch"
+            "("
+                "const word&, "
+                "const dictionary&, "
+                "const label, "
+                "const polyBoundaryMesh&, "
+                "const word&"
+            ")",
+            dict
+        )   << "Non-overlapping patch name " << nonOverlapPatchName_
+            << " cannot be the same as this patch " << name
+            << exit(FatalIOError);
+    }
+
+    // Non-overlapping patch might not be valid yet so cannot determine
+    // associated patchID
+}
+
+
+Foam::cyclicACMIPolyPatch::cyclicACMIPolyPatch
+(
+    const cyclicACMIPolyPatch& pp,
+    const polyBoundaryMesh& bm
+)
+:
+    cyclicAMIPolyPatch(pp, bm),
+    faceAreas0_(),
+    nonOverlapPatchName_(pp.nonOverlapPatchName_),
+    nonOverlapPatchID_(-1),
+    updated_(false)
+{
+    // Non-overlapping patch might not be valid yet so cannot determine
+    // associated patchID
+}
+
+
+Foam::cyclicACMIPolyPatch::cyclicACMIPolyPatch
+(
+    const cyclicACMIPolyPatch& pp,
+    const polyBoundaryMesh& bm,
+    const label index,
+    const label newSize,
+    const label newStart,
+    const word& nbrPatchName,
+    const word& nonOverlapPatchName
+)
+:
+    cyclicAMIPolyPatch(pp, bm, index, newSize, newStart, nbrPatchName),
+    faceAreas0_(),
+    nonOverlapPatchName_(nonOverlapPatchName),
+    nonOverlapPatchID_(-1),
+    updated_(false)
+{
+    if (nonOverlapPatchName_ == name())
+    {
+        FatalErrorIn
+        (
+            "const cyclicACMIPolyPatch& "
+            "const polyBoundaryMesh&, "
+            "const label, "
+            "const label, "
+            "const label, "
+            "const word&, "
+            "const word&"
+        )   << "Non-overlapping patch name " << nonOverlapPatchName_
+            << " cannot be the same as this patch " << name()
+            << exit(FatalError);
+    }
+
+    // Non-overlapping patch might not be valid yet so cannot determine
+    // associated patchID
+}
+
+
+Foam::cyclicACMIPolyPatch::cyclicACMIPolyPatch
+(
+    const cyclicACMIPolyPatch& pp,
+    const polyBoundaryMesh& bm,
+    const label index,
+    const labelUList& mapAddressing,
+    const label newStart
+)
+:
+    cyclicAMIPolyPatch(pp, bm, index, mapAddressing, newStart),
+    faceAreas0_(),
+    nonOverlapPatchName_(pp.nonOverlapPatchName_),
+    nonOverlapPatchID_(-1),
+    updated_(false)
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::cyclicACMIPolyPatch::~cyclicACMIPolyPatch()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+Foam::label Foam::cyclicACMIPolyPatch::nonOverlapPatchID() const
+{
+    if (nonOverlapPatchID_ == -1)
+    {
+        nonOverlapPatchID_ =
+            this->boundaryMesh().findPatchID(nonOverlapPatchName_);
+
+        if (nonOverlapPatchID_ == -1)
+        {
+            FatalErrorIn("cyclicPolyAMIPatch::neighbPatchID() const")
+                << "Illegal non-overlapping patch name " << nonOverlapPatchName_
+                << nl << "Valid patch names are "
+                << this->boundaryMesh().names()
+                << exit(FatalError);
+        }
+
+        const polyPatch& noPp = this->boundaryMesh()[nonOverlapPatchID_];
+
+        bool ok = true;
+
+        if (size() == noPp.size())
+        {
+            const scalarField magSf(mag(faceAreas()));
+            const scalarField noMagSf(mag(noPp.faceAreas()));
+
+            forAll(magSf, faceI)
+            {
+                scalar ratio = mag(magSf[faceI]/(noMagSf[faceI] + ROOTVSMALL));
+
+                if (ratio - 1 > tolerance_)
+                {
+                    ok = false;
+                    break;
+                }
+            }
+        }
+        else
+        {
+            ok = false;
+        }
+
+        if (!ok)
+        {
+            FatalErrorIn
+            (
+                "Foam::label "
+                "Foam::cyclicACMIPolyPatch::nonOverlapPatchID() const"
+            )   << "Inconsistent ACMI patches " << name() << " and "
+                << noPp.name() << ".  Patches should have identical topology"
+                << exit(FatalError);
+        }
+    }
+
+    return nonOverlapPatchID_;
+}
+
+
+void Foam::cyclicACMIPolyPatch::calcGeometry
+(
+    const primitivePatch& referPatch,
+    const pointField& thisCtrs,
+    const vectorField& thisAreas,
+    const pointField& thisCc,
+    const pointField& nbrCtrs,
+    const vectorField& nbrAreas,
+    const pointField& nbrCc
+)
+{
+    cyclicAMIPolyPatch::calcGeometry
+    (
+        referPatch,
+        thisCtrs,
+        thisAreas,
+        thisCc,
+        nbrCtrs,
+        nbrAreas,
+        nbrCc
+    );
+}
+
+
+void Foam::cyclicACMIPolyPatch::initOrder
+(
+    PstreamBuffers& pBufs,
+    const primitivePatch& pp
+) const
+{
+    cyclicAMIPolyPatch::initOrder(pBufs, pp);
+}
+
+
+bool Foam::cyclicACMIPolyPatch::order
+(
+    PstreamBuffers& pBufs,
+    const primitivePatch& pp,
+    labelList& faceMap,
+    labelList& rotation
+) const
+{
+    return cyclicAMIPolyPatch::order(pBufs, pp, faceMap, rotation);
+}
+
+
+void Foam::cyclicACMIPolyPatch::write(Ostream& os) const
+{
+    cyclicAMIPolyPatch::write(os);
+
+    os.writeKeyword("nonOverlapPatch") << nonOverlapPatchName_
+        << token::END_STATEMENT << nl;
+}
+
+
+// ************************************************************************* //

src/meshTools/AMIInterpolation/patches/cyclicACMI/cyclicACMIPolyPatch/cyclicACMIPolyPatch.H

@@ -0,0 +1,349 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::cyclicACMIPolyPatch
+
+Description
+    Cyclic patch for Arbitrarily Coupled Mesh Interface (ACMI)
+
+SourceFiles
+    cyclicACMIPolyPatch.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef cyclicACMIPolyPatch_H
+#define cyclicACMIPolyPatch_H
+
+#include "cyclicAMIPolyPatch.H"
+#include "AMIPatchToPatchInterpolation.H"
+#include "polyBoundaryMesh.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                     Class cyclicACMIPolyPatch Declaration
+\*---------------------------------------------------------------------------*/
+
+class cyclicACMIPolyPatch
+:
+    public cyclicAMIPolyPatch
+{
+
+private:
+
+    // Private data
+
+        //- Copy of the original patch face areas
+        mutable vectorField faceAreas0_;
+
+        //- Name of non-overlapping patch
+        const word nonOverlapPatchName_;
+
+        //- Index of non-overlapping patch
+        mutable label nonOverlapPatchID_;
+
+        //- Flag to indicate that AMI has been updated
+        mutable bool updated_;
+
+
+protected:
+
+        static const scalar tolerance_;
+
+
+    // Protected Member Functions
+
+        //- Initialise patch face areas
+        virtual void initPatchFaceAreas() const;
+
+        //- Reset the AMI interpolator
+        virtual void resetAMI
+        (
+            const AMIPatchToPatchInterpolation::interpolationMethod& AMIMethod =
+                AMIPatchToPatchInterpolation::imFaceAreaWeight
+        ) const;
+
+        //- Set neighbour ACMI patch areas
+        virtual void setNeighbourFaceAreas() const;
+
+        //- Initialise the calculation of the patch geometry
+        virtual void initGeometry(PstreamBuffers&);
+
+        //- Calculate the patch geometry
+        virtual void calcGeometry(PstreamBuffers&);
+
+        //- Initialise the patches for moving points
+        virtual void initMovePoints(PstreamBuffers& pBufs, const pointField&);
+
+        //- Correct patches after moving points
+        virtual void movePoints(PstreamBuffers& pBufs, const pointField&);
+
+        //- Initialise the update of the patch topology
+        virtual void initUpdateMesh(PstreamBuffers&);
+
+        //- Update of the patch topology
+        virtual void updateMesh(PstreamBuffers&);
+
+        //- Clear geometry
+        virtual void clearGeom();
+
+
+public:
+
+    //- Runtime type information
+    TypeName("cyclicACMI");
+
+
+    // Constructors
+
+        //- Construct from (base couped patch) components
+        cyclicACMIPolyPatch
+        (
+            const word& name,
+            const label size,
+            const label start,
+            const label index,
+            const polyBoundaryMesh& bm,
+            const word& patchType,
+            const transformType transform = UNKNOWN
+        );
+
+        //- Construct from dictionary
+        cyclicACMIPolyPatch
+        (
+            const word& name,
+            const dictionary& dict,
+            const label index,
+            const polyBoundaryMesh& bm,
+            const word& patchType
+        );
+
+        //- Construct as copy, resetting the boundary mesh
+        cyclicACMIPolyPatch
+        (
+            const cyclicACMIPolyPatch&,
+            const polyBoundaryMesh&
+        );
+
+        //- Construct given the original patch and resetting the
+        //  face list and boundary mesh information
+        cyclicACMIPolyPatch
+        (
+            const cyclicACMIPolyPatch& pp,
+            const polyBoundaryMesh& bm,
+            const label index,
+            const label newSize,
+            const label newStart,
+            const word& nbrPatchName,
+            const word& nonOverlapPatchName
+        );
+
+        //- Construct given the original patch and a map
+        cyclicACMIPolyPatch
+        (
+            const cyclicACMIPolyPatch& pp,
+            const polyBoundaryMesh& bm,
+            const label index,
+            const labelUList& mapAddressing,
+            const label newStart
+        );
+
+
+        //- Construct and return a clone, resetting the boundary mesh
+        virtual autoPtr<polyPatch> clone(const polyBoundaryMesh& bm) const
+        {
+            return autoPtr<polyPatch>(new cyclicACMIPolyPatch(*this, bm));
+        }
+
+        //- Construct and return a clone, resetting the face list
+        //  and boundary mesh
+        virtual autoPtr<polyPatch> clone
+        (
+            const polyBoundaryMesh& bm,
+            const label index,
+            const label newSize,
+            const label newStart
+        ) const
+        {
+            return autoPtr<polyPatch>
+            (
+                new cyclicACMIPolyPatch
+                (
+                    *this,
+                    bm,
+                    index,
+                    newSize,
+                    newStart,
+                    neighbPatchName(),
+                    nonOverlapPatchName_
+                )
+            );
+        }
+
+        //- Construct and return a clone, resetting the face list
+        //  and boundary mesh
+        virtual autoPtr<polyPatch> clone
+        (
+            const polyBoundaryMesh& bm,
+            const label index,
+            const labelUList& mapAddressing,
+            const label newStart
+        ) const
+        {
+            return autoPtr<polyPatch>
+            (
+                new cyclicACMIPolyPatch
+                (
+                    *this,
+                    bm,
+                    index,
+                    mapAddressing,
+                    newStart
+                )
+            );
+        }
+
+
+    //- Destructor
+    virtual ~cyclicACMIPolyPatch();
+
+
+    // Member Functions
+
+        // Access
+
+            //- Reset the updated flag
+            inline void setUpdated(bool flag) const;
+
+            //- Return access to the updated flag
+            inline bool updated() const;
+
+            //- Return access to the original patch face areas
+            inline const vectorField& faceAreas0() const;
+
+            //- Non-overlapping patch name
+            inline const word& nonOverlapPatchName() const;
+
+            //- Non-overlapping patch ID
+            virtual label nonOverlapPatchID() const;
+
+            //- Return a const reference to the non-overlapping patch
+            inline const polyPatch& nonOverlapPatch() const;
+
+            //- Return a reference to the non-overlapping patch
+            inline polyPatch& nonOverlapPatch();
+
+            //- Mask field where 1 = overlap, 0 = no-overlap
+            inline const scalarField& mask() const;
+
+
+            // Interpolations
+
+                //- Interpolate field
+                template<class Type>
+                tmp<Field<Type> > interpolate
+                (
+                    const Field<Type>& fldCouple,
+                    const Field<Type>& fldNonOverlap
+                ) const;
+
+                //- Interpolate tmp field
+                template<class Type>
+                tmp<Field<Type> > interpolate
+                (
+                    const tmp<Field<Type> >& tFldCouple,
+                    const tmp<Field<Type> >& tFldNonOverlap
+                ) const;
+
+                //- Low-level interpolate List
+                template<class Type, class CombineOp>
+                void interpolate
+                (
+                    const UList<Type>& fldCouple,
+                    const UList<Type>& fldNonOverlap,
+                    const CombineOp& cop,
+                    List<Type>& result
+                ) const;
+
+
+        //- Calculate the patch geometry
+        virtual void calcGeometry
+        (
+            const primitivePatch& referPatch,
+            const pointField& thisCtrs,
+            const vectorField& thisAreas,
+            const pointField& thisCc,
+            const pointField& nbrCtrs,
+            const vectorField& nbrAreas,
+            const pointField& nbrCc
+        );
+
+        //- Initialize ordering for primitivePatch. Does not
+        //  refer to *this (except for name() and type() etc.)
+        virtual void initOrder
+        (
+            PstreamBuffers&,
+            const primitivePatch&
+        ) const;
+
+        //- Return new ordering for primitivePatch.
+        //  Ordering is -faceMap: for every face
+        //  index of the new face -rotation:for every new face the clockwise
+        //  shift of the original face. Return false if nothing changes
+        //  (faceMap is identity, rotation is 0), true otherwise.
+        virtual bool order
+        (
+            PstreamBuffers&,
+            const primitivePatch&,
+            labelList& faceMap,
+            labelList& rotation
+        ) const;
+
+        //- Write the polyPatch data as a dictionary
+        virtual void write(Ostream&) const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#include "cyclicACMIPolyPatchI.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+    #include "cyclicACMIPolyPatchTemplates.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/meshTools/AMIInterpolation/patches/cyclicACMI/cyclicACMIPolyPatch/cyclicACMIPolyPatchI.H

@@ -0,0 +1,83 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+inline void Foam::cyclicACMIPolyPatch::setUpdated(const bool flag) const
+{
+    updated_ = flag;
+}
+
+
+inline bool Foam::cyclicACMIPolyPatch::updated() const
+{
+    return updated_;
+}
+
+
+inline const Foam::vectorField& Foam::cyclicACMIPolyPatch::faceAreas0() const
+{
+    return faceAreas0_;
+}
+
+
+inline const Foam::word& Foam::cyclicACMIPolyPatch::nonOverlapPatchName() const
+{
+    return nonOverlapPatchName_;
+}
+
+
+inline const Foam::polyPatch& Foam::cyclicACMIPolyPatch::nonOverlapPatch() const
+{
+    // note: use nonOverlapPatchID() as opposed to patch name to initialise
+    // demand-driven data
+
+    return this->boundaryMesh()[nonOverlapPatchID()];
+}
+
+
+inline Foam::polyPatch& Foam::cyclicACMIPolyPatch::nonOverlapPatch()
+{
+    // note: use nonOverlapPatchID() as opposed to patch name to initialise
+    // demand-driven data
+
+    return const_cast<polyPatch&>(this->boundaryMesh()[nonOverlapPatchID()]);
+}
+
+
+inline const Foam::scalarField& Foam::cyclicACMIPolyPatch::mask() const
+{
+    if (owner())
+    {
+        return AMI().srcWeightsSum();
+    }
+    else
+    {
+        return neighbPatch().AMI().tgtWeightsSum();
+    }
+}
+
+
+// ************************************************************************* //

src/meshTools/AMIInterpolation/patches/cyclicACMI/cyclicACMIPolyPatch/cyclicACMIPolyPatchTemplates.C

@@ -0,0 +1,91 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+template<class Type>
+Foam::tmp<Foam::Field<Type> > Foam::cyclicACMIPolyPatch::interpolate
+(
+    const Field<Type>& fldCouple,
+    const Field<Type>& fldNonOverlap
+) const
+{
+    if (owner())
+    {
+        const scalarField& w = AMI().srcWeightsSum();
+
+        return
+            w*AMI().interpolateToSource(fldCouple)
+          + (1.0 - w)*fldNonOverlap;
+    }
+    else
+    {
+        const scalarField& w = neighbPatch().AMI().tgtWeightsSum();
+
+        return
+            w*neighbPatch().AMI().interpolateToTarget(fldCouple)
+          + (1.0 - w)*fldNonOverlap;
+    }
+}
+
+
+template<class Type>
+Foam::tmp<Foam::Field<Type> > Foam::cyclicACMIPolyPatch::interpolate
+(
+    const tmp<Field<Type> >& tFldCouple,
+    const tmp<Field<Type> >& tFldNonOverlap
+) const
+{
+    return interpolate(tFldCouple(), tFldNonOverlap());
+}
+
+
+template<class Type, class CombineOp>
+void Foam::cyclicACMIPolyPatch::interpolate
+(
+    const UList<Type>& fldCouple,
+    const UList<Type>& fldNonOverlap,
+    const CombineOp& cop,
+    List<Type>& result
+) const
+{
+    if (owner())
+    {
+        const scalarField& w = AMI().srcWeightsSum();
+
+        AMI().interpolateToSource(fldCouple, cop, result);
+        result = w*result + (1.0 - w)*fldNonOverlap;
+    }
+    else
+    {
+        const scalarField& w = neighbPatch().AMI().tgtWeightsSum();
+
+        neighbPatch().AMI().interpolateToTarget(fldCouple, cop, result);
+        result = w*result + (1.0 - w)*fldNonOverlap;
+    }
+}
+
+
+// ************************************************************************* //

src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMILduInterfaceField/cyclicAMILduInterface.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License

src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMILduInterfaceField/cyclicAMILduInterface.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License

src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMILduInterfaceField/cyclicAMILduInterfaceField.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License

src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMILduInterfaceField/cyclicAMILduInterfaceField.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License

src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMIPointPatch/cyclicAMIPointPatch.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License

src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMIPointPatch/cyclicAMIPointPatch.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License

src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMIPointPatchField/cyclicAMIPointPatchField.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License

src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMIPointPatchField/cyclicAMIPointPatchField.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License

src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMIPointPatchField/cyclicAMIPointPatchFields.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License

src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMIPointPatchField/cyclicAMIPointPatchFields.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License

src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMIPolyPatch/cyclicAMIPolyPatch.C

@@ -232,7 +232,12 @@ void Foam::cyclicAMIPolyPatch::calcTransforms
 }
 
 
-void Foam::cyclicAMIPolyPatch::resetAMI() const
+// * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
+
+void Foam::cyclicAMIPolyPatch::resetAMI
+(
+    const AMIPatchToPatchInterpolation::interpolationMethod& AMIMethod
+) const
 {
     if (owner())
     {
@@ -283,7 +288,7 @@ void Foam::cyclicAMIPolyPatch::resetAMI() const
                 nbrPatch0,
                 surfPtr(),
                 faceAreaIntersect::tmMesh,
-                AMIPatchToPatchInterpolation::imFaceAreaWeight,
+                AMIMethod,
                 AMIReverse_
             )
         );
@@ -301,8 +306,6 @@ void Foam::cyclicAMIPolyPatch::resetAMI() const
 }
 
 
-// * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
-
 void Foam::cyclicAMIPolyPatch::initGeometry(PstreamBuffers& pBufs)
 {
     polyPatch::initGeometry(pBufs);

src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMIPolyPatch/cyclicAMIPolyPatch.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -108,14 +108,18 @@ private:
             const vectorField& half1Areas
         );
 
-        //- Reset the AMI interpolator
-        void resetAMI() const;
-
 
 protected:
 
     // Protected Member Functions
 
+        //- Reset the AMI interpolator
+        virtual void resetAMI
+        (
+            const AMIPatchToPatchInterpolation::interpolationMethod& AMIMethod =
+                AMIPatchToPatchInterpolation::imFaceAreaWeight
+        ) const;
+
         //- Recalculate the transformation tensors
         virtual void calcTransforms();
 

src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMIPolyPatch/cyclicAMIPolyPatchI.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License

src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMIPolyPatch/cyclicAMIPolyPatchTemplates.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License

src/meshTools/Make/files

@@ -175,14 +175,23 @@ $(AMI)/AMIInterpolation/AMIPatchToPatchInterpolation.C
 $(AMI)/faceAreaIntersect/faceAreaIntersect.C
 $(AMI)/GAMG/interfaces/cyclicAMIGAMGInterface/cyclicAMIGAMGInterface.C
 $(AMI)/GAMG/interfaceFields/cyclicAMIGAMGInterfaceField/cyclicAMIGAMGInterfaceField.C
+$(AMI)/GAMG/interfaces/cyclicACMIGAMGInterface/cyclicACMIGAMGInterface.C
+$(AMI)/GAMG/interfaceFields/cyclicACMIGAMGInterfaceField/cyclicACMIGAMGInterfaceField.C
 
-AMICycPatches=$(AMI)/patches/cyclic
+AMICycPatches=$(AMI)/patches/cyclicAMI
 $(AMICycPatches)/cyclicAMILduInterfaceField/cyclicAMILduInterface.C
 $(AMICycPatches)/cyclicAMILduInterfaceField/cyclicAMILduInterfaceField.C
 $(AMICycPatches)/cyclicAMIPolyPatch/cyclicAMIPolyPatch.C
 $(AMICycPatches)/cyclicAMIPointPatch/cyclicAMIPointPatch.C
 $(AMICycPatches)/cyclicAMIPointPatchField/cyclicAMIPointPatchFields.C
 
+ACMICycPatches=$(AMI)/patches/cyclicACMI
+$(ACMICycPatches)/cyclicACMILduInterfaceField/cyclicACMILduInterface.C
+$(ACMICycPatches)/cyclicACMILduInterfaceField/cyclicACMILduInterfaceField.C
+$(ACMICycPatches)/cyclicACMIPolyPatch/cyclicACMIPolyPatch.C
+$(ACMICycPatches)/cyclicACMIPointPatch/cyclicACMIPointPatch.C
+$(ACMICycPatches)/cyclicACMIPointPatchField/cyclicACMIPointPatchFields.C
+
 mappedPatches/mappedPolyPatch/mappedPatchBase.C
 mappedPatches/mappedPolyPatch/mappedPolyPatch.C
 mappedPatches/mappedPolyPatch/mappedWallPolyPatch.C

tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D/0.org/U

@@ -0,0 +1,67 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  dev                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       volVectorField;
+    location    "0";
+    object      U;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+dimensions      [0 1 -1 0 0 0 0];
+
+internalField   uniform (0 0 0);
+
+boundaryField
+{
+    inlet
+    {
+        type            fixedValue;
+        value           uniform (1 0 0);
+    }
+    outlet
+    {
+        type            pressureInletOutletVelocity;
+        value           uniform (0 0 0);
+    }
+    walls
+    {
+//        type            fixedValue;
+        type            movingWallVelocity;
+        value           uniform (0 0 0);
+    }
+    defaultFaces
+    {
+        type            empty;
+    }
+    ACMI1_blockage
+    {
+        type            fixedValue;
+        value           uniform (0 0 0);
+    }
+    ACMI1_couple
+    {
+        type            cyclicACMI;
+        value           uniform (0 0 0);
+    }
+    ACMI2_blockage
+    {
+        type            fixedValue;
+        value           uniform (0 0 0);
+    }
+    ACMI2_couple
+    {
+        type            cyclicACMI;
+        value           uniform (0 0 0);
+    }
+}
+
+
+// ************************************************************************* //

tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D/0.org/epsilon

@@ -0,0 +1,67 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  dev                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       volScalarField;
+    location    "0";
+    object      epsilon;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+dimensions      [0 2 -3 0 0 0 0];
+
+internalField   uniform 1.8e-3;
+
+boundaryField
+{
+    inlet
+    {
+        type            fixedValue;
+        value           $internalField;
+    }
+    outlet
+    {
+        type            inletOutlet;
+        inletValue      $internalField;
+        value           $internalField;
+    }
+    walls
+    {
+        type            epsilonWallFunction;
+        value           $internalField;
+    }
+    defaultFaces
+    {
+        type            empty;
+    }
+    ACMI1_blockage
+    {
+        type            epsilonWallFunction;
+        value           $internalField;
+    }
+    ACMI1_couple
+    {
+        type            cyclicACMI;
+        value           $internalField;
+    }
+    ACMI2_blockage
+    {
+        type            epsilonWallFunction;
+        value           $internalField;
+    }
+    ACMI2_couple
+    {
+        type            cyclicACMI;
+        value           $internalField;
+    }
+}
+
+
+// ************************************************************************* //

tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D/0.org/k

@@ -0,0 +1,67 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  dev                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       volScalarField;
+    location    "0";
+    object      k;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+dimensions      [0 2 -2 0 0 0 0];
+
+internalField   uniform 3.75e-3;
+
+boundaryField
+{
+    inlet
+    {
+        type            fixedValue;
+        value           $internalField;
+    }
+    outlet
+    {
+        type            inletOutlet;
+        inletValue      $internalField;
+        value           $internalField;
+    }
+    walls
+    {
+        type            kqRWallFunction;
+        value           $internalField;
+    }
+    defaultFaces
+    {
+        type            empty;
+    }
+    ACMI1_blockage
+    {
+        type            kqRWallFunction;
+        value           $internalField;
+    }
+    ACMI1_couple
+    {
+        type            cyclicACMI;
+        value           $internalField;
+    }
+    ACMI2_blockage
+    {
+        type            kqRWallFunction;
+        value           $internalField;
+    }
+    ACMI2_couple
+    {
+        type            cyclicACMI;
+        value           $internalField;
+    }
+}
+
+
+// ************************************************************************* //

tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D/0.org/p

@@ -0,0 +1,70 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  dev                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       volScalarField;
+    location    "0";
+    object      p;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+dimensions      [0 2 -2 0 0 0 0];
+
+internalField   uniform 0;
+
+boundaryField
+{
+    inlet
+    {
+        type            zeroGradient;
+    }
+    outlet
+    {
+        type            fixedValue;
+        value           uniform 0;
+    }
+    walls
+    {
+        type            zeroGradient;
+    }
+    couple1
+    {
+        type            zeroGradient;
+    }
+    couple2
+    {
+        type            zeroGradient;
+    }
+    defaultFaces
+    {
+        type            empty;
+    }
+    ACMI1_blockage
+    {
+        type            zeroGradient;
+    }
+    ACMI1_couple
+    {
+        type            cyclicACMI;
+        value           uniform 0;
+    }
+    ACMI2_blockage
+    {
+        type            zeroGradient;
+    }
+    ACMI2_couple
+    {
+        type            cyclicACMI;
+        value           uniform 0;
+    }
+}
+
+
+// ************************************************************************* //

tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D/Allclean

@@ -0,0 +1,9 @@
+#!/bin/sh
+cd ${0%/*} || exit 1    # run from this directory
+
+# Source tutorial clean functions
+. $WM_PROJECT_DIR/bin/tools/CleanFunctions
+
+cleanCase
+
+rm -rf 0

tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D/Allrun

@@ -0,0 +1,9 @@
+#!/bin/sh
+cd ${0%/*} || exit 1    # run from this directory
+
+# Source tutorial run functions
+. $WM_PROJECT_DIR/bin/tools/RunFunctions
+
+./Allrun.pre
+
+runApplication $(getApplication)

tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D/Allrun-parallel

@@ -0,0 +1,13 @@
+#!/bin/sh
+cd ${0%/*} || exit 1    # run from this directory
+
+# Source tutorial run functions
+. $WM_PROJECT_DIR/bin/tools/RunFunctions
+
+./Allrun.pre
+
+runApplication decomposePar
+
+runParallel $(getApplication) 4
+
+runApplication reconstructPar

tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D/Allrun.pre

@@ -0,0 +1,17 @@
+#!/bin/sh
+cd ${0%/*} || exit 1    # run from this directory
+
+# Source tutorial run functions
+. $WM_PROJECT_DIR/bin/tools/RunFunctions
+
+runApplication blockMesh
+
+runApplication topoSet -constant
+
+# split the mesh to generate the ACMI coupled patches
+runApplication createBaffles -overwrite
+
+# remove zero-sized patches
+runApplication createPatch -overwrite
+
+cp -rf 0.org 0

tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D/README

@@ -0,0 +1,104 @@
+oscillatingInletACMI2D
+
+This tutorial case gives an example of the Arbitrarily Coupled Mesh Interface
+(ACMI) usage.  The mesh is composed of two mesh regions: an inlet channel which
+oscillates in the +/- Y-direction, and a fixed mesh region.
+
+Each ACMI patch requires the specification of a 'non-overlapping' patch.  In
+this example, the non-overlapping patches are described as walls, e.g. taken
+from the constant/polyMesh/boundary file:
+
+    1. First ACMI poatch pair applied to the inlet channel outlet
+
+        ACMI1_blockage
+        {
+            type            wall;
+            nFaces          40;
+            startFace       43680;
+        }
+        ACMI1_couple
+        {
+            type            cyclicACMI;
+            nFaces          40;
+            startFace       43720;
+            matchTolerance  0.0001;
+            transform       noOrdering;
+            neighbourPatch  ACMI2_couple;
+            nonOverlapPatch ACMI1_blockage;
+        }
+
+
+    1. Second ACMI poatch pair applied to the fixed mesh region inlet
+
+        ACMI2_blockage
+        {
+            type            wall;
+            nFaces          96;
+            startFace       43760;
+        }
+        ACMI2_couple
+        {
+            type            cyclicACMI;
+            nFaces          96;
+            startFace       43856;
+            matchTolerance  0.0001;
+            transform       noOrdering;
+            neighbourPatch  ACMI1_couple;
+            nonOverlapPatch ACMI2_blockage;
+        }
+
+
+In the above, the ACMI1_blockage and ACMI1_couple patches occupy the same space,
+with duplicate points, edges and faces.  The ACMI2_blockage and ACMI2_couple
+patches are created similarly.
+
+The duplicate patches are initially created using the createBaffles utility.
+Firstly, the original (non-duplicated) patch faces are collected into zones
+using the topoSet utility.
+
+Each ACMI/no-overlapping patch pair is specified using a master-slave approach.
+However, since we are generating boundary patches (which are always master
+patches) the slave patches are simply defined using 'dummy' entries, e.g.:
+
+    type        faceZone;
+    zoneName    couple1Faces;
+
+    patches
+    {
+        // create blockage patch
+        master
+        {
+            //- Master side patch
+            name            ACMI1_blockage;
+            type            wall;
+        }
+        slave1 // dummy entries only
+        {
+            //- Slave side patch
+            name            ACMI1_blockage;
+            type            wall;
+        }
+
+        // create cyclic ACMI patch
+        master2
+        {
+            //- Master side patch
+            name            ACMI1_couple;
+            type            cyclicACMI;
+            matchTolerance  0.0001;
+            neighbourPatch  ACMI2_couple;
+            nonOverlapPatch ACMI1_blockage;
+            transform       noOrdering;
+        }
+        slave2 // dummy entries only
+        {
+            //- Slave side patch
+            name            ACMI1_couple;
+            type            patch;
+        }
+    }
+
+Boundary conditions must then be applied to all geometric patches in the usual,
+manner, and the cases can be executed in parallel (as shown when running the
+Allrun-parallel script) without any speacial treatment, i.e. the case set-up is
+the same as when operating in serial mode.

tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D/constant/RASProperties

@@ -0,0 +1,25 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  dev                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    location    "constant";
+    object      RASProperties;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+RASModel        kEpsilon;
+
+turbulence      on;
+
+printCoeffs     on;
+
+
+// ************************************************************************* //

tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D/constant/dynamicMeshDict

@@ -0,0 +1,36 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  dev                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    location    "constant";
+    object      dynamicMeshDict;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+dynamicFvMesh   solidBodyMotionFvMesh;
+
+motionSolverLibs ( "libfvMotionSolvers.so" );
+
+solidBodyMotionFvMeshCoeffs
+{
+    cellZone        inletChannel;
+
+    solidBodyMotionFunction  oscillatingLinearMotion;
+
+    oscillatingLinearMotionCoeffs
+    {
+        amplitude       (0 0.5 0);
+        omega           3.14; // rad/s  (.5 rps)
+    }
+}
+
+
+// ************************************************************************* //

tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D/constant/polyMesh/blockMeshDict

@@ -0,0 +1,103 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  dev                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    object      blockMeshDict;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+convertToMeters 1;
+
+vertices
+(
+    (0 0.3 0)
+    (1 0.3 0)
+    (1 0.7 0)
+    (0 0.7 0)
+    (0 0.3 0.1)
+    (1 0.3 0.1)
+    (1 0.7 0.1)
+    (0 0.7 0.1)
+
+    (1 0 0)
+    (3 0 0)
+    (3 1 0)
+    (1 1 0)
+    (1 0 0.1)
+    (3 0 0.1)
+    (3 1 0.1)
+    (1 1 0.1)
+);
+
+blocks
+(
+//    hex (0 1 2 3 4 5 6 7) (20 20 1) simpleGrading (1 1 1)
+//    hex (8 9 10 11 12 13 14 15) (40 48 1) simpleGrading (1 1 1)
+    hex (0 1 2 3 4 5 6 7) (80 40 1) simpleGrading (1 1 1)
+    hex (8 9 10 11 12 13 14 15) (80 96 1) simpleGrading (1 1 1)
+);
+
+edges
+(
+);
+
+boundary
+(
+    inlet
+    {
+        type patch;
+        faces
+        (
+            (0 4 7 3)
+        );
+    }
+    outlet
+    {
+        type patch;
+        faces
+        (
+            (10 14 13 9)
+        );
+    }
+    walls
+    {
+        type wall;
+        faces
+        (
+            (3 7 6 2)
+            (1 5 4 0)
+            (11 15 14 10)
+            (9 13 12 8)
+        );
+    }
+    couple1
+    {
+        type patch;
+        faces
+        (
+            (2 6 5 1)
+        );
+    }
+    couple2
+    {
+        type patch;
+        faces
+        (
+            (8 12 15 11)
+        );
+    }
+);
+
+mergePatchPairs
+(
+);
+
+// ************************************************************************* //

tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D/constant/polyMesh/boundary

@@ -0,0 +1,81 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  dev.ACMI                              |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       polyBoundaryMesh;
+    location    "constant/polyMesh";
+    object      boundary;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+8
+(
+    inlet
+    {
+        type            patch;
+        nFaces          40;
+        startFace       21464;
+    }
+    outlet
+    {
+        type            patch;
+        nFaces          96;
+        startFace       21504;
+    }
+    walls
+    {
+        type            wall;
+        nFaces          320;
+        startFace       21600;
+    }
+    defaultFaces
+    {
+        type            empty;
+        inGroups        1(empty);
+        nFaces          21760;
+        startFace       21920;
+    }
+    ACMI1_blockage
+    {
+        type            wall;
+        nFaces          40;
+        startFace       43680;
+    }
+    ACMI1_couple
+    {
+        type            cyclicACMI;
+        inGroups        1(cyclicACMI);
+        nFaces          40;
+        startFace       43720;
+        matchTolerance  0.0001;
+        transform       noOrdering;
+        neighbourPatch  ACMI2_couple;
+        nonOverlapPatch ACMI1_blockage;
+    }
+    ACMI2_blockage
+    {
+        type            wall;
+        nFaces          96;
+        startFace       43760;
+    }
+    ACMI2_couple
+    {
+        type            cyclicACMI;
+        inGroups        1(cyclicACMI);
+        nFaces          96;
+        startFace       43856;
+        matchTolerance  0.0001;
+        transform       noOrdering;
+        neighbourPatch  ACMI1_couple;
+        nonOverlapPatch ACMI2_blockage;
+    }
+)
+
+// ************************************************************************* //

tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D/constant/transportProperties

@@ -0,0 +1,22 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  dev                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    location    "constant";
+    object      transportProperties;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+transportModel  Newtonian;
+
+nu              nu [ 0 2 -1 0 0 0 0 ] 1e-6;
+
+// ************************************************************************* //

tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D/constant/turbulenceProperties

@@ -0,0 +1,21 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  dev                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    location    "constant";
+    object      turbulenceProperties;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+simulationType  RASModel;
+
+
+// ************************************************************************* //

tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D/system/controlDict

@@ -0,0 +1,53 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  dev                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    location    "system";
+    object      controlDict;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+application     pimpleDyMFoam;
+
+startFrom       latestTime;
+
+startTime       0;
+
+stopAt          endTime;
+
+endTime         5;
+
+deltaT          0.005;
+
+writeControl    adjustableRunTime;
+
+writeInterval   0.05;
+
+purgeWrite      0;
+
+writeFormat     ascii;
+
+writePrecision  6;
+
+writeCompression off;
+
+timeFormat      general;
+
+timePrecision   6;
+
+runTimeModifiable true;
+
+adjustTimeStep  true;
+
+maxCo           0.5;
+
+
+// ************************************************************************* //

tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D/system/createBafflesDict

@@ -0,0 +1,107 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  dev                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    object      createBafflesDict;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+// Whether to convert internal faces only (so leave boundary faces intact).
+// This is only relevant if your face selection type can pick up boundary
+// faces.
+internalFacesOnly false;
+
+
+// Baffles to create.
+baffles
+{
+    ACMI1
+    {
+        //- Use predefined faceZone to select faces and orientation.
+        type        faceZone;
+        zoneName    couple1Faces;
+
+        patches
+        {
+            master
+            {
+                //- Master side patch
+                name            ACMI1_blockage;
+                type            wall;
+            }
+            slave // not used since we're manipulating a boundary patch
+            {
+                //- Slave side patch
+                name            ACMI1_blockage;
+                type            wall;
+            }
+
+            master2
+            {
+                //- Master side patch
+                name            ACMI1_couple;
+                type            cyclicACMI;
+                matchTolerance  0.0001;
+                neighbourPatch  ACMI2_couple;
+                nonOverlapPatch ACMI1_blockage;
+                transform       noOrdering;
+            }
+            slave2 // not used since we're manipulating a boundary patch
+            {
+                //- Slave side patch
+                name            ACMI1_couple;
+                type            patch;
+            }
+        }
+    }
+    ACMI2
+    {
+        //- Use predefined faceZone to select faces and orientation.
+        type        faceZone;
+        zoneName    couple2Faces;
+
+        patches
+        {
+            master
+            {
+                //- Master side patch
+                name            ACMI2_blockage;
+                type            wall;
+            }
+            slave // not used since we're manipulating a boundary patch
+            {
+                //- Slave side patch
+                name            ACMI2_blockage;
+                type            wall;
+            }
+
+            master2
+            {
+                //- Master side patch
+                name            ACMI2_couple;
+                type            cyclicACMI;
+                matchTolerance  0.0001;
+                neighbourPatch  ACMI1_couple;
+                nonOverlapPatch ACMI2_blockage;
+                transform       noOrdering;
+            }
+            slave2 // not used since we're manipulating a boundary patch
+            {
+                //- Slave side patch
+                name            ACMI2_couple;
+                type            patch;
+            }
+        }
+    }
+}
+
+
+// ************************************************************************* //

tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D/system/createPatchDict

@@ -0,0 +1,54 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  dev                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    object      createPatchDict;
+}
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+// This application/dictionary controls:
+// - optional: create new patches from boundary faces (either given as
+//   a set of patches or as a faceSet)
+// - always: order faces on coupled patches such that they are opposite. This
+//   is done for all coupled faces, not just for any patches created.
+// - optional: synchronise points on coupled patches.
+
+// 1. Create cyclic:
+// - specify where the faces should come from
+// - specify the type of cyclic. If a rotational specify the rotationAxis
+//   and centre to make matching easier
+// - always create both halves in one invocation with correct 'neighbourPatch'
+//   setting.
+// - optionally pointSync true to guarantee points to line up.
+
+// 2. Correct incorrect cyclic:
+// This will usually fail upon loading:
+//  "face 0 area does not match neighbour 2 by 0.0100005%"
+//  " -- possible face ordering problem."
+// - in polyMesh/boundary file:
+//      - loosen matchTolerance of all cyclics to get case to load
+//      - or change patch type from 'cyclic' to 'patch'
+//        and regenerate cyclic as above
+
+
+// Do a synchronisation of coupled points after creation of any patches.
+// Note: this does not work with points that are on multiple coupled patches
+//       with transformations (i.e. cyclics).
+pointSync false;
+
+// Patches to create.
+patches
+(
+    // none
+);
+
+// ************************************************************************* //

tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D/system/decomposeParDict

@@ -0,0 +1,30 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  dev                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    object      decomposeParDict;
+}
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+numberOfSubdomains 4;
+
+method          scotch;
+
+hierarchicalCoeffs
+{
+    n               (1 4 1);
+    delta           0.001;
+    order           xyz;
+}
+
+
+// ************************************************************************* //

tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D/system/fvSchemes

@@ -0,0 +1,63 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  dev                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    location    "system";
+    object      fvSchemes;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+ddtSchemes
+{
+    default         Euler;
+}
+
+gradSchemes
+{
+    default         Gauss linear;
+    grad(p)         Gauss linear;
+    grad(U)         cellLimited Gauss linear 1;
+}
+
+divSchemes
+{
+    default         none;
+//    div(phi,U)      Gauss upwind;
+    div(phi,U)      Gauss linearUpwind grad(U);
+    div(phi,k)      Gauss upwind;
+    div(phi,epsilon) Gauss upwind;
+    div((nuEff*dev(T(grad(U))))) Gauss linear;
+}
+
+laplacianSchemes
+{
+    default         Gauss linear limited corrected 0.33;
+}
+
+interpolationSchemes
+{
+    default         linear;
+}
+
+snGradSchemes
+{
+    default         limited corrected 0.33;
+}
+
+fluxRequired
+{
+    default         no;
+    pcorr           ;
+    p               ;
+}
+
+
+// ************************************************************************* //

tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D/system/fvSolution

@@ -0,0 +1,80 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  dev                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    object      fvSolution;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+solvers
+{
+    pcorr
+    {
+        solver          GAMG;
+        tolerance       1e-2;
+        relTol          0;
+        smoother        GaussSeidel;
+        cacheAgglomeration no;
+        nCellsInCoarsestLevel 10;
+        agglomerator    faceAreaPair;
+        mergeLevels     1;
+        maxIter         50;
+    }
+
+    p
+    {
+        $pcorr;
+        tolerance       1e-5;
+        relTol          0.01;
+    }
+
+    pFinal
+    {
+        $p;
+        tolerance       1e-6;
+        relTol          0;
+    }
+
+    "(U|k|epsilon)"
+    {
+        solver          smoothSolver;
+        smoother        symGaussSeidel;
+        tolerance       1e-6;
+        relTol          0.1;
+    }
+
+    "(U|k|epsilon)Final"
+    {
+        $U;
+        tolerance       1e-6;
+        relTol          0;
+    }
+}
+
+PIMPLE
+{
+    correctPhi          no;
+    nOuterCorrectors    1;
+    nCorrectors         2;
+    nNonOrthogonalCorrectors 0;
+}
+
+relaxationFactors
+{
+//    "(U|k|epsilon).*"   1;
+}
+
+cache
+{
+    grad(U);
+}
+
+// ************************************************************************* //

tutorials/incompressible/pimpleDyMFoam/oscillatingInletACMI2D/system/topoSetDict

@@ -0,0 +1,89 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  dev                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    object      topoSetDict;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+actions
+(
+    // Get both sides of ami
+    // ~~~~~~~~~~~~~~~~~~~~~
+
+    // Create faceZone for patch couple1
+    {
+        name    couple1Faces;
+        type    faceSet;
+        action  new;
+        source  patchToFace;
+        sourceInfo
+        {
+            name    couple1;
+        }
+    }
+    {
+        name    couple1Faces;
+        type    faceZoneSet;
+        action  new;
+        source  setToFaceZone;
+        sourceInfo
+        {
+            faceSet couple1Faces;
+        }
+    }
+
+    // Create faceZone for patch couple2
+    {
+        name    couple2Faces;
+        type    faceSet;
+        action  new;
+        source  patchToFace;
+        sourceInfo
+        {
+            name    couple2;
+        }
+    }
+    {
+        name    couple2Faces;
+        type    faceZoneSet;
+        action  new;
+        source  setToFaceZone;
+        sourceInfo
+        {
+            faceSet couple2Faces;
+        }
+    }
+
+    // Create cellZone for moving cells in inlet channel
+    {
+        name    inletChannel;
+        type    cellSet;
+        action  new;
+        source  boxToCell;
+        sourceInfo
+        {
+            box     (-100 -100 -100) (1.0001 100 100);
+        }
+    }
+    {
+        name    inletChannel;
+        type    cellZoneSet;
+        action  new;
+        source  setToCellZone;
+        sourceInfo
+        {
+            set     inletChannel;
+        }
+    }
+);
+
+// ************************************************************************* //