diff --git a/src/meshTools/patchToPatch/intersection/intersectionPatchToPatch.C b/src/meshTools/patchToPatch/intersection/intersectionPatchToPatch.C
index e6f0ce5697..c5d9d30b33 100644
--- a/src/meshTools/patchToPatch/intersection/intersectionPatchToPatch.C
+++ b/src/meshTools/patchToPatch/intersection/intersectionPatchToPatch.C
@@ -542,6 +542,20 @@ void Foam::patchToPatches::intersection::initialise
 }
 
 
+Foam::labelList Foam::patchToPatches::intersection::subsetLocalTgt
+(
+    const primitiveOldTimePatch& localTgtPatch
+)
+{
+    const labelList newToOldLocalTgtFace =
+        patchToPatch::subsetLocalTgt(localTgtPatch);
+
+    tgtCouples_ = List<DynamicList<couple>>(tgtCouples_, newToOldLocalTgtFace);
+
+    return newToOldLocalTgtFace;
+}
+
+
 void Foam::patchToPatches::intersection::rDistributeTgt
 (
     const primitiveOldTimePatch& tgtPatch
diff --git a/src/meshTools/patchToPatch/intersection/intersectionPatchToPatch.H b/src/meshTools/patchToPatch/intersection/intersectionPatchToPatch.H
index 2dce50493d..aad2076387 100644
--- a/src/meshTools/patchToPatch/intersection/intersectionPatchToPatch.H
+++ b/src/meshTools/patchToPatch/intersection/intersectionPatchToPatch.H
@@ -328,9 +328,16 @@ private:
             const primitiveOldTimePatch& tgtPatch
         );
 
+        //- Subset the local target patch so that only parts that actually
+        //  intersect the source remain
+        virtual labelList subsetLocalTgt
+        (
+            const primitiveOldTimePatch& localTgtPatch
+        );
+
         //- Send data that resulted from an intersection between the source
         //  patch and a distributed source-local-target patch back to the
-        //  original target processes.
+        //  original target processes
         virtual void rDistributeTgt(const primitiveOldTimePatch& tgtPatch);
 
         //- Finalise the intersection
diff --git a/src/meshTools/patchToPatch/inverseDistance/inverseDistancePatchToPatch.C b/src/meshTools/patchToPatch/inverseDistance/inverseDistancePatchToPatch.C
index 092df8a2cb..8107335cbe 100644
--- a/src/meshTools/patchToPatch/inverseDistance/inverseDistancePatchToPatch.C
+++ b/src/meshTools/patchToPatch/inverseDistance/inverseDistancePatchToPatch.C
@@ -191,6 +191,20 @@ void Foam::patchToPatches::inverseDistance::initialise
 }
 
 
+Foam::labelList Foam::patchToPatches::inverseDistance::subsetLocalTgt
+(
+    const primitiveOldTimePatch& localTgtPatch
+)
+{
+    const labelList newToOldLocalTgtFace =
+        patchToPatch::subsetLocalTgt(localTgtPatch);
+
+    tgtWeights_ = List<DynamicList<scalar>>(tgtWeights_, newToOldLocalTgtFace);
+
+    return newToOldLocalTgtFace;
+}
+
+
 void Foam::patchToPatches::inverseDistance::rDistributeTgt
 (
     const primitiveOldTimePatch& tgtPatch
diff --git a/src/meshTools/patchToPatch/inverseDistance/inverseDistancePatchToPatch.H b/src/meshTools/patchToPatch/inverseDistance/inverseDistancePatchToPatch.H
index a18d96a878..9ff2fc59e8 100644
--- a/src/meshTools/patchToPatch/inverseDistance/inverseDistancePatchToPatch.H
+++ b/src/meshTools/patchToPatch/inverseDistance/inverseDistancePatchToPatch.H
@@ -114,9 +114,16 @@ class inverseDistance
             const primitiveOldTimePatch& tgtPatch
         );
 
+        //- Subset the local target patch so that only parts that actually
+        //  intersect the source remain
+        virtual labelList subsetLocalTgt
+        (
+            const primitiveOldTimePatch& localTgtPatch
+        );
+
         //- Send data that resulted from an intersection between the source
         //  patch and a distributed source-local-target patch back to the
