meshTools: Added patchToPatch class for patch mapping

src/meshTools/Make/files

@@ -256,6 +256,12 @@ $(AMIOverlapPatches)/cyclicRepeatAMIPolyPatch/cyclicRepeatAMIPolyPatch.C
 $(AMIOverlapPatches)/cyclicRepeatAMIPointPatch/cyclicRepeatAMIPointPatch.C
 $(AMIOverlapPatches)/cyclicRepeatAMIPointPatchField/cyclicRepeatAMIPointPatchFields.C
 
+patchToPatch/patchToPatch/patchToPatch.C
+patchToPatch/patchToPatch/patchToPatchParallelOps.C
+patchToPatch/nearest/nearestPatchToPatch.C
+patchToPatch/inverseDistance/inverseDistancePatchToPatch.C
+patchToPatch/intersection/intersectionPatchToPatch.C
+
 mappedPatches/mappedPolyPatch/mappedPatchBase.C
 mappedPatches/mappedPolyPatch/mappedPolyPatch.C
 mappedPatches/mappedPolyPatch/mappedWallPolyPatch.C

src/meshTools/PrimitiveOldTimePatch/PrimitiveOldTimePatch.C

@@ -0,0 +1,235 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2022 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 "PrimitiveOldTimePatch.H"
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+template<class FaceList, class PointField>
+Foam::PrimitiveOldTimePatch<FaceList, PointField>::PrimitiveOldTimePatch
+(
+    const FaceList& faces,
+    const Field<PointType>& points,
+    const Field<PointType>& points0
+)
+:
+    PrimitivePatch<FaceList, PointField>(faces, points),
+    points0_(points0),
+    patch0Ptr_(new patch0Type(faces, points0_)),
+    localPoints0Ptr_(nullptr)
+{}
+
+
+template<class FaceList, class PointField>
+Foam::PrimitiveOldTimePatch<FaceList, PointField>::PrimitiveOldTimePatch
+(
+    const PrimitivePatch<FaceList, PointField>& patch,
+    const Field<PointType>& points0
+)
+:
+    PrimitivePatch<FaceList, PointField>(patch),
+    points0_(points0),
+    patch0Ptr_(new patch0Type(patch, points0_)),
+    localPoints0Ptr_(nullptr)
+{}
+
+
+template<class FaceList, class PointField>
+Foam::PrimitiveOldTimePatch<FaceList, PointField>::PrimitiveOldTimePatch
+(
+    const FaceList& faces,
+    const Field<PointType>& points
+)
+:
+    PrimitivePatch<FaceList, PointField>(faces, points),
+    points0_(NullObjectRef<Field<PointType>>()),
+    patch0Ptr_(nullptr),
+    localPoints0Ptr_(nullptr)
+{}
+
+
+template<class FaceList, class PointField>
+Foam::PrimitiveOldTimePatch<FaceList, PointField>::PrimitiveOldTimePatch
+(
+    const PrimitivePatch<FaceList, PointField>& patch
+)
+:
+    PrimitivePatch<FaceList, PointField>(patch),
+    points0_(NullObjectRef<Field<PointType>>()),
+    patch0Ptr_(nullptr),
+    localPoints0Ptr_(nullptr)
+{}
+
+
+template<class FaceList, class PointField>
+Foam::PrimitiveOldTimePatch<FaceList, PointField>::PrimitiveOldTimePatch
+(
+    const PrimitiveOldTimePatch<FaceList, PointField>& patch
+)
+:
+    PrimitivePatch<FaceList, PointField>(patch),
+    points0_(patch.points0_),
+    patch0Ptr_(patch.patch0Ptr_, false),
+    localPoints0Ptr_(nullptr)
+{}
+
+
+template<class FaceList, class PointField>
+Foam::PrimitiveOldTimePatch<FaceList, PointField>::PrimitiveOldTimePatch
+(
+    PrimitiveOldTimePatch<FaceList, PointField>&& patch
+)
+:
+    PrimitivePatch<FaceList, PointField>(move(patch)),
+    points0_(move(patch.points0_)),
+    patch0Ptr_(patch.patch0Ptr_),
+    localPoints0Ptr_(nullptr)
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+template<class FaceList, class PointField>
+Foam::PrimitiveOldTimePatch<FaceList, PointField>::~PrimitiveOldTimePatch()
+{
+    clearOut();
+}
+
+
+// * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
+
+template<class FaceList, class PointField>
+const Foam::Field
+<
+    typename Foam::PrimitiveOldTimePatch<FaceList, PointField>::PointType
+>& Foam::PrimitiveOldTimePatch<FaceList, PointField>::localPoints0() const
+{
+    // !!! Cannot just call patch0Ptr_->localPoints() as this would generate
+    // topology in patch0Ptr_() that is already available in the base class.
+    // For now, we just duplicate the implementation in PrimitivePatch.
+
+    if (!localPoints0Ptr_)
+    {
+        const labelList& meshPts = this->meshPoints();
+
+        localPoints0Ptr_ = new Field<PointType>(meshPts.size());
+
+        Field<PointType>& locPts = *localPoints0Ptr_;
+
+        forAll(meshPts, pointi)
+        {
+            locPts[pointi] = points0_[meshPts[pointi]];
+        }
+    }
+
+    // But, it would be preferable to add a method to PrimitivePatch which
+    // calculates the local points given a list of points different to those
+    // that are stored. Then the implementations could be shared and we could
+    // do this:
+    /*
+    if (!localPoints0Ptr_)
+    {
+        localPoints0Ptr_ = this->calcLocalPoints(points0_);
+    }
+    */
+
+    return *localPoints0Ptr_;
+}
+
+
+template<class FaceList, class PointField>
+const Foam::Field
+<
+    typename Foam::PrimitiveOldTimePatch<FaceList, PointField>::PointType
+>& Foam::PrimitiveOldTimePatch<FaceList, PointField>::faceCentres0() const
+{
+    return patch0Ptr_->faceCentres();
+}
+
+
+template<class FaceList, class PointField>
+const Foam::Field
+<
+    typename Foam::PrimitiveOldTimePatch<FaceList, PointField>::PointType
+>& Foam::PrimitiveOldTimePatch<FaceList, PointField>::faceAreas0() const
+{
+    return patch0Ptr_->faceAreas();
+}
+
+
+template<class FaceList, class PointField>
+const Foam::Field
+<
+    typename Foam::PrimitiveOldTimePatch<FaceList, PointField>::PointType
+>& Foam::PrimitiveOldTimePatch<FaceList, PointField>::faceNormals0() const
+{
+    return patch0Ptr_->faceNormals();
+}
+
+
+template<class FaceList, class PointField>
+const Foam::Field
+<
+    typename Foam::PrimitiveOldTimePatch<FaceList, PointField>::PointType
+>& Foam::PrimitiveOldTimePatch<FaceList, PointField>::pointNormals0() const
+{
+    // !!! See comments in localPoints0. This isn't needed for now.
+
+    NotImplemented;
+    return NullObjectRef<Field<PointType>>();
+}
+
+
+template<class FaceList, class PointField>
+void Foam::PrimitiveOldTimePatch<FaceList, PointField>::clearOut()
+{
+    PrimitivePatch<FaceList, PointField>::clearOut();
+    if (has0()) patch0Ptr_->clearOut();
+
+    deleteDemandDrivenData(localPoints0Ptr_);
+}
+
+
+template<class FaceList, class PointField>
+void Foam::PrimitiveOldTimePatch<FaceList, PointField>::clearGeom()
+{
+    PrimitivePatch<FaceList, PointField>::clearGeom();
+    if (has0()) patch0Ptr_->clearGeom();
+
+    deleteDemandDrivenData(localPoints0Ptr_);
+}
+
+
+template<class FaceList, class PointField>
+void Foam::PrimitiveOldTimePatch<FaceList, PointField>::movePoints0
+(
+    const Field<PointType>&
+)
+{
+    if (has0()) patch0Ptr_->clearGeom();
+}
+
+
+// ************************************************************************* //

src/meshTools/PrimitiveOldTimePatch/PrimitiveOldTimePatch.H

@@ -0,0 +1,230 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2022 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::PrimitiveOldTimePatch
+
+Description
+
+SourceFiles
+    PrimitiveOldTimePatch.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef PrimitiveOldTimePatch_H
+#define PrimitiveOldTimePatch_H
+
+#include "PrimitivePatch.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// Trait to determine what face list should be used for the old-time patch
+template<class Container>
+struct UFaceList;
+template<class Face>
+struct UFaceList<UList<Face>> { typedef UList<Face> type; };
+template<class Face>
+struct UFaceList<List<Face>> : public UFaceList<UList<Face>> {};
+template<class Face>
+struct UFaceList<SubList<Face>> : public UFaceList<UList<Face>> {};
+template<class Face>
+struct UFaceList<UIndirectList<Face>> { typedef UIndirectList<Face> type; };
+template<class Face>
+struct UFaceList<IndirectList<Face>> : public UFaceList<UIndirectList<Face>> {};
+
+/*---------------------------------------------------------------------------*\
+                     Class PrimitiveOldTimePatch Declaration
+\*---------------------------------------------------------------------------*/
+
+template<class FaceList, class PointField>
+class PrimitiveOldTimePatch
+:
+    public PrimitivePatch<FaceList, PointField>
+{
+public:
+
+    // Public Typedefs
+
+        using typename PrimitivePatch<FaceList, PointField>::FaceListType;
+
+        using typename PrimitivePatch<FaceList, PointField>::FaceType;
+
+        using typename PrimitivePatch<FaceList, PointField>::PointFieldType;
+
+        using typename PrimitivePatch<FaceList, PointField>::PointType;
+
+
+private:
+
+    // Private Typedefs
+
+        typedef
+            PrimitivePatch
+            <
+                typename UFaceList<FaceListType>::type,
+                const PointFieldType&
+            >
+            patch0Type;
+
+
+    // Private Data
+
+        //- Reference to global list of old-time points
+        PointField points0_;
+
+        //- Engine for calculating old-time geometry. Note: Methods that
+        //  generate topology should not be called here. The base patch should
+        //  have all the necessary topology available. The calculation of some
+        //  geometric quantities requires topological data to be available. In
+        //  these cases, special steps need to be taken here to make sure that
+        //  the old-time patch object does not generate duplicate topology.
+        autoPtr<patch0Type> patch0Ptr_;
+
+        //- Points local to patch
+        mutable Field<PointType>* localPoints0Ptr_;
+
+
+public:
+
+    // Constructors
+
+        //- Construct from components
+        PrimitiveOldTimePatch
+        (
+            const FaceList& faces,
+            const Field<PointType>& points,
+            const Field<PointType>& points0
+        );
+
+        //- Construct from patch and old-time points
+        PrimitiveOldTimePatch
+        (
+            const PrimitivePatch<FaceList, PointField>& patch,
+            const Field<PointType>& points0
+        );
+
+        //- Construct from components without old-time points
+        PrimitiveOldTimePatch
+        (
+            const FaceList& faces,
+            const Field<PointType>& points
+        );
+
+        //- Construct from patch without old-time points
+        PrimitiveOldTimePatch
+        (
+            const PrimitivePatch<FaceList, PointField>& patch
+        );
+
+        //- Copy constructor
+        PrimitiveOldTimePatch(const PrimitiveOldTimePatch& patch);
+
+        //- Move constructor
+        PrimitiveOldTimePatch(PrimitiveOldTimePatch&& patch);
+
+        //- Construct and return a clone
+        autoPtr<PrimitiveOldTimePatch<FaceList, PointField>> clone() const
+        {
+            return autoPtr<PrimitiveOldTimePatch<FaceList, PointField>>
+            (
+                new PrimitiveOldTimePatch<FaceList, PointField>(*this)
+            );
+        }
+
+
+    //- Destructor
+    virtual ~PrimitiveOldTimePatch();
+
+
+    // Member Functions
+
+        // Access
+
+            //- Return whether or not old-time geometry is available
+            bool has0() const
+            {
+                return patch0Ptr_.valid();
+            }
+
+            //- Return reference to old-time global points
+            const Field<PointType>& points0() const
+            {
+                return points0_;
+            }
+
+
+        // Geometry
+
+            //- Return pointField of old-time points in patch
+            const Field<PointType>& localPoints0() const;
+
+            //- Return old-time face centres for patch
+            const Field<PointType>& faceCentres0() const;
+
+            //- Return old-time face areas for patch
+            const Field<PointType>& faceAreas0() const;
+
+            //- Return old-time face normals for patch
+            const Field<PointType>& faceNormals0() const;
+
+            //- Return old-time point normals for patch
+            const Field<PointType>& pointNormals0() const;
+
+
+        // Edit
+
+            //- ...
+            void clearOut();
+
+            //- ...
+            void clearGeom();
+
+            //- Correct patch after moving points
+            virtual void movePoints0(const Field<PointType>&);
+
+
+    // Member Operators
+
+        //- Disallow default bitwise assignment
+        void operator=(const PrimitiveOldTimePatch&) = delete;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+    #include "PrimitiveOldTimePatch.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/meshTools/PrimitiveOldTimePatch/primitiveOldTimePatch.H

@@ -0,0 +1,53 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2022 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/>.
+
+Typedef
+    Foam::primitiveOldTimePatch
+
+Description
+    Addressing for a faceList slice.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef primitiveOldTimePatch_H
+#define primitiveOldTimePatch_H
+
+#include "PrimitiveOldTimePatch.H"
+#include "face.H"
+#include "SubList.H"
+#include "pointField.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    typedef
+        PrimitiveOldTimePatch<SubList<face>, const pointField&>
+        primitiveOldTimePatch;
+}
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/meshTools/PrimitiveOldTimePatch/uindirectPrimitiveOldTimePatch.H

@@ -0,0 +1,53 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2022 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/>.
+
+Typedef
+    Foam::uindirectPrimitiveOldTimePatch
+
+Description
+    Addressing for a faceList slice.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef uindirectPrimitiveOldTimePatch_H
+#define uindirectPrimitiveOldTimePatch_H
+
+#include "PrimitiveOldTimePatch.H"
+#include "face.H"
+#include "UIndirectList.H"
+#include "pointField.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    typedef
+        PrimitiveOldTimePatch<UIndirectList<face>, const pointField&>
+        uindirectPrimitiveOldTimePatch;
+}
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/meshTools/patchToPatch/intersection/intersectionPatchToPatch.C