-        //  original target processes.
+        //  original target processes
         virtual void rDistributeTgt(const primitiveOldTimePatch& tgtPatch);
 
         //- Finalise the intersection
diff --git a/src/meshTools/patchToPatch/nearest/nearestPatchToPatch.C b/src/meshTools/patchToPatch/nearest/nearestPatchToPatch.C
index 6fe6ecf4e4..aee1219b4a 100644
--- a/src/meshTools/patchToPatch/nearest/nearestPatchToPatch.C
+++ b/src/meshTools/patchToPatch/nearest/nearestPatchToPatch.C
@@ -200,6 +200,20 @@ void Foam::patchToPatches::nearest::initialise
 }
 
 
+Foam::labelList Foam::patchToPatches::nearest::subsetLocalTgt
+(
+    const primitiveOldTimePatch& localTgtPatch
+)
+{
+    const labelList newToOldLocalTgtFace =
+        patchToPatch::subsetLocalTgt(localTgtPatch);
+
+    tgtDistances_ = List<scalar>(tgtDistances_, newToOldLocalTgtFace);
+
+    return newToOldLocalTgtFace;
+}
+
+
 void Foam::patchToPatches::nearest::rDistributeTgt
 (
     const primitiveOldTimePatch& tgtPatch
diff --git a/src/meshTools/patchToPatch/nearest/nearestPatchToPatch.H b/src/meshTools/patchToPatch/nearest/nearestPatchToPatch.H
index e5c279bd70..ecad42e106 100644
--- a/src/meshTools/patchToPatch/nearest/nearestPatchToPatch.H
+++ b/src/meshTools/patchToPatch/nearest/nearestPatchToPatch.H
@@ -105,9 +105,16 @@ protected:
             const primitiveOldTimePatch& tgtPatch
         );
 
+        //- Subset the local target patch so that only parts that actually
+        //  intersect the source remain
+        virtual labelList subsetLocalTgt
+        (
+            const primitiveOldTimePatch& localTgtPatch
+        );
+
         //- Send data that resulted from an intersection between the source
         //  patch and a distributed source-local-target patch back to the
-        //  original target processes.
+        //  original target processes
         virtual void rDistributeTgt(const primitiveOldTimePatch& tgtPatch);
 
         //- For each source face, the coupled target weights
diff --git a/src/meshTools/patchToPatch/patchToPatch/patchToPatch.C b/src/meshTools/patchToPatch/patchToPatch/patchToPatch.C
index 42117bde28..20ce9642ef 100644
--- a/src/meshTools/patchToPatch/patchToPatch/patchToPatch.C
+++ b/src/meshTools/patchToPatch/patchToPatch/patchToPatch.C
@@ -78,6 +78,75 @@ namespace Foam
     {
         return treeBoundBox(min(a.min(), b.min()), max(a.max(), b.max()));
     }
+
+    void subsetDistributionMap
+    (
+        const boolList& oldIsUsed,
+        distributionMap& map,
+        labelList& oldToNew,
+        labelList& newToOld
+    )
+    {
+        // Create re-indexing
+        oldToNew.resize(map.constructSize());
+        newToOld.resize(count(oldIsUsed, true));
+        oldToNew = -1;
+        newToOld = -1;
+        {
+            label newi = 0;
+            forAll(oldIsUsed, oldi)
+            {
+                if (oldIsUsed[oldi])
+                {
+                    oldToNew[oldi] = newi;
+                    newToOld[newi] = oldi;
+                    ++ newi;
+                }
+            }
+        }
+
+        // Per-processor used list for construction
+        List<boolList> allOldIsUsed(Pstream::nProcs());
+        forAll(map.constructMap(), proci)
+        {
+            allOldIsUsed[proci] =
+                UIndirectList<bool>(oldIsUsed, map.constructMap()[proci]);
+        }
+
+        // Communicate to form a per-processor used list for subsetting
+        List<boolList> allSubOldIsUsed(Pstream::nProcs());
+        Pstream::exchange<boolList, bool>(allOldIsUsed, allSubOldIsUsed);
+
+        // Subset the sub map
+        forAll(map.subMap(), proci)
+        {
+            label newi = 0;
+            forAll(map.subMap()[proci], oldi)
+            {
+                if (allSubOldIsUsed[proci][oldi])
+                {
+                    map.subMap()[proci][newi ++] =
+                        map.subMap()[proci][oldi];
+                }
+            }
+            map.subMap()[proci].resize(newi);
+        }
+
+        // Subset and renumber the construct map
+        forAll(map.constructMap(), proci)
+        {
+            label newi = 0;
+            forAll(map.constructMap()[proci], oldi)
+            {
+                if (allOldIsUsed[proci][oldi])
+                {
+                    map.constructMap()[proci][newi ++] =
+                        oldToNew[map.constructMap()[proci][oldi]];
+                }
+            }
+            map.constructMap()[proci].resize(newi);
+        }
+    }
 }
 
 
@@ -708,71 +777,61 @@ void Foam::patchToPatch::initialise
 }
 
 
-Foam::tmpNrc<Foam::PrimitiveOldTimePatch<Foam::faceList, Foam::pointField>>
-Foam::patchToPatch::distributeTgt
+Foam::labelList Foam::patchToPatch::subsetLocalTgt
 (
-    const primitiveOldTimePatch& srcPatch,
-    const vectorField& srcPointNormals,
-    const vectorField& srcPointNormals0,
-    const primitiveOldTimePatch& tgtPatch
+    const primitiveOldTimePatch& localTgtPatch
 )
 {
-    tgtMapPtr_ =
-        patchDistributionMap
-        (
-            tgtPatchSendFaces
-            (
-                srcPatch,
-                srcPointNormals,
-                srcPointNormals0,
-                tgtPatch
-            )
-        );
-
-    if (localTgtProcFacesPtr_.empty())
+    // Determine which local target faces are actually used
+    boolList oldLocalTgtFaceIsUsed(localTgtPatch.size(), false);
+    forAll(srcLocalTgtFaces_, srcFacei)
     {
-        localTgtProcFacesPtr_.set(new List<procFace>());
+        forAll(srcLocalTgtFaces_[srcFacei], i)
+        {
+            oldLocalTgtFaceIsUsed[srcLocalTgtFaces_[srcFacei][i]] = true;
+        }
     }
 
-    return
-        tmpNrc<PrimitiveOldTimePatch<faceList, pointField>>
-        (
-            new PrimitiveOldTimePatch<faceList, pointField>
-            (
-                distributePatch(tgtMapPtr_(), tgtPatch, localTgtProcFacesPtr_())
-            )
-        );
+    // Subset the target map
+    labelList oldToNewLocalTgtFace, newToOldLocalTgtFace;
+    subsetDistributionMap
+    (
+        oldLocalTgtFaceIsUsed,
+        tgtMapPtr_(),
+        oldToNewLocalTgtFace,
+        newToOldLocalTgtFace
+    );
+
+    // Renumber the addressing
+    forAll(srcLocalTgtFaces_, srcFacei)
+    {
+        forAll(srcLocalTgtFaces_[srcFacei], i)
+        {
+            srcLocalTgtFaces_[srcFacei][i] =
+                oldToNewLocalTgtFace[srcLocalTgtFaces_[srcFacei][i]];
+        }
+    }
+
+    // Subset the local target faces
+    tgtLocalSrcFaces_ =
+        List<DynamicList<label>>(tgtLocalSrcFaces_, newToOldLocalTgtFace);
+    localTgtProcFacesPtr_() =
+        List<procFace>(localTgtProcFacesPtr_(), newToOldLocalTgtFace);
+
+    return newToOldLocalTgtFace;
 }
 
 
-Foam::tmpNrc<Foam::PrimitiveOldTimePatch<Foam::faceList, Foam::pointField>>
-Foam::patchToPatch::distributeSrc
+void Foam::patchToPatch::distributeSrc
 (
     const primitiveOldTimePatch& srcPatch
 )
 {
-    srcMapPtr_ = patchDistributionMap(srcPatchSendFaces());
-
-    if (localSrcProcFacesPtr_.empty())
-    {
-        localSrcProcFacesPtr_.set(new List<procFace>());
-    }
-
-    return
-        tmpNrc<PrimitiveOldTimePatch<faceList, pointField>>
-        (
-            new PrimitiveOldTimePatch<faceList, pointField>
-            (
-                distributePatch(srcMapPtr_(), srcPatch, localSrcProcFacesPtr_())
-            )
-        );
+    distributePatch(srcMapPtr_(), localSrcProcFacesPtr_());
 }
 
 
-void Foam::patchToPatch::rDistributeTgt
-(
-    const primitiveOldTimePatch& tgtPatch
-)
+void Foam::patchToPatch::rDistributeTgt(const primitiveOldTimePatch& tgtPatch)
 {
     // Create a map from source procFace to local source face
     HashTable<label, procFace, Hash<procFace>> srcProcFaceToLocal;
@@ -833,8 +892,8 @@ Foam::patchToPatch::patchToPatch(const bool reverse)
     tgtLocalSrcFaces_(),
     srcMapPtr_(nullptr),
     tgtMapPtr_(nullptr),
-    localSrcProcFacesPtr_(nullptr),
-    localTgtProcFacesPtr_(nullptr)
+    localSrcProcFacesPtr_(new List<procFace>()),
+    localTgtProcFacesPtr_(new List<procFace>())
 {}
 
 
@@ -963,14 +1022,33 @@ void Foam::patchToPatch::update
     }
     else
     {
-        // Distribute the target
-        tmpNrc<PrimitiveOldTimePatch<faceList, pointField>> localTTgtPatchPtr =
-            distributeTgt
+        // Distribute the target patch so that everything is locally available
+        // to the source. This is done based on bound boxes, so quite a lot of
+        // faces will get distributed that ultimately are not used. These will
+        // be filtered out after the intersection has been completed.
+        tgtMapPtr_ =
+            patchDistributionMap
             (
-                srcPatch,
-                srcPointNormals,
-                srcPointNormals0,
-                tTgtPatch
+                tgtPatchSendFaces
+                (
+                    srcPatch,
+                    srcPointNormals,
+                    srcPointNormals0,
+                    tTgtPatch
+                )
+            );
+        tmpNrc<PrimitiveOldTimePatch<faceList, pointField>> localTTgtPatchPtr =
+            tmpNrc<PrimitiveOldTimePatch<faceList, pointField>>
+            (
+                new PrimitiveOldTimePatch<faceList, pointField>
+                (
+                    distributePatch
+                    (
+                        tgtMapPtr_(),
+                        tTgtPatch,
+                        localTgtProcFacesPtr_()
+                    )
+                )
             );
 
         // Massage target patch into form that can be used by the serial
@@ -1004,9 +1082,12 @@ void Foam::patchToPatch::update
             );
         }
 
-        // Distribute the source
-        tmpNrc<PrimitiveOldTimePatch<faceList, pointField>> localSrcPatchPtr =
-            distributeSrc(srcPatch);
+        // Subset the local target patch
+        subsetLocalTgt(localTTgtPatch);
+
+        // Distribute the source patch
+        srcMapPtr_ = patchDistributionMap(srcPatchSendFaces());
+        distributeSrc(srcPatch);
 
         // Reverse distribute coupling data back to the target
         rDistributeTgt(tgtPatch);
diff --git a/src/meshTools/patchToPatch/patchToPatch/patchToPatch.H b/src/meshTools/patchToPatch/patchToPatch/patchToPatch.H
index cba51dab64..fba23b3511 100644
--- a/src/meshTools/patchToPatch/patchToPatch/patchToPatch.H
+++ b/src/meshTools/patchToPatch/patchToPatch/patchToPatch.H
@@ -304,6 +304,14 @@ protected:
                 List<procFace>& localProcFaces
             ) const;
 
+            //- As above, but when you want the proc-faces without the
+            //  associated patch geometry
+            void distributePatch
+            (
+                const distributionMap& map,
+                List<procFace>& localProcFaces
+            ) const;
+
 
         // Hooks
 
@@ -316,33 +324,20 @@ protected:
                 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
-            //  internally set the target map.
-            virtual
-            tmpNrc<PrimitiveOldTimePatch<faceList, pointField>>
-            distributeTgt
+            //- Subset the local target patch so that only parts that actually
+            //  intersect the source remain
+            virtual labelList subsetLocalTgt
             (
-                const primitiveOldTimePatch& srcPatch,
-                const vectorField& srcPointNormals,
-                const vectorField& srcPointNormals0,
-                const primitiveOldTimePatch& tgtPatch
+                const primitiveOldTimePatch& localTgtPatch
             );
 
-            //- 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 internally set the
-            //  source map.
-            virtual
-            tmpNrc<PrimitiveOldTimePatch<faceList, pointField>>
-            distributeSrc(const primitiveOldTimePatch& srcPatch);
+            //- Distribute the source patch so that any information needed by
+            //  the target is locally available
+            virtual void distributeSrc(const primitiveOldTimePatch& srcPatch);
 
             //- Send data that resulted from an intersection between the source
             //  patch and a distributed source-local-target patch back to the
-            //  original target processes.
+            //  original target processes
             virtual void rDistributeTgt(const primitiveOldTimePatch& tgtPatch);
 
             //- Finalising
diff --git a/src/meshTools/patchToPatch/patchToPatch/patchToPatchParallelOps.C b/src/meshTools/patchToPatch/patchToPatch/patchToPatchParallelOps.C
index 030dc6f0c4..a5bc6b9389 100644
--- a/src/meshTools/patchToPatch/patchToPatch/patchToPatchParallelOps.C
+++ b/src/meshTools/patchToPatch/patchToPatch/patchToPatchParallelOps.C
@@ -238,19 +238,19 @@ Foam::patchToPatch::distributePatch
         // Send
         for (label proci = 0; proci < Pstream::nProcs(); proci++)
         {
-            const labelList& sendTgtFaces = map.subMap()[proci];
+            const labelList& sendFaceis = map.subMap()[proci];
 
-            if (proci != thisProci && sendTgtFaces.size())
+            if (proci != thisProci && sendFaceis.size())
             {
                 uindirectPrimitiveOldTimePatch subPatch
                 (
-                    UIndirectList<face>(patch, sendTgtFaces),
+                    UIndirectList<face>(patch, sendFaceis),
                     patch.points(),
                     patch.points0()
                 );
 
                 UOPstream(proci, pBufs)()
-                    << sendTgtFaces
+                    << sendFaceis
                     << subPatch.localFaces()
                     << subPatch.localPoints()
                     << (patch.has0() ? subPatch.localPoints0() : pointField());
@@ -261,16 +261,16 @@ Foam::patchToPatch::distributePatch
 
         // Map local data
         {
-            const labelList& sendTgtFaces = map.subMap()[thisProci];
+            const labelList& sendFaceis = map.subMap()[thisProci];
 
             uindirectPrimitiveOldTimePatch subPatch
             (
-                UIndirectList<face>(patch, sendTgtFaces),
+                UIndirectList<face>(patch, sendFaceis),
                 patch.points(),
                 patch.points0()
             );
 
-            procLocalFaceis[thisProci] = sendTgtFaces;
+            procLocalFaceis[thisProci] = sendFaceis;
             procLocalFaces[thisProci] = subPatch.localFaces();
             procLocalPoints[thisProci] = subPatch.localPoints();
             if (patch.has0())
@@ -282,9 +282,7 @@ Foam::patchToPatch::distributePatch
         // Receive remote data
         for (label proci = 0; proci < Pstream::nProcs(); proci++)
         {
-            const labelList& receiveNewTgtFaces = map.constructMap()[proci];
-
-            if (proci != thisProci && receiveNewTgtFaces.size())
+            if (proci != thisProci && map.constructMap()[proci].size())
             {
                 UIPstream(proci, pBufs)()
                     >> procLocalFaceis[proci]
@@ -296,9 +294,9 @@ Foam::patchToPatch::distributePatch
     }
 
     // Allocate
-    faceList localTgtFaces;
-    pointField localTgtPoints;
-    pointField localTgtPoints0;
+    faceList localFaces;
+    pointField localPoints;
+    pointField localPoints0;
     {
         label nLocalFaces = 0, nLocalPoints = 0;
         forAll(procLocalFaceis, proci)
@@ -307,16 +305,16 @@ Foam::patchToPatch::distributePatch
             nLocalPoints += procLocalPoints[proci].size();
         }
         localProcFaces.setSize(nLocalFaces);
-        localTgtFaces.setSize(nLocalFaces);
-        localTgtPoints.setSize(nLocalPoints);
+        localFaces.setSize(nLocalFaces);
+        localPoints.setSize(nLocalPoints);
         if (patch.has0())
         {
-            localTgtPoints0.setSize(nLocalPoints);
+            localPoints0.setSize(nLocalPoints);
         }
     }
 
     // Renumber and flatten
-    label localTgtFacei = 0, localTgtPointi = 0;
+    label localFacei = 0, localPointi = 0;
 
     // Local data first
     {
@@ -324,21 +322,21 @@ Foam::patchToPatch::distributePatch
         const faceList& fs = procLocalFaces[thisProci];
         forAll(fis, i)
         {
-            localProcFaces[localTgtFacei] = {thisProci, fis[i]};
-            localTgtFaces[localTgtFacei] = face(fs[i] + localTgtPointi);
-            localTgtFacei ++;
+            localProcFaces[localFacei] = {thisProci, fis[i]};
+            localFaces[localFacei] = face(fs[i] + localPointi);
+            localFacei ++;
         }
 
         const pointField& ps = procLocalPoints[thisProci];
         const pointField& ps0 = procLocalPoints0[thisProci];
         forAll(ps, i)
         {
-            localTgtPoints[localTgtPointi] = ps[i];
+            localPoints[localPointi] = ps[i];
             if (patch.has0())
             {
-                localTgtPoints0[localTgtPointi] = ps0[i];
+                localPoints0[localPointi] = ps0[i];
             }
-            localTgtPointi ++;
+            localPointi ++;
         }
     }
 
@@ -351,21 +349,21 @@ Foam::patchToPatch::distributePatch
             const faceList& fs = procLocalFaces[proci];
             forAll(fis, i)
             {
-                localProcFaces[localTgtFacei] = {proci, fis[i]};
-                localTgtFaces[localTgtFacei] = face(fs[i] + localTgtPointi);
-                localTgtFacei ++;
+                localProcFaces[localFacei] = {proci, fis[i]};
+                localFaces[localFacei] = face(fs[i] + localPointi);
+                localFacei ++;
             }
 
             const pointField& ps = procLocalPoints[proci];
             const pointField& ps0 = procLocalPoints0[proci];
             forAll(ps, i)
             {
-                localTgtPoints[localTgtPointi] = ps[i];
+                localPoints[localPointi] = ps[i];
                 if (patch.has0())
                 {
-                    localTgtPoints0[localTgtPointi] = ps0[i];
+                    localPoints0[localPointi] = ps0[i];
                 }
-                localTgtPointi ++;
+                localPointi ++;
             }
         }
     }
@@ -374,16 +372,98 @@ Foam::patchToPatch::distributePatch
         patch.has0()
       ? PrimitiveOldTimePatch<faceList, pointField>
         (
-            localTgtFaces,
-            localTgtPoints,
-            localTgtPoints0
+            localFaces,
+            localPoints,
+            localPoints0
         )
       : PrimitiveOldTimePatch<faceList, pointField>
         (
-            localTgtFaces,
-            localTgtPoints
+            localFaces,
+            localPoints
         );
 }
 
 
+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& sendFaceis = map.subMap()[proci];
+
+            if (proci != thisProci && sendFaceis.size())
+            {
+                UOPstream(proci, pBufs)() << sendFaceis;
+            }
+        }
+
+        pBufs.finishedSends();
+
+        // Map local data
+        {
+            const labelList& sendFaceis = map.subMap()[thisProci];
+
+            procLocalFaceis[thisProci] = sendFaceis;
+        }
+
+        // Receive remote data
+        for (label proci = 0; proci < Pstream::nProcs(); proci++)
+        {
+            if (proci != thisProci && map.constructMap()[proci].size())
+            {
+                UIPstream(proci, pBufs)() >> procLocalFaceis[proci];
+            }
+        }
+    }
+
+    // Allocate
+    {
+        label nLocalFaces = 0;
+        forAll(procLocalFaceis, proci)
+        {
+            nLocalFaces += procLocalFaceis[proci].size();
+        }
+        localProcFaces.setSize(nLocalFaces);
+    }
+
+    // Renumber and flatten
+    label localFacei = 0;
+
+    // Local data first
+    {
+        const labelList& fis = procLocalFaceis[thisProci];
+        forAll(fis, i)
+        {
+            localProcFaces[localFacei] = {thisProci, fis[i]};
+            localFacei ++;
+        }
+    }
+
+    // Remote data after
+    forAll(procLocalFaceis, proci)
+    {
+        if (proci != thisProci)
+        {
+            const labelList& fis = procLocalFaceis[proci];
+            forAll(fis, i)
+            {
+                localProcFaces[localFacei] = {proci, fis[i]};
+                localFacei ++;
+            }
+        }
+    }
+}
+
+
 // ************************************************************************* //
diff --git a/src/meshTools/patchToPatch/rays/raysPatchToPatch.C b/src/meshTools/patchToPatch/rays/raysPatchToPatch.C
index eff3c71e77..58b0b379ff 100644
--- a/src/meshTools/patchToPatch/rays/raysPatchToPatch.C
+++ b/src/meshTools/patchToPatch/rays/raysPatchToPatch.C
@@ -86,56 +86,40 @@ bool Foam::patchToPatches::rays::intersectFaces
 }
 
 
-Foam::tmpNrc<Foam::PrimitiveOldTimePatch<Foam::faceList, Foam::pointField>>
-Foam::patchToPatches::rays::distributeTgt
+Foam::labelList Foam::patchToPatches::rays::subsetLocalTgt
 (
-    const primitiveOldTimePatch& srcPatch,
-    const vectorField& srcPointNormals,
-    const vectorField& srcPointNormals0,
-    const primitiveOldTimePatch& tgtPatch
+    const primitiveOldTimePatch& localTgtPatch
 )
 {
-    // Intercept generation of the local patch. Store it. Return a const
-    // reference tmp instead of a pointer.
+    const labelList newToOldLocalTgtFace =
+        patchToPatch::subsetLocalTgt(localTgtPatch);
 
-    tmpNrc<PrimitiveOldTimePatch<faceList, pointField>> localTgtPatchPtr =
-        patchToPatch::distributeTgt
+    localTgtPatchPtr_.reset
+    (
+        new PrimitiveOldTimePatch<faceList, pointField>
         (
-            srcPatch,
-            srcPointNormals,
-            srcPointNormals0,
-            tgtPatch
-        );
+            faceList(localTgtPatch, newToOldLocalTgtFace),
+            localTgtPatch.points(),
+            localTgtPatch.points0()
+        )
+    );
 
-    localTgtPatchPtr_.reset(localTgtPatchPtr.ptr());
-
-    return
-        tmpNrc<PrimitiveOldTimePatch<faceList, pointField>>
-        (
-            localTgtPatchPtr_()
-        );
+    return newToOldLocalTgtFace;
 }
 
 
-Foam::tmpNrc<Foam::PrimitiveOldTimePatch<Foam::faceList, Foam::pointField>>
-Foam::patchToPatches::rays::distributeSrc
+void Foam::patchToPatches::rays::distributeSrc
 (
     const primitiveOldTimePatch& srcPatch
 )
 {
-    // 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);
-
-    localSrcPatchPtr_.reset(localSrcPatchPtr.ptr());
-
-    return
-        tmpNrc<PrimitiveOldTimePatch<faceList, pointField>>
+    localSrcPatchPtr_.reset
+    (
+        new PrimitiveOldTimePatch<faceList, pointField>
         (
-            localSrcPatchPtr_()
-        );
+            distributePatch(srcMapPtr_(), srcPatch, localSrcProcFacesPtr_())
+        )
+    );
 }
 
 
diff --git a/src/meshTools/patchToPatch/rays/raysPatchToPatch.H b/src/meshTools/patchToPatch/rays/raysPatchToPatch.H
index 7f7e6c721d..000b69e7f9 100644
--- a/src/meshTools/patchToPatch/rays/raysPatchToPatch.H
+++ b/src/meshTools/patchToPatch/rays/raysPatchToPatch.H
@@ -92,23 +92,16 @@ class rays
             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
+        //- Subset the local target patch so that only parts that actually
+        //  intersect the source remain
+        virtual labelList subsetLocalTgt
         (
-            const primitiveOldTimePatch& srcPatch,
-            const vectorField& srcPointNormals,
-            const vectorField& srcPointNormals0,
-            const primitiveOldTimePatch& tgtPatch
+            const primitiveOldTimePatch& localTgtPatch
         );
 
-        //- 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);
+        //- Distribute the source patch so that any information needed by
+        //  the target is locally available
+        virtual void distributeSrc(const primitiveOldTimePatch& srcPatch);
 
         //- Finalising
         virtual label finalise