@@ -0,0 +1,937 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2021-2022 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 "intersectionPatchToPatch.H"
+#include "triIntersect.H"
+#include "vtkWritePolyData.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace patchToPatches
+{
+    defineTypeNameAndDebug(intersection, 0);
+    addToRunTimeSelectionTable(patchToPatch, intersection, bool);
+
+    int intersection::debugSrcFacei =
+        debug::debugSwitch((intersection::typeName + "SrcFace").c_str(), -1);
+    int intersection::debugTgtFacei =
+        debug::debugSwitch((intersection::typeName + "TgtFace").c_str(), -1);
+}
+}
+
+
+// * * * * * * * * * * * Private Static Member Functions * * * * * * * * * * //
+
+template<class Type>
+Foam::FixedList<Type, 3>
+Foam::patchToPatches::intersection::triPointValues
+(
+    const triFace& t,
+    const UList<Type>& values
+)
+{
+    FixedList<Type, 3> result;
+    forAll(t, i)
+    {
+        result[i] = values[t[i]];
+    }
+    return result;
+}
+
+
+// * * * * * * * * * * * * * Static Member Functions * * * * * * * * * * * * //
+
+Foam::treeBoundBox Foam::patchToPatches::intersection::srcBoxStatic
+(
+    const face& srcFace,
+    const pointField& srcPoints,
+    const vectorField& srcPointNormals
+)
+{
+    static DynamicList<point> ps;
+
+    ps.clear();
+
+    const scalar l = sqrt(mag(srcFace.area(srcPoints)));
+
+    forAll(srcFace, srcFacePointi)
+    {
+        const label srcPointi = srcFace[srcFacePointi];
+
+        const point& p = srcPoints[srcPointi];
+        const vector& n = srcPointNormals[srcPointi];
+
+        ps.append(p - l/2*n);
+        ps.append(p + l/2*n);
+    }
+
+    return treeBoundBox(ps);
+}
+
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+Foam::treeBoundBox Foam::patchToPatches::intersection::srcBox
+(
+    const face& srcFace,
+    const pointField& srcPoints,
+    const vectorField& srcPointNormals
+) const
+{
+    return srcBoxStatic(srcFace, srcPoints, srcPointNormals);
+}
+
+
+bool Foam::patchToPatches::intersection::intersectFaces
+(
+    const primitiveOldTimePatch& srcPatch,
+    const vectorField& srcPointNormals,
+    const vectorField& srcPointNormals0,
+    const primitiveOldTimePatch& tgtPatch,
+    const label srcFacei,
+    const label tgtFacei
+)
+{
+    // Quick rejection based on bound box
+    const treeBoundBox srcFaceBox =
+        srcBox
+        (
+            srcPatch.localFaces()[srcFacei],
+            srcPatch.localPoints(),
+            srcPointNormals
+        );
+    const treeBoundBox tgtFaceBox(tgtPatch.points(), tgtPatch[tgtFacei]);
+    if (!srcFaceBox.overlaps(tgtFaceBox)) return false;
+
+    // Construct face triangulations on demand
+    if (srcTriPoints_[srcFacei].empty())
+    {
+        triEngine_.triangulate
+        (
+            UIndirectList<point>
+            (
+                srcPatch.localPoints(),
+                srcPatch.localFaces()[srcFacei]
+            )
+        );
+
+        srcTriPoints_[srcFacei] =
+            triEngine_.triPoints(srcPatch.localFaces()[srcFacei]);
+        srcTriFaceEdges_[srcFacei] = triEngine_.triEdges();
+    }
+    if (tgtTriPoints_[tgtFacei].empty())
+    {
+        triEngine_.triangulate
+        (
+            UIndirectList<point>
+            (
+                tgtPatch.localPoints(),
+                tgtPatch.localFaces()[tgtFacei]
+            )
+        );
+
+        tgtTriPoints_[tgtFacei] =
+            triEngine_.triPoints(tgtPatch.localFaces()[tgtFacei]);
+        tgtTriFaceEdges_[tgtFacei] = triEngine_.triEdges();
+    }
+
+    // Construct and initialise workspace
+    bool srcCouples = false;
+    couple srcCouple;
+    srcFaceEdgePart_.resize(srcPatch[srcFacei].size());
+    forAll(srcFaceEdgePart_, srcFaceEdgei)
+    {
+        const edge e =
+            srcPatch.localFaces()[srcFacei].faceEdge(srcFaceEdgei);
+        const vector eC = e.centre(srcPatch.localPoints());
+        srcFaceEdgePart_[srcFaceEdgei] = part(Zero, eC);
+    }
+
+    bool tgtCouples = false;
+    couple tgtCouple;
+    tgtFaceEdgePart_.resize(tgtPatch[tgtFacei].size());
+    forAll(tgtFaceEdgePart_, tgtFaceEdgei)
+    {
+        const edge e =
+            tgtPatch.localFaces()[tgtFacei].faceEdge(tgtFaceEdgei);
+        const vector eC = e.centre(tgtPatch.localPoints());
+        tgtFaceEdgePart_[tgtFaceEdgei] = part(Zero, eC);
+    }
+
+    part errorPart(Zero, srcPatch.faceCentres()[srcFacei]);
+
+    // Cache the face area magnitudes
+    const scalar srcMagA = mag(srcPatch.faceAreas()[srcFacei]);
+    const scalar tgtMagA = mag(tgtPatch.faceAreas()[tgtFacei]);
+
+    // Determine whether or not to debug this tri intersection
+    const bool debugTriIntersect =
+        (debugSrcFacei != -1 || debugTgtFacei != -1)
+     && (debugSrcFacei == -1 || debugSrcFacei == srcFacei)
+     && (debugTgtFacei == -1 || debugTgtFacei == tgtFacei);
+
+    // Loop the face triangles and compute the intersections
+    bool anyCouples = false;
+    forAll(srcTriPoints_[srcFacei], srcFaceTrii)
+    {
+        const triFace& srcT = srcTriPoints_[srcFacei][srcFaceTrii];
+
+        const FixedList<point, 3> srcPs =
+            triPointValues(srcT, srcPatch.localPoints());
+        const FixedList<vector, 3> srcNs =
+            triPointValues(srcT, srcPointNormals);
+
+        forAll(tgtTriPoints_[tgtFacei], tgtFaceTrii)
+        {
+            const triFace tgtT =
+                reverse()
+              ? tgtTriPoints_[tgtFacei][tgtFaceTrii].reverseFace()
+              : tgtTriPoints_[tgtFacei][tgtFaceTrii];
+
+            const FixedList<point, 3> tgtPs =
+                triPointValues(tgtT, tgtPatch.localPoints());
+
+            // Do tri-intersection
+            ictSrcPoints_.clear();
+            ictSrcPointNormals_.clear();
+            ictTgtPoints_.clear();
+            ictPointLocations_.clear();
+            triIntersect::intersectTris
+            (
+                srcPs,
+                srcNs,
+                {false, false, false},
+                {-1, -1, -1},
+                tgtPs,
+                {false, false, false},
+                {-1, -1, -1},
+                ictSrcPoints_,
+                ictSrcPointNormals_,
+                ictTgtPoints_,
+                ictPointLocations_,
+                debugTriIntersect,
+                debugTriIntersect
+              ? word
+                (
+                    typeName
+                  + "_srcFace=" + Foam::name(srcFacei)
+                  + "_tgtFace=" + Foam::name(tgtFacei)
+                  + "_intersection=" + Foam::name
+                    (srcFaceTrii*tgtTriPoints_[tgtFacei].size() + tgtFaceTrii)
+                )
+              : word::null
+            );
+
+            // If there is no intersection then continue
+            if (ictPointLocations_.empty())
+            {
+                continue;
+            }
+
+            // Mark that there has been an intersection
+            anyCouples = true;
+
+            // Compute the intersection geometry
+            const part ictSrcPart(ictSrcPoints_);
+            const part ictTgtPart(ictTgtPoints_);
+
+            // If the intersection is below tolerance then continue
+            if
+            (
+                mag(ictSrcPart.area) < small*srcMagA
+             || mag(ictTgtPart.area) < small*tgtMagA
+            )
+            {
+                continue;
+            }
+
+            // Mark that the source and target faces intersect
+            srcCouples = tgtCouples = true;
+
+            // Store the intersection geometry
+            srcCouple += ictSrcPart;
+            srcCouple.nbr += ictTgtPart;
+            if (reverse())
+            {
+                tgtCouple += ictTgtPart;
+                tgtCouple.nbr += ictSrcPart;
+            }
+            else
+            {
+                tgtCouple -= ictTgtPart;
+                tgtCouple.nbr -= ictSrcPart;
+            }
+
+            // Store the intersection polygons for debugging
+            const label debugSrcPoint0 = debugPoints_.size();
+            const label debugTgtPoint0 =
+                debugPoints_.size() + ictSrcPoints_.size();
+            if (debug)
+            {
+                debugPoints_.append(ictSrcPoints_);
+                debugPoints_.append(ictTgtPoints_);
+                debugFaces_.append
+                (
+                    debugSrcPoint0 + identity(ictSrcPoints_.size())
+                );
+                debugFaceSrcFaces_.append(srcFacei);
+                debugFaceTgtFaces_.append(tgtFacei);
+                debugFaceSides_.append(1);
+                debugFaces_.append
+                (
+                    debugTgtPoint0 + identity(ictTgtPoints_.size())
+                );
+                debugFaceSrcFaces_.append(srcFacei);
+                debugFaceTgtFaces_.append(tgtFacei);
+                debugFaceSides_.append(-1);
+            }
+
+            // Store edge and error areas
+            forAll(ictPointLocations_, i0)
+            {
+                const label i1 = ictPointLocations_.fcIndex(i0);
+
+                // Get the locations on each end of this edge of the
+                // intersection polygon
+                const triIntersect::location l0 = ictPointLocations_[i0];
+                const triIntersect::location l1 = ictPointLocations_[i1];
+
+                // Get the geometry for the projection of this edge
+                const part ictEdgePart
+                (
+                    FixedList<point, 4>
+                    ({
+                        ictSrcPoints_[i0],
+                        ictSrcPoints_[i1],
+                        ictTgtPoints_[i1],
+                        ictTgtPoints_[i0]
+                    })
+                );
+
+                // Store the "side" of the intersection that this edge
+                // corresponds to
+                label ictEdgeSide = -labelMax;
+
+                // If this edge corresponds to an edge of the source
+                // triangle
+                if
+                (
+                    l0.isSrcNotTgtPoint()
+                 || l1.isSrcNotTgtPoint()
+                 || (
+                        l0.isIntersection()
+                     && l1.isIntersection()
+                     && l0.srcEdgei() == l1.srcEdgei()
+                    )
+                )
+                {
+                    const label srcEi =
+                        l0.isSrcPoint() ? l0.srcPointi()
+                      : l1.isSrcPoint() ? (l1.srcPointi() + 2) % 3
+                      : l0.srcEdgei();
+
+                    const label srcFaceEdgei =
+                        srcTriFaceEdges_[srcFacei][srcFaceTrii][srcEi];
+
+                    if (srcFaceEdgei < srcPatch[srcFacei].size())
+                    {
+                        srcFaceEdgePart_[srcFaceEdgei] += ictEdgePart;
+                        ictEdgeSide = 1;
+                    }
+                    else
+                    {
+                        errorPart += ictEdgePart;
+                        ictEdgeSide = 0;
+                    }
+                }
+
+                // If this edge corresponds to an edge of the target
+                // triangle
+                else if
+                (
+                    l0.isTgtNotSrcPoint()
+                 || l1.isTgtNotSrcPoint()
+                 || (
+                        l0.isIntersection()
+                     && l1.isIntersection()
+                     && l0.tgtEdgei() == l1.tgtEdgei()
+                    )
+                )
+                {
+                    const label tgtEi =
+                        l0.isTgtPoint() ? (l0.tgtPointi() + 2) % 3
+                      : l1.isTgtPoint() ? l1.tgtPointi()
+                      : l0.tgtEdgei();
+
+                    const label tgtFaceEdgei =
+                        tgtTriFaceEdges_[tgtFacei][tgtFaceTrii]
+                        [reverse() ? 2 - tgtEi : tgtEi];
+
+                    if (tgtFaceEdgei < tgtPatch[tgtFacei].size())
+                    {
+                        if (reverse())
+                        {
+                            tgtFaceEdgePart_[tgtFaceEdgei] += ictEdgePart;
+                        }
+                        else
+                        {
+                            tgtFaceEdgePart_[tgtFaceEdgei] -= ictEdgePart;
+                        }
+                        ictEdgeSide = -1;
+                    }
+                    else
+                    {
+                        errorPart += ictEdgePart;
+                        ictEdgeSide = 0;
+                    }
+                }
+
+                // No other location combinations should be possible for an
+                // intersection without any shared points
+                else
+                {
+                    FatalErrorInFunction
+                        << "Tri-intersection topology not recognised. "
+                        << "This is a bug." << exit(FatalError);
+                }
+
+                // Store the projected edge quadrilateral for debugging
+                if (debug)
+                {
+                    debugFaces_.append
+                    (
+                        labelList
+                        ({
+                            debugSrcPoint0 + i0,
+                            debugSrcPoint0 + i1,
+                            debugTgtPoint0 + i1,
+                            debugTgtPoint0 + i0
+                        })
+                    );
+                    debugFaceSrcFaces_.append(srcFacei);
+                    debugFaceTgtFaces_.append(tgtFacei);
+                    debugFaceSides_.append(ictEdgeSide);
+                }
+            }
+        }
+    }
+
+    // If the source face couples the target, then store the intersection
+    if (srcCouples)
+    {
+        srcLocalTgtFaces_[srcFacei].append(tgtFacei);
+        srcCouples_[srcFacei].append(srcCouple);
+    }
+
+    // If any intersection has occurred then store the edge and error parts
+    if (anyCouples)
+    {
+        forAll(srcFaceEdgeParts_[srcFacei], srcFaceEdgei)
+        {
+            srcFaceEdgeParts_[srcFacei][srcFaceEdgei] +=
+                srcFaceEdgePart_[srcFaceEdgei];
+        }
+        srcErrorParts_[srcFacei] -= sum(tgtFaceEdgePart_);
+        srcErrorParts_[srcFacei] += errorPart;
+    }
+
+    // If the target face couples the source, then store in the intersection
+    if (tgtCouples)
+    {
+        tgtLocalSrcFaces_[tgtFacei].append(srcFacei);
+        tgtCouples_[tgtFacei].append(tgtCouple);
+    }
+
+    return anyCouples;
+}
+
+
+void Foam::patchToPatches::intersection::initialise
+(
+    const primitiveOldTimePatch& srcPatch,
+    const vectorField& srcPointNormals,
+    const vectorField& srcPointNormals0,
+    const primitiveOldTimePatch& tgtPatch
+)
+{
+    patchToPatch::initialise
+    (
+        srcPatch,
+        srcPointNormals,
+        srcPointNormals0,
+        tgtPatch
+    );
+
+    srcCouples_.resize(srcPatch.size());
+    forAll(srcLocalTgtFaces_, i)
+    {
+        srcCouples_[i].clear();
+    }
+
+    srcEdgeParts_.resize(srcPatch.nEdges());
+    forAll(srcEdgeParts_, srcEdgei)
+    {
+        const edge& e = srcPatch.edges()[srcEdgei];
+        const point c = e.centre(srcPatch.localPoints());
+        srcEdgeParts_[srcEdgei] = part(Zero, c);
+    }
+
+    srcErrorParts_.resize(srcPatch.size());
+    forAll(srcErrorParts_, srcFacei)
+    {
+        srcErrorParts_[srcFacei] =
+            part(Zero, srcPatch.faceCentres()[srcFacei]);
+    }
+
+    tgtCouples_.resize(tgtPatch.size());
+    forAll(tgtLocalSrcFaces_, i)
+    {
+        tgtCouples_[i].clear();
+    }
+
+    srcTriPoints_ = List<triFaceList>(srcPatch.size());
+    srcTriFaceEdges_ = List<List<FixedList<label, 3>>>(srcPatch.size());
+    tgtTriPoints_ = List<triFaceList>(tgtPatch.size());
+    tgtTriFaceEdges_ = List<List<FixedList<label, 3>>>(tgtPatch.size());
+
+    srcFaceEdgeParts_.resize(srcPatch.size());
+    forAll(srcFaceEdgeParts_, srcFacei)
+    {
+        srcFaceEdgeParts_[srcFacei].resize(srcPatch[srcFacei].size());
+        forAll(srcFaceEdgeParts_[srcFacei], srcFaceEdgei)
+        {
+            const label srcEdgei =
+                srcPatch.faceEdges()[srcFacei][srcFaceEdgei];
+            srcFaceEdgeParts_[srcFacei][srcFaceEdgei] = srcEdgeParts_[srcEdgei];
+        }
+    }
+
+    if (debug)
+    {
+        debugPoints_.clear();
+        debugFaces_.clear();
+        debugFaceSrcFaces_.clear();
+        debugFaceTgtFaces_.clear();
+        debugFaceSides_.clear();
+    }
+}
+
+
+void Foam::patchToPatches::intersection::rDistributeTgt
+(
+    const primitiveOldTimePatch& tgtPatch,
+    const distributionMap& tgtMap
+)
+{
+    patchToPatch::rDistributeTgt(tgtPatch, tgtMap);
+
+    rDistributeListList(tgtPatch.size(), tgtMap, tgtCouples_);
+}
+
+
+Foam::label Foam::patchToPatches::intersection::finalise
+(
+    const primitiveOldTimePatch& srcPatch,
+    const vectorField& srcPointNormals,
+    const vectorField& srcPointNormals0,
+    const primitiveOldTimePatch& tgtPatch,
+    const transformer& tgtToSrc
+)
+{
+    const label nCouples =
+        patchToPatch::finalise
+        (
+            srcPatch,
+            srcPointNormals,
+            srcPointNormals0,
+            tgtPatch,
+            tgtToSrc
+        );
+
+    // Convert face-edge-parts to edge-parts
+    labelList srcEdgeNParts(srcEdgeParts_.size(), 0);
+    forAll(srcEdgeParts_, srcEdgei)
+    {
+        const edge& e = srcPatch.edges()[srcEdgei];
+
+        srcEdgeParts_[srcEdgei] = part();
+
+        forAll(srcPatch.edgeFaces()[srcEdgei], i)
+        {
+            const label srcFacei = srcPatch.edgeFaces()[srcEdgei][i];
+            const label srcFaceEdgei =
+                findIndex(srcPatch.faceEdges()[srcFacei], srcEdgei);
+
+            const edge fe =
+                srcPatch.localFaces()[srcFacei].faceEdge(srcFaceEdgei);
+
+            if (edge::compare(e, fe) > 0)
+            {
+                srcEdgeParts_[srcEdgei] +=
+                    srcFaceEdgeParts_[srcFacei][srcFaceEdgei];
+            }
+            else
+            {
+                srcEdgeParts_[srcEdgei] -=
+                    srcFaceEdgeParts_[srcFacei][srcFaceEdgei];
+            }
+
+            srcEdgeNParts[srcEdgei] ++;
+        }
+    }
+    forAll(srcEdgeParts_, srcEdgei)
+    {
+        srcEdgeParts_[srcEdgei].area /= srcEdgeNParts[srcEdgei];
+    }
+
+    // Add the difference between the face-edge-part and the edge-part into the
+    // face-error-parts
+    forAll(srcEdgeParts_, srcEdgei)
+    {
+        const edge& e = srcPatch.edges()[srcEdgei];
+
+        forAll(srcPatch.edgeFaces()[srcEdgei], i)
+        {
+            const label srcFacei = srcPatch.edgeFaces()[srcEdgei][i];
+            const label srcFaceEdgei =
+                findIndex(srcPatch.faceEdges()[srcFacei], srcEdgei);
+
+            const edge fe =
+                srcPatch.localFaces()[srcFacei].faceEdge(srcFaceEdgei);
+
+            if (edge::compare(e, fe) > 0)
+            {
+                srcErrorParts_[srcFacei] -= srcEdgeParts_[srcEdgei];
+            }
+            else
+            {
+                srcErrorParts_[srcFacei] += srcEdgeParts_[srcEdgei];
+            }
+
+            srcErrorParts_[srcFacei] +=
+                srcFaceEdgeParts_[srcFacei][srcFaceEdgei];
+        }
+    }
+
+    // Transform the target couples back to the target side
+    if (!isNull(tgtToSrc))
+    {
+        forAll(tgtCouples_, tgtFacei)
+        {
+            forAll(tgtCouples_[tgtFacei], i)
+            {
+                couple& c = tgtCouples_[tgtFacei][i];
+
+                c.area = tgtToSrc.invTransform(c.area);
+                c.centre = tgtToSrc.invTransformPosition(c.centre);
+                c.nbr.area = tgtToSrc.invTransform(c.nbr.area);
+                c.nbr.centre = tgtToSrc.invTransformPosition(c.nbr.centre);
+            }
+        }
+    }
+
+    // Clear the triangulation workspace
+    srcTriPoints_.clear();
+    srcTriFaceEdges_.clear();
+    tgtTriPoints_.clear();
+    tgtTriFaceEdges_.clear();
+
+    // Clear face-edge-parts
+    srcFaceEdgePart_.clear();
+    tgtFaceEdgePart_.clear();
+    srcFaceEdgeParts_.clear();
+
+    // Checking and reporting
+    if (nCouples != 0)
+    {
+        scalar srcArea = 0, srcCoupleArea = 0;
+        scalarField srcCoverage(srcPatch.size());
+        scalarField srcOpenness(srcPatch.size());
+        scalarField srcError(srcPatch.size());
+        scalarField srcDepth(srcPatch.size());
+        scalarField srcAngle(srcPatch.size());
+        forAll(srcPatch, srcFacei)
+        {
+            const vector& a = srcPatch.faceAreas()[srcFacei];
+            const scalar magA = mag(a);
+            const point& c = srcPatch.faceCentres()[srcFacei];
+
+            couple Cpl(part(Zero, c), part(Zero, c));
+            forAll(srcCouples_[srcFacei], srcTgtFacei)
+            {
+                const couple& cpl = srcCouples_[srcFacei][srcTgtFacei];
+
+                Cpl += cpl;
+                Cpl.nbr += cpl.nbr;
+            }
+            const scalar magCA = mag(Cpl.area);
+
+            srcArea += magA;
+            srcCoupleArea += magCA;
+            srcCoverage[srcFacei] = magCA/magA;
+
+            vector projectionA = Zero;
+            scalar projectionV = 0;
+            forAll(srcCouples_[srcFacei], srcTgtFacei)
+            {
+                const couple& cpl = srcCouples_[srcFacei][srcTgtFacei];
+
+                projectionA += cpl.nbr.area;
+                projectionV +=
+                    - (cpl.area/3 & (cpl.centre - Cpl.centre))
+                    + (cpl.nbr.area/3 & (cpl.nbr.centre - Cpl.centre));
+            }
+            forAll(srcPatch.faceEdges()[srcFacei], srcFaceEdgei)
+            {
+                const label srcEdgei =
+                    srcPatch.faceEdges()[srcFacei][srcFaceEdgei];
+
+                const edge& e = srcPatch.edges()[srcEdgei];
+                const edge fe =
+                    srcPatch.localFaces()[srcFacei].faceEdge(srcFaceEdgei);
+
+                const scalar sign = edge::compare(e, fe);
+
+                projectionA += sign*srcEdgeParts_[srcEdgei].area;
+                projectionV +=
+                    sign*srcEdgeParts_[srcEdgei].area/3
+                  & (srcEdgeParts_[srcEdgei].centre - Cpl.centre);
+            }
+            projectionA += srcErrorParts_[srcFacei].area;
+            projectionV +=
+                srcErrorParts_[srcFacei].area/3
+              & (srcErrorParts_[srcFacei].centre - Cpl.centre);
+
+            const vector aHat = normalised(a);
+            const vector aOppHat = normalised(a - Cpl.area + Cpl.nbr.area);
+            srcAngle[srcFacei] =
+                radToDeg(acos(min(max(aHat & aOppHat, -1), +1)));
+            srcOpenness[srcFacei] = mag(projectionA - Cpl.area)/magA;
+            srcError[srcFacei] = mag(srcErrorParts_[srcFacei].area)/magA;
+            srcDepth[srcFacei] = mag(projectionV)/pow3(sqrt(magA));
+        }
+
+        reduce(srcArea, sumOp<scalar>());
+        reduce(srcCoupleArea, sumOp<scalar>());
+
+        scalar tgtArea = 0, tgtCoupleArea = 0;
+        scalarField tgtCoverage(tgtPatch.size());
+        forAll(tgtPatch, tgtFacei)
+        {
+            const scalar magA = mag(tgtPatch.faceAreas()[tgtFacei]);
+
+            vector aCouple = Zero;
+            forAll(tgtCouples_[tgtFacei], tgtSrcFacei)
+            {
+                aCouple += tgtCouples_[tgtFacei][tgtSrcFacei].area;
+            }
+            const scalar magACouple = mag(aCouple);
+
+            tgtArea += magA;
+            tgtCoupleArea += magACouple;
+            tgtCoverage[tgtFacei] = magACouple/magA;
+        }
+
+        reduce(tgtArea, sumOp<scalar>());
+        reduce(tgtCoupleArea, sumOp<scalar>());
+
+        Info<< indent << "Source min/average/max coverage = "
+            << gMin(srcCoverage) << '/' << srcCoupleArea/srcArea << '/'
+            << gMax(srcCoverage) << endl
+            << indent << "Target min/average/max coverage = "
+            << gMin(tgtCoverage) << '/' << tgtCoupleArea/tgtArea << '/'
+            << gMax(tgtCoverage) << endl
+            << indent << "Source average openness/error/depth/angle = "
+            << gAverage(srcOpenness) << '/' << gAverage(srcError) << '/'
+            << gAverage(srcDepth) << '/' << gAverage(srcAngle) << endl
+            << indent << "Source max openness/error/depth/angle = "
+            << gMax(srcOpenness) << '/' << gMax(srcError) << '/'
+            << gMax(srcDepth) << '/' << gMax(srcAngle) << endl;
+
+        if (debug)
+        {
+            word name = patchToPatch::typeName + '_' + typeName;
+
+            if (Pstream::parRun())
+            {
+                name += "_proc" + Foam::name(Pstream::myProcNo());
+            }
+
+            Info<< indent << "Writing intersected faces to "
+                << name + ".vtk" << endl;
+            vtkWritePolyData::write
+            (
+                name + ".vtk",
+                name,
+                false,
+                debugPoints_,
+                labelList(),
+                labelListList(),
+                debugFaces_,
+                "srcFace", false, Field<label>(debugFaceSrcFaces_),
+                "tgtFace", false, Field<label>(debugFaceTgtFaces_),
+                "side", false, Field<label>(debugFaceSides_)
+            );
+
+            debugPoints_.clear();
+            debugFaces_.clear();
+            debugFaceSrcFaces_.clear();
+            debugFaceTgtFaces_.clear();
+            debugFaceSides_.clear();
+
+            Info<< indent << "Writing source patch to "
+                << name + "_srcPatch.vtk" << endl;
+            vtkWritePolyData::write
+            (
+                name + "_srcPatch" + ".vtk",
+                name + "_srcPatch",
+                false,
+                srcPatch.localPoints(),
+                labelList(),
+                labelListList(),
+                srcPatch.localFaces(),
+                "coverage", false, srcCoverage,
+                "openness", false, srcOpenness,
+                "error", false, srcError,
+                "depth", false, srcDepth,
+                "angle", false, srcAngle
+            );
+
+            Info<< indent << "Writing target patch to "
+                << name + "_tgtPatch.vtk" << endl;
+            vtkWritePolyData::write
+            (
+                name + "_tgtPatch" + ".vtk",
+                name + "_tgtPatch",
+                false,
+                tgtPatch.localPoints(),
+                labelList(),
+                labelListList(),
+                tgtPatch.localFaces(),
+                "coverage", false, tgtCoverage
+            );
+        }
+    }
+
+    return nCouples;
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::patchToPatches::intersection::intersection(const bool reverse)
+:
+    patchToPatch(reverse),
+
+    srcCouples_(),
+    srcEdgeParts_(),
+    srcErrorParts_(),
+    tgtCouples_(),
+
+    triEngine_(),
+
+    srcTriPoints_(),
+    srcTriFaceEdges_(),
+    tgtTriPoints_(),
+    tgtTriFaceEdges_(),
+
+    ictSrcPoints_(),
+    ictSrcPointNormals_(),
+    ictTgtPoints_(),
+    ictPointLocations_(),
+
+    srcFaceEdgePart_(),
+    tgtFaceEdgePart_(),
+
+    srcFaceEdgeParts_(),
+
+    debugPoints_(),
+    debugFaces_(),
+    debugFaceSrcFaces_(),
+    debugFaceTgtFaces_(),
+    debugFaceSides_()
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::patchToPatches::intersection::~intersection()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+Foam::tmpNrc<Foam::List<Foam::DynamicList<Foam::scalar>>>
+Foam::patchToPatches::intersection::srcWeights
+(
+    const primitivePatch& srcPatch
+) const
+{
+    List<DynamicList<scalar>> result(srcCouples_.size());
+
+    forAll(srcCouples_, srcFacei)
+    {
+        result[srcFacei].resize(srcCouples_[srcFacei].size());
+
+        const scalar magA = mag(srcPatch.faceAreas()[srcFacei]);
+
+        forAll(srcCouples_[srcFacei], i)
+        {
+            result[srcFacei][i] = mag(srcCouples_[srcFacei][i].area)/magA;
+        }
+    }
+
+    return result;
+}
+
+
+Foam::tmpNrc<Foam::List<Foam::DynamicList<Foam::scalar>>>
+Foam::patchToPatches::intersection::tgtWeights
+(
+    const primitivePatch& tgtPatch
+) const
+{
+    List<DynamicList<scalar>> result(tgtCouples_.size());
+
+    forAll(tgtCouples_, tgtFacei)
+    {
+        result[tgtFacei].resize(tgtCouples_[tgtFacei].size());
+
+        const scalar magA = mag(tgtPatch.faceAreas()[tgtFacei]);
+
+        forAll(tgtCouples_[tgtFacei], i)
+        {
+            result[tgtFacei][i] = mag(tgtCouples_[tgtFacei][i].area)/magA;
+        }
+    }
+
+    return result;
+}
+
+
+// ************************************************************************* //

src/meshTools/patchToPatch/intersection/intersectionPatchToPatch.H

@@ -0,0 +1,424 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2021-2022 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::patchToPatches::intersection
+
+Description
+    Class to generate patchToPatch coupling geometry. A full geometric
+    intersection is done between a face and those opposite, and coupling
+    geometry is calculated accordingly.
+
+SourceFiles
+    intersection.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef intersectionPatchToPatch_H
+#define intersectionPatchToPatch_H
+
+#include "patchToPatch.H"
+#include "polygonTriangulate.H"
+#include "triFaceList.H"
+#include "triIntersectLocation.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace patchToPatches
+{
+
+/*---------------------------------------------------------------------------*\
+                          Class intersection Declaration
+\*---------------------------------------------------------------------------*/
+
+class intersection
+:
+    public patchToPatch
+{
+public:
+
+    // Public Structures
+
+        //- Structure to store the geometry associated with part of a patch
+        //  face
+        struct part
+        {
+            //- The area of this part
+            vector area;
+
+            //- The centre of this part
+            point centre;
+
+            //- Default construct
+            part()
+            :
+                area(Zero),
+                centre(point::uniform(NaN))
+            {}
+
+            //- Default construct
+            part(const zero&)
+            :
+                part()
+            {}
+
+            //- Construct from an area and a centre
+            part(const vector& a, const point& c)
+            :
+                area(a),
+                centre(c)
+            {}
+
+            //- Construct from a polygon
+            template<class PointField>
+            part(const PointField& ps)
+            :
+                area(face::area(ps)),
+                centre(face::centre(ps))
+            {}
+
+            //- Negate this part
+            part operator-() const
+            {
+                return part(- area, centre);
+            }
+
+            //- Add another part to this one
+            void operator+=(const part& p)
+            {
+                const scalar magArea = mag(area);
+                const scalar magPArea = mag(p.area);
+
+                area = area + p.area;
+
+                centre =
+                    magArea == 0 ? p.centre
+                  : magPArea == 0 ? centre
+                  : (magArea*centre + magPArea*p.centre)/(magArea + magPArea);
+            }
+
+            //- Subtract another part from this one
+            void operator-=(const part& p)
+            {
+                this->operator+=(-p);
+            }
+
+            //- Equality comparison
+            friend bool operator==(const part& a, const part& b)
+            {
+                return a.area == b.area && a.centre == b.centre;
+            }
+
+            //- Inequality comparison
+            friend bool operator!=(const part& a, const part& b)
+            {
+                return !(a == b);
+            }
+
+            //- Output stream operator
+            friend Ostream& operator<<(Ostream& os, const part& p)
+            {
+                return os << p.area << p.centre;
+            }
+
+            //- Input stream operator
+            friend Istream& operator>>(Istream& is, part& p)
+            {
+                return is >> p.area >> p.centre;
+            }
+        };
+
+        //- Structure to store the geometry associated with the coupling
+        //  between parts of two patch faces
+        struct couple
+        :
+            public part
+        {
+            //- The neighbour part
+            part nbr;
+
+            //- Default construct
+            couple()
+            :
+                part(),
+                nbr()
+            {}
+
+            //- Construct from a coupled pair of parts
+            couple(const part& p, const part& nbrP)
+            :
+                part(p),
+                nbr(nbrP)
+            {}
+
+            //- Equality comparison
+            friend bool operator==(const couple& a, const couple& b)
+            {
+                return
+                    static_cast<const part&>(a) == static_cast<const part&>(b)
+                 && a.nbr == b.nbr;
+            }
+
+            //- Inequality comparison
+            friend bool operator!=(const couple& a, const couple& b)
+            {
+                return !(a == b);
+            }
+
+            //- Output stream operator
+            friend Ostream& operator<<(Ostream& os, const couple& c)
+            {
+                return os << static_cast<const part&>(c) << c.nbr;
+            }
+
+            //- Input stream operator
+            friend Istream& operator>>(Istream& is, couple& c)
+            {
+                return is >> static_cast<part&>(c) >> c.nbr;
+            }
+        };
+
+
+private:
+
+    // Private Member Data
+
+        // Geometry
+
+            //- The coupling geometry for for each source face
+            List<DynamicList<couple>> srcCouples_;
+
+            //- The non-coupled geometry associated with each source edge
+            List<part> srcEdgeParts_;
+
+            //- The non-coupled geometry associated with mismatch in each
+            //  source face's couplings
+            List<part> srcErrorParts_;
+
+            //- The coupling geometry for for each target face
+            List<DynamicList<couple>> tgtCouples_;
+
+
+        //- Triangulation engine
+        mutable polygonTriangulate triEngine_;
+
+
+        // Workspace
+
+            //- Source face triangulation points
+            mutable List<triFaceList> srcTriPoints_;
+
+            //- Source face triangulation edges
+            mutable List<List<FixedList<label, 3>>> srcTriFaceEdges_;
+
+            //- Target face triangulation points
+            mutable List<triFaceList> tgtTriPoints_;
+
+            //- Target face triangulation edges
+            mutable List<List<FixedList<label, 3>>> tgtTriFaceEdges_;
+
+            //- Source intersection points
+            mutable DynamicList<point> ictSrcPoints_;
+
+            //- Source intersection point normals
+            mutable DynamicList<vector> ictSrcPointNormals_;
+
+            //- Target intersection points
+            mutable DynamicList<point> ictTgtPoints_;
+
+            //- Intersection locations
+            mutable DynamicList<triIntersect::location> ictPointLocations_;
+
+            //- Source face edge parts
+            DynamicList<part> srcFaceEdgePart_;
+
+            //- Target face edge parts
+            DynamicList<part> tgtFaceEdgePart_;
+
+            //- Source face edge parts
+            List<List<part>> srcFaceEdgeParts_;
+
+
+        // Debugging
+
+            //- Intersection points
+            mutable DynamicList<point> debugPoints_;
+
+            //- Intersection faces
+            mutable DynamicList<labelList> debugFaces_;
+
+            //- The source face associated with each intersection face
+            mutable DynamicList<label> debugFaceSrcFaces_;
+
+            //- The target face associated with each intersection face
+            mutable DynamicList<label> debugFaceTgtFaces_;
+
+            //- The side of the intersection each face is on; 1 is the source
+            //  side, -1 is the target side, and 0 is a face that spans the
+            //  intersection volume; e.g., an edge or error face.
+            mutable DynamicList<label> debugFaceSides_;
+
+
+    // Private Static Member Functions
+
+        //- Return the values at the points of a tri face
+        template<class Type>
+        static FixedList<Type, 3> triPointValues
+        (
+            const triFace& t,
+            const UList<Type>& values
+        );
+
+
+    // Private Member Functions
+
+        //- Get the bound box for a source face
+        virtual treeBoundBox srcBox
+        (
+            const face& srcFace,
+            const pointField& srcPoints,
+            const vectorField& srcPointNormals
+        ) const;
+
+        //- Intersect two faces
+        virtual bool intersectFaces
+        (
+            const primitiveOldTimePatch& srcPatch,
+            const vectorField& srcPointNormals,
+            const vectorField& srcPointNormals0,
+            const primitiveOldTimePatch& tgtPatch,
+            const label srcFacei,
+            const label tgtFacei
+        );
+
+        //- Initialise the workspace
+        virtual void initialise
+        (
+            const primitiveOldTimePatch& srcPatch,
+            const vectorField& srcPointNormals,
+            const vectorField& srcPointNormals0,
+            const primitiveOldTimePatch& tgtPatch
+        );
+
+        //- Send data that resulted from an intersection between the source
+        //  patch and a distributed source-local-target patch back to the
+        //  original target processes.
+        virtual void rDistributeTgt
+        (
+            const primitiveOldTimePatch& tgtPatch,
+            const distributionMap& tgtMap
+        );
+
+        //- Finalise the intersection
+        virtual label finalise
+        (
+            const primitiveOldTimePatch& srcPatch,
+            const vectorField& srcPointNormals,
+            const vectorField& srcPointNormals0,
+            const primitiveOldTimePatch& tgtPatch,
+            const transformer& tgtToSrc
+        );
+
+
+public:
+
+    //- Runtime type information
+    TypeName("intersection");
+
+
+    // Static Data Members
+
+        //- Extra debugging for intersections between specific faces. Named
+        //  "intersectionSrcFace" and "intersectionTgtFace" respectively.
+        static int debugSrcFacei, debugTgtFacei;
+
+
+    // Static Member Functions
+
+        //- Get the bound box for a source face
+        static treeBoundBox srcBoxStatic
+        (
+            const face& srcFace,
+            const pointField& srcPoints,
+            const vectorField& srcPointNormals
+        );
+
+
+    // Constructors
+
+        //- Construct from components
+        intersection(const bool reverse);
+
+
+    //- Destructor
+    ~intersection();
+
+
+    // Member Functions
+
+        //- For each source face, the source and target areas for each
+        //  target coupling
+        inline const List<DynamicList<couple>>& srcCouples() const;
+
+        //- For each source edge, the non-coupled geometry associated
+        //  with its projection
+        inline const List<part>& srcEdgeParts() const;
+
+        //- For each source face, the area associated with mismatch
+        //  across the coupling
+        inline const List<part>& srcErrorParts() const;
+
+        //- For each target face, the target and source areas for each
+        //  source coupling
+        inline const List<DynamicList<couple>>& tgtCouples() const;
+
+        //- For each source face, the coupled target weights
+        virtual tmpNrc<List<DynamicList<scalar>>> srcWeights
+        (
+            const primitivePatch& srcPatch
+        ) const;
+
+        //- For each target face, the coupled source weights
+        virtual tmpNrc<List<DynamicList<scalar>>> tgtWeights
+        (
+            const primitivePatch& tgtPatch
+        ) const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace patchToPatches
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#include "intersectionPatchToPatchI.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/meshTools/patchToPatch/intersection/intersectionPatchToPatchI.H

@@ -0,0 +1,60 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2011-2022 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 "intersectionPatchToPatch.H"
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+inline const
+Foam::List<Foam::DynamicList<Foam::patchToPatches::intersection::couple>>&
+Foam::patchToPatches::intersection::srcCouples() const
+{
+    return srcCouples_;
+}
+
+
+inline const Foam::List<Foam::patchToPatches::intersection::part>&
+Foam::patchToPatches::intersection::srcEdgeParts() const
+{
+    return srcEdgeParts_;
+}
+
+
+inline const Foam::List<Foam::patchToPatches::intersection::part>&
+Foam::patchToPatches::intersection::srcErrorParts() const
+{
+    return srcErrorParts_;
+}
+
+
+inline const
+Foam::List<Foam::DynamicList<Foam::patchToPatches::intersection::couple>>&
+Foam::patchToPatches::intersection::tgtCouples() const
+{
+    return tgtCouples_;
+}
+
+
+// ************************************************************************* //

src/meshTools/patchToPatch/inverseDistance/inverseDistancePatchToPatch.C

@@ -0,0 +1,284 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2021-2022 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 "inverseDistancePatchToPatch.H"
+#include "mathematicalConstants.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace patchToPatches
+{
+    defineTypeNameAndDebug(inverseDistance, 0);
+    addToRunTimeSelectionTable(patchToPatch, inverseDistance, bool);
+}
+}
+
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+Foam::treeBoundBox Foam::patchToPatches::inverseDistance::srcBox
+(
+    const face& srcFace,
+    const pointField& srcPoints,
+    const vectorField& srcPointNormals
+) const
+{
+    const treeBoundBox bb(srcPoints, srcFace);
+
+    const point c = bb.midpoint();
+    const scalar l = bb.maxDim();
+
+    return treeBoundBox(c - l*vector::one, c + l*vector::one);
+}
+
+
+bool Foam::patchToPatches::inverseDistance::inside
+(
+    const face& f,
+    const pointField& ps,
+    const point& p,
+    const vector& r
+) const
+{
+    using namespace constant::mathematical;
+
+    const tensor T = tensor::I - sqr(r);
+
+    scalar angle = 0;
+
+    forAll(f, i)
+    {
+        const vector& a = T & (ps[f[i]] - p);
+        const vector& b = T & (ps[f[f.fcIndex(i)]] - p);
+        const scalar magAB = sqrt(magSqr(a)*magSqr(b));
+        angle -= sign(r & (a ^ b))*acos((a & b)/magAB);
+    }
+
+    return pi < angle && angle < 3*pi;
+}
+
+
+bool Foam::patchToPatches::inverseDistance::intersectFaces
+(
+    const primitivePatch& patch,
+    const primitivePatch& otherPatch,
+    const label facei,
+    const label otherFacei,
+    DynamicList<label>& faceOtherFaces,
+    DynamicList<scalar>& faceWeights
+) const
+{
+    const face& f = otherPatch[otherFacei];
+    const pointField& ps = otherPatch.points();
+
+    const point& p = patch.faceCentres()[facei];
+    const vector& r = patch.faceNormals()[facei];
+
+    bool intersectsOther = inside(f, ps, p, r);
+
+    if (!intersectsOther)
+    {
+        forAll(otherPatch.faceFaces()[otherFacei], otherFaceFacei)
+        {
+            const label otherFacej =
+                otherPatch.faceFaces()[otherFacei][otherFaceFacei];
+
+            const face& g = otherPatch[otherFacej];
+
+            if (inside(g, ps, p, r))
+            {
+                intersectsOther = true;
+                break;
+            }
+        }
+    }
+
+    if (intersectsOther)
+    {
+        faceOtherFaces.append(otherFacei);
+        faceWeights.append
+        (
+            1/max(mag(p - otherPatch.faceCentres()[otherFacei]), vSmall)
+        );
+    }
+
+    return intersectsOther;
+}
+
+
+bool Foam::patchToPatches::inverseDistance::intersectFaces
+(
+    const primitiveOldTimePatch& srcPatch,
+    const vectorField& srcPointNormals,
+    const vectorField& srcPointNormals0,
+    const primitiveOldTimePatch& tgtPatch,
+    const label srcFacei,
+    const label tgtFacei
+)
+{
+    const bool srcCouples =
+        intersectFaces
+        (
+            srcPatch,
+            tgtPatch,
+            srcFacei,
+            tgtFacei,
+            srcLocalTgtFaces_[srcFacei],
+            srcWeights_[srcFacei]
+        );
+
+    const bool tgtCouples =
+        intersectFaces
+        (
+            tgtPatch,
+            srcPatch,
+            tgtFacei,
+            srcFacei,
+            tgtLocalSrcFaces_[tgtFacei],
+            tgtWeights_[tgtFacei]
+        );
+
+    return srcCouples || tgtCouples;
+}
+
+
+void Foam::patchToPatches::inverseDistance::initialise
+(
+    const primitiveOldTimePatch& srcPatch,
+    const vectorField& srcPointNormals,
+    const vectorField& srcPointNormals0,
+    const primitiveOldTimePatch& tgtPatch
+)
+{
+    patchToPatch::initialise
+    (
+        srcPatch,
+        srcPointNormals,
+        srcPointNormals0,
+        tgtPatch
+    );
+
+    srcWeights_.resize(srcPatch.size());
+    tgtWeights_.resize(tgtPatch.size());
+}
+
+
+void Foam::patchToPatches::inverseDistance::rDistributeTgt
+(
+    const primitiveOldTimePatch& tgtPatch,
+    const distributionMap& tgtMap
+)
+{
+    patchToPatch::rDistributeTgt(tgtPatch, tgtMap);
+
+    rDistributeListList(tgtPatch.size(), tgtMap, tgtWeights_);
+}
+
+
+Foam::label Foam::patchToPatches::inverseDistance::finalise
+(
+    const primitiveOldTimePatch& srcPatch,
+    const vectorField& srcPointNormals,
+    const vectorField& srcPointNormals0,
+    const primitiveOldTimePatch& tgtPatch,
+    const transformer& tgtToSrc
+)
+{
+    const label nCouples =
+        patchToPatch::finalise
+        (
+            srcPatch,
+            srcPointNormals,
+            srcPointNormals0,
+            tgtPatch,
+            tgtToSrc
+        );
+
+    forAll(srcWeights_, srcFacei)
+    {
+        const scalar w = sum(srcWeights_[srcFacei]);
+
+        forAll(srcWeights_[srcFacei], i)
+        {
+            srcWeights_[srcFacei][i] /= max(w, vSmall);
+        }
+    }
+
+    forAll(tgtWeights_, tgtFacei)
+    {
+        const scalar w = sum(tgtWeights_[tgtFacei]);
+
+        forAll(tgtWeights_[tgtFacei], i)
+        {
+            tgtWeights_[tgtFacei][i] /= max(w, vSmall);
+        }
+    }
+
+    return nCouples;
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::patchToPatches::inverseDistance::inverseDistance(const bool reverse)
+:
+    patchToPatch(reverse),
+    srcWeights_(),
+    tgtWeights_()
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::patchToPatches::inverseDistance::~inverseDistance()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+Foam::tmpNrc<Foam::List<Foam::DynamicList<Foam::scalar>>>
+Foam::patchToPatches::inverseDistance::srcWeights
+(
+    const primitivePatch& srcPatch
+) const
+{
+    return srcWeights_;
+}
+
+
+Foam::tmpNrc<Foam::List<Foam::DynamicList<Foam::scalar>>>
+Foam::patchToPatches::inverseDistance::tgtWeights
+(
+    const primitivePatch& tgtPatch
+) const
+{
+    return tgtWeights_;
+}
+
+
+// ************************************************************************* //

src/meshTools/patchToPatch/inverseDistance/inverseDistancePatchToPatch.H

@@ -0,0 +1,178 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2021-2022 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::patchToPatches::inverseDistance
+
+Description
+    Class to generate patchToPatch coupling geometry. Couples a face to the
+    opposite face onto which its centre-normal ray projects, plus the immediate
+    neighbours to that opposite face. The proportion of contribution from the
+    different faces is calculated using inverse distance weighting.
+
+SourceFiles
+    inverseDistance.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef inverseDistancePatchToPatch_H
+#define inverseDistancePatchToPatch_H
+
+#include "patchToPatch.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace patchToPatches
+{
+
+/*---------------------------------------------------------------------------*\
+                          Class inverseDistance Declaration
+\*---------------------------------------------------------------------------*/
+
+class inverseDistance
+:
+    public patchToPatch
+{
+    // Private Member Data
+
+        //- For each source face, the coupled target weights
+        List<DynamicList<scalar>> srcWeights_;
+
+        //- For each target face, the coupled source weights
+        List<DynamicList<scalar>> tgtWeights_;
+
+
+    // Private Member Functions
+
+        //- Get the bound box for a source face
+        virtual treeBoundBox srcBox
+        (
+            const face& srcFace,
+            const pointField& srcPoints,
+            const vectorField& srcPointNormals
+        ) const;
+
+        //- Return whether or not the face contains a point
+        bool inside
+        (
+            const face& f,
+            const pointField& ps,
+            const point& p,
+            const vector& r
+        ) const;
+
+        //- Intersect two faces
+        virtual bool intersectFaces
+        (
+            const primitivePatch& patch,
+            const primitivePatch& otherPatch,
+            const label facei,
+            const label otherFacei,
+            DynamicList<label>& faceOtherFaces,
+            DynamicList<scalar>& faceWeights
+        ) const;
+
+        //- Intersect two faces
+        virtual bool intersectFaces
+        (
+            const primitiveOldTimePatch& srcPatch,
+            const vectorField& srcPointNormals,
+            const vectorField& srcPointNormals0,
+            const primitiveOldTimePatch& tgtPatch,
+            const label srcFacei,
+            const label tgtFacei
+        );
+
+        //- Initialisation
+        virtual void initialise
+        (
+            const primitiveOldTimePatch& srcPatch,
+            const vectorField& srcPointNormals,
+            const vectorField& srcPointNormals0,
+            const primitiveOldTimePatch& tgtPatch
+        );
+
+        //- Send data that resulted from an intersection between the source
+        //  patch and a distributed source-local-target patch back to the
+        //  original target processes.
+        virtual void rDistributeTgt
+        (
+            const primitiveOldTimePatch& tgtPatch,
+            const distributionMap& tgtMap
+        );
+
+        //- Finalise the intersection
+        virtual label finalise
+        (
+            const primitiveOldTimePatch& srcPatch,
+            const vectorField& srcPointNormals,
+            const vectorField& srcPointNormals0,
+            const primitiveOldTimePatch& tgtPatch,
+            const transformer& tgtToSrc
+        );
+
+
+public:
+
+    //- Runtime type information
+    TypeName("inverseDistance");
+
+
+    // Constructors
+
+        //- Construct from components
+        inverseDistance(const bool reverse);
+
+
+    //- Destructor
+    ~inverseDistance();
+
+
+    // Member Functions
+
+        //- For each source face, the coupled target weights
+        virtual tmpNrc<List<DynamicList<scalar>>> srcWeights
+        (
+            const primitivePatch& srcPatch
+        ) const;
+
+        //- For each target face, the coupled source weights
+        virtual tmpNrc<List<DynamicList<scalar>>> tgtWeights
+        (
+            const primitivePatch& tgtPatch
+        ) const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace patchToPatches
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/meshTools/patchToPatch/nearest/nearestPatchToPatch.C

@@ -0,0 +1,303 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2021-2022 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 "nearestPatchToPatch.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace patchToPatches
+{
+    defineTypeNameAndDebug(nearest, 0);
+    addToRunTimeSelectionTable(patchToPatch, nearest, bool);
+}
+}
+
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+Foam::treeBoundBox Foam::patchToPatches::nearest::srcBox
+(
+    const face& srcFace,
+    const pointField& srcPoints,
+    const vectorField& srcPointNormals
+) const
+{
+    const treeBoundBox bb(srcPoints, srcFace);
+
+    const point c = bb.midpoint();
+    const scalar l = bb.maxDim();
+
+    return treeBoundBox(c - l*vector::one, c + l*vector::one);
+}
+
+
+bool Foam::patchToPatches::nearest::intersectFaces
+(
+    const primitivePatch& patch,
+    const primitivePatch& otherPatch,
+    const label facei,
+    const label otherFacei,
+    DynamicList<label>& faceOtherFaces,
+    scalar& faceDistance
+) const
+{
+    auto closest = [&patch,&otherPatch]
+    (
+        const label facei,
+        const label otherFacei
+    )
+    {
+        const point& c = patch.faceCentres()[facei];
+        const point& otherC = otherPatch.faceCentres()[otherFacei];
+        const scalar distSqr = magSqr(c - otherC);
+
+        forAll(otherPatch.faceEdges()[otherFacei], otherFaceEdgei)
+        {
+            const label otherEdgei =
+                otherPatch.faceEdges()[otherFacei][otherFaceEdgei];
+
+            point otherNbrC;
+
+            if (otherPatch.edgeFaces()[otherEdgei].size() == 2)
+            {
+                const label facej =
+                    otherPatch.edgeFaces()[otherEdgei]
+                    [otherPatch.edgeFaces()[otherEdgei][0] == otherFacei];
+
+                otherNbrC = otherPatch.faceCentres()[facej];
+            }
+            else
+            {
+                const edge& e = otherPatch.edges()[otherEdgei];
+                const point& p = otherPatch.localPoints()[e[0]];
+                const vector dp = e.vec(otherPatch.localPoints());
+                const vector n = otherPatch.faceNormals()[otherFacei] ^ dp;
+
+                otherNbrC = p + ((tensor::I - 2*sqr(n)) & (otherC - p));
+            }
+
+            if (magSqr(c - otherNbrC) < distSqr)
+            {
+                return false;
+            }
+        }
+
+        return true;
+    };
+
+    if (closest(facei, otherFacei))
+    {
+        const point& c = patch.faceCentres()[facei];
+        const point& otherC = otherPatch.faceCentres()[otherFacei];
+        const scalar distSqr = magSqr(c - otherC);
+
+        if (faceOtherFaces.empty() || faceDistance > distSqr)
+        {
+            faceOtherFaces.clear();
+            faceOtherFaces.append(otherFacei);
+            faceDistance = distSqr;
+        }
+
+        return true;
+    }
+
+    const labelList& otherFaceFaces = otherPatch.faceFaces()[otherFacei];
+    forAll(otherFaceFaces, otherFaceFacei)
+    {
+        if (closest(facei, otherFaceFaces[otherFaceFacei]))
+        {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+
+bool Foam::patchToPatches::nearest::intersectFaces
+(
+    const primitiveOldTimePatch& srcPatch,
+    const vectorField& srcPointNormals,
+    const vectorField& srcPointNormals0,
+    const primitiveOldTimePatch& tgtPatch,
+    const label srcFacei,
+    const label tgtFacei
+)
+{
+    const bool srcCouples =
+        intersectFaces
+        (
+            srcPatch,
+            tgtPatch,
+            srcFacei,
+            tgtFacei,
+            srcLocalTgtFaces_[srcFacei],
+            srcDistances_[srcFacei]
+        );
+
+    const bool tgtCouples =
+        intersectFaces
+        (
+            tgtPatch,
+            srcPatch,
+            tgtFacei,
+            srcFacei,
+            tgtLocalSrcFaces_[tgtFacei],
+            tgtDistances_[tgtFacei]
+        );
+
+    return srcCouples || tgtCouples;
+
+}
+
+
+void Foam::patchToPatches::nearest::initialise
+(
+    const primitiveOldTimePatch& srcPatch,
+    const vectorField& srcPointNormals,
+    const vectorField& srcPointNormals0,
+    const primitiveOldTimePatch& tgtPatch
+)
+{
+    patchToPatch::initialise
+    (
+        srcPatch,
+        srcPointNormals,
+        srcPointNormals0,
+        tgtPatch
+    );
+
+    srcDistances_.resize(srcPatch.size());
+    srcDistances_ = vGreat;
+
+    tgtDistances_.resize(tgtPatch.size());
+    tgtDistances_ = vGreat;
+}
+
+
+void Foam::patchToPatches::nearest::rDistributeTgt
+(
+    const primitiveOldTimePatch& tgtPatch,
+    const distributionMap& tgtMap
+)
+{
+    // Create a list-list of distances to match the addressing
+    List<List<scalar>> tgtDistances(tgtLocalSrcFaces_.size());
+    forAll(tgtLocalSrcFaces_, tgtFacei)
+    {
+        if (!tgtLocalSrcFaces_[tgtFacei].empty())
+        {
+            tgtDistances[tgtFacei].resize(1, tgtDistances_[tgtFacei]);
+        }
+    }
+
+    // Let the base class reverse distribute the addressing
+    patchToPatch::rDistributeTgt(tgtPatch, tgtMap);
+
+    // Reverse distribute the distances
+    rDistributeListList(tgtPatch.size(), tgtMap, tgtDistances);
+
+    // If there is more than one address, remove all but the closest
+    forAll(tgtLocalSrcFaces_, tgtFacei)
+    {
+        if (tgtLocalSrcFaces_[tgtFacei].size() > 1)
+        {
+            const label i = findMin(tgtDistances[tgtFacei]);
+
+            const label srcFacei = tgtLocalSrcFaces_[tgtFacei][i];
+
+            tgtLocalSrcFaces_[tgtFacei].resize(1);
+            tgtLocalSrcFaces_[tgtFacei][0] = srcFacei;
+
+            tgtDistances_[tgtFacei] = tgtDistances[tgtFacei][i];
+        }
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::patchToPatches::nearest::nearest(const bool reverse)
+:
+    patchToPatch(reverse)
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::patchToPatches::nearest::~nearest()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+Foam::tmpNrc<Foam::List<Foam::DynamicList<Foam::scalar>>>
+Foam::patchToPatches::nearest::srcWeights(const primitivePatch& srcPatch) const
+{
+    tmpNrc<List<DynamicList<scalar>>> tResult
+    (
+        new List<DynamicList<scalar>>(srcLocalTgtFaces_.size())
+    );
+
+    List<DynamicList<scalar>>& result = tResult.ref();
+
+    forAll(srcLocalTgtFaces_, srcFacei)
+    {
+        if (!srcLocalTgtFaces_[srcFacei].empty())
+        {
+            result[srcFacei].resize(1, scalar(1));
+        }
+    }
+
+    return tResult;
+}
+
+
+Foam::tmpNrc<Foam::List<Foam::DynamicList<Foam::scalar>>>
+Foam::patchToPatches::nearest::tgtWeights(const primitivePatch& tgtPatch) const
+{
+    tmpNrc<List<DynamicList<scalar>>> tResult
+    (
+        new List<DynamicList<scalar>>(tgtLocalSrcFaces_.size())
+    );
+
+    List<DynamicList<scalar>>& result = tResult.ref();
+
+    forAll(tgtLocalSrcFaces_, tgtFacei)
+    {
+        if (!tgtLocalSrcFaces_[tgtFacei].empty())
+        {
+            result[tgtFacei].resize(1, scalar(1));
+        }
+    }
+
+    return tResult;
+}
+
+
+// ************************************************************************* //

src/meshTools/patchToPatch/nearest/nearestPatchToPatch.H

@@ -0,0 +1,157 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2021-2022 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::patchToPatches::nearest
+
+Description
+    Class to generate patchToPatch coupling geometry. Couples a face to the
+    single nearest opposite face only.
+
+SourceFiles
+    nearest.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef nearestPatchToPatch_H
+#define nearestPatchToPatch_H
+
+#include "patchToPatch.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace patchToPatches
+{
+
+/*---------------------------------------------------------------------------*\
+                          Class nearest Declaration
+\*---------------------------------------------------------------------------*/
+
+class nearest
+:
+    public patchToPatch
+{
+    // Private Member Data
+
+        //- For each source face, the distance to its coupled target face
+        List<scalar> srcDistances_;
+
+        //- For each target face, the distance to its coupled source face
+        List<scalar> tgtDistances_;
+
+
+    // Private Member Functions
+
+        //- Get the bound box for a source face
+        virtual treeBoundBox srcBox
+        (
+            const face& srcFace,
+            const pointField& srcPoints,
+            const vectorField& srcPointNormals
+        ) const;
+
+        //- Intersect two faces
+        bool intersectFaces
+        (
+            const primitivePatch& patch,
+            const primitivePatch& otherPatch,
+            const label facei,
+            const label otherFacei,
+            DynamicList<label>& faceOtherFaces,
+            scalar& faceDistance
+        ) const;
+
+        //- Intersect two faces
+        virtual bool intersectFaces
+        (
+            const primitiveOldTimePatch& srcPatch,
+            const vectorField& srcPointNormals,
+            const vectorField& srcPointNormals0,
+            const primitiveOldTimePatch& tgtPatch,
+            const label srcFacei,
+            const label tgtFacei
+        );
+
+        //- Initialisation
+        virtual void initialise
+        (
+            const primitiveOldTimePatch& srcPatch,
+            const vectorField& srcPointNormals,
+            const vectorField& srcPointNormals0,
+            const primitiveOldTimePatch& tgtPatch
+        );
+
+        //- Send data that resulted from an intersection between the source
+        //  patch and a distributed source-local-target patch back to the
+        //  original target processes.
+        virtual void rDistributeTgt
+        (
+            const primitiveOldTimePatch& tgtPatch,
+            const distributionMap& tgtMap
+        );
+
+
+public:
+
+    //- Runtime type information
+    TypeName("nearest");
+
+
+    // Constructors
+
+        //- Construct from components
+        nearest(const bool reverse);
+
+
+    //- Destructor
+    ~nearest();
+
+
+    // Member Functions
+
+        //- For each source face, the coupled target weights
+        virtual tmpNrc<List<DynamicList<scalar>>> srcWeights
+        (
+            const primitivePatch& srcPatch
+        ) const;
+
+        //- For each target face, the coupled source weights
+        virtual tmpNrc<List<DynamicList<scalar>>> tgtWeights
+        (
+            const primitivePatch& tgtPatch
+        ) const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace patchToPatches
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/meshTools/patchToPatch/patchToPatch/patchToPatch.H

@@ -0,0 +1,485 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2011-2022 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::patchToPatch
+
+Description
+    Class to generate coupling geometry between two primitive patches
+
+SourceFiles
+    patchToPatch.C
+    patchToPatchParallelOps.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef patchToPatch_H
+#define patchToPatch_H
+
+#include "distributionMap.H"
+#include "primitivePatch.H"
+#include "primitiveOldTimePatch.H"
+#include "runTimeSelectionTables.H"
+#include "treeBoundBox.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                        Class patchToPatch Declaration
+\*---------------------------------------------------------------------------*/
+
+class patchToPatch
+{
+public:
+
+    // Public Structures
+
+        //- Structure to conveniently store processor and face indices
+        struct procFace
+        {
+            //- The processor index
+            label proci;
+
+            //- The face index
+            label facei;
+
+            //- Equality comparison
+            friend bool operator==(const procFace& a, const procFace& b)
+            {
+                return a.proci == b.proci && a.facei == b.facei;
+            }
+
+            //- Inequality comparison
+            friend bool operator!=(const procFace& a, const procFace& b)
+            {
+                return !(a == b);
+            }
+
+            //- Output stream operator
+            friend Ostream& operator<<(Ostream& os, const procFace& p)
+            {
+                return os << p.proci << token::SPACE << p.facei;
+            }
+
+            //- Input stream operator
+            friend Istream& operator>>(Istream& is, procFace& p)
+            {
+                return is >> p.proci >> p.facei;
+            }
+        };
+
+
+protected:
+
+    // Private Data
+
+        //- Flag to indicate that the two patches are co-directional and
+        //  that the orientation of one should therefore be reversed
+        const bool reverse_;
+
+        //- Index of the processor holding all faces of the patchToPatch, or -1
+        //  if spread across multiple processors
+        label singleProcess_;
+
+        //- When running in parallel, a map from local source face index to
+        //  source processor and face index
+        autoPtr<List<procFace>> localSrcProcFacesPtr_;
+
+        //- When running in parallel, a map from local target face index to
+        //  target processor and face index
+        autoPtr<List<procFace>> localTgtProcFacesPtr_;
+
+        //- For each source face, the coupled local target faces
+        List<DynamicList<label>> srcLocalTgtFaces_;
+
+        //- For each target face, the coupled local source faces
+        List<DynamicList<label>> tgtLocalSrcFaces_;
+
+
+    // Private Member Functions
+
+        // Indexing
+
+            //- Transfer list-list b into list-list a
+            template<class SubListA, class SubListB>
+            static inline void transferListList
+            (
+                List<SubListA>& a,
+                List<SubListB>& b
+            );
+
+            //- Reverse distribute a list-list given the map
+            template<class Type>
+            static inline void rDistributeListList
+            (
+                const label size,
+                const distributionMap& map,
+                List<List<Type>>& data
+            );
+
+            //- Reverse distribute a dynamic list-list given the map
+            template<class Type>
+            static inline void rDistributeListList
+            (
+                const label size,
+                const distributionMap& map,
+                List<DynamicList<Type>>& data
+            );
+
+            //- Map local faces to proc faces
+            static List<List<procFace>> localFacesToProcFaces
+            (
+                const List<DynamicList<label>>& localFaces,
+                const List<procFace>& map = NullObjectRef<List<procFace>>()
+            );
+
+            //- Map proc faces to local faces
+            static List<DynamicList<label>> procFacesToLocalFaces
+            (
+                const List<List<procFace>>& procFaces,
+                const HashTable<label, procFace, Hash<procFace>>& map
+            );
+
+
+        // Searching
+
+            //- Get the bound box for a source face
+            virtual treeBoundBox srcBox
+            (
+                const face& srcFace,
+                const pointField& srcPoints,
+                const vectorField& srcPointNormals
+            ) const = 0;
+
+            //- Get the bound box for a source face
+            treeBoundBox srcBox
+            (
+                const primitiveOldTimePatch& srcPatch,
+                const vectorField& srcPointNormals,
+                const vectorField& srcPointNormals0,
+                const label srcFacei
+            ) const;
+
+            //- Get the bound box for the source patch
+            treeBoundBox srcBox
+            (
+                const primitiveOldTimePatch& srcPatch,
+                const vectorField& srcPointNormals,
+                const vectorField& srcPointNormals0
+            ) const;
+
+            //- Get the bound box for a target face
+            treeBoundBox tgtBox
+            (
+                const primitiveOldTimePatch& tgtPatch,
+                const label tgtFacei
+            ) const;
+
+            //- Get the bound box for the target patch
+            treeBoundBox tgtBox
+            (
+                const primitiveOldTimePatch& tgtPatch
+            ) const;
+
+
+        // Intersection
+
+            //- Intersect two faces
+            virtual bool intersectFaces
+            (
+                const primitiveOldTimePatch& srcPatch,
+                const vectorField& srcPointNormals,
+                const vectorField& srcPointNormals0,
+                const primitiveOldTimePatch& tgtPatch,
+                const label srcFacei,
+                const label tgtFacei
+            ) = 0;
+
+            //- Intersect two faces
+            bool findOrIntersectFaces
+            (
+                const primitiveOldTimePatch& srcPatch,
+                const vectorField& srcPointNormals,
+                const vectorField& srcPointNormals0,
+                const primitiveOldTimePatch& tgtPatch,
+                const label srcFacei,
+                const label tgtFacei
+            );
+
+            //- Intersect a queue of source-target face pairs. Update completion
+            //  lists and form a new queue of target-source face pairs.
+            label intersectPatchQueue
+            (
+                const primitiveOldTimePatch& srcPatch,
+                const vectorField& srcPointNormals,
+                const vectorField& srcPointNormals0,
+                const primitiveOldTimePatch& tgtPatch,
+                const bool isSrc,
+                const DynamicList<labelPair>& queue,
+                labelList& faceComplete,
+                DynamicList<labelPair>& otherQueue,
+                const labelList& otherFaceComplete,
+                boolList& otherFaceQueued,
+                boolList& otherFaceVisited
+            );
+
+            //- Intersect the patches
+            void intersectPatches
+            (
+                const primitiveOldTimePatch& srcPatch,
+                const vectorField& srcPointNormals,
+                const vectorField& srcPointNormals0,
+                const primitiveOldTimePatch& tgtPatch
+            );
+
+
+        // Parallel functionality
+
+            //- Determine whether or not the intersection of the given patches
+            //  is on a single process. Set singleProcess_ to that process if
+            //  so, and to -1 if not.
+            void calcSingleProcess
+            (
+                const primitiveOldTimePatch& srcPatch,
+                const primitiveOldTimePatch& tgtPatch
+            );
+
+            //- Determine which target faces need to be sent to the source.
+            //  This is done before intersection. Bound boxes are used to
+            //  estimate what faces will intersect.
+            labelListList tgtPatchSendFaces
+            (
+                const primitiveOldTimePatch& srcPatch,
+                const vectorField& srcPointNormals,
+                const vectorField& srcPointNormals0,
+                const primitiveOldTimePatch& tgtPatch
+            ) const;
+
+            //- Determine which source faces need to be sent to the target.
+            //  This is done after intersection, using the addressing generated
+            //  by the intersection.
+            labelListList srcPatchSendFaces() const;
+
+            //- Create a distribution map from a list-list of faces to be sent
+            //  (i.e., the result of calling one of the above methods).
+            distributionMap patchDistributionMap
+            (
+                labelListList&& sendFaces
+            ) const;
+
+            //- Distribute a patch given its distribution map. Just generate
+            //  local-proc-face addressing; not the distributed patch itself.
+            void distributePatch
+            (
+                const distributionMap& map,
+                List<procFace>& localProcFaces
+            ) const;
+
+            //- Distribute a patch given its distribution map
+            PrimitiveOldTimePatch<faceList, pointField> distributePatch
+            (
+                const distributionMap& map,
+                const primitiveOldTimePatch& patch,
+                List<procFace>& localProcFaces
+            ) const;
+
+
+        // Hooks
+
+            //- Initialisation
+            virtual void initialise
+            (
+                const primitiveOldTimePatch& srcPatch,
+                const vectorField& srcPointNormals,
+                const vectorField& srcPointNormals0,
+                const primitiveOldTimePatch& tgtPatch
+            );
+
+            //- Distribute the target patch so that enough is locally available
+            //  for its intersection with the source patch can be computed.
+            //  Happens before intersection. Bound boxes are used to determine
+            //  what is needed where. Return the resulting local patch and the
+            //  map from which it was calculated.
+            virtual
+            tmpNrc<PrimitiveOldTimePatch<faceList, pointField>>
+            distributeTgt
+            (
+                const primitiveOldTimePatch& srcPatch,
+                const vectorField& srcPointNormals,
+                const vectorField& srcPointNormals0,
+                const primitiveOldTimePatch& tgtPatch,
+                distributionMap& tgtMap
+            );
+
+            //- Distribute the source patch so that everything the target
+            //  intersects is locally available. Happens after intersection.
+            //  The intersection addressing is used to determine what is needed
+            //  where. Return the resulting local patch and the map from which
+            //  it was calculated.
+            virtual
+            tmpNrc<PrimitiveOldTimePatch<faceList, pointField>>
+            distributeSrc
+            (
+                const primitiveOldTimePatch& srcPatch,
+                distributionMap& srcMap
+            );
+
+            //- Send data that resulted from an intersection between the source
+            //  patch and a distributed source-local-target patch back to the
+            //  original target processes.
+            virtual void rDistributeTgt
+            (
+                const primitiveOldTimePatch& tgtPatch,
+                const distributionMap& tgtMap
+            );
+
+            //- Finalising
+            virtual label finalise
+            (
+                const primitiveOldTimePatch& srcPatch,
+                const vectorField& srcPointNormals,
+                const vectorField& srcPointNormals0,
+                const primitiveOldTimePatch& tgtPatch,
+                const transformer& tgtToSrc
+            );
+
+
+public:
+
+    //- Runtime type information
+    TypeName("patchToPatch");
+
+
+    //- Declare runtime constructor selection table
+    declareRunTimeSelectionTable
+    (
+        autoPtr,
+        patchToPatch,
+        bool,
+        (const bool reverse),
+        (reverse)
+    );
+
+
+    // Constructors
+
+        //- Construct from components
+        patchToPatch(const bool reverse);
+
+        //- Disallow default bitwise copy construction
+        patchToPatch(const patchToPatch&) = delete;
+
+
+    //- Destructor
+    virtual ~patchToPatch();
+
+
+    // Selector
+
+        //- Select from name
+        static autoPtr<patchToPatch> New
+        (
+            const word& patchToPatchType,
+            const bool reverse
+        );
+
+
+    // Member Functions
+
+        // Access
+
+            //- Flag to indicate that the two patches are co-directional and
+            //  that the orientation of one should therefore be reversed
+            inline bool reverse() const;
+
+            //- Index of the processor holding all faces of the patchToPatch,
+            //  or -1 if spread across multiple processors
+            inline label singleProcess() const;
+
+            //- Is this intersection on a single process?
+            inline bool isSingleProcess() const;
+
+            //- For each source face, the coupled target procs and faces
+            inline List<List<procFace>> srcTgtProcFaces() const;
+
+            //- For each target face, the coupled source procs and faces
+            inline List<List<procFace>> tgtSrcProcFaces() const;
+
+            //- For each source face, the coupled target weights
+            virtual tmpNrc<List<DynamicList<scalar>>> srcWeights
+            (
+                const primitivePatch& srcPatch
+            ) const = 0;
+
+            //- For each target face, the coupled source weights
+            virtual tmpNrc<List<DynamicList<scalar>>> tgtWeights
+            (
+                const primitivePatch& tgtPatch
+            ) const = 0;
+
+
+        // Manipulation
+
+            //- Update addressing and weights for the given patches
+            void update
+            (
+                const primitiveOldTimePatch& srcPatch,
+                const vectorField& srcPointNormals,
+                const vectorField& srcPointNormals0,
+                const primitiveOldTimePatch& tgtPatch,
+                const transformer& tgtToSrc = NullObjectRef<transformer>()
+            );
+
+            //- Update addressing and weights for the given patches
+            void update
+            (
+                const primitivePatch& srcPatch,
+                const vectorField& srcPointNormals,
+                const primitivePatch& tgtPatch,
+                const transformer& tgtToSrc = NullObjectRef<transformer>()
+            );
+
+
+    // Member Operators
+
+        //- Disallow default bitwise assignment
+        void operator=(const patchToPatch&) = delete;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#include "patchToPatchI.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/meshTools/patchToPatch/patchToPatch/patchToPatchI.H

@@ -0,0 +1,125 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2011-2022 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 "patchToPatch.H"
+
+// * * * * * * * * * * * Private Static Member Functions * * * * * * * * * * //
+
+template<class SubListA, class SubListB>
+inline void Foam::patchToPatch::transferListList
+(
+    List<SubListA>& a,
+    List<SubListB>& b
+)
+{
+    a.resize(b.size());
+    forAll(a, i)
+    {
+        a[i].transfer(b[i]);
+    }
+}
+
+
+template<class Type>
+inline void Foam::patchToPatch::rDistributeListList
+(
+    const label size,
+    const distributionMap& map,
+    List<List<Type>>& data
+)
+{
+    distributionMapBase::distribute
+    (
+        Pstream::commsTypes::nonBlocking,
+        List<labelPair>(),
+        size,
+        map.constructMap(),
+        false,
+        map.subMap(),
+        false,
+        data,
+        ListAppendEqOp<Type>(),
+        flipOp(),
+        List<Type>()
+    );
+}
+
+
+template<class Type>
+inline void Foam::patchToPatch::rDistributeListList
+(
+    const label size,
+    const distributionMap& map,
+    List<DynamicList<Type>>& data
+)
+{
+    List<List<Type>> tData;
+    transferListList(tData, data);
+    rDistributeListList(size, map, tData);
+    transferListList(data, tData);
+}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+inline bool Foam::patchToPatch::reverse() const
+{
+    return reverse_;
+}
+
+
+inline Foam::label Foam::patchToPatch::singleProcess() const
+{
+    return singleProcess_;
+}
+
+
+inline bool Foam::patchToPatch::isSingleProcess() const
+{
+    return singleProcess_ != -1;
+}
+
+
+inline Foam::List<Foam::List<Foam::patchToPatch::procFace>>
+Foam::patchToPatch::srcTgtProcFaces() const
+{
+    return
+        isSingleProcess()
+      ? localFacesToProcFaces(srcLocalTgtFaces_)
+      : localFacesToProcFaces(srcLocalTgtFaces_, localTgtProcFacesPtr_());
+}
+
+
+inline Foam::List<Foam::List<Foam::patchToPatch::procFace>>
+Foam::patchToPatch::tgtSrcProcFaces() const
+{
+    return
+        isSingleProcess()
+      ? localFacesToProcFaces(tgtLocalSrcFaces_)
+      : localFacesToProcFaces(tgtLocalSrcFaces_, localSrcProcFacesPtr_());
+}
+
+
+// ************************************************************************* //

src/meshTools/patchToPatch/patchToPatch/patchToPatchParallelOps.C

@@ -0,0 +1,469 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2011-2022 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 "patchToPatch.H"
+#include "treeBoundBoxList.H"
+#include "uindirectPrimitivePatch.H"
+#include "uindirectPrimitiveOldTimePatch.H"
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+void Foam::patchToPatch::calcSingleProcess
+(
+    const primitiveOldTimePatch& srcPatch,
+    const primitiveOldTimePatch& tgtPatch
+)
+{
+    singleProcess_ = 0;
+
+    if (Pstream::parRun())
+    {
+        boolList procHasFaces(Pstream::nProcs(), false);
+
+        if ((srcPatch.size() > 0) || (tgtPatch.size() > 0))
+        {
+            procHasFaces[Pstream::myProcNo()] = true;
+        }
+
+        Pstream::gatherList(procHasFaces);
+        Pstream::scatterList(procHasFaces);
+
+        const label nProcsHaveFaces = count(procHasFaces, true);
+
+        if (nProcsHaveFaces == 0)
+        {
+            singleProcess_ = 0;
+        }
+        if (nProcsHaveFaces == 1)
+        {
+            singleProcess_ = findIndex(procHasFaces, true);
+        }
+        if (nProcsHaveFaces > 1)
+        {
+            singleProcess_ = -1;
+        }
+    }
+}
+
+
+Foam::labelListList Foam::patchToPatch::tgtPatchSendFaces
+(
+    const primitiveOldTimePatch& srcPatch,
+    const vectorField& srcPointNormals,
+    const vectorField& srcPointNormals0,
+    const primitiveOldTimePatch& tgtPatch
+) const
+{
+    // Get the bound boxes for the source patch. Just a single box for now.
+    List<treeBoundBoxList> srcPatchProcBbs(Pstream::nProcs());
+    if (srcPatch.size())
+    {
+        srcPatchProcBbs[Pstream::myProcNo()] =
+            treeBoundBoxList
+            (
+                1,
+                srcBox(srcPatch, srcPointNormals, srcPointNormals0)
+            );
+    }
+    else
+    {
+        srcPatchProcBbs[Pstream::myProcNo()] = treeBoundBoxList();
+    }
+
+    // Distribute the boxes
+    Pstream::gatherList(srcPatchProcBbs);
+    Pstream::scatterList(srcPatchProcBbs);
+
+    // Send a target face to a process if it overlaps the source patch box
+    // for that process
+    List<DynamicList<label>> resultDyn(Pstream::nProcs());
+    forAll(tgtPatch, tgtFacei)
+    {
+        const treeBoundBox tgtFaceBb = tgtBox(tgtPatch, tgtFacei);
+        forAll(srcPatchProcBbs, proci)
+        {
+            forAll(srcPatchProcBbs[proci], bbi)
+            {
+                if (srcPatchProcBbs[proci][bbi].overlaps(tgtFaceBb))
+                {
+                    resultDyn[proci].append(tgtFacei);
+                    break;
+                }
+            }
+        }
+    }
+
+    // Transfer to non-dynamic storage
+    labelListList result(Pstream::nProcs());
+    forAll(result, proci)
+    {
+        result[proci].transfer(resultDyn[proci]);
+    }
+
+    return result;
+}
+
+
+Foam::labelListList Foam::patchToPatch::srcPatchSendFaces() const
+{
+    // Send a source face to a proc if target face on that proc intersects it
+    List<labelHashSet> resultDyn(Pstream::nProcs());
+    forAll(tgtLocalSrcFaces_, tgtFacei)
+    {
+        const label tgtProci = localTgtProcFacesPtr_()[tgtFacei].proci;
+
+        forAll(tgtLocalSrcFaces_[tgtFacei], i)
+        {
+            const label srcFacei = tgtLocalSrcFaces_[tgtFacei][i];
+
+            resultDyn[tgtProci].insert(srcFacei);
+        }
+    }
+
+    // Transfer to non-dynamic storage
+    labelListList result(Pstream::nProcs());
+    forAll(result, proci)
+    {
+        result[proci] = resultDyn[proci].toc();
+    }
+
+    return result;
+}
+
+
+Foam::distributionMap Foam::patchToPatch::patchDistributionMap
+(
+    labelListList&& sendFaces
+) const
+{
+    // Figure out how many target faces are to be received
+    labelList nReceiveFaces(Pstream::nProcs());
+    {
+        labelListList nSendFaces(Pstream::nProcs());
+
+        nSendFaces[Pstream::myProcNo()].setSize(Pstream::nProcs());
+        forAll(sendFaces, proci)
+        {
+            nSendFaces[Pstream::myProcNo()][proci] =
+                sendFaces[proci].size();
+        }
+
+        Pstream::gatherList(nSendFaces);
+        Pstream::scatterList(nSendFaces);
+
+        forAll(sendFaces, proci)
+        {
+            nReceiveFaces[proci] =
+                nSendFaces[proci][Pstream::myProcNo()];
+        }
+    }
+
+    // Determine order of receiving
+    labelListList receiveFaces(Pstream::nProcs());
+
+    // Local faces first
+    receiveFaces[Pstream::myProcNo()] =
+        identity(sendFaces[Pstream::myProcNo()].size());
+
+    // Remote faces next
+    label localFacei = receiveFaces[Pstream::myProcNo()].size();
+    forAll(receiveFaces, proci)
+    {
+        if (proci != Pstream::myProcNo())
+        {
+            const label n = nReceiveFaces[proci];
+            receiveFaces[proci].setSize(n);
+            for (label i = 0; i < n; i ++)
+            {
+                receiveFaces[proci][i] = localFacei ++;
+            }
+        }
+    }
+
+    // Construct and return the map
+    return
+        distributionMap
+        (
+            localFacei,
+            move(sendFaces),
+            move(receiveFaces)
+        );
+}
+
+
+void Foam::patchToPatch::distributePatch
+(
+    const distributionMap& map,
+    List<procFace>& localProcFaces
+) const
+{
+    static const label thisProci = Pstream::myProcNo();
+
+    // Exchange per-processor data
+    List<labelList> procLocalFaceis(Pstream::nProcs());
+    {
+        PstreamBuffers pBufs(Pstream::commsTypes::nonBlocking);
+
+        // Send
+        for (label proci = 0; proci < Pstream::nProcs(); proci++)
+        {
+            const labelList& sendFaces = map.subMap()[proci];
+
+            if (proci != thisProci && sendFaces.size())
+            {
+                UOPstream(proci, pBufs)() << sendFaces;
+            }
+        }
+
+        pBufs.finishedSends();
+
+        // Map local data
+        {
+            const labelList& sendFaces = map.subMap()[thisProci];
+
+            procLocalFaceis[thisProci] = sendFaces;
+        }
+
+        // Receive remote data
+        for (label proci = 0; proci < Pstream::nProcs(); proci++)
+        {
+            const labelList& receiveNewFaces = map.constructMap()[proci];
+
+            if (proci != thisProci && receiveNewFaces.size())
+            {
+                UIPstream(proci, pBufs)() >> procLocalFaceis[proci];
+            }
+        }
+    }
+
+    // Allocate
+    {
+        label nLocalFaces = 0;
+        forAll(procLocalFaceis, proci)
+        {
+            nLocalFaces += procLocalFaceis[proci].size();
+        }
+        localProcFaces.setSize(nLocalFaces);
+    }
+
+    // Renumber and flatten
+    label localTgtFacei = 0;
+
+    // Local data first
+    {
+        const labelList& fis = procLocalFaceis[thisProci];
+        forAll(fis, i)
+        {
+            localProcFaces[localTgtFacei] = {thisProci, fis[i]};
+            localTgtFacei ++;
+        }
+    }
+
+    // Remote data after
+    forAll(procLocalFaceis, proci)
+    {
+        if (proci != thisProci)
+        {
+            const labelList& fis = procLocalFaceis[proci];
+            forAll(fis, i)
+            {
+                localProcFaces[localTgtFacei] = {proci, fis[i]};
+                localTgtFacei ++;
+            }
+        }
+    }
+}
+
+
+Foam::PrimitiveOldTimePatch<Foam::faceList, Foam::pointField>
+Foam::patchToPatch::distributePatch
+(
+    const distributionMap& map,
+    const primitiveOldTimePatch& patch,
+    List<procFace>& localProcFaces
+) const
+{
+    static const label thisProci = Pstream::myProcNo();
+
+    // Exchange per-processor data
+    List<labelList> procLocalFaceis(Pstream::nProcs());
+    List<faceList> procLocalFaces(Pstream::nProcs());
+    List<pointField> procLocalPoints(Pstream::nProcs());
+    List<pointField> procLocalPoints0(Pstream::nProcs());
+    {
+        PstreamBuffers pBufs(Pstream::commsTypes::nonBlocking);
+
+        // Send
+        for (label proci = 0; proci < Pstream::nProcs(); proci++)
+        {
+            const labelList& sendTgtFaces = map.subMap()[proci];
+
+            if (proci != thisProci && sendTgtFaces.size())
+            {
+                uindirectPrimitiveOldTimePatch subPatch
+                (
+                    UIndirectList<face>(patch, sendTgtFaces),
+                    patch.points(),
+                    patch.points0()
+                );
+
+                UOPstream(proci, pBufs)()
+                    << sendTgtFaces
+                    << subPatch.localFaces()
+                    << subPatch.localPoints()
+                    << (patch.has0() ? subPatch.localPoints0() : pointField());
+            }
+        }
+
+        pBufs.finishedSends();
+
+        // Map local data
+        {
+            const labelList& sendTgtFaces = map.subMap()[thisProci];
+
+            uindirectPrimitiveOldTimePatch subPatch
+            (
+                UIndirectList<face>(patch, sendTgtFaces),
+                patch.points(),
+                patch.points0()
+            );
+
+            procLocalFaceis[thisProci] = sendTgtFaces;
+            procLocalFaces[thisProci] = subPatch.localFaces();
+            procLocalPoints[thisProci] = subPatch.localPoints();
+            if (patch.has0())
+            {
+                procLocalPoints0[thisProci] = subPatch.localPoints0();
+            }
+        }
+
+        // Receive remote data
+        for (label proci = 0; proci < Pstream::nProcs(); proci++)
+        {
+            const labelList& receiveNewTgtFaces = map.constructMap()[proci];
+
+            if (proci != thisProci && receiveNewTgtFaces.size())
+            {
+                UIPstream(proci, pBufs)()
+                    >> procLocalFaceis[proci]
+                    >> procLocalFaces[proci]
+                    >> procLocalPoints[proci]
+                    >> procLocalPoints0[proci];
+            }
+        }
+    }
+
+    // Allocate
+    faceList localTgtFaces;
+    pointField localTgtPoints;
+    pointField localTgtPoints0;
+    {
+        label nLocalFaces = 0, nLocalPoints = 0;
+        forAll(procLocalFaceis, proci)
+        {
+            nLocalFaces += procLocalFaces[proci].size();
+            nLocalPoints += procLocalPoints[proci].size();
+        }
+        localProcFaces.setSize(nLocalFaces);
+        localTgtFaces.setSize(nLocalFaces);
+        localTgtPoints.setSize(nLocalPoints);
+        if (patch.has0())
+        {
+            localTgtPoints0.setSize(nLocalPoints);
+        }
+    }
+
+    // Renumber and flatten
+    label localTgtFacei = 0, localTgtPointi = 0;
+
+    // Local data first
+    {
+        const labelList& fis = procLocalFaceis[thisProci];
+        const faceList& fs = procLocalFaces[thisProci];
+        forAll(fis, i)
+        {
+            localProcFaces[localTgtFacei] = {thisProci, fis[i]};
+            localTgtFaces[localTgtFacei] = face(fs[i] + localTgtPointi);
+            localTgtFacei ++;
+        }
+
+        const pointField& ps = procLocalPoints[thisProci];
+        const pointField& ps0 = procLocalPoints0[thisProci];
+        forAll(ps, i)
+        {
+            localTgtPoints[localTgtPointi] = ps[i];
+            if (patch.has0())
+            {
+                localTgtPoints0[localTgtPointi] = ps0[i];
+            }
+            localTgtPointi ++;
+        }
+    }
+
+    // Remote data after
+    forAll(procLocalFaces, proci)
+    {
+        if (proci != thisProci)
+        {
+            const labelList& fis = procLocalFaceis[proci];
+            const faceList& fs = procLocalFaces[proci];
+            forAll(fis, i)
+            {
+                localProcFaces[localTgtFacei] = {proci, fis[i]};
+                localTgtFaces[localTgtFacei] = face(fs[i] + localTgtPointi);
+                localTgtFacei ++;
+            }
+
+            const pointField& ps = procLocalPoints[proci];
+            const pointField& ps0 = procLocalPoints0[proci];
+            forAll(ps, i)
+            {
+                localTgtPoints[localTgtPointi] = ps[i];
+                if (patch.has0())
+                {
+                    localTgtPoints0[localTgtPointi] = ps0[i];
+                }
+                localTgtPointi ++;
+            }
+        }
+    }
+
+    return
+        patch.has0()
+      ? PrimitiveOldTimePatch<faceList, pointField>
+        (
+            localTgtFaces,
+            localTgtPoints,
+            localTgtPoints0
+        )
+      : PrimitiveOldTimePatch<faceList, pointField>
+        (
+            localTgtFaces,
+            localTgtPoints
+        );
+}
+
+
+// ************************************************************************* //

src/meshTools/patchToPatch/rays/raysPatchToPatch.C

@@ -0,0 +1,332 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2021-2022 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 "raysPatchToPatch.H"
+#include "intersectionPatchToPatch.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace patchToPatches
+{
+    defineTypeNameAndDebug(rays, 0);
+    addToRunTimeSelectionTable(patchToPatch, rays, bool);
+}
+}
+
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+Foam::treeBoundBox Foam::patchToPatches::rays::srcBox
+(
+    const face& srcFace,
+    const pointField& srcPoints,
+    const vectorField& srcPointNormals
+) const
+{
+    return intersection::srcBoxStatic(srcFace, srcPoints, srcPointNormals);
+}
+
+
+bool Foam::patchToPatches::rays::intersectFaces
+(
+    const primitiveOldTimePatch& srcPatch,
+    const vectorField& srcPointNormals,
+    const vectorField& srcPointNormals0,
+    const primitiveOldTimePatch& tgtPatch,
+    const label srcFacei,
+    const label tgtFacei
+)
+{
+    const treeBoundBox srcFaceBox =
+        patchToPatch::srcBox
+        (
+            srcPatch,
+            srcPointNormals,
+            srcPointNormals0,
+            srcFacei
+        );
+    const treeBoundBox tgtFaceBox =
+        patchToPatch::tgtBox(tgtPatch, tgtFacei);
+
+    if (srcFaceBox.overlaps(tgtFaceBox))
+    {
+        srcLocalTgtFaces_[srcFacei].append(tgtFacei);
+        tgtLocalSrcFaces_[tgtFacei].append(srcFacei);
+
+        return true;
+    }
+    else
+    {
+        return false;
+    }
+}
+
+
+Foam::tmpNrc<Foam::PrimitiveOldTimePatch<Foam::faceList, Foam::pointField>>
+Foam::patchToPatches::rays::distributeTgt
+(
+    const primitiveOldTimePatch& srcPatch,
+    const vectorField& srcPointNormals,
+    const vectorField& srcPointNormals0,
+    const primitiveOldTimePatch& tgtPatch,
+    distributionMap& tgtMap
+)
+{
+    // Intercept generation of the local patch. Store it. Return a const
+    // reference tmp instead of a pointer.
+
+    tmpNrc<PrimitiveOldTimePatch<faceList, pointField>> localTgtPatchPtr =
+        patchToPatch::distributeTgt
+        (
+            srcPatch,
+            srcPointNormals,
+            srcPointNormals0,
+            tgtPatch,
+            tgtMap
+        );
+
+    localTgtPatchPtr_.reset(localTgtPatchPtr.ptr());
+
+    return
+        tmpNrc<PrimitiveOldTimePatch<faceList, pointField>>
+        (
+            localTgtPatchPtr_()
+        );
+}
+
+
+Foam::tmpNrc<Foam::PrimitiveOldTimePatch<Foam::faceList, Foam::pointField>>
+Foam::patchToPatches::rays::distributeSrc
+(
+    const primitiveOldTimePatch& srcPatch,
+    distributionMap& srcMap
+)
+{
+    // Intercept generation of the local patch. Store it. Return a const
+    // reference tmp instead of a pointer.
+
+    tmpNrc<PrimitiveOldTimePatch<faceList, pointField>> localSrcPatchPtr =
+        patchToPatch::distributeSrc(srcPatch, srcMap);
+
+    localSrcPatchPtr_.reset(localSrcPatchPtr.ptr());
+
+    return
+        tmpNrc<PrimitiveOldTimePatch<faceList, pointField>>
+        (
+            localSrcPatchPtr_()
+        );
+}
+
+
+Foam::label Foam::patchToPatches::rays::finalise
+(
+    const primitiveOldTimePatch& srcPatch,
+    const vectorField& srcPointNormals,
+    const vectorField& srcPointNormals0,
+    const primitiveOldTimePatch& tgtPatch,
+    const transformer& tgtToSrc
+)
+{
+    const label nCouples =
+        patchToPatch::finalise
+        (
+            srcPatch,
+            srcPointNormals,
+            srcPointNormals0,
+            tgtPatch,
+            tgtToSrc
+        );
+
+    // Transform the source-local target patch back to the target
+    if (!isSingleProcess() && !isNull(tgtToSrc))
+    {
+        autoPtr<PrimitiveOldTimePatch<faceList, pointField>>
+            localTgtPatchPtr(localTgtPatchPtr_.ptr());
+
+        localTgtPatchPtr_.set
+        (
+            new PrimitiveOldTimePatch<faceList, pointField>
+            (
+                localTgtPatchPtr(),
+                tgtToSrc.invTransformPosition(localTgtPatchPtr().points()),
+                isNull(localTgtPatchPtr().points0())
+              ? NullObjectRef<pointField>()
+              : tgtToSrc.invTransformPosition(localTgtPatchPtr().points0())()
+            )
+        );
+    }
+
+    return nCouples;
+}
+
+
+Foam::patchToPatch::procFace Foam::patchToPatches::rays::ray
+(
+    const primitiveOldTimePatch& outPatch,
+    const autoPtr<PrimitiveOldTimePatch<faceList, pointField>>&
+        localOutPatchPtr,
+    const autoPtr<List<procFace>>& localOutProcFacesPtr,
+    const List<DynamicList<label>>& inLocalOutFaces,
+    const scalar fraction,
+    const label inFacei,
+    const point& inP,
+    const vector& inN,
+    point& outP
+) const
+{
+    forAll(inLocalOutFaces[inFacei], i)
+    {
+        const label localOutFacei = inLocalOutFaces[inFacei][i];
+
+        const face& outF =
+            isSingleProcess()
+          ? outPatch[localOutFacei]
+          : localOutPatchPtr()[localOutFacei];
+
+        const pointField& outPoints =
+            isSingleProcess()
+          ? outPatch.points()
+          : localOutPatchPtr().points();
+        const pointField& outPoints0 =
+            isSingleProcess()
+          ? outPatch.points0()
+          : localOutPatchPtr().points0();
+
+        const pointField outPoly
+        (
+            (1 - fraction)*outF.points(outPoints0)
+          + fraction*outF.points(outPoints)
+        );
+
+        const pointHit ray =
+            face(identity(outPoly.size()))
+           .ray(inP, inN, outPoly, Foam::intersection::algorithm::visible);
+
+        if (ray.hit())
+        {
+            outP = ray.rawPoint();
+
+            return
+                isSingleProcess()
+              ? procFace({Pstream::myProcNo(), localOutFacei})
+              : localOutProcFacesPtr()[localOutFacei];
+        }
+    }
+
+    return procFace({-1, -1});
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::patchToPatches::rays::rays
+(
+    const bool reverse
+)
+:
+    patchToPatch(reverse)
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::patchToPatches::rays::~rays()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+Foam::tmpNrc<Foam::List<Foam::DynamicList<Foam::scalar>>>
+Foam::patchToPatches::rays::srcWeights(const primitivePatch& srcPatch) const
+{
+    NotImplemented;
+    return tmpNrc<List<DynamicList<scalar>>>(nullptr);
+}
+
+
+Foam::tmpNrc<Foam::List<Foam::DynamicList<Foam::scalar>>>
+Foam::patchToPatches::rays::tgtWeights(const primitivePatch& tgtPatch) const
+{
+    NotImplemented;
+    return tmpNrc<List<DynamicList<scalar>>>(nullptr);
+}
+
+
+Foam::patchToPatch::procFace Foam::patchToPatches::rays::srcToTgtRay
+(
+    const primitiveOldTimePatch& tgtPatch,
+    const scalar fraction,
+    const label srcFacei,
+    const vector& srcP,
+    const vector& srcN,
+    point& tgtP
+) const
+{
+    return
+        ray
+        (
+            tgtPatch,
+            localTgtPatchPtr_,
+            localTgtProcFacesPtr_,
+            srcLocalTgtFaces_,
+            fraction,
+            srcFacei,
+            srcP,
+            srcN,
+            tgtP
+        );
+}
+
+
+Foam::patchToPatch::procFace Foam::patchToPatches::rays::tgtToSrcRay
+(
+    const primitiveOldTimePatch& srcPatch,
+    const scalar fraction,
+    const label tgtFacei,
+    const vector& tgtP,
+    const vector& tgtN,
+    point& srcP
+) const
+{
+    return
+        ray
+        (
+            srcPatch,
+            localSrcPatchPtr_,
+            localSrcProcFacesPtr_,
+            tgtLocalSrcFaces_,
+            fraction,
+            tgtFacei,
+            tgtP,
+            tgtN,
+            srcP
+        );
+}
+
+
+// ************************************************************************* //

src/meshTools/patchToPatch/rays/raysPatchToPatch.H

@@ -0,0 +1,204 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2021-2022 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::patchToPatches::intersection
+
+Description
+    Class to generate patchToPatch coupling geometry. Coupling is determined by
+    means of comparing the bound boxes generated by the intersection method.
+    This generates an outer "envelope" of possible intersections that can be
+    used for ray shooting and Lagrangian transfer.
+
+SourceFiles
+    rays.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef raysPatchToPatch_H
+#define raysPatchToPatch_H
+
+#include "patchToPatch.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace patchToPatches
+{
+
+/*---------------------------------------------------------------------------*\
+                          Class rays Declaration
+\*---------------------------------------------------------------------------*/
+
+class rays
+:
+    public patchToPatch
+{
+    // Private Data
+
+        // Parallel
+
+            //- Cache of the part of the source patch local to the target
+            autoPtr<PrimitiveOldTimePatch<faceList, pointField>>
+                localSrcPatchPtr_;
+
+            //- Cache of the part of the target patch local to the source
+            autoPtr<PrimitiveOldTimePatch<faceList, pointField>>
+                localTgtPatchPtr_;
+
+
+    // Private Member Functions
+
+        //- Get the bound box for a source face
+        virtual treeBoundBox srcBox
+        (
+            const face& srcFace,
+            const pointField& srcPoints,
+            const vectorField& srcPointNormals
+        ) const;
+
+        //- Intersect two faces
+        virtual bool intersectFaces
+        (
+            const primitiveOldTimePatch& srcPatch,
+            const vectorField& srcPointNormals,
+            const vectorField& srcPointNormals0,
+            const primitiveOldTimePatch& tgtPatch,
+            const label srcFacei,
+            const label tgtFacei
+        );
+
+        //- Distribute the target patch so that enough is locally available
+        //  for its intersection with the source patch can be computed
+        virtual
+        tmpNrc<PrimitiveOldTimePatch<faceList, pointField>>
+        distributeTgt
+        (
+            const primitiveOldTimePatch& srcPatch,
+            const vectorField& srcPointNormals,
+            const vectorField& srcPointNormals0,
+            const primitiveOldTimePatch& tgtPatch,
+            distributionMap& tgtMap
+        );
+
+        //- Distribute the source patch so that everything the target
+        //  intersects is locally available. Happens after intersection.
+        virtual
+        tmpNrc<PrimitiveOldTimePatch<faceList, pointField>>
+        distributeSrc
+        (
+            const primitiveOldTimePatch& srcPatch,
+            distributionMap& srcMap
+        );
+
+        //- Finalising
+        virtual label finalise
+        (
+            const primitiveOldTimePatch& srcPatch,
+            const vectorField& srcPointNormals,
+            const vectorField& srcPointNormals0,
+            const primitiveOldTimePatch& tgtPatch,
+            const transformer& tgtToSrc
+        );
+
+        //- Compute a ray intersection
+        procFace ray
+        (
+            const primitiveOldTimePatch& outPatch,
+            const autoPtr<PrimitiveOldTimePatch<faceList, pointField>>&
+                localOutPatchPtr,
+            const autoPtr<List<procFace>>& localOutProcFacesPtr,
+            const List<DynamicList<label>>& inLocalOutFacesPtr,
+            const scalar fraction,
+            const label inFacei,
+            const point& inP,
+            const vector& inN,
+            point& outP
+        ) const;
+
+
+public:
+
+    //- Runtime type information
+    TypeName("rays");
+
+
+    // Constructors
+
+        //- Construct from components
+        rays(const bool reverse);
+
+
+    //- Destructor
+    ~rays();
+
+
+    // Member Functions
+
+        //- For each source face, the coupled target weights
+        virtual tmpNrc<List<DynamicList<scalar>>> srcWeights
+        (
+            const primitivePatch& srcPatch
+        ) const;
+
+        //- For each target face, the coupled source weights
+        virtual tmpNrc<List<DynamicList<scalar>>> tgtWeights
+        (
+            const primitivePatch& tgtPatch
+        ) const;
+
+        //- Compute a ray intersection from the source side to the target
+        procFace srcToTgtRay
+        (
+            const primitiveOldTimePatch& tgtPatch,
+            const scalar fraction,
+            const label srcFacei,
+            const vector& srcP,
+            const vector& srcN,
+            point& tgtP
+        ) const;
+
+        //- Compute a ray intersection from the target side to the source
+        procFace tgtToSrcRay
+        (
+            const primitiveOldTimePatch& srcPatch,
+            const scalar fraction,
+            const label tgtFacei,
+            const vector& tgtP,
+            const vector& tgtN,
+            point& srcP
+        ) const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace patchToPatches
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //